boneIO 0.1.0.dev14__tar.gz → 0.1.0.dev16__tar.gz

{boneio-0.1.0.dev14 → boneio-0.1.0.dev16}/PKG-INFO

@@ -1,10 +1,10 @@
 Metadata-Version: 2.1
 Name: boneio
-Version: 0.1.0.dev14
+Version: 0.1.0.dev16
 Summary: Python Helper for BoneIO
 Home-page: https://github.com/maciejk1984/boneIO
 License: GNU General Public License v3.0
-Download-URL: https://github.com/maciejk1984/boneIO/archive/0.1.0.dev14.zip
+Download-URL: https://github.com/maciejk1984/boneIO/archive/0.1.0.dev16.zip
 Platform: UNKNOWN
 Classifier: Programming Language :: Python
 Classifier: Programming Language :: Python :: 3.7

{boneio-0.1.0.dev14 → boneio-0.1.0.dev16}/boneio/bonecli.py

@@ -8,7 +8,7 @@ from colorlog import ColoredFormatter
 
 from boneio.const import (
     ENABLED,
-    GPIO_INPUT,
+    INPUT,
     HA_DISCOVERY,
     HOST,
     MCP23017,
@@ -20,6 +20,7 @@ from boneio.const import (
     TOPIC_PREFIX,
     USERNAME,
     LM75,
+    ADC,
 )
 from boneio.helper import CustomValidator, load_yaml_file
 from boneio.manager import Manager
@@ -135,12 +136,13 @@ async def run(ctx, debug: int, config: str, mqttpassword: str = ""):
         send_message=client.send_message,
         topic_prefix=_config[MQTT][TOPIC_PREFIX],
         relay_pins=_config.get(OUTPUT, []),
-        input_pins=_config.get(GPIO_INPUT, []),
+        input_pins=_config.get(INPUT, []),
         ha_discovery=_config[MQTT][HA_DISCOVERY][ENABLED],
         ha_discovery_prefix=_config[MQTT][HA_DISCOVERY][TOPIC_PREFIX],
         mcp23017=_config.get(MCP23017, []),
         lm75=_config.get(LM75),
         oled=_config.get(OLED),
+        adc_list=_config.get(ADC, []),
     )
     tasks = set()
     tasks.update(manager.get_tasks())

{boneio-0.1.0.dev14 → boneio-0.1.0.dev16}/boneio/const.py

@@ -1,31 +1,15 @@
 # from typing import Literal
 from datetime import timedelta
-
+from Adafruit_BBIO.GPIO import HIGH, LOW, BOTH, FALLING
 from typing_extensions import Literal
 
-DEBOUNCE_DURATION = timedelta(seconds=0.2)
-LONG_PRESS_DURATION = timedelta(seconds=0.7)
-DELAY_DURATION = 0.1
-SECOND_DELAY_DURATION = 0.3
+
+# MISCELLANEOUS CONSTS
 RELAY = "relay"
-SINGLE = "single"
-DOUBLE = "double"
-LONG = "long"
-ONLINE = "online"
 ON = "ON"
 OFF = "OFF"
 STATE = "state"
-PAHO = "paho.mqtt.client"
-ClickTypes = Literal[SINGLE, DOUBLE, LONG]
-MQTT = "mqtt"
-HOST = "host"
-USERNAME = "username"
-PASSWORD = "password"
-TOPIC_PREFIX = "topic_prefix"
-HOMEASSISTANT = "homeassistant"
-HA_DISCOVERY = "ha_discovery"
 ENABLED = "enabled"
-GPIO_INPUT = "gpio_input"
 OUTPUT = "output"
 PIN = "pin"
 ID = "id"
@@ -34,17 +18,29 @@ GPIO = "gpio"
 ACTIONS = "actions"
 ACTION = "action"
 OUTPUT = "output"
-ADDRESS = "address"
-MCP23017 = "mcp23017"
 SWITCH = "switch"
 CONFIG_PIN = "/usr/bin/config-pin"
-MCP = "mcp"
-MCP_ID = "mcp_id"
+UPDATE_INTERVAL = "update_interval"
+ADC = "adc"
+
+# TIMINGS FOR BUTTONS
+DEBOUNCE_DURATION = timedelta(seconds=0.2)
+LONG_PRESS_DURATION = timedelta(seconds=0.7)
+DELAY_DURATION = 0.1
+SECOND_DELAY_DURATION = 0.3
+
+# HA CONSTS
+HOMEASSISTANT = "homeassistant"
+HA_DISCOVERY = "ha_discovery"
 HA_TYPE = "ha_type"
+SHOW_HA = "show_in_ha"
+
+# OLED CONST
+OLED = "oled"
+FONTS = "fonts"
+OLED_PIN = "P9_41"
 GIGABYTE = 1073741824
 MEGABYTE = 1048576
-OLED_PIN = "P9_41"
-NUM_OF_SCREENS = 6
 WIDTH = 128
 UPTIME = "uptime"
 NETWORK = "network"
@@ -53,11 +49,42 @@ DISK = "disk"
 MEMORY = "memory"
 SWAP = "swap"
 WHITE = "white"
