2019-08-02 01:25:58 -07:00
|
|
|
import socket,numpy,time,_thread,json,requests,zlib,gnupg,binascii
|
2019-07-30 05:52:22 -07:00
|
|
|
has_mqtt=False
|
|
|
|
try:
|
|
|
|
import paho.mqtt.client as mqtt
|
|
|
|
import paho.mqtt.publish as publish
|
|
|
|
except:
|
|
|
|
has_mqtt=False
|
|
|
|
else:
|
|
|
|
has_mqtt=True
|
2019-07-29 03:31:59 -07:00
|
|
|
from uuid import getnode
|
2019-07-30 21:22:34 -07:00
|
|
|
gpg=gnupg.GPG()
|
2019-08-02 01:25:58 -07:00
|
|
|
_STRINGREMOVE=str.maketrans(dict.fromkeys("/:;\\{}(){]%&"))
|
2019-07-29 21:23:49 -07:00
|
|
|
|
2019-06-23 21:26:41 -07:00
|
|
|
class meas_data:
|
2019-08-02 08:08:31 -07:00
|
|
|
def __init__(self,var_name,ring_length=100,sigma=2,device=socket.gethostname(),sensor="CPU",i2c=0,store_file="/home/pi/data",multiplicator=1,digits=5,check_last=0,mac=0,sql_min_wait=5,rsa_key="",check_last_shrinking=0.99,mean_count=5):
|
2019-07-01 01:43:38 -07:00
|
|
|
self.set_varname(var_name)
|
2019-06-23 21:26:41 -07:00
|
|
|
self.value=[]
|
2019-06-30 10:19:49 -07:00
|
|
|
self.mval=[]
|
2019-08-02 08:08:31 -07:00
|
|
|
self.set_mean_count(mean_count)
|
2019-06-23 21:26:41 -07:00
|
|
|
self.sensebox=""
|
|
|
|
self.senseid=""
|
|
|
|
self.sense_url="https://ingress.opensensemap.org/"
|
|
|
|
self.sense_intervall=300
|
|
|
|
self.sense_last_time=0
|
2019-07-29 03:31:59 -07:00
|
|
|
self.sql_min_wait=sql_min_wait
|
2019-06-23 21:26:41 -07:00
|
|
|
self.sqlhost=""
|
|
|
|
self.sqlport=0
|
2019-07-29 03:31:59 -07:00
|
|
|
self.sql_last_transmit=0
|
2019-06-23 21:26:41 -07:00
|
|
|
self.bsense=False
|
|
|
|
self.bsql=False
|
|
|
|
self.bchanged=False
|
|
|
|
self.bfile=False
|
|
|
|
self.store_file=store_file
|
2019-06-24 07:08:14 -07:00
|
|
|
self.sigma=sigma
|
2019-07-01 01:43:38 -07:00
|
|
|
self.set_device(device)
|
|
|
|
self.set_sensor(sensor)
|
2019-07-03 20:44:45 -07:00
|
|
|
self.set_digits(digits)
|
2019-07-30 05:52:22 -07:00
|
|
|
self.set_check_last(check_last,check_last_shrinking)
|
2019-07-29 21:23:49 -07:00
|
|
|
self.set_i2c(i2c)
|
2019-07-01 01:43:38 -07:00
|
|
|
self.set_multiplicator(multiplicator)
|
2019-07-02 05:17:52 -07:00
|
|
|
self.mqtt_broker=""
|
|
|
|
self.mqtt_port=1883
|
|
|
|
self.mqtt_topic=""
|
|
|
|
self.mqtt_bool=False
|
2019-07-29 03:31:59 -07:00
|
|
|
self.hash=0
|
2019-07-29 21:23:49 -07:00
|
|
|
self.set_mac()
|
|
|
|
self.set_id()
|
|
|
|
self.set_rsa(rsa_key)
|
2019-07-31 03:30:42 -07:00
|
|
|
self.sql_out=""
|
2019-07-29 21:23:49 -07:00
|
|
|
self.json_out={"hash":self.hash,"signature":"","payload":{"device":self.device,"varname":self.var_name,"i2c":self.i2c,"sensor":self.sensor,"mac":self.mac,"measures":{}}}
|
2019-07-30 05:52:22 -07:00
|
|
|
def sign(self):
|
2019-07-31 03:30:42 -07:00
|
|
|
self.sql_out=self.json_out
|
|
|
|
if self.brsa and not self.brsa_sql:
|
2019-08-02 01:25:58 -07:00
|
|
|
self.sql_out={"signed_gpg":gpg.sign(json.dumps(self.json_out),keyid=self.rsa['keyid']).data.decode('utf-8'),"hash":self.hash}
|
2019-07-29 21:23:49 -07:00
|
|
|
def set_rsa(self,rsa_key):
|
2019-07-30 05:52:22 -07:00
|
|
|
self.brsa=False
|
2019-07-31 03:30:42 -07:00
|
|
|
self.brsa_sql=False
|
2019-07-29 21:23:49 -07:00
|
|
|
if len(rsa_key)>0:
|
|
|
|
self.brsa=False
|
|
|
|
try:
|
2019-08-02 01:25:58 -07:00
|
|
|
gpgkey=gpg.list_keys(keys=rsa_key.translate(_STRINGREMOVE))
|
2019-07-29 21:23:49 -07:00
|
|
|
except:
|
2019-07-30 21:22:34 -07:00
|
|
|
self.brsa=False
|
2019-07-29 21:23:49 -07:00
|
|
|
else:
|
2019-07-30 21:22:34 -07:00
|
|
|
if len(gpgkey)>0:
|
2019-07-31 03:30:42 -07:00
|
|
|
self.rsa=gpgkey[0]
|
2019-07-30 21:22:34 -07:00
|
|
|
self.brsa=True
|
2019-07-29 21:23:49 -07:00
|
|
|
else:
|
2019-07-30 21:22:34 -07:00
|
|
|
self.brsa=False
|
2019-07-29 03:31:59 -07:00
|
|
|
def set_id(self):
|
2019-07-29 21:23:49 -07:00
|
|
|
idstring=str(hex(getnode()))[2:-1]+self.device+str(self.i2c)+self.sensor+self.var_name
|
2019-08-02 01:25:58 -07:00
|
|
|
self.hash=zlib.crc32(idstring.encode("utf-8")) % (1<<32)
|
2019-07-29 03:31:59 -07:00
|
|
|
def get_id(self):
|
|
|
|
print(self.hash)
|
2019-07-29 21:23:49 -07:00
|
|
|
def set_mac(self):
|
2019-07-30 05:52:22 -07:00
|
|
|
self.mac=format(getnode(),"x")
|
2019-07-29 03:31:59 -07:00
|
|
|
def set_i2c(self,i2c):
|
2019-08-02 01:25:58 -07:00
|
|
|
if (isinstance(i2c,(int,float)) and not isinstance(i2c,bool)):
|
2019-07-29 03:31:59 -07:00
|
|
|
self.i2c=i2c
|
|
|
|
else:
|
|
|
|
self.i2c=0
|
2019-07-01 01:43:38 -07:00
|
|
|
def set_varname(self,var_name):
|
2019-08-02 01:25:58 -07:00
|
|
|
tvn=var_name.translate(_STRINGREMOVE)
|
2019-07-01 01:43:38 -07:00
|
|
|
if len(tvn)==0:
|
|
|
|
tvn="var"
|
|
|
|
self.var_name=tvn
|
2019-07-29 21:23:49 -07:00
|
|
|
def set_check_last(self,check_last,check_last_shrinking):
|
2019-08-02 01:25:58 -07:00
|
|
|
if (isinstance(check_last,(int,float)) and not isinstance(check_last,bool))and(isinstance(check_last_shrinking,(int,float)) and not isinstance(check_last_shrinking,bool)):
|
|
|
|
self.checklast_min=0
|
|
|
|
self.checklast_max=0
|
|
|
|
self.checklast_shrinking=1
|
|
|
|
if check_last > 0:
|
|
|
|
self.bchecklast=True
|
|
|
|
self.checklast=check_last
|
|
|
|
if (check_last_shrinking < 1) and (check_last_shrinking > 0):
|
|
|
|
self.checklast_shrinking=check_last_shrinking
|
|
|
|
else:
|
|
|
|
self.bchecklast=False
|
|
|
|
self.ckecklast=0
|
2019-07-03 20:44:45 -07:00
|
|
|
def set_digits(self,digits):
|
2019-07-03 20:52:52 -07:00
|
|
|
self.digits=1
|
2019-08-02 01:25:58 -07:00
|
|
|
if (isinstance(digits,(int,float)) and not isinstance(digits,bool)):
|
|
|
|
try:
|
|
|
|
td=int(digits)-1
|
|
|
|
except:
|
|
|
|
print("could not set digits")
|
|
|
|
else:
|
|
|
|
if td<0:
|
|
|
|
td=1
|
|
|
|
if td>20:
|
|
|
|
td=20
|
|
|
|
self.digits=td
|
2019-07-01 01:43:38 -07:00
|
|
|
def set_ring_length(self,ring_length):
|
2019-08-02 01:25:58 -07:00
|
|
|
self.ring_length=60
|
|
|
|
if (isinstance(ring_length,(int,float)) and not isinstance(ring_length,bool)):
|
|
|
|
trl=int(ring_length)
|
|
|
|
if trl<0:
|
|
|
|
trl=(-1)*trl
|
|
|
|
if trl==0:
|
|
|
|
trl = 60
|
|
|
|
self.ring_length=trl
|
2019-07-01 01:43:38 -07:00
|
|
|
def set_mean_count(self,mean_count):
|
2019-08-02 01:25:58 -07:00
|
|
|
self.mean_count=5
|
|
|
|
if (isinstance(mean_count,(int,float)) and not isinstance(mean_count,bool)):
|
|
|
|
tmc=int(mean_count)
|
|
|
|
if tmc < 0:
|
|
|
|
tmc=(-1)*tmc
|
|
|
|
if tmc == 0:
|
|
|
|
tmc=self.ring_length
|
|
|
|
if mean_count>self.ring_length:
|
|
|
|
mean_count=self.ring_length
|
|
|
|
self.mean_count=mean_count
|
2019-06-23 21:26:41 -07:00
|
|
|
def set_sensebox(self,sensebox,senseid,intervall=300):
|
2019-08-02 01:25:58 -07:00
|
|
|
tsb=sensebox.translate(_STRINGREMOVE)
|
2019-06-25 07:32:44 -07:00
|
|
|
tsb=tsb[0:24]
|
2019-06-23 21:26:41 -07:00
|
|
|
self.sensebox=tsb
|
2019-08-02 01:25:58 -07:00
|
|
|
tsi=senseid.translate(_STRINGREMOVE)
|
2019-06-25 07:32:44 -07:00
|
|
|
tsi=tsi[0:24]
|
2019-06-23 21:26:41 -07:00
|
|
|
self.senseid=tsi
|
|
|
|
self.sense_intervall=int(intervall)
|
|
|
|
self.bsense=True
|
|
|
|
self.sense_url="https://ingress.opensensemap.org/boxes/%s/%s" % (tsb,tsi)
|
2019-06-25 07:32:44 -07:00
|
|
|
print(self.sense_url)
|
2019-07-31 21:21:11 -07:00
|
|
|
def set_sql(self,host,port=8080,min_wait=5):
|
2019-08-02 01:25:58 -07:00
|
|
|
self.bsql=True
|
|
|
|
th=host.translate(_STRINGREMOVE)
|
2019-06-23 21:26:41 -07:00
|
|
|
self.sqlhost=th
|
2019-08-02 01:25:58 -07:00
|
|
|
self.sqlport=8080
|
|
|
|
if (isinstance(port,(int,float)) and not isinstance(port,bool)):
|
|
|
|
self.sqlport=int(port)
|
|
|
|
if self.sqlport<1024 or self.sqlport > 2**16:
|
|
|
|
self.bsql=False
|
2019-08-01 05:56:05 -07:00
|
|
|
self.sqlurl="http://"+self.sqlhost+":"+str(self.sqlport)+"/data/"+str(self.hash)
|
2019-08-02 01:25:58 -07:00
|
|
|
if isinstance(min_wait,(int,float)) and not isinstance(min_wait,bool):
|
2019-07-30 05:52:22 -07:00
|
|
|
self.sql_min_wait=min_wait
|
|
|
|
else:
|
|
|
|
self.sql_min_wait=0
|
2019-07-30 21:22:34 -07:00
|
|
|
self.brsa_sql=False
|
|
|
|
if self.brsa:
|
|
|
|
skey=gpg.list_keys(keys="@"+th)
|
|
|
|
if len(skey)>0:
|
|
|
|
self.brsa_sql=True
|
|
|
|
self.sql_rsa=skey[1]
|
|
|
|
else:
|
|
|
|
self.brsa_sql=False
|
2019-07-29 03:31:59 -07:00
|
|
|
def set_mqtt(self,broker="localhost",port=1883,topic=""):
|
2019-08-02 01:25:58 -07:00
|
|
|
mt=topic.translate(_STRINGREMOVE)
|
2019-07-02 05:17:52 -07:00
|
|
|
if len(mt)==0:
|
|
|
|
mt=self.device+"/"+self.sensor+"/"+self.var_name
|
|
|
|
else:
|
2019-07-02 07:28:15 -07:00
|
|
|
mt=mt.translate(":;\\{}(){]%&")
|
2019-08-02 01:25:58 -07:00
|
|
|
mb=broker.translate(_STRINGREMOVE)
|
|
|
|
mport=1883
|
|
|
|
if (isinstance(port,(int,float)) and not isinstance(port,bool)):
|
|
|
|
mport=int(port)
|
2019-07-02 08:11:41 -07:00
|
|
|
self.mqtt_broker=mb
|
|
|
|
self.mqtt_port=mport
|
2019-07-02 07:28:15 -07:00
|
|
|
self.mqtt_topic=mt
|
2019-07-30 05:52:22 -07:00
|
|
|
self.mqtt_bool=has_mqtt
|
|
|
|
if has_mqtt:
|
|
|
|
if mport < 1024:
|
|
|
|
mport=1883
|
|
|
|
try:
|
|
|
|
mqtt.connect(host=mb,port=mport)
|
|
|
|
except:
|
|
|
|
print("no connection to broker")
|
|
|
|
self.mqtt=False
|
|
|
|
#else:
|
|
|
|
else:
|
|
|
|
self.mqtt_bool=False
|
2019-06-23 21:26:41 -07:00
|
|
|
def set_file_log(self,store_file="/home/pi/data"):
|
|
|
|
if len(store_file)>1:
|
|
|
|
self.store_file=store_file+"_{:d}.txt"
|
|
|
|
try:
|
|
|
|
f1=open(self.store_file+"_{:d}.txt".format(int(time.time()/3600)),"a")
|
|
|
|
except:
|
|
|
|
print("could not open data storage")
|
|
|
|
self.bfile=False
|
|
|
|
else:
|
|
|
|
self.bfile=True
|
|
|
|
def show_def(self):
|
|
|
|
print(self.var_name)
|
|
|
|
print(self.value)
|
2019-07-01 01:43:38 -07:00
|
|
|
def set_device(self,device):
|
2019-08-02 01:25:58 -07:00
|
|
|
self.device=device.translate(_STRINGREMOVE)
|
2019-07-01 01:43:38 -07:00
|
|
|
def set_sensor(self,sensor):
|
2019-08-02 01:25:58 -07:00
|
|
|
ts=sensor.translate(_STRINGREMOVE)
|
2019-07-01 01:43:38 -07:00
|
|
|
self.sensor=ts
|
2019-06-30 12:23:04 -07:00
|
|
|
def set_multiplicator(self,multiplicator):
|
2019-07-01 01:43:38 -07:00
|
|
|
tmult=float(multiplicator)
|
|
|
|
if tmult < 1:
|
|
|
|
tmult=tmult*(-1)
|
|
|
|
self.mult=tmult
|
2019-06-23 21:26:41 -07:00
|
|
|
def append(self,value):
|
2019-08-02 01:25:58 -07:00
|
|
|
if (isinstance(value,(int,float)) and not isinstance(value,bool)):
|
|
|
|
tdif=-1
|
|
|
|
if value>0:
|
|
|
|
try:
|
|
|
|
tdig=10**(round(numpy.log10(value))-self.digits)
|
|
|
|
except:
|
|
|
|
print("")
|
|
|
|
else:
|
|
|
|
tdig=1
|
|
|
|
if tdig>=0:
|
|
|
|
try:
|
|
|
|
tv=round(value/tdig)*tdig
|
|
|
|
except:
|
|
|
|
tv=value
|
|
|
|
btv=True
|
|
|
|
if self.bchecklast and (len(self.value)>0):
|
|
|
|
# check if new value is within range between min - max
|
|
|
|
if (tv <= self.checklast_max) and (tv >= self.checklast_min):
|
|
|
|
btv=False
|
|
|
|
minmax=(self.checklast_max-self.checklast_min)*(1-self.checklast_shrinking)/2
|
|
|
|
if minmax>0:
|
|
|
|
self.checklast_max=self.checklast_max-minmax
|
|
|
|
self.checklast_min=self.checklast_min+minmax
|
|
|
|
if self.checklast_min>self.checklast_max:
|
|
|
|
self.checklaft_min=self.checklast_max
|
2019-07-29 21:23:49 -07:00
|
|
|
else:
|
2019-08-02 01:25:58 -07:00
|
|
|
# check if new value is exact within last values
|
|
|
|
testvalue=self.value[-1*min(self.checklast,len(self.value)):]
|
|
|
|
if isinstance(testvalue,list):
|
|
|
|
if tv in testvalue:
|
|
|
|
btv=False
|
|
|
|
else:
|
|
|
|
if tv==testvalue:
|
|
|
|
btv=False
|
|
|
|
if btv:
|
|
|
|
self.value.append(tv)
|
|
|
|
if self.bchecklast:
|
|
|
|
# calc new min/max values
|
|
|
|
checklast_amount=min(self.checklast,len(self.value))
|
|
|
|
btv=True
|
|
|
|
testvalue=[]
|
|
|
|
startcheck=len(self.value)-1
|
|
|
|
# get last unique values
|
|
|
|
while btv:
|
|
|
|
tv=self.value[startcheck]
|
|
|
|
if not tv in testvalue:
|
|
|
|
testvalue.append(tv)
|
|
|
|
startcheck=startcheck-1
|
|
|
|
if (startcheck<=0) or (len(testvalue)>self.checklast):
|
|
|
|
btv=False
|
|
|
|
if isinstance(testvalue,list):
|
|
|
|
if len(testvalue)>=3: # simple check for outlier
|
|
|
|
tvrmin=testvalue
|
|
|
|
tvrmax=testvalue
|
|
|
|
tvrmin.remove(min(tvrmin))
|
|
|
|
tvrmax.remove(max(tvrmin))
|
|
|
|
tvrminm=numpy.mean(tvrmin)
|
|
|
|
tvrmaxm=numpy.mean(tvrmax)
|
|
|
|
tvrmins=numpy.std(tvrmin)*3
|
|
|
|
tvrmaxs=numpy.std(tvrmax)*3
|
|
|
|
if min(testvalue)<(tvrminm-tvrmins):
|
|
|
|
testvalue.remove(min(testvalue))
|
|
|
|
if max(testvalue)>(tvrmaxm+tvrmaxs):
|
|
|
|
testvalue.remove(max(testvalue))
|
|
|
|
self.checklast_min=min(testvalue)
|
|
|
|
self.checklast_max=max(testvalue)
|
|
|
|
else:
|
|
|
|
self.checklast_min=testvalue
|
|
|
|
self.checklast_max=testvalue
|
|
|
|
if self.mqtt_bool:
|
|
|
|
_thread.start_new_thread(self.send_mqtt,(0,))
|
|
|
|
if self.bsql:
|
|
|
|
_thread.start_new_thread(self.send_sql,(0,))
|
|
|
|
if (len(self.mval)==0) and (len(self.value)>1):
|
|
|
|
self.stat_mean=numpy.mean(self.value)
|
|
|
|
self.stat_std=numpy.std(self.value)/numpy.sqrt(len(self.value)-1)
|
|
|
|
self.mval.append(value)
|
|
|
|
if self.bsense:
|
|
|
|
if len(self.mval)==self.mean_count:
|
|
|
|
mmean=numpy.mean(self.mval)
|
|
|
|
nstd=self.stat_std+numpy.std(self.mval)/numpy.sqrt(len(self.mval)-1)
|
|
|
|
bsave=self.bstoreeach
|
|
|
|
if abs(mmean-self.stat_mean) > (self.sigma*nstd):
|
|
|
|
bsave=True
|
|
|
|
if bsave:
|
|
|
|
if self.stat_val_std==0:
|
|
|
|
self.stat_val_std=abs(self.stat_val_mean/100)
|
|
|
|
nstd=10**(round(numpy.log10(numpy.maximum(0.001,numpy.std(self.mval))))-1)
|
|
|
|
mmean=round(mmean/nstd,0)*nstd
|
|
|
|
self.act_value=int(self.mult*mmean)
|
|
|
|
self.act_std=int(self.mult*numpy.std(self.mval))
|
|
|
|
self.act_time=int(1000*time.time())
|
|
|
|
if self.bfile:
|
|
|
|
_thread.start_new_thread(self.send_file,(0,))
|
|
|
|
if self.bsense:
|
|
|
|
_thread.start_new_thread(self.upload_osm,(0,))
|
|
|
|
self.mval=[]
|
|
|
|
if len(self.value)>=self.ring_length:
|
|
|
|
self.value=self.value[((-1)*self.ring_length):]
|
2019-06-23 21:26:41 -07:00
|
|
|
def get_ring(self):
|
|
|
|
return(self.value)
|
|
|
|
def get_act_value(self):
|
|
|
|
return(self.act_value)
|
|
|
|
def send_file(self,trigger=0):
|
|
|
|
try:
|
|
|
|
f1=open(self.store_file.format(int(time.time()/3600)),"a")
|
|
|
|
except:
|
|
|
|
print("could not open log file")
|
|
|
|
else:
|
|
|
|
f1.write("time:{0};".format(int(self.act_time))+self.var_name+":{0}".format(self.act_value)+"\n")
|
|
|
|
f1.close()
|
|
|
|
def send_sql(self,trigger=0):
|
2019-07-04 21:59:29 -07:00
|
|
|
sv=(-99)
|
|
|
|
if len(self.value)>0:
|
|
|
|
if len(self.value)>1:
|
|
|
|
if self.value[-1]!=self.value[-2]:
|
|
|
|
sv=self.value[-1]
|
|
|
|
else:
|
|
|
|
sv=self.value[-1]
|
|
|
|
if sv >(-99):
|
|
|
|
act_time=int(1000*time.time())
|
2019-07-29 03:31:59 -07:00
|
|
|
self.json_out['payload']['measures'][act_time]=int(sv*self.mult)
|
2019-07-31 03:30:42 -07:00
|
|
|
if ((act_time-self.sql_last_transmit)>(self.sql_min_wait*1000)) and (len(self.json_out['payload']['measures'])>0):
|
|
|
|
self.sign()
|
2019-07-04 21:59:29 -07:00
|
|
|
try:
|
2019-08-01 05:56:05 -07:00
|
|
|
self._r=requests.post(self.sqlurl,json=json.dumps(self.sql_out))
|
2019-07-04 21:59:29 -07:00
|
|
|
except:
|
2019-07-31 03:30:42 -07:00
|
|
|
self._r={"status_code":404}
|
2019-07-04 21:59:29 -07:00
|
|
|
else:
|
2019-07-31 03:30:42 -07:00
|
|
|
if self._r.status_code==200:
|
2019-07-30 05:52:22 -07:00
|
|
|
self.json_out['payload']['measures']={}
|
|
|
|
self.sql_last_transmit=time.time()*1000
|
2019-06-23 21:26:41 -07:00
|
|
|
def upload_osm(self,trigger=0):
|
2019-06-24 05:38:23 -07:00
|
|
|
if (self.act_time-self.sense_last_time)>(self.sense_intervall*1000):
|
2019-06-30 12:23:04 -07:00
|
|
|
r = requests.post(self.sense_url,json={'value': float(self.act_value)/self.mult})
|
2019-06-24 05:38:23 -07:00
|
|
|
if (r.status_code != requests.codes.ok) & (r.status_code != 201):
|
|
|
|
print("Error %d: %s" % (r.status_code,r.text))
|
|
|
|
else:
|
|
|
|
self.sense_last_time=self.act_time
|
2019-07-03 07:49:05 -07:00
|
|
|
def send_mqtt(self,trigger=0):
|
2019-07-04 21:59:29 -07:00
|
|
|
sv=(-99)
|
|
|
|
if len(self.value)>0:
|
|
|
|
if len(self.value)>1:
|
|
|
|
if self.value[-1]!=self.value[-2]:
|
2019-07-03 10:10:40 -07:00
|
|
|
sv=self.value[-1]
|
2019-07-04 21:59:29 -07:00
|
|
|
else:
|
|
|
|
sv=self.value[-1]
|
|
|
|
if sv >(-99):
|
|
|
|
try:
|
|
|
|
publish.single(self.mqtt_topic,sv,hostname=self.mqtt_broker,port=self.mqtt_port)
|
|
|
|
except:
|
|
|
|
print("could not send mqtt")
|
2019-06-23 21:26:41 -07:00
|
|
|
|
|
|
|
|