HydroBot/hydrobot-software Changeset - 7b33cc2da5f0

Changeset - 7b33cc2da5f0

Parent rev.

Child rev.

[Not reviewed]

tip refactor

0 6 0

matthewreed - 6 years ago 2020-02-25 20:19:03

Added new gas sensing and other stuff from a long time ago

6 files changed with 197 insertions and 61 deletions:

alerts.py

database.py

hydrobot.py

hydrobot_def.json

module.py

network_interface.py

0 comments (0 inline, 0 general)

alerts.py

➞

Show inline comments

 import smtplib
 from email.mime.text import MIMEText
 from abc import ABCMeta, abstractmethod
 import configparser
 import logging
 class AlertManager:
     def __init__(self, config):
+    def __init__(self, database, config):
         self.logger = logging.getLogger('hydrobot')
         self.database = database
         self.from_addr = config.get("alerts", "from_address")
         self.to_addr  = config.get("alerts", "to_address")
         self.mail_server = config.get("alerts", "mail_server")
         self.username = config.get("alerts", "username")
         self.password = config.get("alerts", "password")
         self.alerts = []
         self.load_alerts(config)
     def load_alerts(self, config):
         for section in config.sections():
             if "alert" in section and section != "alerts":
                 type = config.get(section, "type")
                 if type == "output_feedback":
                     name = config.get(section, "name")
                     output_module = config.get(section, "output_module")
                     output_type = config.get(section, "output_type")
                     output_number = config.get(section, "output_number")
                     input_module = config.get(section, "input_module")
                     input_type = config.get(section, "input_type")
                     input_number = config.get(section, "input_number")
                     on_threshold = config.getfloat(section, "on_threshold")
                     off_threshold = config.getfloat(section, "off_threshold")
@@ @@ -38,100 +39,108 @@ class AlertManager: @@
                     name = config.get(section, "name")
                     input_module = config.get(section, "input_module")
                     input_type = config.get(section, "input_type")
                     input_number = config.get(section, "input_number")
                     high_threshold = config.getfloat(section, "high_threshold")
                     low_threshold = config.getfloat(section, "low_threshold")
                     hysteresis = config.getfloat(section, "hysteresis")
                     self.alerts.append(MeasurementAlert(self, name, input_module, input_type, input_number, high_threshold, low_threshold, hysteresis))
     def send_alert(self, message):
         msg = MIMEText(message)
         msg['Subject'] = "HydroBot Alert"
         msg['From'] = self.from_addr
         msg['To'] = self.to_addr
         try:
             server = smtplib.SMTP(self.mail_server)
             server.ehlo()
             server.starttls()
             server.login(self.username, self.password)
             server.send_message(msg)
             server.quit()
-            self.logger.debug("Sent email alert: " + message)
+            self.logger.info("Sent email alert: " + message)
         except:
             self.logger.error("Sending email alert failed!")
     def evaluate_alerts(self):
         for alert in self.alerts:
             alert.evalutate()
 class Alert(metaclass=ABCMeta):
     def __init__(self, manager, name):
         self.manager = manager
         self.name = name
     @abstractmethod
     def evalutate(self):
         pass
 class OutputFeedbackAlert(Alert):
     def __init__(self, manager, name, output_module, output_type, output_number, input_module, input_type, input_number, on_threshold, off_threshold, hysteresis):
         super(OutputFeedbackAlert, self).__init__(manager, name)
         self.output_module = output_module
         self.output_type = output_type
         self.output_number = output_number
         self.input_module = input_module
         self.input_type = input_type
         self.input_number = input_number
         self.on_threshold = on_threshold
         self.off_threshold = off_threshold
         self.hysteresis = hysteresis
     def evalutate(self):
         #get output status
         output_status = 1
         output_status = self.manager.database.read_value(self.output_module, self.output_type, int(self.output_number))
         print("Output status: " + str(output_status))
         #get input status
         input_status = 0
         if output_status == 1:
             if input_status < self.on_threshold:
                 #alert!
                 print("Alert! " + self.name + " did not turn on!")
                 self.manager.send_alert("Alert! " + self.name + " did not turn on!")
         if output_status == 0:
             if input_status > self.off_threshold:
                 #alert!
                 print("Alert! " + self.name + " did not turn off!")
                 self.manager.send_alert("Alert! " + self.name + " did not turn off!")
         input_status = self.manager.database.read_value(self.input_module, self.input_type, int(self.input_number))
         print("Input status: " + str(input_status))
         if input_status != None:
             if output_status == 1:
                 if input_status < self.on_threshold:
                     #alert!
                     #print("Alert! " + self.name + " did not turn on!")
                     self.manager.send_alert("Alert! " + self.name + " did not turn on!")
             if output_status == 0:
                 if input_status > self.off_threshold:
                     #alert!
                     #print("Alert! " + self.name + " did not turn off!")
                     self.manager.send_alert("Alert! " + self.name + " did not turn off!")
 class MeasurementAlert(Alert):
     def __init__(self, manager, name, input_module, input_type, input_number, high_threshold, low_threshold, hysteresis):
         super(MeasurementAlert, self).__init__(manager, name)
         self.input_module = input_module
         self.input_type = input_type
         self.input_number = input_number
         self.high_threshold = high_threshold
         self.low_threshold = low_threshold
         self.hysteresis = hysteresis
     def evalutate(self):
         #get input status
         input_status = 0
         if input_status > self.high_threshold:
             #alert!
             print("Alert! " + self.name + " is too high!")
             self.manager.send_alert("Alert! " + self.name + " is too high!")
         if input_status < self.low_threshold:
             #alert!
             print("Alert! " + self.name + " is too low!")
             self.manager.send_alert("Alert! " + self.name + " is too low!")
         #get measurement
         measurement = self.manager.database.read_value(self.input_module, self.input_type, int(self.input_number))
         print("Measurement: " + str(measurement))
         if measurement != None:
             if measurement > self.high_threshold:
                 #alert!
                 #print("Alert! " + self.name + " is too high!")
                 self.manager.send_alert("Alert! " + self.name + " is too high!")
             if measurement < self.low_threshold:
                 #alert!
                 #print("Alert! " + self.name + " is too low!")
                 self.manager.send_alert("Alert! " + self.name + " is too low!")