-OLED = "oled"
-FONTS = "fonts"
-OledDataTypes = Literal[UPTIME, NETWORK, CPU, DISK, MEMORY, SWAP, OUTPUT]
-INIT_SLEEP = "init_sleep"
+
+# INPUT CONST
 INPUT = "input"
+SINGLE = "single"
+DOUBLE = "double"
+LONG = "long"
+PRESSED = "pressed"
+RELEASED = "released"
+
+
+# MQTT CONST
+PAHO = "paho.mqtt.client"
+MQTT = "mqtt"
+HOST = "host"
+USERNAME = "username"
+PASSWORD = "password"
+ONLINE = "online"
+TOPIC_PREFIX = "topic_prefix"
+
+# I2C and MCP CONST
+ADDRESS = "address"
+MCP23017 = "mcp23017"
+MCP = "mcp"
+MCP_ID = "mcp_id"
+INIT_SLEEP = "init_sleep"
+
+# SENSOR CONST
 TEMPERATURE = "temperature"
 SENSOR = "sensor"
-LM75="lm75"
+BINARY_SENSOR = "binary_sensor"
+LM75 = "lm75"
+INPUT_SENSOR = "inputsensor"
+
+# TYPING
+ClickTypes = Literal[SINGLE, DOUBLE, LONG, PRESSED, RELEASED]
+OledDataTypes = Literal[UPTIME, NETWORK, CPU, DISK, MEMORY, SWAP, OUTPUT]
+Gpio_States = Literal[HIGH, LOW]
+Gpio_Edges = Literal[BOTH, FALLING]
+InputTypes = Literal[INPUT, INPUT_SENSOR]

{boneio-0.1.0.dev14 → boneio-0.1.0.dev16}/boneio/helper/__init__.py

@@ -1,27 +1,48 @@
 """Helper dir for BoneIO."""
-from boneio.helper.gpio import edge_detect, setup_input, read_input
+from boneio.helper.gpio import (
+    edge_detect,
+    setup_input,
+    setup_output,
+    read_input,
+    write_output,
+    GpioBaseClass,
+    configure_pin,
+)
 from boneio.helper.oled import make_font
+from boneio.helper.mqtt import BasicMqtt
 from boneio.helper.stats import HostData, host_stats
 from boneio.helper.yaml import CustomValidator, load_yaml_file
 from boneio.helper.ha_discovery import (
     ha_relay_availibilty_message,
-    ha_sensor_availibilty_message,
     ha_sensor_temp_availibilty_message,
+    ha_binary_sensor_availibilty_message,
+    ha_input_availibilty_message,
+    ha_sensor_availibilty_message,
+    ha_adc_sensor_availibilty_message,
 )
 from boneio.helper.exceptions import GPIOInputException, I2CError
 
+
 __all__ = [
     "CustomValidator",
     "load_yaml_file",
     "HostData",
     "host_stats",
     "setup_input",
+    "setup_output",
     "edge_detect",
     "read_input",
+    "write_output",
     "make_font",
     "ha_relay_availibilty_message",
     "ha_sensor_availibilty_message",
+    "ha_adc_sensor_availibilty_message",
     "ha_sensor_temp_availibilty_message",
+    "ha_binary_sensor_availibilty_message",
+    "ha_input_availibilty_message",
     "GPIOInputException",
     "I2CError",
+    "GpioBaseClass",
+    "configure_pin",
+    "BasicMqtt",
 ]

boneio-0.1.0.dev16/boneio/helper/gpio.py

@@ -0,0 +1,79 @@
+import asyncio
+import logging
+from Adafruit_BBIO import GPIO
+
+from boneio.helper.exceptions import GPIOInputException
+from boneio.const import LOW, FALLING, Gpio_Edges, Gpio_States
+from typing import Callable
+import subprocess
+
+from boneio.const import (
+    CONFIG_PIN,
+    GPIO as GPIO_STR,
+    ClickTypes,
+)
+
+_LOGGER = logging.getLogger(__name__)
+
+
+def configure_pin(pin: str) -> None:
+    pin = f"{pin[0:3]}0{pin[3]}" if len(pin) == 4 else pin
+    _LOGGER.debug(f"Configuring pin for GPIO {pin}")
+    subprocess.run(
+        [CONFIG_PIN, pin, GPIO_STR],
+        stdout=subprocess.DEVNULL,
+        stderr=subprocess.STDOUT,
+        timeout=1,
+    )
+
+
+def setup_output(pin: str):
+    """Set up a GPIO as output."""
+
+    GPIO.setup(pin, GPIO.OUT, pull_up_down=GPIO.PUD_DOWN)
+
+
+def setup_input(pin: str, pull_mode: str = "UP"):
+    """Set up a GPIO as input."""
+    try:
+        GPIO.setup(pin, GPIO.IN, GPIO.PUD_DOWN if pull_mode == "DOWN" else GPIO.PUD_UP)
+    except (ValueError, SystemError) as err:
+        raise GPIOInputException(err)
+
+
+def write_output(pin: str, value: str):
+    """Write a value to a GPIO."""
+
+    GPIO.output(pin, value)
+
+
+def read_input(pin: str, on_state: Gpio_States = LOW):
+    """Read a value from a GPIO."""
+    return GPIO.input(pin) is on_state
+
+
+def edge_detect(pin: str, callback: Callable, bounce: int, edge: Gpio_Edges = FALLING):
+    """Add detection for RISING and FALLING events."""
+    try:
+        GPIO.add_event_detect(gpio=pin, edge=edge, callback=callback, bouncetime=bounce)
+    except RuntimeError as err:
+        raise GPIOInputException(err)
+
+
+class GpioBaseClass:
+    """Base class for initialize GPIO"""
+
+    def __init__(
+        self, pin: str, press_callback: Callable[[ClickTypes, str], None], **kwargs
+    ) -> None:
+        """Setup GPIO Input Button"""
+        self._pin = pin
+        configure_pin(pin)
+        self._loop = asyncio.get_running_loop()
+        self._press_callback = press_callback
+        setup_input(self._pin)
+
+    @property
+    def is_pressed(self):
+        """Is button pressed."""
+        return read_input(self._pin)

