def get_settings():
settings = {}
try:
my_file = Path(settingsFile)
my_abs_path = my_file.resolve()
if str(getpwuid(os.stat(settingsFile).st_uid).pw_name) != "www-data":
os.system("sudo chown www-data " + str(settingsFile))
if str(getgrgid(os.stat(settingsFile).st_gid).gr_name) != "www-data":
os.system("sudo chgrp www-data " + str(settingsFile))
# Check wittypi_scheduleFile
if os.path.exists(wittypi_scheduleFile):
if str(getpwuid(os.stat(
wittypi_scheduleFile).st_uid).pw_name) != "www-data":
os.system("sudo chown www-data " + str(wittypi_scheduleFile))
if str(getgrgid(os.stat(
wittypi_scheduleFile).st_gid).gr_name) != "www-data":
os.system("sudo chgrp www-data " + str(wittypi_scheduleFile))
with io.open(settingsFile, encoding="utf-8") as data_file:
settings = json.loads(data_file.read())
except Exception as ex:
error_log(
"Warning: Loading default settings because File does not exist.")
# FileNotFoundError: doesn't exist => default values
# FileReadError / json.loads Error => default values
settings = get_defaults()
write_settings(settings)
settings = validate_settings(settings)
return settings
def write_csv(ts_fields):
try:
csv_file = scriptsFolder + '/offline.csv'
# Allowed ThingSpeak fields:
csv_columns = [
'datetime', 'field1', 'field2', 'field3', 'field4', 'field5',
'field6', 'field7', 'field8', 'latitude', 'longitude', 'elevation',
'status'
]
check_file(csv_file, 5, 10, 1)
# Create row with data
row = {}
row['datetime'] = datetime.now()
for key, value in ts_fields.items():
row[key] = str(value)
# Write to CSV File
write_header = (not os.path.isfile(csv_file)
or os.stat(csv_file).st_size == 0
) # exists or is empty
with io.open(csv_file, 'a', newline='', encoding='utf8') as csvfile:
writer = csv.DictWriter(csvfile,
fieldnames=csv_columns,
extrasaction='ignore',
delimiter=',',
lineterminator='\n')
if write_header:
writer.writeheader() # file doesn't exist yet, write a header
writer.writerow(row)
except IOError as ex1:
error_log(ex1, "Write-CSV IOError")
except Exception as ex:
error_log(ex, "Write-CSV Exception")
async def event_command_error(self, ctx: commands.Context, error: Exception):
if type(error) == commands.errors.CommandNotFound:
await ctx.send("[Not a valid command!]")
return
print(f'"{type(error)}"')
print(f'"{commands.errors.CommandNotFound}"')
traceback.print_exception(type(error), error, error.__traceback__)
error_log(f"({type(error)})\n{error}\n{error.__traceback__}")
async def routine_check_better_server():
print("[Subroutine] Better Server Check")
try:
while CFG.crashed:
print("[Better Server Check] Currently crashed, waiting...")
await async_sleep(60)
await CFG.add_action_queue(ActionQueueItem("check_for_better_server"))
except Exception:
error_log(traceback.format_exc())
async def routine_crash_check():
if CFG.crashed:
return
try:
crashed = await do_crash_check()
if crashed:
print("[Routine] Crash detected")
await CFG.add_action_queue(ActionQueueItem("handle_crash"))
await async_sleep(60)
except Exception:
error_log(traceback.format_exc())
async def routine_anti_afk():
print("[Subroutine] AntiAFK")
try:
await CFG.add_action_queue(ActionQueueItem("anti_afk"))
CFG.anti_afk_runs += 1
if CFG.anti_afk_runs % 3 == 0:
await CFG.add_action_queue(ActionQueueItem("chat", {"msgs": ["/clear"]}))
await CFG.add_action_queue(ActionQueueItem("advert"))
print("[Subroutine] Queued Advert")
CFG.anti_afk_runs = 0
except Exception:
error_log(traceback.format_exc())
def main():
global isActive, measurement_stop, measurement, debug, gpio, GPIO_LED
# setup LED
#GPIO.setwarnings(False) # Ignore warning for now
GPIO.setmode(GPIO.BCM) # Zaehlweise der GPIO-PINS auf der Platine
GPIO.setup(GPIO_LED, GPIO.OUT) # Set pin 21 to led output
# by default is AccessPoint down
stop_ap(1)
# blink with LED on startup
blink_led()
settings = get_settings() # read settings for number of GPIO pin
debug = settings[
"debug"] # flag to enable debug mode (HDMI output enabled and no rebooting)
if not debug:
# stop HDMI power (save energy)
print("Shutting down HDMI to save energy.")
stop_tv()
if debug:
error_log("Info: Raspberry Pi has been powered on.")
# Create virtual uap0 for WLAN
create_ap()
# start as seperate background thread
# because Taster pressing was not recognised
measurement_stop = threading.Event() # create event to stop measurement
measurement = threading.Thread(target=start_measurement,
args=(measurement_stop, ))
measurement.start() # start measurement
# setup Button
gpio = settings["button_pin"] # read pin from settings
GPIO.setup(
gpio, GPIO.IN, pull_up_down=GPIO.PUD_DOWN
) # Set pin 16 to be an input pin and set initial value to be pulled low (off)
bouncetime = 300 # ignoring further edges for 300ms for switch bounce handling
# register button press event
GPIO.add_event_detect(gpio,
GPIO.BOTH,
callback=button_pressed,
bouncetime=bouncetime)
# Main Lopp: Cancel with STRG+C
while True:
time.sleep(0.2) # wait 200 ms to give CPU chance to do other things
pass
print("This text will never be printed.")
def manage_transfer_to_ts(ts_channels, ts_fields, server_url, offline, debug):
# update ThingSpeak / transfer values
connectionErrorHappened = transfer_all_channels_to_ts(
ts_channels, ts_fields, server_url, debug)
if connectionErrorHappened:
# Write to CSV-File if ConnectionError occured
if offline == 2:
s = write_csv(ts_fields, ts_channels)
if s and debug:
error_log("Info: Data succesfully saved to CSV-File.")
return connectionErrorHappened
def button_pressed_falling():
global time_start, debug
time_end = miliseconds()
time_elapsed = time_end - time_start
MIN_TIME_TO_ELAPSE = 500 # miliseconds
MAX_TIME_TO_ELAPSE = 3000
if time_elapsed >= MIN_TIME_TO_ELAPSE and time_elapsed <= MAX_TIME_TO_ELAPSE:
time_start = 0 # reset to prevent multiple fallings from the same rising
toggle_measurement()
elif time_elapsed >= 5000 and time_elapsed <= 10000:
time_start = 0 # reset to prevent multiple fallings from the same rising
shutdown()
elif debug:
error_log(
"Info: Too short Button press, Too long Button press OR inteference occured."
)
def measure_voltage(ts_sensor):
fields = {}
# I2C-address of YL-40 PCF8591
address = 0x48
try:
# Create I2C instance and open the bus
PCF8591 = smbus.SMBus(get_smbus())
# read pin from ts_sensor settings
if 'pin' in ts_sensor and ts_sensor['pin'] is not None:
pin = int(ts_sensor['pin'])
else:
pin = 2
# AIN0 => Pin 0
# AIN1 => Pin 1
# AIN2 => Pin 2 (default)
# AIN3 => Pin 3
#factor = 0.09765625 # 25V/256 (=5V analog output signal)
factor = 16.5 / 256 # 16.5V/256 | 16.5V max voltage for 0xff (=3.3V analog output signal)
if 'I2CVoltage' in ts_sensor and ts_sensor['I2CVoltage'] is not None:
# convert 8 bit number to voltage
factor = float(ts_sensor['I2CVoltage']) / 256
PCF8591.write_byte(address, 0x40 +
pin) # set channel to AIN0, AIN1, AIN2 or AIN3
# measure once just for fun
_v = PCF8591.read_byte(address)
Voltage_8bit = PCF8591.read_byte(address) # = i2cget -y 1 0x48
voltage = Voltage_8bit * factor # convert 8 bit number to voltage
if 'ts_field' in ts_sensor and isinstance(voltage, (int, float)):
fields[ts_sensor["ts_field"]] = round(voltage, 4)
return fields
except Exception as e:
error_log(
e,
'Error while reading PCF8591 (Voltage). Is the Sensor connected?')
return None
def measure_aht10(ts_sensor):
try:
fields = {}
temperature,humidity = read_aht10(DEVICE)
# ThingSpeak fields
# Create returned dict if ts_field is defined
if 'ts_field_temperature' in ts_sensor and isinstance(temperature, (int, float)):
if 'offset' in ts_sensor and ts_sensor["offset"] is not None:
temperature = temperature-ts_sensor["offset"]
fields[ts_sensor["ts_field_temperature"]] = round(temperature, 2)
if 'ts_field_humidity' in ts_sensor and isinstance(humidity, (int, float)):
fields[ts_sensor["ts_field_humidity"]] = round(humidity, 2)
return fields
except Exception as e:
error_log(e, 'Error: Error while reading AHT10 Sensor. Is it connected?')
return None
def toggle_measurement():
global isActive, measurement_stop, measurement
if isActive == 0:
print("Button was pressed: Stop measurement")
# stop the measurement by event's flag
measurement_stop.set()
start_ap() # finally start AP
else:
print("Button was pressed: Start measurement")
if measurement.is_alive():
error_log("Warning: Thread should not be active anymore")
measurement_stop.clear() # reset flag
measurement_stop = threading.Event(
) # create event to stop measurement
measurement = threading.Thread(target=start_measurement,
args=(measurement_stop, ))
measurement.start() # start measurement
stop_ap() # finally stop AP
def button_pressed_falling():
global time_rising, debug
time_falling = miliseconds()
time_elapsed = time_falling - time_rising
time_rising = 0 # reset to prevent multiple fallings from the same rising
MIN_TIME_TO_ELAPSE = 500 # miliseconds
MAX_TIME_TO_ELAPSE = 3000
stop_led()
if time_elapsed >= MIN_TIME_TO_ELAPSE and time_elapsed <= MAX_TIME_TO_ELAPSE:
toggle_measurement()
elif time_elapsed >= 5000 and time_elapsed <= 10000:
shutdown()
elif time_elapsed >= 10000 and time_elapsed <= 15000:
delete_settings()
shutdown()
elif debug:
error_log(
"Info: Too short Button press, Too long Button press OR inteference occured: "
+ str(time_elapsed) + "ms elapsed.")
async def routine_ocr():
if (
CFG.action_running
or CFG.crashed
or (not CFG.chat_cleared_after_response)
or (not CFG.chat_ocr_ready)
):
return
if not CFG.chat_ocr_active:
if not CFG.chat_ocr_activation_queued and await can_activate_ocr():
await CFG.add_action_queue(ActionQueueItem("activate_ocr"))
else:
try:
# HACK: psuedo-blocking, make non-async
CFG.chat_ocr_ready = False
await do_chat_ocr()
except Exception:
CFG.chat_ocr_ready = True
CFG.chat_cleared_after_response = True
error_log(traceback.format_exc())
def diag():
diag = ""
try:
os.system(
"echo '\n\nUnterspannung seit Bootvorgang:\n' >> /tmp/diag.txt")
os.system("sudo vcgencmd get_throttled >> /tmp/diag.txt")
os.system(
"echo '0x50000 = Unterspannung seit Systemstart\n' > /tmp/diag.txt"
)
os.system(
"echo '0x50005 = Unterspannung seit Systemstart\n\n' > /tmp/diag.txt"
)
os.system("echo 'ifconfig:\n' > /tmp/diag.txt")
os.system("sudo ifconfig >> /tmp/diag.txt")
os.system("echo '\n\nroute:\n' >> /tmp/diag.txt")
os.system("sudo route >> /tmp/diag.txt")
os.system("echo '\n\nWLAN0 status:\n' >> /tmp/diag.txt")
os.system("sudo wpa_cli -i wlan0 status >> /tmp/diag.txt")
os.system("echo '\n\nlsusb:\n' >> /tmp/diag.txt")
os.system("sudo lsusb >> /tmp/diag.txt")
os.system("echo '\n\ndmesg:\n' >> /tmp/diag.txt")
os.system("sudo dmesg | grep USB >> /tmp/diag.txt")
os.system("sudo dmesg | grep ttyUSB >> /tmp/diag.txt")
os.system("echo '\n\nttyUSB*:\n' >> /tmp/diag.txt")
os.system("sudo ls -la /dev/ttyUSB* >> /tmp/diag.txt")
os.system("echo '\n\nlog:\n' >> /tmp/diag.txt")
os.system(
"sudo grep -a -B 2 -A 2 'usb_modeswitch\|modem\|pppd\|PPP\|ppp0\|ttyUSB0\|wvdial' /var/log/messages >> /tmp/diag.txt"
)
os.system("echo '\n\nFirmware:\n' >> /tmp/diag.txt")
os.system("sudo uname -a >> /tmp/diag.txt")
with io.open("/tmp/diag.txt", encoding="utf-8") as data_file:
diag = data_file.read()
return diag
except Exception as e:
error_log(e, "Unhandled Exception in diag")
# Error occured
return diag
def _measure_all():
address = 0x5e #I2C-address of EE-895
try:
# Create I2C instance and open the bus
EE895 = smbus.SMBus(get_smbus())
_c = EE895.read_word_data(address, 0x0) # co2
_t = EE895.read_word_data(address, 0x2) # temp
_p = EE895.read_word_data(address, 0x6) # pressure
co = _switchBit(_c)
temp = _switchBit(_t) / 100
pressure = _switchBit(_p) / 10
return co, temp, pressure
except Exception as e:
error_log(e,
'Error: Error while reading EE895 Sensor. Is it connected?')
return None, None, None
def measurement():
# dict with all fields and values which will be tranfered to ThingSpeak later
ts_fields = {}
try:
# load settings
settings = get_settings()
# read configured sensors from settings.json
ds18b20Sensors = get_sensors(settings, 0)
bme680Sensors = get_sensors(settings, 1)
weightSensors = get_sensors(settings, 2)
dhtSensors = get_sensors(settings, 3)
tcSensors = get_sensors(settings, 4)
bme280Sensors = get_sensors(settings, 5)
voltageSensors = get_sensors(settings, 6)
ee895Sensors = get_sensors(settings, 7)
aht10Sensors = get_sensors(settings, 8)
sht31Sensors = get_sensors(settings, 9)
hdc1008Sensors = get_sensors(settings, 10)
bme680IsInitialized = {}
# if bme680 is configured
for (sensorIndex, bme680Sensor) in enumerate(bme680Sensors):
bme680IsInitialized[sensorIndex] = 0
bme680IsInitialized[sensorIndex] = initBME680FromMain(bme680Sensor)
ts_fields = measure_all_sensors(False, None, ds18b20Sensors,
bme680Sensors, bme680IsInitialized,
dhtSensors, aht10Sensors, sht31Sensors,
hdc1008Sensors, tcSensors,
bme280Sensors, voltageSensors,
ee895Sensors, weightSensors, None)
return json.dumps(ts_fields)
except Exception as e:
error_log(e, "Unhandled Exception in Measurement 2")
# Error occured
return {}
def measure_ee895(ts_sensor):
fields = {}
try:
#read all values from sensor
co2, temp, pressure = _measure_all()
# ThingSpeak fields
# Create returned dict if ts-field is defined
if 'ts_field' in ts_sensor and isinstance(co2, (int, float)):
fields[ts_sensor["ts_field"]] = round(co2, 2)
if 'ts_field_temperature' in ts_sensor and isinstance(
temp, (int, float)):
fields[ts_sensor["ts_field_temperature"]] = round(temp, 1)
if 'ts_field_air_pressure' in ts_sensor and isinstance(
pressure, (int, float)):
fields[ts_sensor["ts_field_air_pressure"]] = round(pressure, 1)
except OSError:
error_log('Warning: No EE895 Sensor connected.')
except Exception as ex:
error_log(ex, 'Error: Error while measuring EE895 Sensor.')
return fields
def transfer_all_channels_to_ts(ts_channels, ts_fields, server_url, debug):
connectionErrorWithinAnyChannel = []
for (channelIndex, channel) in enumerate(ts_channels, 0):
channel_id = channel["ts_channel_id"]
write_key = channel["ts_write_key"]
if channel_id and write_key:
if debug:
print('Channel ' + str(channelIndex) + ' with ID ' +
str(channel_id))
ts_fields_cleaned = clean_fields(ts_fields, channelIndex, False)
if ts_fields_cleaned:
connectionError = upload_single_channel(
write_key, ts_fields_cleaned, server_url, debug)
connectionErrorWithinAnyChannel.append(connectionError)
else:
error_log(
"Warning: No ThingSpeak data transfer because no fields defined for Channel "
+ str(channelIndex))
else:
error_log("Warning: No ThingSpeak upload for this channel (" +
str(channelIndex) +
") because because channel_id or write_key is None.")
return any(c == True for c in connectionErrorWithinAnyChannel)
GPIO.setup(
gpio, GPIO.IN, pull_up_down=GPIO.PUD_DOWN
) # Set pin 16 to be an input pin and set initial value to be pulled low (off)
bouncetime = 300 # ignoring further edges for 300ms for switch bounce handling
# register button press event
GPIO.add_event_detect(gpio,
GPIO.BOTH,
callback=button_pressed,
bouncetime=bouncetime)
# Main Lopp: Cancel with STRG+C
while True:
time.sleep(0.2) # wait 200 ms to give CPU chance to do other things
pass
print("This text will never be printed.")
if __name__ == '__main__':
try:
main()
except (KeyboardInterrupt, SystemExit):
close_script()
except Exception as e:
error_log(e, "Unhandled Exception in Main")
if not debug:
time.sleep(60)
reboot()
def position_enum_values():
starttime = time.time()
csvfile = utilities.opencsv()
api_url, headers = utilities.login()
for i, row in enumerate(csvfile, 1):
try:
enum_value_uri = row[0]
desired_position = row[1]
get_enum_value = requests.get(api_url + enum_value_uri,
headers=headers).json()
enum_value_json = requests.post(
api_url + enum_value_uri + '/position?position=' +
desired_position,
headers=headers,
data=json.dumps(get_enum_val)).json()
except Exception as exc:
logging.debug(record_uri)
logging.exception('Error: ')
print(record_uri)
print(traceback.format_exc())
logging.debug('Total update attempts: ' + str(i))
logging.debug('Records updated successfully: ' + str(x))
print('All Done!')
print('Total update attempts: ' + str(i))
print('Records updated successfully: ' + str(x))
utilities.keeptime(starttime)
if __name__ == "__main__":
utilities.error_log()
position_enum_values()
# ThingSpeak fields
# Create returned dict if ts-field is defined
if 'ts_field' in ts_sensor and isinstance(co2, (int, float)):
fields[ts_sensor["ts_field"]] = round(co2, 2)
if 'ts_field_temperature' in ts_sensor and isinstance(
temp, (int, float)):
fields[ts_sensor["ts_field_temperature"]] = round(temp, 1)
if 'ts_field_air_pressure' in ts_sensor and isinstance(
pressure, (int, float)):
fields[ts_sensor["ts_field_air_pressure"]] = round(pressure, 1)
except OSError:
error_log('Warning: No EE895 Sensor connected.')
except Exception as ex:
error_log(ex, 'Error: Error while measuring EE895 Sensor.')
return fields
if __name__ == '__main__':
try:
# just for testing the values
print(measure_raw())
except (KeyboardInterrupt, SystemExit):
pass
except Exception as e:
error_log(e, "Unhandled Exception in EE895 Measurement")
def start_measurement(measurement_stop):
try:
start_time = time.time()
# load settings
settings = get_settings()
# ThingSpeak data
channel_id = settings["ts_channel_id"]
write_key = settings["ts_write_key"]
interval = settings["interval"]
debug = settings[
"debug"] # flag to enable debug mode (HDMI output enabled and no rebooting)
shutdownAfterTransfer = settings["shutdownAfterTransfer"]
offline = settings["offline"] # flag to enable offline csv storage
if debug:
print("Debug-Mode is enabled.")
error_log("Info: The measurements have started.")
# with process shared variables
connectionErrors = Value('i', 0)
measurementIsRunning = Value('i', 0)
if interval and not isinstance(
interval,
int) or interval == 0 or not channel_id or not write_key:
error_log(
"Info: No measurement because ThingSpeak settings are not complete or measurement interval is null."
)
measurement_stop.set()
# read configured sensors from settings.json
ds18b20Sensors = get_sensors(settings, 0)
bme680Sensors = get_sensors(settings, 1)
weightSensors = get_sensors(settings, 2)
dhtSensors = get_sensors(settings, 3)
tcSensors = get_sensors(settings, 4)
bme280Sensors = get_sensors(settings, 5)
# -- Run Pre Configuration --
# if bme680 is configured
if bme680Sensors and len(bme680Sensors) == 1:
bme680IsInitialized = initBME680FromMain()
else:
bme680IsInitialized = 0
# if hx711 is set
hxInits = []
for (i, sensor) in enumerate(weightSensors):
_hx = init_hx711(sensor, debug)
hxInits.append(_hx)
# ThingSpeak channel
channel = thingspeak.Channel(id=channel_id, write_key=write_key)
# start at -6 because we want to get 6 values before we can filter some out
counter = -6
time_measured = 0
while not measurement_stop.is_set():
counter += 1
# read values from sensors every second
for (sensorIndex, sensor) in enumerate(ds18b20Sensors):
checkIfSensorExistsInArray(sensorIndex)
if 'device_id' in sensor:
read_unfiltered_temperatur_values(sensorIndex,
sensor['device_id'])
# wait seconds of interval before next check
# free ThingSpeak account has an upload limit of 15 seconds
time_now = time.time()
isTimeToMeasure = (time_now - time_measured >= interval
) and counter > 0 # old: counter%interval == 0
if isTimeToMeasure or interval == 1:
now = time.strftime("%H:%M", time.localtime(time_now))
lastMeasurement = time.strftime("%H:%M",
time.localtime(time_measured))
if time_measured == 0:
print("First time measurement. Now: " + str(now))
else:
print("Last measurement was at " + str(lastMeasurement))
print("Time over for a new measurement. Time is now: " +
str(now))
time_measured = time.time()
if measurementIsRunning.value == 0:
q = Queue()
p = Process(target=measure,
args=(offline, debug, channel,
filtered_temperature, ds18b20Sensors,
bme680Sensors, bme680IsInitialized,
dhtSensors, tcSensors, bme280Sensors,
weightSensors, hxInits, connectionErrors,
measurementIsRunning))
p.start()
p.join()
else:
error_log(
"Warning: Forerun measurement is not finished yet. Consider increasing interval."
)
# stop measurements after uploading once
if interval == 1:
print("Only one measurement was set => stop measurements.")
measurement_stop.set()
if shutdownAfterTransfer:
print(
"Shutting down was set => Waiting 10seconds and then shutdown."
)
time.sleep(10)
shutdown()
time.sleep(6) # wait 6 seconds before next measurement check
end_time = time.time()
time_taken = end_time - start_time # time_taken is in seconds
time_taken_s = float(
"{0:.2f}".format(time_taken)) # remove microseconds
print("Measurement-Script runtime was " + str(time_taken_s) +
" seconds.")
except Exception as e:
error_log(e, "Unhandled Exception while Measurement")
if not debug:
time.sleep(10)
reboot()
def measure_all_sensors(debug, filtered_temperature, ds18b20Sensors,
bme680Sensors, bme680IsInitialized, dhtSensors,
aht10Sensors, sht31Sensors, hdc1008Sensors, tcSensors,
bme280Sensors, voltageSensors, ee895Sensors,
weightSensors, hxInits):
ts_fields = {
} # dict with all fields and values which will be tranfered to ThingSpeak later
try:
# measure every sensor with type 0 (Ds18b20)
try:
for (sensorIndex, sensor) in enumerate(ds18b20Sensors):
filter_temperatur_values(sensorIndex)
except Exception as e:
error_log(
e,
"Unhandled Exception in measure_all_sensors / ds18b20Sensors filter_temperatur_values"
)
try:
for (sensorIndex, sensor) in enumerate(ds18b20Sensors):
if filtered_temperature is not None and len(
filtered_temperature[sensorIndex]
) > 0 and 'ts_field' in sensor:
# if we have at leat one filtered value we can upload
ds18b20_temperature = filtered_temperature[
sensorIndex].pop()
if sensor["ts_field"] and ds18b20_temperature is not None:
if 'offset' in sensor and sensor["offset"] is not None:
ds18b20_temperature = ds18b20_temperature - float(
sensor["offset"])
ds18b20_temperature = float("{0:.2f}".format(
ds18b20_temperature)) # round to two decimals
ts_fields.update(
{sensor["ts_field"]: ds18b20_temperature})
elif 'ts_field' in sensor:
# Case for filtered_temperature was not filled, use direct measured temperture in this case
ds18b20_temperature = measure_temperature(sensor)
if sensor["ts_field"] and ds18b20_temperature is not None:
if 'offset' in sensor and sensor["offset"] is not None:
ds18b20_temperature = ds18b20_temperature - float(
sensor["offset"])
ds18b20_temperature = float("{0:.2f}".format(
ds18b20_temperature)) # round to two decimals
ts_fields.update(
{sensor["ts_field"]: ds18b20_temperature})
except Exception as e:
error_log(
e,
"Unhandled Exception in measure_all_sensors / ds18b20Sensors")
# measure BME680 (can only be one) [type 1]
for (sensorIndex, bme680Sensor) in enumerate(bme680Sensors):
if bme680IsInitialized[sensorIndex]:
bme680_values = measure_bme680(bme680Sensor, 30)
ts_fields.update(bme680_values)
# measure every sensor with type 3 [DHT11/DHT22]
for (i, sensor) in enumerate(dhtSensors):
tempAndHum = measure_dht(sensor)
ts_fields.update(tempAndHum)
# measure every sensor with type 4 [MAX6675]
for (i, sensor) in enumerate(tcSensors):
tc_temp = measure_tc(sensor)
ts_fields.update(tc_temp)
# measure BME280 (can only be one) [type 5]
if bme280Sensors and len(bme280Sensors) == 1:
bme280_values = measure_bme280(bme280Sensors[0])
ts_fields.update(bme280_values)
# measure YL-40 PFC8591 (can only be one) [type 6]
if voltageSensors and len(voltageSensors) == 1:
voltage = measure_voltage(voltageSensors[0])
if voltage is not None:
ts_fields.update(voltage)
# measure EE895 (can only be one) [type 7]
if ee895Sensors and len(ee895Sensors) == 1:
ee895_values = measure_ee895(ee895Sensors[0])
if ee895_values is not None:
ts_fields.update(ee895_values)
# measure AHT10 (can only be one) [type 8]
if aht10Sensors and len(aht10Sensors) == 1:
aht10_fields = measure_aht10(aht10Sensors[0])
if aht10_fields is not None:
ts_fields.update(aht10_fields)
# measure sht31 (can only be one) [type 9]
if sht31Sensors and len(sht31Sensors) == 1:
sht31_fields = measure_sht31(sht31Sensors[0])
if sht31_fields is not None:
ts_fields.update(sht31_fields)
# measure hdc1008 (can only be one) [type 10]
if hdc1008Sensors and len(hdc1008Sensors) == 1:
hdc1008_fields = measure_hdc1008(hdc1008Sensors[0])
if hdc1008_fields is not None:
ts_fields.update(hdc1008_fields)
# measure every sensor with type 2 [HX711]
start_single()
for (i, sensor) in enumerate(weightSensors):
if hxInits is not None:
weight = measure_weight(sensor, hxInits[i], debug)
weight = compensate_temperature(sensor, weight, ts_fields)
ts_fields.update(weight)
else:
weight = measure_weight(sensor)
weight = compensate_temperature(sensor, weight, ts_fields)
ts_fields.update(weight)
stop_single()
# print all measurement values stored in ts_fields
if debug:
for key, value in ts_fields.items():
print(key + ": " + str(value))
return ts_fields
except Exception as ex:
error_log(ex, "Exception during measurement 1")
return ts_fields
from read_hx711 import measure_weight
from utilities import start_single, stop_single, blockPrinting, error_log
import sys
@blockPrinting
def get_weight(sensor):
start_single()
weight = measure_weight(sensor)
stop_single()
# return weight in gramms
return weight
if __name__ == '__main__':
try:
weight_sensor = {}
weight_sensor["pin_dt"] = int(sys.argv[1])
weight_sensor["pin_sck"] = int(sys.argv[2])
weight_sensor["channel"] = sys.argv[3]
weight_sensor["offset"] = 0
weight_sensor["reference_unit"] = 1
print(get_weight(weight_sensor))
except (KeyboardInterrupt, SystemExit):
pass
except Exception as e:
error_log(e, "Unhandled Exception in Weight Measurement")
def measure(offline, debug, channel, filtered_temperature, ds18b20Sensors,
bme680Sensors, bme680IsInitialized, dhtSensors, tcSensors,
bme280Sensors, weightSensors, hxInits, connectionErrors,
measurementIsRunning):
measurementIsRunning.value = 1 # set flag
# filter the values out
for (sensorIndex, sensor) in enumerate(ds18b20Sensors):
filter_temperatur_values(sensorIndex)
# dict with all fields and values which will be tranfered to ThingSpeak later
ts_fields = {}
# measure every sensor with type 0
for (sensorIndex, sensor) in enumerate(ds18b20Sensors):
# if we have at leat one filtered value we can upload
if len(filtered_temperature[sensorIndex]) > 0 and 'ts_field' in sensor:
ds18b20_temperature = filtered_temperature[sensorIndex].pop(
) # get last value from array
ts_field_ds18b20 = sensor["ts_field"]
if ts_field_ds18b20:
ts_fields.update({ts_field_ds18b20: ds18b20_temperature})
# measure BME680 (can only be one) [type 1]
if bme680Sensors and len(bme680Sensors) == 1 and bme680IsInitialized:
bme680_values = measure_bme680(bme680Sensors[0], 30)
ts_fields.update(bme680_values)
# measure every sensor with type 3 [DHT11/DHT22]
for (i, sensor) in enumerate(dhtSensors):
tempAndHum = measure_dht(sensor)
ts_fields.update(tempAndHum)
# measure every sensor with type 4 [MAX6675]
for (i, sensor) in enumerate(tcSensors):
tc_temp = measure_tc(sensor)
ts_fields.update(tc_temp)
# measure BME280 (can only be one) [type 5]
if bme280Sensors and len(bme280Sensors) == 1:
bme280_values = measure_bme280(bme280Sensors[0])
ts_fields.update(bme280_values)
start_single()
# measure every sensor with type 2 [HX711]
for (i, sensor) in enumerate(weightSensors):
weight = measure_weight(sensor, hxInits[i])
weight = compensate_temperature(sensor, weight, ts_fields)
ts_fields.update(weight)
stop_single()
# print all measurement values stored in ts_fields
for key, value in ts_fields.items():
print(key + ": " + str(value))
if len(ts_fields) > 0:
if offline == 1 or offline == 3:
try:
s = write_csv(ts_fields)
if s and debug:
error_log("Info: Data succesfully saved to CSV-File.")
except Exception as ex:
error_log(ex, "Exception")
# if transfer to thingspeak is set
if offline == 0 or offline == 1 or offline == 2:
# do-while to retry failed transfer
retries = 0
connectionError = True
while True:
try:
# update ThingSpeak / transfer values
channel.update(ts_fields)
if debug:
error_log(
"Info: Data succesfully transfered to ThingSpeak.")
if connectionErrors.value > 0:
if debug:
error_log("Info: Connection Errors (" +
str(connectionErrors.value) +
") Counting resetet.")
# reset connectionErrors because transfer succeded
connectionErrors.value = 0
# break do-while because transfer succeded
connectionError = False
break
except requests.exceptions.HTTPError as errh:
error_log(errh, "Http Error")
except requests.exceptions.ConnectionError as errc:
pass
except requests.exceptions.Timeout as errt:
error_log(errt, "Timeout Error")
except requests.exceptions.RequestException as err:
error_log(err, "Something Else")
except Exception as ex:
error_log(ex, "Exception while sending Data")
finally:
if connectionError:
print(
"Warning: Waiting for internet connection to try transfer again..."
)
wait_for_internet_connection(
15) # wait before next try
retries += 1
# Maximum 3 retries
if retries >= 3:
break # break do-while
if connectionError:
# Write to CSV-File if ConnectionError occured
if offline == 2:
s = write_csv(ts_fields)
if s and debug:
error_log("Info: Data succesfully saved to CSV-File.")
# Do Rebooting if to many connectionErrors in a row
connectionErrors.value += 1
error_log("Error: Failed internet connection. Count: " +
str(connectionErrors.value))
if connectionErrors.value >= 5:
if not debug:
error_log(
"Info: Too many ConnectionErrors in a row => Rebooting"
)
time.sleep(4)
reboot()
else:
error_log(
"Info: Did not reboot because debug mode is enabled."
)
elif debug:
error_log("Info: No measurement data to send.")
measurementIsRunning.value = 0 # clear flag
# if bme680 is configured
for (sensorIndex, bme680Sensor) in enumerate(bme680Sensors):
bme680IsInitialized[sensorIndex] = 0
bme680IsInitialized[sensorIndex] = initBME680FromMain(bme680Sensor)
ts_fields = measure_all_sensors(False, None, ds18b20Sensors,
bme680Sensors, bme680IsInitialized,
dhtSensors, aht10Sensors, sht31Sensors,
hdc1008Sensors, tcSensors,
bme280Sensors, voltageSensors,
ee895Sensors, weightSensors, None)
return json.dumps(ts_fields)
except Exception as e:
error_log(e, "Unhandled Exception in Measurement 2")
# Error occured
return {}
if __name__ == '__main__':
try:
print(measurement())
except (KeyboardInterrupt, SystemExit):
pass
except Exception as e:
error_log(e, "Unhandled Exception in Measurement 3")
# Create returned dict if ts_field is defined
if 'ts_field_temperature' in ts_sensor and isinstance(
temperature, (int, float)):
if 'offset' in ts_sensor and ts_sensor["offset"] is not None:
temperature = temperature - ts_sensor["offset"]
fields[ts_sensor["ts_field_temperature"]] = round(temperature, 2)
if 'ts_field_humidity' in ts_sensor and isinstance(
humidity, (int, float)):
fields[ts_sensor["ts_field_humidity"]] = round(humidity, 2)
return fields
except Exception as e:
error_log(e,
'Error: Error while reading SHT3x Sensor. Is it connected?')
return None
if __name__ == '__main__':
try:
cTemp, humidity = read_sht31(DEVICE)
print("Temperature:", cTemp, "C")
print("Humidity:", humidity, "%RH")
except (KeyboardInterrupt, SystemExit):
pass
except Exception as e:
error_log(e, "Unhandled Exception in SHT31 Measurement")
def upload_single_channel(write_key, ts_fields_cleaned, server_url, debug):
# do-while to retry failed transfer
retries = 0
MAX_RETRIES = 3
isConnectionError = True
while isConnectionError:
try:
thingspeak_update(write_key, ts_fields_cleaned, server_url)
if debug:
error_log("Info: Data succesfully transfered to ThingSpeak.")
# break because transfer succeded
isConnectionError = False
break
except requests.exceptions.HTTPError as errh:
error_log(errh,
"Warning: Propaply a wrong ThingSpeak WRITE API-Key.")
except requests.exceptions.ConnectionError as errc:
pass
except requests.exceptions.Timeout as errt:
error_log(errt, "Error: Timeout Error")
except requests.exceptions.RequestException as err:
error_log(err, "Error: Something Else")
except Exception as ex:
error_log(ex, "Error: Exception while sending Data")
finally:
if isConnectionError:
retries += 1
# Break after 3 retries
if retries > MAX_RETRIES:
break
error_log(
"Warning: Waiting 15 seconds for internet connection to try transfer again ("
+ str(retries) + "/" + str(MAX_RETRIES) + ")...")
wait_for_internet_connection(15)
return isConnectionError
os.system("sudo dmesg | grep USB >> /tmp/diag.txt")
os.system("sudo dmesg | grep ttyUSB >> /tmp/diag.txt")
os.system("echo '\n\nttyUSB*:\n' >> /tmp/diag.txt")
os.system("sudo ls -la /dev/ttyUSB* >> /tmp/diag.txt")
os.system("echo '\n\nlog:\n' >> /tmp/diag.txt")
os.system(
"sudo grep -a -B 2 -A 2 'usb_modeswitch\|modem\|pppd\|PPP\|ppp0\|ttyUSB0\|wvdial' /var/log/messages >> /tmp/diag.txt"
)
os.system("echo '\n\nFirmware:\n' >> /tmp/diag.txt")
os.system("sudo uname -a >> /tmp/diag.txt")
with io.open("/tmp/diag.txt", encoding="utf-8") as data_file:
diag = data_file.read()
return diag
except Exception as e:
error_log(e, "Unhandled Exception in diag")
# Error occured
return diag
if __name__ == '__main__':
try:
print(diag())
except (KeyboardInterrupt, SystemExit):
pass
except Exception as e:
error_log(e, "Unhandled Exception in diag")
