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 init(self):
super().init()
ports = []
for n, (port_id, port_desc, hwid) in enumerate(sorted(comports()), 1):
port_str = port_id + ' - ' + port_desc
ports.append(port_str)
Machine.set_feature('UART', ports)
Machine.set_handler_class('UART', UART_PC)
def get_features(self):
features = {}
err, ret = Machine.get_features('UART')
if not err:
features['UARTS'] = ret
features['PNAME'] = self.module.PNAME
return features
def cmd_machine_pin(cmd: dict) -> tuple:
""" gets featue for MACHINE instances (merged) """
id = cmd.get('id', None)
value = cmd.get('value', 0)
err, ret = Machine.pin(id, value)
return (err, ret)
def cmd_machine_set(cmd: dict) -> tuple:
""" sets params for MACHINE instances (merged) """
params = cmd.get('params', None)
if params and type(params) is str:
params = json.loads(params)
err, ret = Machine.set_param(params)
return (err, ret)
def cmd_system_load(cmd:dict) -> tuple:
""" loads all configuration and parameters of the plugins from ezPiC.set """
try:
with open(CONFIG_FILE, 'r') as infile:
config_all = json.load(infile)
Device.load(config_all)
Machine.load(config_all)
Gadget.load(config_all)
Gateway.load(config_all)
Rule.load(config_all)
# ...
except FileNotFoundError as e:
pass
except Exception as e:
return (-101, 'Error on collectin load values - ' + str(e))
return (0, None)
def get_features(self):
features = {}
err, ret = Machine.get_features('I2C')
if not err:
features['Ports'] = ret
if self._last_error:
features['ERROR'] = self._last_error
self._last_error = None
features['Addrs'] = self.get_addrs()
features['PNAME'] = self.module.PNAME
return features
def cmd_system_save(cmd:dict) -> tuple:
""" saves all configuration and parameters of the plugins to cezPiC.set """
err = None
with open(CONFIG_FILE, 'w') as outfile:
try:
save_dict = {}
Device.save(save_dict)
Machine.save(save_dict)
Gadget.save(save_dict)
Gateway.save(save_dict)
Rule.save(save_dict)
# add other stuff like Gateway
if MICROPYTHON:
json.dump(save_dict, outfile)
else:
json.dump(save_dict, outfile, indent=2)
except Exception as e:
return (-100, 'Error on collectin save values - ' + str(e))
return (0, None)
def init(self):
super().init()
key = self.param['TrigVar']
out = self._get_variable(key)
id = self.param['Port']
err, ret = Machine.get_handler_instance('PIN_IO', id)
if not err:
self._pin = ret
self._pin.mode(self._pin.OUT)
self._pin.set(out)
else:
self._pin = None
def init(self):
super().init()
try:
id = self.param['PORT']
err, ret = Machine.get_handler_instance('UART', id)
if not err:
self._ser = ret
else:
self._ser = None
except Exception as e:
self._last_error = str(e)
self._ser = None
def init(self):
super().init()
if not self.param['ENABLE']:
return
try:
id = self.param['PORT']
err, ret = Machine.get_handler_instance('I2C', id)
if not err:
self._i2c = ret
self._addr = int(self.param['ADDR'].split(' ', 1)[0], 16)
else:
self._i2c = None
except Exception as e:
self._last_error = str(e)
self._i2c = None
def init(self):
super().init()
Machine.set_feature('PIN_IO', LIST_PIN_IO)
Machine.set_feature('PIN_I', LIST_PIN_IO)
Machine.set_feature('PIN_O', LIST_PIN_IO)
Machine.set_feature('PIN_ADC', LIST_PIN_ADC)
Machine.set_feature('PIN_DAC', LIST_PIN_DAC)
Machine.set_feature('I2C', LIST_I2C)
Machine.set_feature('SPI', LIST_SPI)
Machine.set_feature('UART', LIST_UART)
Machine.set_feature('CAN', LIST_CAN)
Machine.set_handler_class('PIN_IO', Pin_PyB)
Machine.set_handler_class('UART', UART_PyB)
def init(self):
super().init()
GPIO.setmode(GPIO.BCM)
GPIO.setwarnings(False)
Machine.set_feature('PIN_IO', LIST_PIN_IO)
Machine.set_feature('PIN_I', LIST_PIN_IO)
Machine.set_feature('PIN_O', LIST_PIN_IO)
Machine.set_feature('I2C', LIST_I2C)
Machine.set_feature('SPI', LIST_SPI)
ports = []
for n, (port_id, port_desc, hwid) in enumerate(sorted(comports()), 1):
port_str = port_id + ' - ' + port_desc
ports.append(port_str)
Machine.set_feature('UART', ports)
print(ports)
Machine.set_handler_class('PIN_IO', Pin_RPi)
Machine.set_handler_class('UART', UART_RPi)
Machine.set_handler_class('I2C', I2C_RPi)
def init(self):
super().init()
Machine.set_feature('I2C', LIST_I2C)
Machine.set_handler_class('I2C', I2C_PC)
def init(self):
super().init()
Machine.set_feature('PIN_IO', LIST_PIN_IO)
Machine.set_feature('PIN_I', LIST_PIN_IO)
Machine.set_feature('PIN_O', LIST_PIN_IO)
Machine.set_feature('I2C', LIST_I2C)
Machine.set_feature('SPI', LIST_SPI)
Machine.set_handler_class('PIN_IO', Pin_PC)
Machine.set_handler_class('I2C', I2C_PC)
def cmd_machine_list(cmd: dict) -> tuple:
""" gets a list of all available MACHINE plugins """
err, ret = Machine.get_plugin_list()
return (err, ret)
def cmd_machine_task_list(cmd: dict) -> tuple:
""" gets a list of all MACHINE instances """
err, ret = Machine.get_list()
return (err, ret)
def init(self):
super().init()
Machine.set_feature('PIN_IO', LIST_PIN_IO)
Machine.set_feature('PIN_I', LIST_PIN_IO)
Machine.set_feature('PIN_O', LIST_PIN_IO)
Machine.set_feature('I2C', LIST_I2C)
Machine.set_feature('SPI', LIST_SPI)
Machine.set_feature('UART', LIST_UART)
Machine.set_handler_class('PIN_IO', Pin_ESP32)
Machine.set_handler_class('I2C', I2C_ESP32)
Machine.set_handler_class('ADC', ADC_ESP32)
Machine.set_handler_class('UART', UART_ESP32)
def get_features(self):
features = {}
err, ret = Machine.get_features('PIN_O')
if not err:
features['PIN_O'] = ret
return features
def cmd_machine_feature(cmd: dict) -> tuple:
""" gets featue for MACHINE instances (merged) """
feature = cmd.get('feature', None)
err, ret = Machine.get_features(feature)
return (err, ret)
def cmd_machine_get(cmd: dict) -> tuple:
""" gets params from MACHINE instances (merged) """
key = cmd.get('key', None)
err, ret = Machine.get_param(key)
return (err, ret)