{boneio-0.1.0.dev14 → boneio-0.1.0.dev16}/boneio/helper/ha_discovery.py

@@ -1,7 +1,7 @@
 from boneio.version import __version__
 
 
-from boneio.const import INPUT, OFF, ON, RELAY, STATE, SENSOR
+from boneio.const import INPUT, OFF, ON, RELAY, STATE, SENSOR, INPUT_SENSOR
 
 
 def ha_relay_availibilty_message(id: str, name: str, topic: str = "boneio"):
@@ -25,7 +25,9 @@ def ha_relay_availibilty_message(id: str, name: str, topic: str = "boneio"):
     }
 
 
-def ha_sensor_availibilty_message(id: str, name: str, topic: str = "boneio"):
+def ha_availibilty_message(
+    id: str, name: str, topic: str = "boneio", sensor_type: str = INPUT
+):
     """Create availability topic for HA."""
     return {
         "availability": [{"topic": f"{topic}/{STATE}"}],
@@ -38,8 +40,45 @@ def ha_sensor_availibilty_message(id: str, name: str, topic: str = "boneio"):
         },
         "icon": "mdi:gesture-double-tap",
         "name": name,
-        "state_topic": f"{topic}/{INPUT}/{id}",
-        "unique_id": f"{topic}{INPUT}{id}",
+        "state_topic": f"{topic}/{sensor_type}/{id}",
+        "unique_id": f"{topic}{sensor_type}{id}",
+    }
+
+
+def ha_input_availibilty_message(**kwargs):
+    return ha_availibilty_message(sensor_type=INPUT, **kwargs)
+
+
+def ha_adc_sensor_availibilty_message(**kwargs):
+    msg = ha_availibilty_message(sensor_type=SENSOR, **kwargs)
+    msg["unit_of_measurement"] = "V"
+    msg["device_class"] = "voltage"
+    msg["state_class"] = "measurement"
+    return msg
+
+
+def ha_sensor_availibilty_message(unit_of_measurement: str = None, **kwargs):
+    msg = ha_availibilty_message(sensor_type=SENSOR, **kwargs)
+    if not unit_of_measurement:
+        return msg
+
+
+def ha_binary_sensor_availibilty_message(id: str, name: str, topic: str = "boneio"):
+    """Create availability topic for HA."""
+    return {
+        "availability": [{"topic": f"{topic}/{STATE}"}],
+        "device": {
+            "identifiers": [topic],
+            "manufacturer": "BoneIO",
+            "model": "BoneIO Relay Board",
+            "name": f"BoneIO {topic}",
+            "sw_version": __version__,
+        },
+        "payload_on": "pressed",
+        "payload_off": "released",
+        "name": name,
+        "state_topic": f"{topic}/{INPUT_SENSOR}/{id}",
+        "unique_id": f"{topic}{INPUT_SENSOR}{id}",
     }
 
 

boneio-0.1.0.dev16/boneio/helper/mqtt.py

@@ -0,0 +1,30 @@
+"""Class to help initialize classes which uses mqtt send."""
+from typing import Callable, Union
+
+
+class BasicMqtt:
+    """Basic MQTT class."""
+
+    def __init__(
+        self,
+        id: str,
+        topic_prefix: str,
+        name: str,
+        send_message: Callable[[str, Union[str, dict]], None],
+        topic_type: str,
+    ):
+        """Initialize module."""
+        self._id = id.replace(" ", "")
+        self._name = name
+        self._send_message = send_message
+        self._send_topic = f"{topic_prefix}/{topic_type}/{self.id}"
+
+    @property
+    def id(self) -> bool:
+        """Id of the module."""
+        return self._id
+
+    @property
+    def name(self):
+        """Return name of the sensor."""
+        return self._name

{boneio-0.1.0.dev14 → boneio-0.1.0.dev16}/boneio/helper/stats.py

