def init(self):
super().init()
#if self._i2c and self.param['InitVal']:
self._i2c.write_byte(0)
Variable.set_meta(self.param['RespVar'], '°C', '{:.1f}')
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):
name = self.param['RespVarCode']
if name:
val = touched()
print(val)
if val != self._last_val:
self._last_val = val
Variable.set(name, val)
def init(self):
super().init()
#if self._i2c and self.param['InitVal']:
self._i2c.write_reg_buffer(1, [0xCE, 0x10])
self._i2c.write_byte(0)
Variable.set_meta(self.param['RespVar'], 'Lux', '{:.2f}')
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):
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 init(self):
super().init()
# set to cyclic measurement
self._i2c.write_buffer([0x22, 0x36])
Variable.set_meta(self.param['RespVarT'], '°C', '{:.1f}')
Variable.set_meta(self.param['RespVarH'], '%', '{:.1f}')
def main():
""" Entry point for ezPiC """
#test.main()
log(LOG_DEBUG, '# Starting main init')
if CNF['useIoT']:
Timer.init()
Cmd.init()
Machine.init()
Gadget.init()
Gateway.init()
Rule.init()
Device.init()
Variable.init()
if CNF['useCLI']:
CLI.init()
if CNF['useTelnet']:
TelnetServer.init(port=CNF['portTelnet'])
if CNF['useWeb']:
Web.init(port=CNF['portWeb'])
log(LOG_INFO, '# Starting main run')
if CNF['useIoT']:
Timer.run()
Cmd.run()
Machine.run()
Gadget.run()
Gateway.run()
Rule.run()
Device.run()
Variable.run()
# DEBUG
if not MICROPYTHON:
Cmd.excecute(
'vs Lorem_ {"e": 2, "d": 756, "c": 234, "b": 12313, "a": 123}')
Cmd.excecute('vs Lörém_ [0, 8, 15]')
Cmd.excecute('vs Lorem {"e":2,"d":756,"c":234,"b":12313,"a":123}')
Cmd.excecute('vs Lörém [0,8,15]')
log(LOG_DEBUG, '# Load settings')
Cmd.excecute("load")
if CNF['useWeb']:
log(LOG_DEBUG, '# Starting web server')
Web.run(
threaded=CNF['useIoT']) # this call never comes back .. normally
if CNF['useIoT']:
if CNF['useCLI']:
log(LOG_DEBUG, '# Starting CLI')
CLI.run(threaded=CNF['useTelnet'])
if CNF['useTelnet']:
log(LOG_DEBUG, '# Starting telnet server')
TelnetServer.run() # this call never comes back .. normally
log(LOG_ERROR, 'PANIC! Server terminated')
RUN = False
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_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):
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):
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 init(self):
super().init()
if self._ser:
self._ser.init(9600, 8, None,
1) # baud=9600 databits=8 parity=none stopbits=1
Variable.set_meta(self.param['RespVar'], 'ppm', '{:.0f}')
if self.timer_period < 1000:
self.timer_period = 1000
self.timer_next = 1
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 init(self):
super().init()
if self._ser:
self._ser.init(9600, 8, None, 1) # baud=9600 databits=8 parity=none stopbits=1
#self._ser.set_dtr(True) # DTR-pin to +
#self._ser.set_rts(False) # RTS-pin to -
Variable.set_meta(self.param['RespVarPM100'], UNIT, '{:.1f}')
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 variables(self, news: dict):
for i, key in enumerate(
'TrigVar0',
'TrigVar1',
'TrigVar2',
'TrigVar3',
'TrigVar4',
'TrigVar5',
'TrigVar6',
'TrigVar7',
'TrigVar8',
'TrigVar9',
'TrigVarA',
'TrigVarB',
'TrigVarC',
'TrigVarD',
'TrigVarE',
'TrigVarF',
):
name = self.param[key]
if name and name in news:
val = Variable.get(name)
if type(val) == list:
for ii, subval in enumerate(val, i):
self._set_val(ii, subval)
else:
self._set_val(i, val)
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 _is_variable_active(self, name):
val = str(Variable.get(name))
if self.param['TrigVals1'] and self.param['TrigVals1'].find(val) >= 0:
return True
return False
def _get_variable(self, key):
val = str(Variable.get(key))
if self.param['TrigVals1'] and self.param['TrigVals1'].find(val) >= 0:
return True
return False
def cmd_variable_list(cmd: dict) -> tuple:
""" gets a list of dics with variable key and formatted value """
index = cmd['IDX']
last_tick, variables = Variable.get_news(index)
ret = {'tick': last_tick, 'variables': variables}
return (0, ret)
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 cmd_variable_full_list(cmd: dict) -> tuple:
""" gets a list of dics with all variable parameters """
index = cmd['IDX']
last_tick, variables = Variable.get_news_full(index)
ret = {'tick': last_tick, 'variables': variables}
return (0, ret)
def variables(self, news: dict):
name = self.param['TrigVar']
if name and name in news:
val = Variable.get(name)
if type(val) == str:
val = int(val, 0)
if 0 <= val <= 0xFFFF:
self._i2c.write_buffer([val & 0xFF, (val >> 8) & 0xFF])
def variables(self, news: dict):
name = self.param['TrigVar']
if name and name in news:
val = Variable.get(name)
if type(val) == str:
val = int(val, 0)
if 0 <= val <= 255:
self._i2c.write_byte(val)
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)
