def variables(self, news: dict):
trigger_key = self.param['trigger_key']
if not trigger_key: return
if trigger_key not in news: return
new_val = news[trigger_key]
trigger_val = self.param['trigger_val']
if trigger_val and trigger_val != new_val: return
#TODO if..
out_time = int(float(self.param['out_time']) * 1000) #TODO
if self.triggered:
trigger_re = self.param['trigger_re']
#TODO retrigger
self.timer_next = Timer.clock() + out_time
else:
self.triggered = True
self.timer_next = Timer.clock() + out_time
Variable.set(self.param['out_key'], self.param['out_val_1'])
log(LOG_DEBUG, 'TimeSwitch for trigger {}', trigger_key)
def timer(self, prepare: bool):
while self.process():
print(self.value, self.unit, self.form)
key = self.param['RespVar']
source = self.param['NAME']
Variable.set(key, self.value, source)
if self._ser:
self._ser.write(COMMAND_READ)
def timer(self, prepare: bool):
name = self.param['RespVarCode']
if name:
val = touched()
print(val)
if val != self._last_val:
self._last_val = val
Variable.set(name, val)
def timer(self, prepare: bool):
name = self.param['RespVar']
if name:
val = self._i2c.read_byte()
print(val)
if val != self._last_val:
self._last_val = val
Variable.set(name, val)
def timer(self, prepare: bool):
name = self.param['RespVar']
if name:
data = self._i2c.read_buffer(2)
val = (data[1] << 8) | data[0]
#print(val)
if val != self._last_val:
self._last_val = val
Variable.set(name, val)
def timer(self, prepare:bool):
for key, reg in (('RespVarA', MCP23017_GPIOA), ('RespVarB', MCP23017_GPIOB)):
name = self.param[key]
if name:
val = self._i2c.read_reg_byte(reg)
print(val)
if val != self._last_val:
self._last_val = val
Variable.set(name, val)
def timer(self, prepare: bool):
name = self.param['RespVar']
if name:
#data = self._i2c.read_reg_buffer(0, 2)
data = self._i2c.read_buffer(2)
e = (data[0] >> 4) & 0x0F
m = ((data[0] & 0x0F) << 8) | data[1]
val = 0.01 * (1 << e) * m
print(val)
Variable.set(name, val)
def timer(self, prepare: bool):
name = self.param['RespVar']
if name:
data = self._i2c.read_buffer(2)
val = ((data[0] & 0xFF) << 3) | ((data[1] & 0x01) >> 5)
if val >= 0x400:
val -= 0x800
val /= 8
print(val)
Variable.set(name, val)
def timer(self, prepare:bool):
if self.sum_count:
source = self.param['NAME']
pm100 = self.sum_pm100 / self.sum_count
print(pm100)
key = self.param['RespVarPM100']
Variable.set(key, pm100, source)
self.sum_pm100 = 0
self.sum_count = 0
def timer(self, prepare: bool):
name = self.param['RespVar']
if name:
val = self._i2c.read_reg_word(0, little_endian=False, signed=True)
#print(val)
if self._map_adc_0 != self._map_adc_1:
val = (val - self._map_adc_0) \
/ (self._map_adc_1 - self._map_adc_0) \
* (self._map_val_1 - self._map_val_0) \
+ self._map_val_0
#print(val)
Variable.set(name, val)
def timer(self, prepare:bool):
name_t = self.param['RespVarT']
name_h = self.param['RespVarH']
if name_t or name_h:
data = self._i2c.read_reg_buffer(self, 0, 5)
#TODO Checksum data[4]
print(data)
if name_t:
t = data[2] + data[3]/10
Variable.set(name_t, t)
if name_h:
h = data[0] + data[1]/10
Variable.set(name_h, h)
def timer(self, prepare: bool):
data = self._i2c.read_reg_buffer(self._ctrl_reg, 5)
for i, key in enumerate(
['RespVar0', 'RespVar1', 'RespVar2', 'RespVar3'], 1):
name = self.param[key]
if name:
val = data[i]
if self._map_adc_0 != self._map_adc_1:
val = (val - self._map_adc_0) \
/ (self._map_adc_1 - self._map_adc_0) \
* (self._map_val_1 - self._map_val_0) \
+ self._map_val_0
print(val)
Variable.set(name, val)
def timer(self, prepare: bool):
name_t = self.param['RespVarT']
name_h = self.param['RespVarH']
if name_t or name_h:
self._i2c.write_buffer([0xE0, 0x00])
data = self._i2c.read_buffer(6)
#TODO Checksum data[2] data[5]
#print(data)
if name_t:
t = ((data[0] << 8) | data[1]) / (65535 / 175) - 45
Variable.set(name_t, t)
if name_h:
h = ((data[3] << 8) | data[4]) / 655.35
Variable.set(name_h, h)
def timer(self, prepare:bool):
if self.sum_count:
source = self.param['NAME']
pm2_5 = self.sum_pm2_5 / self.sum_count * 0.1
pm10 = self.sum_pm10 / self.sum_count * 0.1
#print(pm2_5, pm10)
key = self.param['RespVarPM2_5']
Variable.set(key, pm2_5, source)
key = self.param['RespVarPM10']
Variable.set(key, pm10, source)
self.sum_pm2_5 = 0
self.sum_pm10 = 0
self.sum_count = 0
def timer(self, prepare: bool):
if not self._i2c:
return
try:
name = self.param['RespVar']
if name:
val = self._i2c.read_byte()
print(val)
if val != self._last_val:
self._last_val = val
Variable.set(name, val)
except Exception as e:
print(str(e))
self._last_error = str(e)
def timer(self, prepare: bool):
self.idle()
counter = self._counter
clock = Timer.clock()
clock_diff = clock - self._last_clock
self._counter = 0
self._last_clock = clock
counter *= 1000 / clock_diff
scale_str = self.param['Scale']
if scale_str:
counter *= float(scale_str)
key = self.param['RespVar']
source = self.param['NAME']
Variable.set(key, counter, source)
def _process_inputs(self):
if not self._i2c:
return
print('+', end='')
try:
name = self.param['RespVar']
if name:
val = self._read()
print(val)
if val != self._last_val:
self._last_val = val
Variable.set(name, val)
except Exception as e:
print(str(e))
self._last_error = str(e)
def _process_inputs(self):
if not self._ser:
return
try:
name = self.param['RespVarDSR']
if name:
val = self._ser.dsr
if val != self._last_dsr:
self._last_dsr = val
Variable.set(name, self._get_val_obj(val))
name = self.param['RespVarCTS']
if name:
val = self._ser.cts
if val != self._last_cts:
self._last_cts = val
Variable.set(name, self._get_val_obj(val))
name = self.param['RespVarRI']
if name:
val = self._ser.ri
if val != self._last_ri:
self._last_ri = val
Variable.set(name, self._get_val_obj(val))
name = self.param['RespVarCD']
if name:
val = self._ser.cd
if val != self._last_cd:
self._last_cd = val
Variable.set(name, self._get_val_obj(val))
name = self.param['RespVarRXD']
if name:
val = self._ser.in_waiting > 0 # Hack: pull RXD pin to low get at least 1 char in buffer
if val:
self._ser.reset_input_buffer(
) # Hack: This leaves in_waiting to 1 if RXD pin is still low
if val != self._last_rxd:
self._last_rxd = val
Variable.set(name, self._get_val_obj(val))
except Exception as e:
self._last_error = str(e)
pass
def cmd_variable_set(cmd: dict) -> tuple:
""" sets the value of a variable """
key = cmd.get('key', None)
value = cmd.get('value', None)
source = cmd.get('SRC', None)
source = cmd.get('source', source)
try:
if type(value) is str:
value = json.loads(value)
except:
pass
last_tick = Variable.set(key, value, source)
return (0, last_tick)
def idle(self):
if not self._ser:
return
while self._ser.any():
data = self._ser.read()
data = data.decode()
sentence = self._gps.update(data)
if sentence:
#print(sentence, self._gps.timestamp)
if sentence == 'GPRMC' and self._gps.valid:
source = self.param['NAME']
#print(sentence, self._gps.timestamp, self._gps.local_offset)
key = self.param['RespVarPos']
if key:
lat = self._gps.latitude
lon = self._gps.longitude
pos = '{:d}°{:02d}\'{:02.1f}"{} {:d}°{:02d}\'{:02.1f}"{}'.format(
lat[0], int(lat[1]),
math.modf(lat[1])[0] * 60.0, lat[2], lon[0],
int(lon[1]),
math.modf(lon[1])[0] * 60.0, lon[2])
#pos = self._gps.latitude_string() + ' ' + self._gps.longitude_string()
Variable.set(key, pos, source)
key = self.param['RespVarLat']
if key:
lat = self._gps.latitude
value = lat[0] + lat[1] / 60
if lat[2] == 'S':
value = -value
Variable.set(key, value, source, '°', '{:.6f}')
key = self.param['RespVarLon']
if key:
lon = self._gps.longitude
value = lon[0] + lon[1] / 60
if lon[2] == 'W':
value = -value
Variable.set(key, value, source, '°', '{:.6f}')
key = self.param['RespVarAlt']
if key:
alt = self._gps.altitude
Variable.set(key, alt, source, 'm', '{:.1f}')
key = self.param['RespVarCrs']
if key:
crs = self._gps.course
Variable.set(key, crs, source, '°', '{:.1f}')
key = self.param['RespVarSpd']
if key:
spd = self._gps.speed[2]
Variable.set(key, spd, source, 'km/h', '{:.3f}')
def timer(self):
self.triggered = False
self.timer_next = None
Variable.set(self.param['out_key'], self.param['out_val_0'])
log(LOG_DEBUG, 'TimeSwitch reset')
def timer(self, prepare: bool):
log(5, 'ggTestA Timer')
Variable.set((self.param['NAME'], self.param['name_t']),
random.random())
def timer(self, prepare: bool):
while self.process():
print(self.value, self.unit, self.form)
key = self.param['RespVar']
source = self.param['NAME']
Variable.set(key, self.value, source, self.unit, self.form)
def timer(self, prepare: bool):
log(5, 'ggTestB Timer')
Variable.set((self.param['NAME'], 'Voltage'), random.random() * 23.0)
def timer(self, prepare: bool):
gest_data = self._i2c_read_reg_buffer(0x43, 1)
Variable.set(self.param["Gesture"], gest_data[0])
def timer(self, prepare: bool):
x, y, z = self._accel.x(), self._accel.y(), self._accel.z()
Variable.set((self.param['NAME'], self.param['name_x']), x)
Variable.set((self.param['NAME'], self.param['name_y']), y)
Variable.set((self.param['NAME'], self.param['name_z']), z)
def on_message(client, self, msg):
topic = self.param['SubVarPrefix'] + msg.topic.replace('/', '.')
payload = msg.payload.decode()
print(topic + " " + payload)
Variable.set(topic, payload, 'MQTT')