@@ -85,9 +85,9 @@ async def get_memory_info(host_data):
         host_data.write(
             MEMORY,
             {
-                "total": f"{floor(vm.total / MEGABYTE)}%",
-                "used": f"{floor(vm.used / MEGABYTE)}%",
-                "free": f"{floor(vm.available / MEGABYTE)}%",
+                "total": f"{floor(vm.total / MEGABYTE)}MB",
+                "used": f"{floor(vm.used / MEGABYTE)}MB",
+                "free": f"{floor(vm.available / MEGABYTE)}MB",
             },
         )
         await asyncio.sleep(10)
@@ -100,9 +100,9 @@ async def get_swap_info(host_data):
         host_data.write(
             SWAP,
             {
-                "total": f"{floor(swap.total / MEGABYTE)}%",
-                "used": f"{floor(swap.used / MEGABYTE)}%",
-                "free": f"{floor(swap.free / MEGABYTE)}%",
+                "total": f"{floor(swap.total / MEGABYTE)}MB",
+                "used": f"{floor(swap.used / MEGABYTE)}MB",
+                "free": f"{floor(swap.free / MEGABYTE)}MB",
             },
         )
         await asyncio.sleep(10)

boneio-0.1.0.dev16/boneio/input/__init__.py

@@ -0,0 +1,5 @@
+"""Input classes."""
+
+from boneio.input.gpio import GpioInputButton
+
+__all__ = ["GpioInputButton"]

{boneio-0.1.0.dev14 → boneio-0.1.0.dev16}/boneio/input/gpio.py

@@ -1,51 +1,28 @@
 """GPIOInputButton to receive signals."""
-import asyncio
 import logging
-import subprocess
 from datetime import datetime
 from functools import partial
-from typing import Callable
 
 from boneio.const import (
-    CONFIG_PIN,
     DEBOUNCE_DURATION,
     DELAY_DURATION,
     DOUBLE,
-    GPIO,
     LONG,
     LONG_PRESS_DURATION,
     SECOND_DELAY_DURATION,
     SINGLE,
-    ClickTypes,
 )
-from boneio.helper import edge_detect, read_input, setup_input
+from boneio.helper import edge_detect, GpioBaseClass
 
 _LOGGER = logging.getLogger(__name__)
 
 
-def configure_pin(pin: str) -> None:
-    pin = f"{pin[0:3]}0{pin[3]}" if len(pin) == 4 else pin
-    _LOGGER.debug(f"Configuring pin for GPIO {pin}")
-    subprocess.run(
-        [CONFIG_PIN, pin, GPIO],
-        stdout=subprocess.DEVNULL,
-        stderr=subprocess.STDOUT,
-        timeout=1,
-    )
-
-
-class GpioInputButton:
+class GpioInputButton(GpioBaseClass):
     """Represent Gpio input switch."""
 
-    def __init__(
-        self, pin: str, press_callback: Callable[[ClickTypes, str], None], **kwargs
-    ) -> None:
+    def __init__(self, **kwargs) -> None:
         """Setup GPIO Input Button"""
-        self._pin = pin
-        configure_pin(pin)
-        self._loop = asyncio.get_running_loop()
-        self._press_callback = press_callback
-        setup_input(self._pin)
+        super().__init__(**kwargs)
         edge_detect(self._pin, callback=self._handle_press, bounce=25)
         self._first_press_timestamp = None
         self._is_long_press = False
@@ -53,7 +30,7 @@ class GpioInputButton:
         self._second_check = False
         _LOGGER.debug("Configured listening for input pin %s", self._pin)
 
-    def _handle_press(self, pin) -> None:
+    def _handle_press(self, pin: str) -> None:
         """Handle the button press callback"""
         # Ignore if we are in a long press
         if self._is_long_press:
@@ -85,11 +62,6 @@ class GpioInputButton:
             self.check_press_length,
         )
 
-    @property
-    def is_pressed(self):
-        """Is button pressed."""
-        return read_input(self._pin)
-
     def check_press_length(self) -> None:
         """Check if it's a single, double or long press"""
         # Check if button is still pressed
@@ -109,7 +81,7 @@ class GpioInputButton:
             diff = datetime.now() - self._first_press_timestamp
             if not self._is_long_press and diff > LONG_PRESS_DURATION:
                 self._is_long_press = True
-                _LOGGER.debug("Long button press, call callback")
+                _LOGGER.debug("Long button press on pin %s, call callback", self._pin)
                 self._loop.call_soon_threadsafe(
                     partial(self._press_callback, LONG, self._pin)
                 )
@@ -129,7 +101,8 @@ class GpioInputButton:
             if self._second_check:
                 if self._second_press_timestamp:
                     _LOGGER.debug(
-                        "Double click event, roznica %s",
+                        "Double click event on pin %s, roznica %s",
+                        self._pin,
                         self._second_press_timestamp - self._first_press_timestamp,
                     )
                     self._loop.call_soon_threadsafe(
@@ -137,7 +110,7 @@ class GpioInputButton:
                     )
 
                 elif self._first_press_timestamp:
