def rrd_particulates(self):
data_complete = True
rrd_template = ""
rrd_data = "N:"
for p in Particulates:
if not data[p]:
data_complete = False
else:
try:
rrd_template += data[p].split(":N:")[0] + ":"
rrd_data += data[p].split(":N:")[1] + ":"
except IndexError:
Log("Wrong data format: {0[0]} {0[1]}".format(
sys.exc_info()))
Log("data[p]: {}".format(data[p]))
return
if data_complete:
self.update_rrd(RRDFILE_PARTICULATES, rrd_template, rrd_data)
def send(self, data):
payload = data
datagram = "{},{}".format(payload,
self.digest(payload)).encode('utf-8')
try:
sent = self.socket.sendto(
datagram, (CONFIG.IP_ADDRESS_SERVER, CONFIG.UDP_PORT))
# Log("Sent bytes: {}; data: {}".format(sent,datagram))
except:
Log("Cannot send data: {0[0]} {0[1]}".format(sys.exc_info()))
def shutdown_application ():
"""called on shutdown; stops all threads"""
Log("shutdown_application()")
control.stop()
control.join()
anteroom.stop()
sys.exit(0)
def verify(cls, payload):
try:
(data, digest) = payload.rsplit(',', 1)
(msgid, data) = data.split(',', 1) # msgid is not part of digest
except ValueError:
Log("WARN: Payload corrupted: {}".format(payload))
else:
try:
if hmac.compare_digest(digest, cls.digest(data)):
return True
else:
Log("WARN: Hashes do not match on data: {}".format(
payload))
except TypeError:
Log("WARN: non-ascii characters found: {}".format(payload))
except:
raise
return False
def shutdown_application ():
"""called on shutdown; stops all threads"""
Log("Shutdown.")
display.off()
counter.stop()
counter.join()
screen.stop()
sys.exit(0)
def update_rrd(db, template, data):
template = template.rstrip(":")
data = data.rstrip(":")
# Log(template)
# Log(data)
try:
rrdtool.update(db, "--template", template, data)
except rrdtool.OperationalError:
Log("Cannot update rrd database: {0[0]} {0[1]}".format(
sys.exc_info()))
def stop_play(self, nosound=False):
if Touchevent.event(): # brightness control
if not nosound:
Sound.play(CONFIG.CLICK_SOUND)
Log("Stopping radio station.")
if self.radio_process:
self.radio_process.terminate()
self.radio_process.communicate()
self.radio_process = None
def countSerie(self, Y, X, **kwargs):
# optional parameters
prediction = kwargs.get('prediction', 1)
mu = kwargs.get('mu', 0.9)
self.w = kwargs.get('weigths', self.w)
logging = kwargs.get('logging', False)
log = Log(logging, "MLP.phiCell()")
log.message("start")
N = len(Y) # X.shape[0]
e = zeros(N)
yn = Y.copy() # init output neuronu (site)
nx = len(X) * 3 + 1 #lenX * X width + 1
nw = (nx * nx + nx) / 2
if len(self.w) < 1:
self.w = random.randn(nw) / nw
x = []
colx = []
J = zeros((N, nw))
I = eye(nw)
# for record
MSE = [] #mean squer error
for k in range(N - prediction):
#input vector
x = [1.]
for i in range(len(X)):
x = concatenate(
(x, [X[i][k], X[i][k - 1],
X[i][k - 2]])) #, X[i][k-3], X[i][k-4], X[i][k-5] ]))
colx = []
for i in range(nx):
for j in range(i, nx):
colx.append(x[i] * x[j])
yn[k + prediction] = dot(self.w, colx)
e[k] = Y[k] - yn[k]
dydw = colx # for QNU and HONU (Higher Order Neural Units)
J[k, :] = dydw
print "___"
print len(dot(linalg.inv(dot(J.T, J) + 1.0 / mu * I), J.T))
print len(e)
print len(inv(dot(J.T, J) + 1. / mu * I))
dw = dot(dot(linalg.inv(dot(J.T, J) + 1.0 / mu * I), J.T), e)
self.w = self.w + dw
MSE.append(sum(e**2) / N)
return yn, self.w, MSE, e
def run (self):
while self._running:
try:
datagram = self.socket.recv(self.MAX_PACKET_SIZE).decode('utf-8')
Log("Received: {}".format(datagram))
self.process_data(datagram)
except BlockingIOError:
for _ in range(50): # interruptible sleep
if not self._running:
break
time.sleep(0.1)
def off(self, immediate=False):
if not immediate:
if self.__thread_off:
self.__thread_off.join()
self.__thread_off = None
self.__thread_off = threading.Thread(
target=self.__off, kwargs={'immediate': immediate})
self.__thread_off.start()
else:
super().off()
Log(f"Fan {self.pin} switched off immediately.")
def Receiver ():
rrd_template = DS_TEMP + ":" + \
DS_TEMPCPU + ":" + \
DS_HUMI + ":" + \
DS_AIRPRESSURE + ":" + \
DS_LIGHTNESS + ":" + \
DS_AIRQUALITY + ":" + \
DS_OPEN1 + ":" + \
DS_OPEN2 + ":" + \
DS_OPEN3 + ":" + \
DS_OPEN4
udp = UDP.Receiver(CREDENTIALS)
while True:
rrd_data = udp.receive()
Log(f"RRD data received: {rrd_data}")
try:
rrdtool.update(RRDFILE, "--template", rrd_template, rrd_data)
except rrdtool.OperationalError:
Log("Cannot update rrd database: {0[0]} {0[1]}".format(sys.exc_info()))
def run(self):
while self._running:
for id_ in self.values.values.keys():
if self.values.values[id_].valid_until < time.time():
Log("Setting {} to NN/AA".format(id_))
self.values.values[id_].tk_StringVar.set("NN/AA")
for _ in range(600):
time.sleep(0.1)
if not self._running:
break
def __init__(self, sender=True):
super().__init__(config=LoRa_Cfg,
frequency=CONFIG.Livetracking.LoRa_Frequency,
int_pin=CONFIG.Livetracking.LoRa_pinInterrupt,
reset_pin=CONFIG.Livetracking.LoRa_pinReset)
if not self.init():
Log("Error: RFM96W not found!")
self.cleanup() # TODO: show some message on SSD1306!
sys.exit()
else:
Log("RFM96W LoRa mode ok!")
if sender:
if CONFIG.APP.autostart:
self.set_tx_power(
eval(CONFIG.Livetracking.LoRa_TX_Power_OnAutostart))
else:
self.set_tx_power(eval(CONFIG.Livetracking.LoRa_TX_Power))
else:
self.set_lna(LNA_BOOST_MAX)
def Receiver():
rrd_template = DS_TEMP + ":" + \
DS_HUMI + ":" + \
DS_PRESSURE + ":" + \
DS_AIRQUALITY + ":" + \
DS_TEMPCPU
udp = UDP.Receiver(CREDENTIALS)
while True:
try:
data = udp.receive()
except DatagramError:
Log("Datagram error")
else:
Log(f"RRD Data received: {data}")
try:
rrdtool.update(RRDFILE, "--template", rrd_template, data)
except rrdtool.OperationalError:
Log("Cannot update rrd database: {0[0]} {0[1]}".format(
sys.exc_info()))
def Receiver ():
global disp
rf95.spi_write(REG_0C_LNA, LNA_BOOST_MAX) # TODO: find a better place for this
# taken from https://github.com/PiInTheSky/lora-gateway/blob/master/gateway.c#L118
disp = SSD1306()
disp.begin()
disp.clear()
disp.display()
xpos = 4
ypos = 4
width = disp.width
height = disp.height
image = Image.new('1', (width, height))
draw = ImageDraw.Draw(image)
font = ImageFont.load_default()
(_, textheight) = draw.textsize("Text", font=font)
while True:
while not rf95.available():
pass
draw.rectangle((0,0,width,height), outline=0, fill=255)
y = ypos
draw.text((xpos, y), "Zeit: {}".format(time.strftime("%X")), font=font, fill=0)
data = rf95.recv()
Log("RSSI: {}".format(rf95.last_rssi))
str = "".join(map(chr, data))
Log("{}\n".format(str))
y += textheight
draw.text((xpos, y), "RSSI: {}".format(rf95.last_rssi))
y += textheight
draw.text((xpos, y), "{}".format(str[:20]))
disp.image(image)
disp.display()
def run (self):
while self._running:
data_complete = True
rrd_template = ""
rrd_data = "N:"
for p in PIs:
if not data[p]:
data_complete = False
else:
rrd_template = rrd_template + self.DS[p][self.TEMPCPU] + ":" + \
self.DS[p][self.LOAD] + ":" + \
self.DS[p][self.FREQ] + ":" + \
self.DS[p][self.CPU_USE0] + ":" + \
self.DS[p][self.CPU_USE1] + ":" + \
self.DS[p][self.CPU_USE2] + ":" + \
self.DS[p][self.CPU_USE3] + ":" + \
self.DS[p][self.TEMPROOM] + ":" + \
self.DS[p][self.TEMPAIRFLOW] + ":" + \
self.DS[p][self.HUMIDITY] + ":" + \
self.DS[p][self.RES0] + ":" + \
self.DS[p][self.RES1] + ":" + \
self.DS[p][self.RES2] + ":"
rrd_data = rrd_data + data[p].split("N:")[1].rstrip() + ":"
if data_complete:
rrd_template = rrd_template.rstrip(":")
rrd_data = rrd_data.rstrip(":")
# Log(rrd_template)
Log(rrd_data)
try:
pass
# rrdtool.update(RRDFILE, "--template", rrd_template, rrd_data)
except rrdtool.OperationalError:
Log("Cannot update rrd database: {0[0]} {0[1]}".format(sys.exc_info()))
for _ in range(600): # interruptible sleep
if not self._running:
break
time.sleep(0.1)
def send (self, data):
Log(f"Sending data: {data.csv}".replace('\n',' '))
subprocess.run(["bash", "-c", f"echo \"{data.csv}\" > {self.filename_csv}"])
subprocess.run(["bash", "-c", f"echo \"{data.html}\" > {self.filename_html}"])
t1 = threading.Thread(target=self.scp,
args=(f"{self.user}@{self.host1}:{self.directory1}",))
t2 = threading.Thread(target=self.scp,
args=(f"{self.user}@{self.host2}:{self.directory2}",))
t1.start()
t2.start()
t1.join
t2.join
def run(self):
self._running = True
while self._running:
if self.io.input(CONFIG.PIN.BTN_Control) == 0:
shutdown_thread = threading.Thread(target=shutdown)
shutdown_thread.start()
Log("Shutdown thread started.")
while self._running: # wait until process has been stopped
time.sleep(0.05)
time.sleep(0.05)
def shutdown_application():
"""called on shutdown; stops all threads"""
Log("shutdown_application()")
control.stop()
control.join()
countdown.stop()
countdown.join()
timer.stop()
sys.exit(0)
def set_power_mode(self, value, blocking=True):
"""Set power mode"""
if value not in (SLEEP_MODE, FORCED_MODE):
Log("BME680 Error: Power mode should be one of SLEEP_MODE or FORCED_MODE"
)
self.power_mode = value
self._set_bits(CONF_T_P_MODE_ADDR, MODE_MSK, MODE_POS, value)
while blocking and self.get_power_mode() != self.power_mode:
time.sleep(POLL_PERIOD_MS / 1000.0)
def run(self):
self._running = True
last = None
while self._running:
actual = timer.status
if actual != last:
if actual != 0:
self.led_on.on()
self.relais.on()
self.led_off.off()
Log(f"Circulation pump on until {actual.strftime('%H:%M:%S')}."
)
else:
self.led_on.off()
self.relais.off()
self.led_off.on()
Log("Circulation pump off.")
last = actual
time.sleep(0.1)
def API_Relais():
relais_ = request.args.get('status', 'off')
Log("Request: relais={}".format(relais_), True)
# TODO: validate param
save_energy.reset()
if relais_ == 'on':
relais.status = Switch.ON
else:
relais.status = Switch.OFF
return "OK. Status: {}".format(relais_)
def run(self):
while self._running:
rrd_data = "N:{}".format(relais.status_stretchon().value) + \
":{:.2f}".format(self.cpu.read_temperature()) + \
":{}".format(0.0) + \
":{}".format(0.0) + \
":{}".format(0.0) + \
":{}".format(0.0) + \
":{}".format(0.0)
Log(rrd_data, True)
try:
rrdtool.update(RRDFILE, "--template", self.rrd_template,
rrd_data)
except rrdtool.OperationalError:
Log("Cannot write to rrd: {0[0]} {0[1]}".format(
sys.exc_info()))
for _ in range(500): # interruptible sleep
if self._running:
sleep(0.1)
else:
break
def shutdown_application ():
"""called on shutdown; stops all threads"""
Log("shutdown_application()")
oos.stop()
oos.join()
print("after oos.join()")
clock.stop()
clock.join()
print("after clock.join()")
values.stop()
values.join()
print("after values.join()")
weather.stop()
print("after weather.stop()")
sys.exit(0)
def run(self):
sds011 = SDS011("/dev/ttyUSB0", use_query_mode=True)
while self._running:
# sds011 = SDS011("/dev/ttyUSB0", use_query_mode=True)
sds011.sleep(sleep=False)
time.sleep(25)
values = sds011.query()
if values is not None:
self.data = {self.PM25: values[0], self.PM10: values[1]}
Log("Data read: PM25: {0[0]}, PM10: {0[1]}".format(values))
else:
Log("Reading SDS011 failed.")
sds011.sleep()
# time.sleep(1)
# sds011.close()
time.sleep(5)
# sds011 = None
for _ in range(UPDATE_INTERVAL * 10): # interruptible sleep
if not self._running:
break
time.sleep(0.1)
def API_Toggle():
triggered_by_button = request.args.get("button", "0") == "1"
save_energy.reset()
if relais.status == Switch.ON:
relais.status = Switch.OFF
else:
relais.status = Switch.ON
if triggered_by_button:
save_energy.set()
Log("Request: toggle to {}; triggered by button: {}".format(
relais.status, triggered_by_button))
return "OK. Status: {}".format(relais.status)
def count(self, Y, X, **kwargs):
prediction = kwargs.get('prediction', 1)
beta = kwargs.get('beta', 0.1)
logging = kwargs.get('logging', False)
log = Log(logging, "RBF.count()")
log.message("start")
N = len(Y)
self.Yn = Y.copy()
e = zeros(N)
colx = []
allColx = []
for j in range(N - prediction):
log.message(j, conditioned=True)
#update neuronu LIFO (moving window) start updating after prediction lag
if (j > 0 and j > prediction):
self.W = self.W[1:] #remove first
self.W.append(allColx[-prediction])
self.Y = self.Y[1:] #remove first
self.Y.append(Y[j])
colx = []
for i in range(len(X)):
colx.append(
[X[i][j]]) #, X[i][j-1], X[i][j-2], X[i][j-3], X[i][j-4]])
allColx.append(colx)
Nw = len(self.W)
phi = zeros(Nw)
nu = zeros(Nw)
for i in range(Nw):
nu[i] = self.fnu(asarray(self.W[i]),
asarray(colx)) #nu[i]=fnu(W[i,:],x)
phi = self.fphi(nu, beta) # output of RBF
self.Yn[j + prediction] = sum(
asarray(phi) * asarray(self.Y)) / sum(asarray(phi))
log.message("done \n")
return self.Yn
def run(self):
self._running = True
i = 0
while self._running:
if daylight():
filename = f"{TEMPDIR}pic_{datetime.now().strftime('%Y%m%d-%H%M%S')}_{i:05d}.jpg"
run_command(self.raspistill.format(i, filename))
Log(f"{filename} captured")
self.queue.put(filename)
i += 1
else:
i = 0 # Reset counter during the night
time.sleep(0.5)
# Log("Sending QSTOP")
self.queue.put(QSTOP)
def run (self):
def share_and_log ():
pile.save()
pile.share()
Log("Iteration #{}: {} field(s) toppled; grains on center field: {}"
.format(i, toppled, pile.pile[CONFIG.PILE.X//2][CONFIG.PILE.Y//2]))
i = 0
toppled = None
while toppled != 0:
toppled = self.iterate()
i += 1
if i % 2500 == 0:
share_and_log()
Log("Done!")
share_and_log()
def Sensor ():
"""reads data from sensor"""
if this_PI not in PIs:
Log("wrong host!")
global shutdown_application
shutdown_application()
tempds = DS1820(AddressesDS1820[this_PI])
tempcpu = CPU()
if this_PI == pik_i:
bme680 = BME680(i2c_addr=BME_680_SECONDARYADDR)
else:
htu21df = HTU21DF()
udp_rrd = UDP.Sender(CREDENTIALS_RRD) # Server for all rrd stuff
udp_ha = UDP.Sender(CREDENTIALS_HA) # Display at home ("Homeautomation")
pressure = 1013.25 # in case of no BME680 available
airquality = 0
while True:
temp_ds = tempds.read_temperature()
temp_cpu = tempcpu.read_temperature()
if this_PI == pik_i:
bme680.get_sensor_data()
temp = bme680.data.temperature
humi = bme680.data.humidity
pressure = bme680.data.pressure
airquality = bme680.data.air_quality_score \
if bme680.data.air_quality_score != None else 0
else:
temp = htu21df.read_temperature()
humi = htu21df.read_humidity()
rrd_data = "N:{:.2f}".format(temp_ds) + \
":{:.2f}".format(temp) + \
":{:.2f}".format(temp_cpu) + \
":{:.2f}".format(humi) + \
":{:.2f}".format(pressure) + \
":{:.2f}".format(airquality)
udp_rrd.send(f"{this_PI},{rrd_data}")
udp_ha.send(f"{this_PI},{rrd_data}")
time.sleep(45)