database.py

➞

Show inline comments

@@ @@ -8,52 +8,73 @@ class MySeriesHelper(SeriesHelper): @@
     # Meta class stores time series helper configuration.
     class Meta:
         # The client should be an instance of InfluxDBClient.
         #client = myclient
         # The series name must be a string. Add dependent fields/tags in curly brackets.
         series_name = '{measurement}'
         # Defines all the fields in this time series.
         fields = ['value']
         # Defines all the tags for the series.
         tags = ['measurement']
         # Defines the number of data points to store prior to writing on the wire.
         bulk_size = 5
         # autocommit must be set to True when using bulk_size
         autocommit = True
 class Database:
     def __init__(self, config):
         self.logger = logging.getLogger('hydrobot')
         host = config.get("database", "host")
         port = config.get("database", "port")
         username = config.get("database", "username")
         password = config.get("database", "password")
         database = config.get("database", "database")
+        self.database = config.get("database", "database")
         self.name = config.get("system", "name")
         try:
             self.client = InfluxDBClient(host, port, username, password, database)
+            self.client = InfluxDBClient(host, port, username, password, self.database)
             MySeriesHelper.Meta.client = self.client
             MySeriesHelper.Meta.series_name = self.name + '.{measurement}'
             self.logger.info("Connected to database")
         except:
             self.logger.error("Could not connect to database")
         # To manually submit data points which are not yet written, call commit:
         #MySeriesHelper.commit()
     def log_message(self, name, message):
         data_name = protocol.lookup_data_name_by_key(message.data_key)
         if not data_name == None:
             if message.sensor_num > 0:
                 num = "_" + str(message.sensor_num)
             else:
                 num = ""
             try:
                 self.logger.debug("Database log: " + name + "." + data_name + num)
                 MySeriesHelper(measurement=(name + "." + data_name + num), value=(float)(message.data))
             except:
                 self.logger.error("Database issue!")
         else:
             self.logger.warning("Unknown data key: " + str(message))
     def read_value(self, name, data_name, sensor_num):
         #try:
         if sensor_num > 0:
             num = "_" + str(sensor_num)
         else:
             num = ""
         measurement = "\"" + self.name + "." + name + "." + data_name + num + "\""
         results = self.client.query(("SELECT last(\"value\") from %s") % (measurement))
         points = results.get_points()
         for item in points:
             return item["last"]
         #except:
         #    self.logger.error("Database issue!")

hydrobot.py

➞