-                    _LOGGER.debug("One click event, call callback")
+                    _LOGGER.debug("One click event on pin %s, call callback", self._pin)
                     self._loop.call_soon_threadsafe(
                         partial(self._press_callback, SINGLE, self._pin)
                     )

{boneio-0.1.0.dev14 → boneio-0.1.0.dev16}/boneio/manager.py

@@ -28,19 +28,28 @@ from boneio.const import (
     RELAY,
     STATE,
     ClickTypes,
+    InputTypes,
+    SENSOR,
+    SHOW_HA,
+    BINARY_SENSOR,
+    INPUT_SENSOR,
+    UPDATE_INTERVAL,
 )
 from boneio.helper import (
     HostData,
     ha_relay_availibilty_message,
-    ha_sensor_availibilty_message,
+    ha_input_availibilty_message,
+    ha_adc_sensor_availibilty_message,
     ha_sensor_temp_availibilty_message,
+    ha_binary_sensor_availibilty_message,
     host_stats,
     GPIOInputException,
     I2CError,
 )
 from boneio.input import GpioInputButton
-from boneio.oled import Oled
+
 from boneio.relay import GpioRelay, MCPRelay
+from boneio.sensor import GpioInputSensor
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -59,6 +68,7 @@ class Manager:
         ha_discovery_prefix: str = HOMEASSISTANT,
         mcp23017: Optional[List] = None,
         oled: bool = False,
+        adc_list: Optional[List] = None,
     ) -> None:
         """Initialize the manager."""
         _LOGGER.info("Initializing manager module.")
@@ -119,12 +129,48 @@ class Manager:
                     _LOGGER.error("Can't connect to MCP %s. %s", id, err)
                     pass
 
+        def create_adc():
+            from boneio.sensor import initialize_adc, GpioADCSensor
+
+            initialize_adc()
+
+            ## TODO: find what exception can ADC gpio throw.
+            for gpio in adc_list:
+                name = gpio.get(ID)
+                id = name.replace(" ", "")
+                pin = gpio[PIN]
+                try:
+                    adc = GpioADCSensor(
+                        id=id,
+                        pin=pin,
+                        name=name,
+                        send_message=self.send_message,
+                        topic_prefix=topic_prefix,
+                        update_interval=gpio.get(UPDATE_INTERVAL, 60),
+                    )
+                    self.send_ha_autodiscovery(
+                        id=id,
+                        name=name,
+                        ha_type=SENSOR,
+                        prefix=ha_discovery_prefix,
+                        availibilty_msg_func=ha_adc_sensor_availibilty_message,
+                    )
+                    self._tasks.append(asyncio.create_task(adc.send_state()))
+                except I2CError as err:
+                    _LOGGER.error("Can't configure ADC sensor %s. %s", id, err)
+                    pass
+
+            return True
+
         if lm75:
             create_lm75_sensor()
 
         if mcp23017:
             create_mcp23017()
 
+        if adc_list:
+            create_adc()
+
         def configure_relay(gpio: dict) -> Any:
             """Configure kind of relay. Most common MCP."""
             relay_id = gpio[ID].replace(" ", "")
@@ -177,31 +223,54 @@ class Manager:
                 out.send_state,
             )
 
-        def configure_button(gpio):
+        def configure_input(gpio):
             try:
                 pin = gpio[PIN]
-                GpioInputButton(
-                    pin=pin,
-                    press_callback=lambda x, i: self.press_callback(
-                        x, i, gpio.get(ACTIONS, {})
-                    ),
-                    rest_pin=gpio,
-                )
-                self.send_ha_autodiscovery(
-                    id=pin,
-                    name=gpio.get(ID, pin),
-                    ha_type="sensor",
-                    prefix=ha_discovery_prefix,
-                    availibilty_msg_func=ha_sensor_availibilty_message,
-                )
+                input_type = gpio.get(KIND)
+                if input_type == SENSOR:
+                    GpioInputSensor(
+                        pin=pin,
+                        press_callback=lambda x, i: self.press_callback(
+                            x=x,
+                            inpin=i,
+                            actions=gpio.get(ACTIONS, {}),
+                            input_type=INPUT_SENSOR,
+                        ),
+                        rest_pin=gpio,
+                    )
+                    availibilty_msg_func = ha_binary_sensor_availibilty_message
+                    ha_type = BINARY_SENSOR
+                else:
+                    GpioInputButton(
+                        pin=pin,
+                        press_callback=lambda x, i: self.press_callback(
+                            x=x,
+                            inpin=i,
+                            actions=gpio.get(ACTIONS, {}),
+                            input_type=INPUT,
+                        ),
+                        rest_pin=gpio,
+                    )
+                    availibilty_msg_func = ha_input_availibilty_message
+                    ha_type = SENSOR
+                if gpio.get(SHOW_HA, True):
+                    self.send_ha_autodiscovery(
+                        id=pin,
+                        name=gpio.get(ID, pin),
+                        ha_type=ha_type,
+                        prefix=ha_discovery_prefix,
+                        availibilty_msg_func=availibilty_msg_func,
+                    )
             except GPIOInputException as err:
                 _LOGGER.error("This PIN %s can't be configured. %s", pin, err)
                 pass
 
         for gpio in self._input_pins:
