def main():
variables = {
'PC IP': {
'type': 'string',
'value': False,
'bind': ping_pc,
},
'PC WoL': {
'type': 'bool',
'value': False,
'bind': wake_pc,
},
'CPU Temp': {
'type': 'numeric',
'bind': chip.cpu_temp
}
}
# Put system data declarations here
diagnostics = {
'IP Address': chip.ip_address,
'Host': gethostname(),
'Operating System': " ".join(uname())
}
device = cloud4rpi.connect(DEVICE_TOKEN)
device.declare(variables)
device.declare_diag(diagnostics)
device.publish_config()
# adds a 1 second delay to ensure device variables are created
sleep(1)
try:
diag_timer = 0
data_timer = 0
while True:
if data_timer <= 0:
device.publish_data()
data_timer = DATA_SENDING_INTERVAL
if diag_timer <= 0:
device.publish_diag()
diag_timer = DIAG_SENDING_INTERVAL
diag_timer -= POLL_INTERVAL
data_timer -= POLL_INTERVAL
sleep(POLL_INTERVAL)
except KeyboardInterrupt:
cloud4rpi.log.info('Keyboard interrupt received. Stopping...')
except Exception as e:
error = cloud4rpi.get_error_message(e)
cloud4rpi.log.error("ERROR! %s %s", error, sys.exc_info()[0])
sys.exit(1)
finally:
sys.exit(0)
def main():
rgb.init()
# Put variable declarations here
variables = {
'Omega LED': {
'type': 'bool',
'value': False,
'bind': o2.led_control
},
'RGB LED - Red': {
'type': 'numeric',
'value': 0,
'bind': rgb.set_R
},
'RGB LED - Green': {
'type': 'numeric',
'value': 0,
'bind': rgb.set_G
},
'RGB LED - Blue': {
'type': 'numeric',
'value': 0,
'bind': rgb.set_B
}
}
# Put system data declarations here
diagnostics = {
'Host': gethostname(),
'Operating System': " ".join(uname()),
'Omega2 Version': 'Omega2 Plus' if 'p' in o2.version else 'Omega2',
'Client Version:': cloud4rpi.__version__
}
device = cloud4rpi.connect(DEVICE_TOKEN)
device.declare(variables)
device.declare_diag(diagnostics)
device.publish_config()
# Adds a 1 second delay to ensure device variables are created
sleep(1)
try:
device.publish_diag()
while True:
device.publish_data()
sleep(DATA_SENDING_INTERVAL)
except KeyboardInterrupt:
cloud4rpi.log.info('Keyboard interrupt received. Stopping...')
sys.exit(0)
except Exception as e:
error = cloud4rpi.get_error_message(e)
cloud4rpi.log.error("ERROR! %s %s", error, sys.exc_info()[0])
sys.exit(1)
def main():
# Put variable declarations here
variables = {
'Gravity': {
'type': 'numeric',
'bind': getGravity
},
'Beer Temp': {
'type': 'numeric',
'bind': getTemp
}
}
diagnostics = {
'CPU Temp': rpi.cpu_temp,
'IP Address': rpi.ip_address,
'Host': gethostname(),
'Operating System': " ".join(uname())
}
device = cloud4rpi.connect(DEVICE_TOKEN)
device.declare(variables)
device.declare_diag(diagnostics)
device.publish_config()
# Adds a 1 second delay to ensure device variables are created
time.sleep(1)
try:
data_timer = 0
diag_timer = 0
while True:
if data_timer <= 0:
global beacon
beacon = tilt.getFirstTilt()
device.publish_data()
data_timer = DATA_SENDING_INTERVAL
if diag_timer <= 0:
device.publish_diag()
diag_timer = DIAG_SENDING_INTERVAL
time.sleep(POLL_INTERVAL)
diag_timer -= POLL_INTERVAL
data_timer -= POLL_INTERVAL
except KeyboardInterrupt:
cloud4rpi.log.info('Keyboard interrupt received. Stopping...')
except Exception as e:
error = cloud4rpi.get_error_message(e)
cloud4rpi.log.error("ERROR! %s %s", error, sys.exc_info()[0])
finally:
sys.exit(0)
def main():
# Put variable declarations here
# Available types: 'bool', 'numeric', 'string', 'location'
variables = {
'Room Temp': {
'type': 'numeric',
'bind': room_temp
},
'Outside Temp': {
'type': 'numeric',
'bind': outside_temp
}
}
# Put system data declarations here
diagnostics = {
'CPU Temp': cpu_temp,
'IP Address': ip_address,
'Host Name': hostname,
'Operating System': osname
}
device = cloud4rpi.connect(DEVICE_TOKEN)
device.declare(variables)
device.declare_diag(diagnostics)
device.publish_config()
# Adds a 1 second delay to ensure device variables are created
sleep(1)
try:
diag_timer = 0
data_timer = 0
while True:
if data_timer <= 0:
device.publish_data()
data_timer = DATA_SENDING_INTERVAL
if diag_timer <= 0:
device.publish_diag()
diag_timer = DIAG_SENDING_INTERVAL
diag_timer -= POLL_INTERVAL
data_timer -= POLL_INTERVAL
sleep(POLL_INTERVAL)
except KeyboardInterrupt:
cloud4rpi.log.info('Keyboard interrupt received. Stopping...')
except Exception as e:
error = cloud4rpi.get_error_message(e)
cloud4rpi.log.error("ERROR! %s %s", error, sys.exc_info()[0])
finally:
sys.exit(0)
def main():
# Put variable declarations here
variables = {
'Room Temp': {
'type': 'numeric',
'bind': room_temp
},
'Outside Temp': {
'type': 'numeric',
'bind': outside_temp
}
}
# Put system data declarations here
diagnostics = {
'CPU Temp': cpu_temp,
'IP Address': ip_address,
'Host Name': hostname,
'Operating System': osname
}
device = cloud4rpi.connect(DEVICE_TOKEN)
device.declare(variables)
device.declare_diag(diagnostics)
device.publish_config()
# Adds a 1 second delay to ensure device variables are created
sleep(1)
try:
diag_timer = 0
data_timer = 0
while True:
if data_timer <= 0:
device.publish_data()
data_timer = DATA_SENDING_INTERVAL
if diag_timer <= 0:
device.publish_diag()
diag_timer = DIAG_SENDING_INTERVAL
diag_timer -= POLL_INTERVAL
data_timer -= POLL_INTERVAL
sleep(POLL_INTERVAL)
except KeyboardInterrupt:
cloud4rpi.log.info('Keyboard interrupt received. Stopping...')
except Exception as e:
error = cloud4rpi.get_error_message(e)
cloud4rpi.log.error("ERROR! %s %s", error, sys.exc_info()[0])
finally:
sys.exit(0)
def main():
o2 = omega2.Omega2()
# Put variable declarations here
variables = {
'Omega LED': {
'type': 'bool',
'value': False,
'bind': o2.led_control
}
}
# Put system data declarations here
diagnostics = {
'Host': gethostname(),
'Operating System': " ".join(uname()),
'Omega2 version': 'Omega2 Plus' if 'p' in o2.version else 'Omega2'
}
device = cloud4rpi.connect(DEVICE_TOKEN)
device.declare(variables)
device.declare_diag(diagnostics)
device.publish_config()
try:
device.publish_diag()
while True:
device.publish_data()
sleep(DATA_SENDING_INTERVAL)
except KeyboardInterrupt:
cloud4rpi.log.info('Keyboard interrupt received. Stopping...')
sys.exit(0)
except Exception as e:
error = cloud4rpi.get_error_message(e)
cloud4rpi.log.error("ERROR! %s %s", error, sys.exc_info()[0])
sys.exit(1)
def main():
try:
lastrun = time.time() - 300
device = cloud4rpi.connect(CLOUD4RPI_DEVICE_TOKEN)
epd = epd2in13_V2.EPD()
epd.init(epd.FULL_UPDATE)
# epd.Clear(0xFF)
image = Image.new("1", (epd.height, epd.width), 255) # 255: clear the frame
draw = ImageDraw.Draw(image)
epd.displayPartBaseImage(epd.getbuffer(image))
epd.init(epd.PART_UPDATE)
while True:
status, remitdata = InstaRemRate()
if status:
rate_instarem = round(remitdata["destination_amount"]/1000, 2)
fx_rate = round(remitdata["fx_rate"], 2)
else:
rate_instarem = 0
# Remitly
status, rate_remitly = RemitlyRate()
# Xoom
status, rate_xoom = XoomRate()
# Ria Rate
status, rate_ria = RiaRate()
datetime = time.strftime("%m/%d/%y %H:%M:%S")
print(f"FX Rate: {fx_rate} Instarem: {rate_instarem} Remitly: {rate_remitly} Xoom: {rate_xoom} Ria: {rate_ria} Last Updated {datetime}")
draw.rectangle([(0, 0), (epd.height, 26)], fill=255)
draw.text((0, 0), f"$1 = {fx_rate}", font=font24, fill=0)
draw.text((140, 2), time.strftime("%m/%d %H:%M"), font=font20, fill=0)
draw.line([(0, 30), (epd.height, 30)], fill=0, width=1)
rate_all = {
"instarem": rate_instarem,
"remitly": rate_remitly,
"xoom": rate_xoom,
"ria": rate_ria
}
rate_sorted = sorted(rate_all.items(), key=lambda x: x[1], reverse=True)
draw.rectangle([(0, 75), (epd.height, 105)], fill=255)
ypos_icon = 10
ypos_rate = 0
space_icon = 65
for name, rate in rate_sorted:
image.paste(get_icon(name), (ypos_icon, 40))
if rate != 0:
draw.text((ypos_rate, 75), str(rate), font=font20, fill=0)
ypos_icon += space_icon
ypos_rate += space_icon
draw.rectangle((0, 104, 249, 121), fill=255, outline=0)
epd.displayPartial(epd.getbuffer(image))
currentperf = time.time()
try:
diagnostics = {
"CPU Temp": rpi.cpu_temp,
"IP Address": rpi.ip_address,
"Host": rpi.host_name,
"Operating System": rpi.os_name,
"Client Version:": cloud4rpi.__version__,
}
variables = {
"Fx Rate": {
"type": "numeric",
"value": fx_rate if fx_rate != 0 else ""
},
"Instarem": {
"type": "numeric",
"value": rate_instarem if rate_instarem != 0 else ""
},
"Remitly": {
"type": "numeric",
"value": rate_remitly if rate_remitly != 0 else ""
},
"Xoom": {
"type": "numeric",
"value": rate_xoom if rate_xoom != 0 else ""
},
"Ria": {
"type": "numeric",
"value": rate_ria if rate_ria != 0 else ""
}
}
device.declare(variables)
device.declare_diag(diagnostics)
# device.publish_config()
# time.sleep(1)
device.publish_diag()
if currentperf - lastrun > 300:
print("Uploading Data to cloud4rpi")
device.publish_data()
lastrun = time.time()
except Exception as e:
error = cloud4rpi.get_error_message(e)
cloud4rpi.log.exception("ERROR! %s %s", error, sys.exc_info()[0])
for i in range(10, 255, 10):
draw.rectangle((0, 107, i, 118), fill=0)
epd.displayPartial(epd.getbuffer(image))
time.sleep(2)
except KeyboardInterrupt:
epd2in13_V2.epdconfig.module_exit()
exit()
def main():
# Put variable declarations here
# Available types: 'bool', 'numeric', 'string', 'location'
variables = {
'LED On': {
'type': 'bool',
'value': False,
'bind': relay_control
},
}
diagnostics = {
'CPU Temp': rpi.cpu_temp,
'IP Address': rpi.ip_address,
'Host': rpi.host_name,
'Operating System': rpi.os_name,
'Client Version:': cloud4rpi.__version__,
}
device = cloud4rpi.connect(DEVICE_TOKEN)
# Use the following 'device' declaration
# to enable the MQTT traffic encryption (TLS).
#
# tls = {
# 'ca_certs': '/etc/ssl/certs/ca-certificates.crt'
# }
# device = cloud4rpi.connect(DEVICE_TOKEN, tls_config=tls)
try:
device.declare(variables)
device.declare_diag(diagnostics)
device.publish_config()
# Adds a 1 second delay to ensure device variables are created
sleep(1)
data_timer = 0
diag_timer = 0
while True:
if data_timer <= 0:
device.publish_data()
data_timer = DATA_SENDING_INTERVAL
if diag_timer <= 0:
device.publish_diag()
diag_timer = DIAG_SENDING_INTERVAL
sleep(POLL_INTERVAL)
diag_timer -= POLL_INTERVAL
data_timer -= POLL_INTERVAL
except KeyboardInterrupt:
cloud4rpi.log.info('Keyboard interrupt received. Stopping...')
except Exception as e:
error = cloud4rpi.get_error_message(e)
cloud4rpi.log.exception("ERROR! %s %s", error, sys.exc_info()[0])
finally:
sys.exit(0)
def main():
# Load w1 modules
ds18b20.init_w1()
# Detect ds18b20 temperature sensors
ds_sensors = ds18b20.DS18b20.find_all()
# Put variable declarations here
# Available types: 'bool', 'numeric', 'string', 'location'
variables = {
'Room Temp': {
'type': 'numeric',
'bind': ds_sensors[0] if ds_sensors else None
},
# 'Outside Temp': {
# 'type': 'numeric',
# 'bind': ds_sensors[1] if len(ds_sensors) > 1 else None
# },
'LED On': {
'type': 'bool',
'value': False,
'bind': led_control
},
'CPU Temp': {
'type': 'numeric',
'bind': rpi.cpu_temp
},
'STATUS': {
'type': 'string',
'bind': listen_for_events
},
'Eiffel Tower': {
'type': 'location',
'bind': get_location
}
}
diagnostics = {
'CPU Temp': rpi.cpu_temp,
'IP Address': rpi.ip_address,
'Host': rpi.host_name,
'Operating System': rpi.os_name
}
device = cloud4rpi.connect(DEVICE_TOKEN)
# Use the following 'device' declaration
# to enable the MQTT traffic encryption (TLS).
#
# tls = {
# 'ca_certs': '/etc/ssl/certs/ca-certificates.crt'
# }
# device = cloud4rpi.connect(DEVICE_TOKEN, tls_config=tls)
try:
device.declare(variables)
device.declare_diag(diagnostics)
device.publish_config()
# Adds a 1 second delay to ensure device variables are created
sleep(1)
data_timer = 0
diag_timer = 0
while True:
if data_timer <= 0:
device.publish_data()
data_timer = DATA_SENDING_INTERVAL
if diag_timer <= 0:
device.publish_diag()
diag_timer = DIAG_SENDING_INTERVAL
sleep(POLL_INTERVAL)
diag_timer -= POLL_INTERVAL
data_timer -= POLL_INTERVAL
except KeyboardInterrupt:
cloud4rpi.log.info('Keyboard interrupt received. Stopping...')
except Exception as e:
error = cloud4rpi.get_error_message(e)
cloud4rpi.log.exception("ERROR! %s %s", error, sys.exc_info()[0])
finally:
sys.exit(0)
'bind': sysErrorSet
},
'String': {
'type': 'string',
'bind': changeString
}
}
diagnostics = {
'CPU Temp': rpi.cpu_temp,
'IP Address': rpi.ip_address,
'Host': rpi.host_name,
'Operating Sytem': rpi.os_name
}
device = cloud4rpi.connect(DEVICE_TOKEN)
try:
device.declare(variables)
device.declare_diag(diagnostics)
device.publish_config()
print('Cloud Connected!')
except Exception as e:
error = cloud4rpi.get_error_message(e)
cloud4rpi.log.exception("ERROR! %s %s", error, sys.exc_info()[0])
print('Cloud Connection Error!')
#-----------------------------------------------------------
def main():
# initialize lcd
# drivelcd.lcd_init()
# Load w1 modules
ds18b20.init_w1()
# Detect ds18b20 temperature sensors
ds_sensors = ds18b20.DS18b20.find_all()
# Put variable declarations here
# Available types: 'bool', 'numeric', 'string'
variables = {
'Temp1': {
'type': 'numeric',
'bind': ds_sensors[0] if ds_sensors else None
},
'Temp2': {
'type': 'numeric',
'bind': ds_sensors[1] if len(ds_sensors) > 1 else None
},
'Temp3': {
'type': 'numeric',
'bind': ds_sensors[2] if len(ds_sensors) > 1 else None
},
'Temp4': {
'type': 'numeric',
'bind': ds_sensors[3] if len(ds_sensors) > 1 else None
},
'Temp5': {
'type': 'numeric',
'bind': ds_sensors[4] if len(ds_sensors) > 1 else None
},
'CPU Temp': {
'type': 'numeric',
'bind': rpi.cpu_temp
},
'STATUS': {
'type': 'string',
'bind': listen_for_events
}
# 'LED On': {
# 'type': 'bool',
# 'value': False,
# 'bind': led_control#
# },
}
diagnostics = {
'CPU Temp': rpi.cpu_temp,
'IP Address': rpi.ip_address,
'Host': rpi.host_name,
'Operating System': rpi.os_name
}
device = cloud4rpi.connect(DEVICE_TOKEN)
# Use the following 'device' declaration
# to enable the MQTT traffic encryption (TLS).
#
# tls = {
# 'ca_certs': '/etc/ssl/certs/ca-certificates.crt'
# }
# device = cloud4rpi.connect(DEVICE_TOKEN, tls_config=tls)
try:
device.declare(variables)
device.declare_diag(diagnostics)
device.publish_config()
# Adds a 1 second delay to ensure device variables are created
sleep(1)
data_timer = 0
diag_timer = 0
while True:
if data_timer <= 0:
device.publish_data()
data_timer = DATA_SENDING_INTERVAL
if diag_timer <= 0:
device.publish_diag()
diag_timer = DIAG_SENDING_INTERVAL
sleep(POLL_INTERVAL)
diag_timer -= POLL_INTERVAL
data_timer -= POLL_INTERVAL
temp1 = variables['Temp1']
tempuno = str(temp1.get("value"))
temp2 = variables['Temp2']
tempdos = str(temp2.get("value"))
page1 = 'GlyRes:' + str(tempuno) + '\nGlyRet:' + str(tempdos)
temp3 = variables['Temp3']
temptre = str(temp3.get("value"))
temp4 = variables['Temp4']
tempcua = str(temp4.get("value"))
page2 = 'CompTop:' + str(temptre) + '\nCompBot:' + str(tempcua)
temp5 = variables['Temp5']
tempcin = str(temp5.get("value"))
cputemp = variables['CPU Temp']
cputemp = str(cputemp.get("value"))
page3 = 'Ambient:' + str(tempcin) + '\nCPU:' + str(cputemp)
lcd.message(page1)
sleep(5.0)
lcd.clear()
lcd.message(page2)
sleep(3.0)
lcd.clear()
lcd.message(page3)
sleep(3.0)
lcd.clear()
except KeyboardInterrupt:
cloud4rpi.log.info('Keyboard interrupt received. Stopping...')
except Exception as e:
error = cloud4rpi.get_error_message(e)
cloud4rpi.log.exception("ERROR! %s %s", error, sys.exc_info()[0])
finally:
sys.exit(0)
def main():
# Put variable declarations here
# Available types: 'bool', 'numeric', 'string'
variables = {
##### RASP PI ######
'CPU Temp': {
'type': 'numeric',
'bind': rpi.cpu_temp
},
##### NETWORK ######
'Network Latency': {
'type': 'numeric',
'bind': network_latency
},
'Localnet Latency': {
'type': 'numeric',
'bind': localnet_latency
},
'Hosts Up': {
'type': 'numeric',
'bind': hosts_up
},
##### WEMO ######
'WEMO Online': {
'type': 'numeric',
'bind': wemo_online
},
'UPS State': {
'type': 'bool',
'bind': wemo_status
},
##### UPS ######
'UPS Line Voltage': {
'type': 'numeric',
'bind': line_voltage
},
'UPS LoadPCT': {
'type': 'numeric',
'bind': loadpct
},
'UPS Last On Battery': {
'type': 'string',
'bind': xonbatt
},
'UPS Last Off Battery': {
'type': 'string',
'bind': xoffbatt
},
'UPS Last Transfer': {
'type': 'string',
'bind': lastxfer
},
##### 4G ROUTER ######
'GSM Rssi': {
'type': 'numeric',
'bind': gsm_rssi
},
'GSM Rsrq': {
'type': 'numeric',
'bind': gsm_rsrq
},
'GSM Rsrp': {
'type': 'numeric',
'bind': gsm_rsrp
},
'GSM Band': {
'type': 'numeric',
'bind': gsm_band
},
'GSM Signal': {
'type': 'numeric',
'bind': gsm_signal
},
'GSM Mode': {
'type': 'string',
'bind': gsm_mode
},
'GSM Status': {
'type': 'string',
'bind': gsm_status
},
####### ARLO ########
'Arlo Base Station Status': {
'type': 'bool',
'bind': arlo_basestationstatus
},
'Arlo Camera 0 Status': {
'type': 'bool',
'bind': arlo_camera_0_connectionstate
},
'Arlo Camera 0 Battery Level': {
'type': 'numeric',
'bind': arlo_camera_0_batterylevel
},
'Arlo Camera 0 Signal Strength': {
'type': 'numeric',
'bind': arlo_camera_0_signalstrength
},
'Arlo Camera 1 Status': {
'type': 'bool',
'bind': arlo_camera_1_connectionstate
},
'Arlo Camera 1 Battery Level': {
'type': 'numeric',
'bind': arlo_camera_1_batterylevel
},
'Arlo Camera 1 Signal Strength': {
'type': 'numeric',
'bind': arlo_camera_1_signalstrength
},
}
diagnostics = {
'IP Address': rpi.ip_address,
'Host': rpi.host_name,
'Operating System': rpi.os_name,
}
tls = {
'ca_certs': '/etc/ssl/certs/ca-certificates.crt'
}
device = cloud4rpi.connect(DEVICE_TOKEN, tls_config=tls)
try:
device.declare(variables)
device.declare_diag(diagnostics)
device.publish_config()
# Adds a 1 second delay to ensure device variables are created
sleep(1)
data_timer = 0
diag_timer = 0
while True:
if data_timer <= 0:
update_gsm()
apcaccess()
arlo_updatecamerasstate()
update_wemo()
device.publish_data()
data_timer = DATA_SENDING_INTERVAL
if diag_timer <= 0:
device.publish_diag()
diag_timer = DIAG_SENDING_INTERVAL
sleep(POLL_INTERVAL)
diag_timer -= POLL_INTERVAL
data_timer -= POLL_INTERVAL
except KeyboardInterrupt:
cloud4rpi.log.info('Keyboard interrupt received. Stopping...')
except Exception as e:
error = cloud4rpi.get_error_message(e)
cloud4rpi.log.exception("ERROR! %s %s", error, sys.exc_info()[0])
finally:
sys.exit(0)
def main():
# load w1 modules
ds18b20.init_w1()
# detect ds18b20 temperature sensors
ds_sensors = ds18b20.DS18b20.find_all()
# Put variable declarations here
variables = {
'Room Temp': {
'type': 'numeric',
'bind': ds_sensors[0] if ds_sensors else None
},
# 'Outside Temp': {
# 'type': 'numeric',
# 'bind': ds_sensors[1] if len(ds_sensors) > 1 else None
# },
'LED On': {
'type': 'bool',
'value': False,
'bind': led_control
},
'CPU Temp': {
'type': 'numeric',
'bind': rpi.cpu_temp
},
'STATUS': {
'type': 'string',
'bind': listen_for_events
}
}
diagnostics = {
'CPU Temp': rpi.cpu_temp,
'IP Address': rpi.ip_address,
'Host': gethostname(),
'Operating System': " ".join(uname())
}
device = cloud4rpi.connect(DEVICE_TOKEN)
device.declare(variables)
device.declare_diag(diagnostics)
device.publish_config()
# Adds a 1 second delay to ensure device variables are created
time.sleep(1)
try:
data_timer = 0
diag_timer = 0
while True:
if data_timer <= 0:
device.publish_data()
data_timer = DATA_SENDING_INTERVAL
if diag_timer <= 0:
device.publish_diag()
diag_timer = DIAG_SENDING_INTERVAL
time.sleep(POLL_INTERVAL)
diag_timer -= POLL_INTERVAL
data_timer -= POLL_INTERVAL
except KeyboardInterrupt:
cloud4rpi.log.info('Keyboard interrupt received. Stopping...')
except Exception as e:
error = cloud4rpi.get_error_message(e)
cloud4rpi.log.error("ERROR! %s %s", error, sys.exc_info()[0])
finally:
sys.exit(0)
def main():
variables = {
'CPU Temp': {
'type': 'numeric',
'bind': cpu_temp
},
'CPU %': {
'type': 'numeric',
'bind': cpu_percent
},
'CPU freq': {
'type': 'numeric',
'bind': cpu_freq
},
'Memory Usage %': {
'type': 'numeric',
'bind': mem_percent
},
'Swap Usage %': {
'type': 'numeric',
'bind': swap_percent
},
'Disk Usage %': {
'type': 'numeric',
'bind': disk_percent
},
'Up Time': {
'type': 'string',
'bind': up_time
},
'Last Boot Time': {
'type': 'string',
'bind': boot_time
}
}
# Check if OpenWeatherMap api key and location where specified
owm_enabled = (not is_empty(OWM_API_KEY)) and (
not is_empty(OWM_CITY_COUNTRY))
if owm_enabled:
print()
print(
f'OpenWeatherMap data enabled: Key: {OWM_API_KEY}, Location: {OWM_CITY_COUNTRY}'
)
print()
variables['Weather Location'] = {
'type': 'string',
'bind': get_owm_location
}
variables['Weather Temperature Celsius'] = {
'type': 'numeric',
'bind': get_owm_temp
}
variables['Weather Humidity %'] = {
'type': 'numeric',
'bind': get_owm_hum
}
print(variables)
diagnostics = {
'IP Address': rpi.ip_address,
'Host': rpi.host_name,
'Operating System': rpi.os_name
}
device = cloud4rpi.connect(DEVICE_TOKEN)
# Use the following 'device' declaration
# to enable the MQTT traffic encryption (TLS).
#
# tls = {
# 'ca_certs': '/etc/ssl/certs/ca-certificates.crt'
# }
# device = cloud4rpi.connect(DEVICE_TOKEN, tls_config=tls)
try:
device.declare(variables)
device.declare_diag(diagnostics)
device.publish_config()
# Adds a 1 second delay to ensure device variables are created
sleep(1)
data_timer = 0
diag_timer = 0
owm_timer = 0
while True:
if owm_enabled:
# Check if owm data needs to be updated:
if owm_timer <= 0:
get_current_owm_data()
owm_timer = OWM_INTERVAL_SEC
if data_timer <= 0:
device.publish_data()
data_timer = DATA_SENDING_INTERVAL
if diag_timer <= 0:
device.publish_diag()
diag_timer = DIAG_SENDING_INTERVAL
sleep(POLL_INTERVAL)
diag_timer -= POLL_INTERVAL
data_timer -= POLL_INTERVAL
owm_timer -= POLL_INTERVAL
except KeyboardInterrupt:
cloud4rpi.log.info('Keyboard interrupt received. Stopping...')
except Exception as e:
error = cloud4rpi.get_error_message(e)
cloud4rpi.log.exception("ERROR! %s %s", error, sys.exc_info()[0])
finally:
sys.exit(0)
def main():
# load w1 modules
ds18b20.init_w1()
# Detect DS18B20 temperature sensors.
ds_sensors = ds18b20.DS18b20.find_all()
# Put variable declarations here
# Available types: 'bool', 'numeric', 'string', 'location'
variables = {
'Room Temp': {
'type': 'numeric' if ds_sensors else 'string',
'bind': ds_sensors[0] if ds_sensors else sensor_not_connected
},
'LED On': {
'type': 'bool',
'value': False,
'bind': led_control,
},
'CPU Temp': {
'type': 'numeric',
'bind': chip.cpu_temp
},
'STATUS': {
'type': 'string',
'bind': listen_for_events
},
'Location': {
'type': 'location',
'bind': get_location
}
}
# Put system data declarations here
diagnostics = {
'CPU Temp': chip.cpu_temp,
'IP Address': chip.ip_address,
'Host': chip.host_name,
'Operating System': chip.os_name,
'Client Version:': cloud4rpi.__version__
}
device = cloud4rpi.connect(DEVICE_TOKEN)
device.declare(variables)
device.declare_diag(diagnostics)
device.publish_config()
# adds a 1 second delay to ensure device variables are created
sleep(1)
try:
diag_timer = 0
data_timer = 0
while True:
if data_timer <= 0:
device.publish_data()
data_timer = DATA_SENDING_INTERVAL
if diag_timer <= 0:
device.publish_diag()
diag_timer = DIAG_SENDING_INTERVAL
diag_timer -= POLL_INTERVAL
data_timer -= POLL_INTERVAL
sleep(POLL_INTERVAL)
except KeyboardInterrupt:
cloud4rpi.log.info('Keyboard interrupt received. Stopping...')
except Exception as e:
error = cloud4rpi.get_error_message(e)
cloud4rpi.log.error("ERROR! %s %s", error, sys.exc_info()[0])
sys.exit(1)
finally:
sys.exit(0)
def main():
variables = {
'Distance': {
'type': 'numeric',
},
'Status': {
'type': 'string',
},
'PumpRelay': {
'type': 'bool',
'value': False
},
'WaterLevel': {
'type': 'numeric',
}
}
diagnostics = {
'Pump_Enabled': is_pump_enabled,
'IP_Address': rpi.ip_address,
'Host': rpi.host_name,
'CPU_Temp': rpi.cpu_temp,
'OS': rpi.os_name,
'Uptime': rpi.uptime_human
}
cloud = cloud4rpi.connect(C4R_TOKEN, C4R_HOST)
cloud.declare(variables)
cloud.declare_diag(diagnostics)
cloud.publish_config()
data_timer = 0
diag_timer = 0
log_timer = 0
log_info("Setup GPIO...")
GPIO.setmode(GPIO.BCM)
GPIO.setup(GPIO_PUMP, GPIO.IN)
GPIO.add_event_detect(GPIO_PUMP, GPIO.BOTH, callback=pump_relay_handle, bouncetime=PUMP_BOUNCE_TIME)
toggle_pump(STOP_PUMP)
try:
log_debug('Start...')
while True:
global disable_alerts
distance = wait_for_distance() # Read the current water depth
if distance is None:
log_error('Distance error!')
if not disable_alerts:
notify_in_background(calc_alert(SENSOR_ERROR))
send(cloud, variables, distance, error_code=SENSOR_ERROR, force=True)
disable_alerts = True
if is_pump_on() and prev_distance < STOP_PUMP_DISTANCE + DISTANCE_DELTA:
log_error('[!] Emergency stop of the pump. No signal from a distance sensor')
toggle_pump(STOP_PUMP)
continue
now = time()
should_log = now - log_timer > DEBUG_LOG_INTERVAL
if should_log:
#log_debug("Distance = %.2f (cm)" % (distance))
log_timer = now
if distance <= STOP_PUMP_DISTANCE: # Stop pouring
toggle_pump(STOP_PUMP)
if GPIO.event_detected(GPIO_PUMP):
is_pouring = is_pump_on()
set_emergency_stop_time(now, is_pouring)
log_debug('[!] Pump event detected: %s' % ('On' if is_pouring else 'Off'))
send(cloud, variables, distance, force=True)
global pump_disabled
if check_water_source_empty(now):
log_error('[!] Emergency stop of the pump. Water source is empty')
toggle_pump(STOP_PUMP)
pump_disabled = True
notify_in_background(calc_alert(NO_WATER_ERROR))
send(cloud, variables, distance, error_code=NO_WATER_ERROR, force=True)
if distance > MAX_DISTANCE * 2: # Distance is out of expected range: do not start pouring
log_error('Distance is out of range: %.2f' % distance)
continue
if distance > MAX_DISTANCE: # Start pouring
toggle_pump(START_PUMP)
if water_level_changed(prev_distance, distance):
log_debug("Distance changed to %.2f (cm)" % (distance))
send(cloud, variables, distance)
update_distance(distance)
set_emergency_stop_time(now, is_pump_on())
pump_disabled = False # Allow to activate pump next time
if now - data_timer > DATA_SENDING_INTERVAL:
send(cloud, variables, distance)
data_timer = now
if now - diag_timer > DIAG_SENDING_INTERVAL:
cloud.publish_diag()
diag_timer = now
disable_alerts = False
sleep(POLL_INTERVAL)
except Exception as e:
log_error('ERROR: %s' % e)
traceback.print_exc()
finally:
log_debug('Stopped!')
GPIO.remove_event_detect(GPIO_PUMP)
GPIO.cleanup()
sys.exit(0)
def main():
global beer_lines
global trigger
ds18b20.init_w1()
ds_sensors = ds18b20.DS18b20.find_all()
for k, v in beer_lines.items():
button = Button(k)
button.when_pressed = on_pulse
# Put variable declarations here
# Available types: 'bool', 'numeric', 'string', 'location'
variables = {
"Cellar Temp": {
"type": "numeric" if ds_sensors else "string",
"bind": ds_sensors[0] if ds_sensors else sensor_not_connected,
},
"lps1": {
"type": "numeric",
"bind": get_val(17, "lps")
},
"lps2": {
"type": "numeric",
"bind": get_val(18, "lps")
},
"liters1": {
"type": "numeric",
"bind": get_val(17, "liters")
},
"liters2": {
"type": "numeric",
"bind": get_val(18, "liters")
},
}
diagnostics = {
"CPU Temp": rpi.cpu_temp,
"IP Address": rpi.ip_address,
"Host": rpi.host_name,
"Operating System": rpi.os_name,
"Client Version:": cloud4rpi.__version__,
}
device = cloud4rpi.connect(DEVICE_TOKEN)
# Use the following 'device' declaration
# to enable the MQTT traffic encryption (TLS).
#
# tls = {
# 'ca_certs': '/etc/ssl/certs/ca-certificates.crt'
# }
# device = cloud4rpi.connect(DEVICE_TOKEN, tls_config=tls)
try:
device.declare(variables)
device.declare_diag(diagnostics)
device.publish_config()
# Adds a 1 second delay to ensure device variables are created
sleep(1)
data_timer = 0
diag_timer = 0
while True:
pouring = on_tick()
if (data_timer <= 0) or trigger or pouring:
print("trigger: ", trigger, "pouring: ", pouring)
# print("time: ", time())
# print("1111111 ",beer_lines)
calc_values()
if trigger:
trigger = False
# print("2222222 ",beer_lines)
device.publish_data()
data_timer = DATA_SENDING_INTERVAL
if diag_timer <= 0:
device.publish_diag()
diag_timer = DIAG_SENDING_INTERVAL
sleep(POLL_INTERVAL)
diag_timer -= POLL_INTERVAL
data_timer -= POLL_INTERVAL
except KeyboardInterrupt:
cloud4rpi.log.info("Keyboard interrupt received. Stopping...")
except Exception as e:
error = cloud4rpi.get_error_message(e)
cloud4rpi.log.exception("ERROR! %s %s", error, sys.exc_info()[0])
finally:
sys.exit(0)
def save_sensor_values():
device = cloud4rpi.connect(DEVICE_TOKEN)
adapter = pygatt.GATTToolBackend()
try:
adapter.start()
conn = adapter.connect(mac)
time_info = int(time.time() * 1000000000.0)
sensor_values = {}
for sensor in char_uuids:
value = conn.char_read(char_uuids[sensor])
sensor_values[sensor] = float(value.decode("utf-8").rstrip('\00'))
measure_all = []
for sensor in sensor_values:
measure = {
"measurement": sensor,
"time": time_info,
"fields": {
"value": sensor_values[sensor]
}
}
measure_all.append(measure)
co2_value = sensor_values['co2']
tvoc_value = sensor_values['tvoc']
battery_value = sensor_values['battery']
hum_value = sensor_values['humidity']
temp_value = sensor_values['temperature']
light_value = sensor_values['ambient-light']
pressure_value = sensor_values['pressure']
altitude_value = sensor_values['altitude']
# print(measure_all)
variables = {
'CO2': {
'type': 'numeric',
'value': co2_value
},
'Pollution Level': {
'type': 'numeric',
'value': tvoc_value
},
'Battery': {
'type': 'numeric',
'value': battery_value
},
'Humidity': {
'type': 'numeric',
'value': hum_value
},
'Temperature': {
'type': 'numeric',
'value': temp_value
},
'Air Pressure': {
'type': 'numeric',
'value': pressure_value
},
'Altitude': {
'type': 'numeric',
'value': altitude_value
},
'Sun': {
'type': 'numeric',
'value': light_value
}
}
device.declare(variables)
device.publish_config()
time.sleep(1)
device.publish_data()
print(sensor_values)
except Exception as e:
print("Error: ", e)
# msg = "ParkScan: [%d] %s"%(time_info, e)
finally:
adapter.stop()
def main():
# Save the initial time, we will use this to find out when it is time to take a picture or save a reading
last_read_sensor = last_pic_time = int(time.time())
# Send to Cloud4rpi using library
# Put variable declarations here
# Available types: 'bool', 'numeric', 'string'
variables = {
"Room Temp": {
"type": "numeric",
"bind": readTemperature
},
'Humidity': {
"type": "numeric",
"bind": readHumidity
},
"InfraRed Light": {
"type": "numeric",
"bind": readIR
},
"Visible Light": {
"type": "numeric",
"bind": readVisible
},
"UV Light": {
"type": "numeric",
"bind": readUV
},
"Soil Moisture1": {
"type": "numeric",
"bind": readMoisture1
},
"Soil Moisture2": {
"type": "numeric",
"bind": readMoisture2
},
"Full Spectrum Light": {
"type": "numeric",
"bind": readFullLight
},
"Ifra-Red Light": {
"type": "numeric",
"bind": readIRLight
}
}
# Send diagnostic data to Cloud4RPI
diagnostics = {
'CPU Temp': rpi.cpu_temp,
'IP Address': rpi.ip_address,
'Host': rpi.host_name,
'Operating System': rpi.os_name
}
# Cloud4RPI functions
device = cloud4rpi.connect(DEVICE_TOKEN)
device.declare(variables)
device.declare_diag(diagnostics)
device.publish_config()
while True:
curr_time_sec = int(time.time())
# If it is time to take the sensor reading - based on time set at the top
if curr_time_sec - last_read_sensor > time_for_sensor:
device.publish_data()
# Update the last read time
last_read_sensor = curr_time_sec
# If it is time to take the picture - based on time set at the top
if curr_time_sec - last_pic_time > time_for_picture:
take_picture()
last_pic_time = curr_time_sec
device.publish_diag()
# Slow down the loop
time.sleep(time_to_sleep)
def main():
#Configure the Rack information.
rack = 'rackA'
device = cloud4rpi.connect(DEVICE_TOKEN)
#The gateway node diagnostics information.
diagnostics = {
'CPU Temp': 33,
'IP Address': "10.0.0.0",
'Host': rack,
'Operating System': "Linux",
'Client Version:': cloud4rpi.__version__,
}
device.declare_diag(diagnostics)
device.publish_diag()
#The individual node data.
variables = {
'id': {
'type': 'numeric',
'bind': get_id
},
'temperature': {
'type': 'numeric',
'bind': get_temperature
},
'humidity': {
'type': 'numeric',
'bind': get_humidity
},
'pathogenPresence': {
'type': 'numeric',
'bind': get_pathogenpresence
},
'Location': {
'type': 'location',
'bind': get_location
}
}
device.declare(variables)
device.publish_config()
sleep(1)
# sleep for a second to make sure the configuration data is published.
#Pick the jsons recorded by the sensor.
fileArr = os.listdir(rack + '/')
for file in fileArr:
if re.match('NE', file):
#Load json file to a json dictionary
fileContent = open(rack + '/' + file, 'r')
fileJson = json.loads(fileContent.read())
fileContent.close()
os.rename(r'' + rack + '/' + file,
r'' + rack + '/IE' + str(fileJson["id"]) + '.json')
headers = {'content-type': 'application/json'}
request = requests.post(url + rack + '/' + str(fileJson["id"]) +
'?qos=1',
data=json.dumps(fileJson),
headers=headers,
cert=('bf0d06941b-certificate.pem.crt',
'bf0d06941b-private.pem.key'),
verify='AmazonRootCA1.pem.txt')
print(request.status_code)
#os.rename(r''+rack+'/IE'+str(fileJson["id"])+'.json',r''+rack+'/CE'+str(fileJson["id"])+'.json')
device.publish_data()
os.rename(r'' + rack + '/IE' + str(fileJson["id"]) + '.json',
r'' + rack + '/CE' + str(fileJson["id"]) + '.json')
sleep(DATA_SENDING_INTERVAL)
def main():
try:
device = cloud4rpi.connect(CLOUD4RPI_DEVICE_TOKEN)
status, remitdata = InstaRemRate()
if status:
rate_instarem = round(remitdata["destination_amount"]/1000, 2)
fx_rate = round(remitdata["fx_rate"], 2)
else:
rate_instarem = 0
# Remitly
status, rate_remitly = RemitlyRate()
# Xoom
status, rate_xoom = XoomRate()
# Ria Rate
status, rate_ria = RiaRate()
# Transferwise Rate
status, rate_transferwise = TransferWise()
datetime = time.strftime("%m/%d/%y %H:%M:%S")
print(f"FX Rate: {fx_rate} Instarem: {rate_instarem} Remitly: {rate_remitly} Xoom: {rate_xoom} Ria: {rate_ria}, TransferWise: {rate_transferwise} Last Updated {datetime}")
rate_all = {
"instarem": rate_instarem,
"remitly": rate_remitly,
"xoom": rate_xoom,
"ria": rate_ria,
"transferwise": rate_transferwise
}
try:
variables = {
"Fx Rate": {
"type": "numeric" if fx_rate else "string",
"value": fx_rate if fx_rate else "N/A"
},
"Instarem": {
"type": "numeric" if rate_instarem else "string",
"value": rate_instarem if rate_instarem else "N/A"
},
"Remitly": {
"type": "numeric" if rate_remitly else "string",
"value": rate_remitly if rate_remitly else "N/A"
},
"Xoom": {
"type": "numeric" if rate_xoom else "string",
"value": rate_xoom if rate_xoom else "N/A"
},
"Ria": {
"type": "numeric" if rate_ria else "string",
"value": rate_ria if rate_ria else "N/A"
},
"TransferWise": {
"type": "numeric" if rate_transferwise else "string",
"value": rate_transferwise if rate_transferwise else "N/A"
}
}
device.declare(variables)
# Uncomment Below 2 Lines in first run after Cloud4Rpi Device Creation
# device.publish_config()
# time.sleep(1)
print("Uploading Data to cloud4rpi")
device.publish_data()
lastrun = time.time()
except Exception as e:
error = cloud4rpi.get_error_message(e)
cloud4rpi.log.exception("ERROR! %s %s", error, sys.exc_info()[0])
except KeyboardInterrupt:
epd2in13_V2.epdconfig.module_exit()
exit()
def main():
variables = {
'Acc_x': {
'type': 'numeric',
'bind': check_acc_x
},
'Acc_y': {
'type': 'numeric',
'bind': check_acc_y
},
'Acc_z': {
'type': 'numeric',
'bind': check_acc_z
},
'Gyro_x': {
'type': 'numeric',
'bind': check_gyro_x
},
'Gyro_y': {
'type': 'numeric',
'bind': check_gyro_y
},
'Gyro_z': {
'type': 'numeric',
'bind': check_gyro_z
},
'Mag_x': {
'type': 'numeric',
'bind': check_mag_x
},
'Mag_y': {
'type': 'numeric',
'bind': check_mag_y
},
'Mag_z': {
'type': 'numeric',
'bind': check_mag_z
},
'latitude': {
'type': 'numeric',
'bind': check_lat
},
'longitude': {
'type': 'numeric',
'bind': check_long
},
'CPU Temp': {
'type': 'numeric',
'bind': rpi.cpu_temp
},
}
diagnostics = {
'CPU Temp': rpi.cpu_temp,
'IP Address': rpi.ip_address,
'Host': rpi.host_name,
'Operating System': rpi.os_name
}
device = cloud4rpi.connect(DEVICE_TOKEN)
# Use the following 'device' declaration
# to enable the MQTT traffic encryption (TLS).
#
# tls = {
# 'ca_certs': '/etc/ssl/certs/ca-certificates.crt'
# }
# device = cloud4rpi.connect(DEVICE_TOKEN, tls_config=tls)
try:
device.declare(variables)
device.declare_diag(diagnostics)
device.publish_config()
# Adds a 1 second delay to ensure device variables are created
sleep(1)
data_timer = 0
diag_timer = 0
while True:
if data_timer <= 0:
device.publish_data()
data_timer = DATA_SENDING_INTERVAL
if diag_timer <= 0:
device.publish_diag()
diag_timer = DIAG_SENDING_INTERVAL
sleep(POLL_INTERVAL)
diag_timer -= POLL_INTERVAL
data_timer -= POLL_INTERVAL
except KeyboardInterrupt:
cloud4rpi.log.info('Keyboard interrupt received. Stopping...')
except Exception as e:
error = cloud4rpi.get_error_message(e)
cloud4rpi.log.exception("ERROR! %s %s", error, sys.exc_info()[0])
finally:
sys.exit(0)
def main():
# Put variable declarations here
# Available types: 'bool', 'numeric', 'string'
variables = {
'VALUE': {
'type': 'numeric',
'bind': get_data
},
'VOLTAGE': {
'type': 'numeric',
'bind': get_volts
},
'STATUS': {
'type': 'string',
'bind': get_status
}
}
diagnostics = {
'IP Address': rpi.ip_address,
'Host': rpi.host_name,
'Operating System': rpi.os_name
}
device = cloud4rpi.connect(DEVICE_TOKEN)
# Use the following 'device' declaration to enable the MQTT traffic encryption (TLS).
try:
device.declare(variables)
device.declare_diag(diagnostics)
device.publish_config()
# Adds a 1 second delay to ensure device variables are created
sleep(1)
data_timer = 0
diag_timer = 0
while True:
if data_timer <= 0:
device.publish_data()
data_timer = DATA_SENDING_INTERVAL
if diag_timer <= 0:
device.publish_diag()
diag_timer = DIAG_SENDING_INTERVAL
sleep(POLL_INTERVAL)
diag_timer -= POLL_INTERVAL
data_timer -= POLL_INTERVAL
except KeyboardInterrupt:
cloud4rpi.log.info('Keyboard interrupt received. Stopping...')
except Exception as e:
error = cloud4rpi.get_error_message(e)
cloud4rpi.log.exception("ERROR! %s %s", error, sys.exc_info()[0])
finally:
sys.exit(0)