Show inline comments

 #!/usr/bin/env python
 import sys
 import time
 import signal
 import configparser
 import logging
 import network
 import network_interface
 from message import HydroBotMessage
 import module
 import protocol
 from database import Database
 from scheduler import Scheduler
 import alerts
 #TODO
 #add periodic output refresh
 #add output cleanup on shutdown
 #validate config settings on load
 #load config file
 config = configparser.ConfigParser(allow_no_value = True)
 config.read("hydrobot.conf")
 #set up logger
 logger = logging.getLogger('hydrobot')
 log_level = config.get("system", "log_level")
 levels = {"CRITICAL" : 50, "ERROR" : 40, "WARNING" : 30, "INFO" : 20, "DEBUG" : 10, "NOTSET" : 0}
 logger.setLevel(levels[log_level])
 fh = logging.FileHandler('hydrobot.log')
 fh.setLevel(logging.INFO)
 formatter = logging.Formatter('[%(asctime)s][%(levelname)s][%(module)s][%(funcName)s] %(message)s') #('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
 fh.setFormatter(formatter)
 logger.addHandler(fh)
 ch = logging.StreamHandler(sys.stdout)
 ch.setLevel(logging.DEBUG)
 formatter = logging.Formatter('[%(asctime)s][%(levelname)s][%(module)s][%(funcName)s] %(message)s') #('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
 ch.setFormatter(formatter)
 logger.addHandler(ch)
 logger.info('Logger initialized')
 def main(argv):
     logger.info("Starting HydroBot!")
     if len(argv) < 1:
         logger.error("Please specify a can interface")
         return 1
     #if len(argv) < 1:
     #    logger.error("Please specify a can interface")
     #    return 1
     database = Database(config)
     module_network = network.Network(database, config)
     module_network.start_all_interfaces()
     scheduler = Scheduler(module_network, config)
     scheduler.start()
     alert_manager = alerts.AlertManager(database, config)
     #alert_manager.evaluate_alerts()
     while True:
         time.sleep(0.1)
 def close_program(signum, frame):
     logger.info("Closing now!")
     sys.exit(0)
 signal.signal(signal.SIGINT, close_program)
 if __name__ == "__main__":
     main(sys.argv[1:])

hydrobot_def.json

➞

Show inline comments

@@ @@ -19,53 +19,62 @@ @@
                     "functions" : [
                         "air_temp"
+                    ]
                 },
+                {
                     "name" : "humidity",
                     "type" : "input",
                     "sensor_num" : "0",
                     "functions" : [
                         "air_humidity"
+                    ]
                 },
+                {
                     "name" : "pressure",
                     "type" : "input",
                     "sensor_num" : "0",
                     "functions" : [
                         "air_pressure"
+                    ]
                 },
+                {
-                    "name" : "light",
+                    "name" : "eco2",
                     "type" : "input",
                     "sensor_num" : "0",
                     "functions" : [
                         "ambient_light"
                         "air_eco2"
+                    ]
                 },
+                {
                     "name" : "tvoc",
                     "type" : "input",
                     "sensor_num" : "0",
                     "functions" : [
                         "air_tvoc"
+                    ]
+                }
+            ]
         },