-            configure_button(gpio=gpio)
+            configure_input(gpio=gpio)
 
         if oled:
+            from boneio.oled import Oled
+
             self._host_data = HostData(
                 output=self._grouped_outputs,
                 lm75=self._lm75,
@@ -214,7 +283,7 @@ class Manager:
                 self._oled = Oled(
                     host_data=self._host_data, output_groups=list(self._grouped_outputs)
                 )
-            except GPIOInputException as err:
+            except (GPIOInputException, I2CError) as err:
                 _LOGGER.error("Can't configure OLED display. %s", err)
 
         self.send_message(topic=f"{topic_prefix}/{STATE}", payload=ONLINE)
@@ -227,10 +296,12 @@ class Manager:
     def get_tasks(self) -> Set[asyncio.Task]:
         return self._tasks
 
-    def press_callback(self, x: ClickTypes, inpin: str, actions: dict) -> None:
+    def press_callback(
+        self, x: ClickTypes, inpin: str, actions: dict, input_type: InputTypes = INPUT
+    ) -> None:
         """Press callback to use in input gpio.
         If relay input map is provided also toggle action on relay."""
-        topic = f"{self._topic_prefix}/{INPUT}/{inpin}"
+        topic = f"{self._topic_prefix}/{input_type}/{inpin}"
         self.send_message(topic=topic, payload=x)
         action = actions.get(x)
         if action:

{boneio-0.1.0.dev14 → boneio-0.1.0.dev16}/boneio/oled.py

@@ -5,11 +5,18 @@ from typing import List
 from luma.core.interface.serial import i2c
 from luma.core.render import canvas
 from luma.oled.device import sh1106
+from luma.core.error import DeviceNotFoundError
 from PIL import ImageDraw
 
 from boneio.const import CPU, DISK, MEMORY, NETWORK, OLED_PIN, SWAP, UPTIME, WHITE
-from boneio.helper import HostData, edge_detect, make_font, setup_input
-from boneio.input import configure_pin
+from boneio.helper import (
+    HostData,
+    configure_pin,
+    edge_detect,
+    make_font,
+    setup_input,
+    I2CError,
+)
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -38,9 +45,12 @@ class Oled:
         self._host_data = host_data
         configure_pin(OLED_PIN)
         setup_input(OLED_PIN)
-        edge_detect(OLED_PIN, callback=self._handle_press, bounce=50)
-        serial = i2c(port=2, address=0x3C)
-        self._device = sh1106(serial)
+        edge_detect(pin=OLED_PIN, callback=self._handle_press, bounce=50)
+        try:
+            serial = i2c(port=2, address=0x3C)
+            self._device = sh1106(serial)
+        except DeviceNotFoundError as err:
+            raise I2CError(err)
         _LOGGER.debug("Configuring OLED screen.")
 
     def _draw_standard(self, data: dict, draw: ImageDraw) -> None:

{boneio-0.1.0.dev14 → boneio-0.1.0.dev16}/boneio/relay/basic.py

@@ -2,31 +2,23 @@
 
 import asyncio
 import logging
-from typing import Callable, Union
+from typing import Callable
 
 from boneio.const import OFF, ON, RELAY, STATE, SWITCH
+from boneio.helper import BasicMqtt
 
 _LOGGER = logging.getLogger(__name__)
 
 
-class BasicRelay:
+class BasicRelay(BasicMqtt):
     """Basic relay class."""
 
     def __init__(
-        self,
-        send_message: Callable[[str, Union[str, dict]], None],
-        callback: Callable,
-        topic_prefix: str,
-        id: str = None,
-        ha_type=SWITCH,
+        self, callback: Callable, id: str = None, ha_type=SWITCH, **kwargs
     ) -> None:
         """Initialize Basic relay."""
-        self._id = id.replace(" ", "")
-        self._name = id
+        super().__init__(id=id, name=id, topic_type=RELAY, **kwargs)
         self._ha_type = ha_type
-        self._send_message = send_message
-        self._relay_topic = f"{topic_prefix}/{RELAY}/"
-        self._send_topic = f"{self._relay_topic}{self.id}"
         self._state = False
         self._callback = callback
         self._loop = asyncio.get_running_loop()

{boneio-0.1.0.dev14 → boneio-0.1.0.dev16}/boneio/relay/gpio.py

@@ -5,8 +5,9 @@ Created just in case.
 
 import logging
 
-from boneio.helper.gpio import HIGH, LOW, read_input, setup_output, write_output
+from boneio.helper import read_input, setup_output, write_output
 from boneio.relay.basic import BasicRelay
+from boneio.const import HIGH, LOW
 
 _LOGGER = logging.getLogger(__name__)
 

{boneio-0.1.0.dev14 → boneio-0.1.0.dev16}/boneio/schema.yaml

@@ -131,7 +131,7 @@ output:
           label: If HA discovery is used device if relay is light or switch.
 
 
-gpio_input:
+input:
   type: list
   meta:
     label: GPIO inputs section
@@ -148,6 +148,19 @@ gpio_input:
         required: True
         meta:
           label: PIN to use.
+      show_in_ha:
+        type: boolean
+        required: True
+        default: True
+        meta:
+          label: If you want you can disable discovering this input in HA.
+      kind:
+        type: string
+        allowed: ['switch', 'sensor']
+        default: switch
+        required: True
+        meta:
+          label: Either switch or sensor. If sensor then no clicks are detected, just simple on/off on gpio.
       actions:
         required: False
         type: dict
@@ -188,3 +201,58 @@ gpio_input:
                 type: string
               message:
                 type: string
+          pressed:
+            required: False
+            type: dict
+            schema:
+              action:
+                type: string
+                allowed: ['mqtt', 'output']
+                default: output
+              pin:
+                type: string
+              message:
+                type: string
+          released:
+            required: False
+            type: dict
+            schema:
+              action:
+                type: string
+                allowed: ['mqtt', 'output']
+                default: output
+              pin:
+                type: string
+              message:
+                type: string
+
+adc:
+  type: list
+  meta:
+    label: GPIO ADC section
+  schema:
+    type: dict
+    schema:
+      id:
+        type: string
+        required: False
+        meta:
+          label: Id to use in HA if needed. Default to pin number.
+      pin:
+        type: string
+        required: True
+        allowed: ['P9_33', 'P9_35', 'P9_36', 'P9_37', 'P9_38', 'P9_39', 'P9_40']
+        meta:
+          label: PIN to use.
+      update_interval:
+        type: integer
+        required: True
+        default: 60
+        meta:
+          label: Update interval in seconds.
+      show_in_ha:
+        type: boolean
+        required: True
+        default: True
+        meta:
+          label: If you want you can disable discovering this input in HA.

boneio-0.1.0.dev16/boneio/sensor/__init__.py

@@ -0,0 +1,6 @@
+"""Sensor module."""
+from boneio.sensor.lm75 import LM75Sensor
+from boneio.sensor.gpio import GpioInputSensor
+from boneio.sensor.adc import initialize_adc, GpioADCSensor
+
+__all__ = ["LM75Sensor", "GpioInputSensor", "initialize_adc", "GpioADCSensor"]

boneio-0.1.0.dev16/boneio/sensor/adc.py

@@ -0,0 +1,38 @@
+"""ADC GPIO BBB sensor."""
+import logging
+import asyncio
+
+from boneio.const import SENSOR
+from boneio.helper import BasicMqtt
+import Adafruit_BBIO.ADC as ADC
+
+_LOGGER = logging.getLogger(__name__)
+
+
+def initialize_adc():
+    ADC.setup()
+
+
+class GpioADCSensor(BasicMqtt):
+    """Represent Gpio ADC sensor."""
+
+    def __init__(self, pin: str, update_interval: int = 60, **kwargs) -> None:
+        """Setup GPIO ADC Sensor"""
+        super().__init__(topic_type=SENSOR, **kwargs)
+        self._pin = pin
+        self._update_interval = update_interval
+        _LOGGER.debug("Configured sensor pin %s", self._pin)
+
+    @property
+    def state(self):
+        """Give rounded value of temperature."""
+        return round(ADC.read(self._pin) * 1.8, 2)
+
+    async def send_state(self):
+        """Fetch temperature periodically and send to MQTT."""
+        while True:
+            self._send_message(
+                topic=self._send_topic,
+                payload=self.state,
+            )
+            await asyncio.sleep(self._update_interval)

boneio-0.1.0.dev16/boneio/sensor/gpio.py

@@ -0,0 +1,32 @@
+"""GPIOInputButton to receive signals."""
+import logging
+from functools import partial
+
+from boneio.const import BOTH, PRESSED, RELEASED
+from boneio.helper import edge_detect, GpioBaseClass
+
+_LOGGER = logging.getLogger(__name__)
+
+
+class GpioInputSensor(GpioBaseClass):
+    """Represent Gpio sensor on input boards."""
+
+    def __init__(self, **kwargs) -> None:
+        """Setup GPIO Input Button"""
+        super().__init__(**kwargs)
+        edge_detect(self._pin, callback=self._handle_press, bounce=25, edge=BOTH)
+        _LOGGER.debug("Configured sensor pin %s", self._pin)
+
+    def _handle_press(self, pin: str) -> None:
+        """Handle the button press callback"""
+        # Ignore if we are in a long press
+        if self.is_pressed:
+            _LOGGER.debug("Pressed event on pin %s", self._pin)
+            self._loop.call_soon_threadsafe(
+                partial(self._press_callback, PRESSED, self._pin)
+            )
+        else:
+            _LOGGER.debug("Released event on pin %s", self._pin)
+            self._loop.call_soon_threadsafe(
+                partial(self._press_callback, RELEASED, self._pin)
+            )

{boneio-0.1.0.dev14 → boneio-0.1.0.dev16}/boneio/sensor/lm75.py

@@ -2,39 +2,23 @@
 
 import asyncio
 from adafruit_pct2075 import PCT2075
-from typing import Callable, Union
 from boneio.const import STATE, SENSOR, LM75
 
 from boneio.helper.exceptions import I2CError
+from boneio.helper import BasicMqtt
 
 
-class LM75Sensor:
+class LM75Sensor(BasicMqtt):
     """Represent LM75 sensor in BoneIO."""
 
-    def __init__(
-        self,
-        i2c,
-        address,
-        topic_prefix: str,
-        name: str,
-        send_message: Callable[[str, Union[str, dict]], None],
-        id: str = LM75,
-    ):
+    def __init__(self, i2c, address, id: str = LM75, **kwargs):
         """Initialize LM75 class."""
-        self._id = id
-        self._name = name
-        self._send_message = send_message
-        self._send_topic = f"{topic_prefix}/{SENSOR}/{self._id}"
+        super().__init__(id=id, topic_type=SENSOR, **kwargs)
         try:
             self._pct = PCT2075(i2c_bus=i2c, address=address)
         except ValueError as err:
             raise I2CError(err)
 
-    @property
-    def name(self):
-        """Return name of the sensor."""
-        return self._name
-
     @property
     def state(self):
         """Give rounded value of temperature."""

boneio-0.1.0.dev16/boneio/version.py

@@ -0,0 +1,2 @@
+# flake8: noqa
+__version__ = "0.1.0.dev16"

{boneio-0.1.0.dev14 → boneio-0.1.0.dev16}/boneio.egg-info/PKG-INFO

@@ -1,10 +1,10 @@
 Metadata-Version: 2.1
 Name: boneio
-Version: 0.1.0.dev14
+Version: 0.1.0.dev16
 Summary: Python Helper for BoneIO
 Home-page: https://github.com/maciejk1984/boneIO
 License: GNU General Public License v3.0
-Download-URL: https://github.com/maciejk1984/boneIO/archive/0.1.0.dev14.zip
+Download-URL: https://github.com/maciejk1984/boneIO/archive/0.1.0.dev16.zip
 Platform: UNKNOWN
 Classifier: Programming Language :: Python
 Classifier: Programming Language :: Python :: 3.7

{boneio-0.1.0.dev14 → boneio-0.1.0.dev16}/boneio.egg-info/SOURCES.txt

@@ -21,6 +21,7 @@ boneio/helper/__init__.py
 boneio/helper/exceptions.py
 boneio/helper/gpio.py
 boneio/helper/ha_discovery.py
+boneio/helper/mqtt.py
 boneio/helper/oled.py
 boneio/helper/stats.py
 boneio/helper/yaml.py
@@ -31,4 +32,6 @@ boneio/relay/basic.py
 boneio/relay/gpio.py
 boneio/relay/mcp.py
 boneio/sensor/__init__.py
+boneio/sensor/adc.py
+boneio/sensor/gpio.py
 boneio/sensor/lm75.py

boneio-0.1.0.dev14/boneio/helper/gpio.py

@@ -1,38 +0,0 @@
-import logging
-from Adafruit_BBIO import GPIO
-from Adafruit_BBIO.GPIO import HIGH, LOW
-
-from boneio.helper.exceptions import GPIOInputException
-
-
-def setup_output(pin: str):
-    """Set up a GPIO as output."""
-
-    GPIO.setup(pin, GPIO.OUT, pull_up_down=GPIO.PUD_DOWN)
-
-
-def setup_input(pin: str, pull_mode: str = "UP"):
-    """Set up a GPIO as input."""
-    try:
-        GPIO.setup(pin, GPIO.IN, GPIO.PUD_DOWN if pull_mode == "DOWN" else GPIO.PUD_UP)
-    except (ValueError, SystemError) as err:
-        raise GPIOInputException(err)
-
-
-def write_output(pin: str, value: str):
-    """Write a value to a GPIO."""
-
-    GPIO.output(pin, value)
-
-
-def read_input(pin: str, on_state=LOW):
-    """Read a value from a GPIO."""
-    return GPIO.input(pin) is on_state
-
-
-def edge_detect(pin, callback, bounce):
-    """Add detection for RISING and FALLING events."""
-    try:
-        GPIO.add_event_detect(pin, GPIO.FALLING, callback=callback, bouncetime=bounce)
-    except RuntimeError as err:
-        raise GPIOInputException(err)

boneio-0.1.0.dev14/boneio/input/__init__.py

@@ -1,5 +0,0 @@
-"""Input classes."""
-
-from boneio.input.gpio import GpioInputButton, configure_pin
-
-__all__ = ["GpioInputButton", "configure_pin"]

boneio-0.1.0.dev14/boneio/sensor/__init__.py

@@ -1,4 +0,0 @@
-"""Sensor module."""
-from boneio.sensor.lm75 import LM75Sensor
-
-__all__ = ["LM75Sensor"]

boneio-0.1.0.dev14/boneio/version.py

@@ -1,2 +0,0 @@
-# flake8: noqa
-__version__ = "0.1.0.dev14"