123 lines
3.8 KiB
Python
123 lines
3.8 KiB
Python
import logging.handlers
|
|
import time
|
|
import os
|
|
import json
|
|
from controllers import ModbusRTURead, EthernetIPRead
|
|
from tb_gateway_mqtt import TBDeviceMqttClient, RateLimit
|
|
def parse_config(config_file):
|
|
"""Parses the configuration file and returns a dictionary."""
|
|
|
|
with open(config_file, 'r') as f:
|
|
config = json.load(f)
|
|
|
|
return config
|
|
|
|
CONFIG_DATA = parse_config('device_supervisor.cfg')
|
|
THINGSBOARD_SERVER = CONFIG_DATA['clouds'][0]['args']['host']
|
|
ACCESS_TOKEN = CONFIG_DATA['clouds'][0]['args']['username']
|
|
# Convert string level to logging level constant
|
|
logging_levels = {
|
|
"DEBUG": logging.DEBUG,
|
|
"INFO": logging.INFO,
|
|
"WARNING": logging.WARNING,
|
|
"ERROR": logging.ERROR,
|
|
"CRITICAL": logging.CRITICAL
|
|
}
|
|
log_level_int = logging_levels.get(CONFIG_DATA['misc']['logLvl'], logging.INFO)
|
|
logging.basicConfig(filename='main.log',
|
|
level=log_level_int,
|
|
format='%(asctime)s - %(levelname)s - %(message)s')
|
|
|
|
client = None
|
|
|
|
# default blinking period
|
|
period = 1.0
|
|
|
|
|
|
|
|
# callback function that will call when we will change value of our Shared Attribute
|
|
|
|
|
|
def attribute_callback(result, _):
|
|
logging.info(result)
|
|
# make sure that you paste YOUR shared attribute name
|
|
period = result.get('blinkingPeriod', 1.0)
|
|
|
|
# callback function that will call when we will send RPC
|
|
|
|
|
|
def rpc_callback(id, request_body):
|
|
# request body contains method and other parameters
|
|
logging.info(request_body)
|
|
method = request_body.get('method')
|
|
if method == 'getTelemetry':
|
|
attributes, telemetry = get_data()
|
|
client.send_attributes(attributes)
|
|
client.send_telemetry(telemetry)
|
|
else:
|
|
logging.error('Unknown method: ' + method)
|
|
|
|
|
|
def get_data(controllers=[], measures=[], groups=[]):
|
|
for measure in measures:
|
|
logging.info(f"Controller: {measure['ctrlName']}, Measure: {measure['name']}, Group: {measure['group']}")
|
|
if controllers[measure['ctrlName']]['protocol'] == "Modbus-RTU":
|
|
logging.info(ModbusRTURead())
|
|
elif controllers[measure['ctrlName']]['protocol'] == "EtherNet/IP":
|
|
logging.info(EthernetIPRead())
|
|
attributes = {
|
|
"latestReportTime": int(round(time.time() * 1000))
|
|
}
|
|
telemetry = {
|
|
"test": "test"
|
|
}
|
|
logging.info(attributes, telemetry)
|
|
return attributes, telemetry
|
|
|
|
# request attribute callback
|
|
|
|
|
|
def sync_state(result, exception=None):
|
|
global period
|
|
if exception is not None:
|
|
logging.info("Exception: " + str(exception))
|
|
else:
|
|
period = result.get('shared', {'blinkingPeriod': 1.0})[
|
|
'blinkingPeriod']
|
|
|
|
def rearrange_config(config):
|
|
out = {}
|
|
for c in config:
|
|
out[c['name']] = c
|
|
return out
|
|
def main():
|
|
global client
|
|
# Example Usage:
|
|
|
|
controllers = rearrange_config(CONFIG_DATA['controllers'])
|
|
measures = CONFIG_DATA['measures']
|
|
groups = rearrange_config(CONFIG_DATA['groups'])
|
|
logging.info(controllers)
|
|
client = TBDeviceMqttClient(THINGSBOARD_SERVER, username=ACCESS_TOKEN, rate_limit="10:1,60:60,")
|
|
client.connect()
|
|
client.request_attributes(
|
|
shared_keys=['blinkingPeriod'], callback=sync_state)
|
|
|
|
# now attribute_callback will process shared attribute request from server
|
|
sub_id_1 = client.subscribe_to_attribute(
|
|
"blinkingPeriod", attribute_callback)
|
|
sub_id_2 = client.subscribe_to_all_attributes(attribute_callback)
|
|
|
|
# now rpc_callback will process rpc requests from server
|
|
client.set_server_side_rpc_request_handler(rpc_callback)
|
|
|
|
while not client.stopped:
|
|
attributes, telemetry = get_data(controllers=controllers, measures=measures, groups=groups)
|
|
client.send_attributes(attributes)
|
|
client.send_telemetry({"ts": int(round(time.time() * 1000)), "values": telemetry})
|
|
time.sleep(60)
|
|
|
|
|
|
if __name__ == '__main__':
|
|
main()
|