+        {
             "id" : "0x02",
             "name" : "relaydrive",
             "display" : "RelayDrive",
             "class" : "RelayDriveModule",
             "sensors" : [
+                {
                     "name" : "input_1",
                     "type" : "input",
                     "sensor_num" : "1",
                     "functions" : [
                         "digital_in",
                         "freq_in"
+                    ]
                 },
+                {
                     "name" : "input_2",
                     "type" : "input",
                     "sensor_num" : "2",
@@ @@ -211,49 +220,77 @@ @@
+                {
                     "name" : "temp",
                     "type" : "input",
                     "sensor_num" : "0",
                     "functions" : [
                         "water_temp"
+                    ]
                 },
+                {
                     "name" : "level",
                     "type" : "input",
                     "sensor_num" : "0",
                     "functions" : [
                         "water_level"
+                    ]
+                }
+            ]
         },
+        {
             "id" : "0x04",
             "name" : "protomodule",
             "display" : "ProtoModule",
             "class" : "ProtoModule"
             "class" : "ProtoModule",
             "sensors" : [
+                {
                     "name" : "ph",
                     "type" : "input",
                     "sensor_num" : "0",
                     "functions" : [
                         "ph"
+                    ]
+                }
+            ]
         },
+        {
             "id" : "0x05",
             "name" : "lightsense",
             "display" : "LightSense",
             "class" : "LightSense",
             "sensors" : [
+                {
                     "name" : "light",
                     "type" : "input",
                     "sensor_num" : "0",
                     "functions" : [
                         "ambient_light"
+                    ]
+                }
+            ]
+        }
     ],
     "data_keys" : [
+        {
             "key" : "0x0001",
             "name" : "digital_in",
             "display" : "Digital Input",
             "units" : "bool"
         },
+        {
             "key" : "0x0002",
             "name" : "freq_in",
             "display" : "Frequency Input",
             "units" : "Hz"
         },
+        {
             "key" : "0x0003",
             "name" : "analog_in",
             "display" : "Analog Input",
             "units" : "V"
         },
+        {
             "key" : "0x0004",
             "name" : "digital_out",
@@ @@ -300,48 +337,60 @@ @@
             "key" : "0x000B",
             "name" : "water_temp",
             "display" : "Water Temp",
             "units" : "degC"
         },
+        {
             "key" : "0x000C",
             "name" : "water_level",
             "display" : "Water Level",
             "units" : "%Full"
         },
+        {
             "key" : "0x000D",
             "name" : "ec",
             "display" : "Conductivity",
             "units" : "uS"
         },
+        {
             "key" : "0x000E",
             "name" : "ph",
             "display" : "pH",
             "units" : "pH"
         },
+        {
             "key" : "0x000F",
             "name" : "air_eco2",
             "display" : "Air eCO2",
             "units" : "ppm"
         },
+        {
             "key" : "0x0010",
             "name" : "air_tvoc",
             "display" : "Air TVOC",
             "units" : "ppb"
         },
+        {
             "key" : "0x0100",
             "name" : "can_id",
             "display" : "CAN ID",
             "units" : "hex"
         },
+        {
             "key" : "0x0101",
             "name" : "data_rate",
             "display" : "Data Rate",
             "units" : "seconds"
         },
+        {
             "key" : "0x0102",
             "name" : "led_brightness",
             "display" : "LED Brightness",
             "units" : "%"
         },
+        {
             "key" : "0x0103",
             "name" : "input",
             "display" : "Input",
             "units" : ""
         },
+        {

module.py

➞

Show inline comments

@@ @@ -160,43 +160,81 @@ class RelayDriveModule(Module): @@
     def set_output(self, output, value):
         message = HydroBotMessage(self.uuid, (0x80 | protocol.lookup_command_key_by_name("set_output")), protocol.lookup_data_key_by_name("digital_out"), int(output), value)
         self.send_message(message)
         self.database.log_message(self.name, message)
 class WaterSenseModule(Module):
     def __init__(self, address, interface, name, database):
         super(WaterSenseModule, self).__init__(address, interface, name, database)
     def send_message(self, message):
         self.interface.network.send_message(message)
     def receive_message(self, message):
         self.logger.debug("Receive message! From: " + self.name)
         self.database.log_message(self.name, message)
     def update(self):
         pass
     def config(self, data_key, sensor_num, value):
         message = HydroBotMessage(self.uuid, (0x80 | protocol.lookup_command_key_by_name("config")), protocol.lookup_data_key_by_name(data_key), sensor_num, value)
         self.interface.send_message(message)
 class ProtoModule(Module):
     def __init__(self, address, interface, name, database):
         super(ProtoModule, self).__init__(address, interface, name, database)
     def send_message(self, message):
         self.interface.network.send_message(message)
     def receive_message(self, message):
         self.logger.debug("Receive message! From: " + self.name)
         self.database.log_message(self.name, message)
     def update(self):
         pass
     def config(self, data_key, sensor_num, value):
         message = HydroBotMessage(self.uuid, (0x80 | protocol.lookup_command_key_by_name("config")), protocol.lookup_data_key_by_name(data_key), sensor_num, value)
         self.interface.send_message(message)
 class LightSenseModule(Module):
     def __init__(self, address, interface, name, database):
         super(LightSenseModule, self).__init__(address, interface, name, database)
     def send_message(self, message):
         self.interface.network.send_message(message)
     def receive_message(self, message):
         self.logger.debug("Receive message! From: " + self.name)
         self.database.log_message(self.name, message)
     def update(self):
         pass
     def config(self, data_key, sensor_num, value):
         message = HydroBotMessage(self.uuid, (0x80 | protocol.lookup_command_key_by_name("config")), protocol.lookup_data_key_by_name(data_key), sensor_num, value)
         self.interface.send_message(message)
 class UnknownModule(Module):
     def __init__(self, address, interface, name, database):
         super(UnknownModule, self).__init__(address, interface, name, database)
     def send_message(self, message):
         pass
     def receive_message(self, message):
         self.logger.debug("Receive message! From: " + self.name)
     def update(self):
         pass
     def config(self, data_key, sensor_num, value):
         message = HydroBotMessage(self.uuid, (0x80 | protocol.lookup_command_key_by_name("config")), protocol.lookup_data_key_by_name(data_key), sensor_num, value)
         self.interface.send_message(message)

network_interface.py

➞

Show inline comments

@@ @@ -15,86 +15,100 @@ from canard.utils import queue @@
 class NetworkInterface(metaclass=ABCMeta):
     def __init__(self, network):
         self.logger = logging.getLogger('hydrobot')
         self.network = network
     @abstractmethod
     def start(self):
         self.logger.info("Network: start")
     @abstractmethod
     def send_message(self, message):
         pass
     def process_message(self, message):
         self.logger.debug("Network Interface: process message")
 class CanBusNetworkInterface(NetworkInterface):
     def __init__(self, network, interface_name):
         super(CanBusNetworkInterface, self).__init__(network)
         # Bring up CAN interface (maybe do this in a systemd service file)
         # Passing random arguments to sudo is super dangerous
         os.system("sudo ip link set " + interface_name + " up type can bitrate 500000")
         self.interface_name = interface_name
         self.dev = socketcan.SocketCanDev(interface_name)
         self.queue = queue.CanQueue(self.dev)
         try:
             # Bring up CAN interface (maybe do this in a systemd service file)
             # Passing random arguments to sudo is super dangerous
             os.system("sudo ip link set " + interface_name + " up type can bitrate 500000")
             self.interface_name = interface_name
             self.queue = None
             self.dev = socketcan.SocketCanDev(interface_name)
             self.queue = queue.CanQueue(self.dev)
         except:
             self.logger.error("Can Bus failed to initilize")
         #bidirectional address <==> uuid lookup
         self.address_lookup = {}
         self.uuid_lookup = {}
     def start(self):
         super(CanBusNetworkInterface, self).start()
         self.logger.info("CanBusNetworkInterface: start")
         self.queue.start()
         _thread.start_new_thread(self.process_message, ())
         if self.queue != None:
             self.queue.start()
             _thread.start_new_thread(self.process_message, ())
         else:
             self.logger.error("Can Bus failed to start")
     def send_message(self, message):
         address = self.uuid_lookup[message.module_uuid]
         can_frame = can.Frame(address, 8, [message.message_type, (message.data_key>>8) & 0xff, (message.data_key>>0) & 0xff, message.sensor_num] + list(struct.pack("f", message.data)))
         self.logger.debug("Send CAN message! CAN ID: " + hex(can_frame.id) + " Data: " + str(can_frame.data))
         self.queue.send(can_frame)
         if self.queue != None:
             self.queue.send(can_frame)
         else:
             self.logger.error("Can Bus is not initilized")
     def process_message(self):
         while True:
             frame = self.queue.recv()
             if frame != None:
                 base_id = frame.id & 0x7fe
             if self.queue != None:
                 frame = self.queue.recv()
                 if not base_id in self.address_lookup:
                     self.logger.debug("Uknown module address: " + hex(base_id))
                     device_id = frame.data[0] & 0x7f
                     new_module = self.network.module_list.new_module(device_id, base_id, self)
                     self.address_lookup[base_id] = new_module.uuid
                     self.uuid_lookup[new_module.uuid] = base_id
                 self.logger.debug("Received CAN message! ID: " + hex(frame.id))
                 data = [frame.data[7], frame.data[6], frame.data[5], frame.data[4]]
                 b = struct.pack('4B', *data)
                 f_data = struct.unpack('>f', b)[0]
                 message = HydroBotMessage(self.address_lookup[base_id], frame.data[0], ((frame.data[1] << 8) + frame.data[2]), frame.data[3], f_data)
                 self.logger.debug("Process message: " + str(message))
                 self.network.process_message(message)
                 if frame != None:
                     base_id = frame.id & 0x7fe
                     if not base_id in self.address_lookup:
                         self.logger.debug("Uknown module address: " + hex(base_id))
                         device_id = frame.data[0] & 0x7f
                         new_module = self.network.module_list.new_module(device_id, base_id, self)
                         self.address_lookup[base_id] = new_module.uuid
                         self.uuid_lookup[new_module.uuid] = base_id
                     self.logger.debug("Received CAN message! ID: " + hex(frame.id))
                     data = [frame.data[7], frame.data[6], frame.data[5], frame.data[4]]
                     b = struct.pack('4B', *data)
                     f_data = struct.unpack('>f', b)[0]
                     message = HydroBotMessage(self.address_lookup[base_id], frame.data[0], ((frame.data[1] << 8) + frame.data[2]), frame.data[3], f_data)
                     self.logger.debug("Process message: " + str(message))
                     self.network.process_message(message)
             else:
                 self.logger.error("Can Bus is not initilized")
 class WifiNetworkInterface(NetworkInterface):
     def __init__(self, network):
         super(WifiNetworkInterface, self).__init__(network)
     def start(self):
         pass
     def send_message(self, message):
         pass
     def process_message(self, message):
         pass

0 comments (0 inline, 0 general)