boneIO 0.1.0.dev13__tar.gz → 0.1.0.dev15__tar.gz

{boneio-0.1.0.dev13 → boneio-0.1.0.dev15}/PKG-INFO

@@ -1,10 +1,10 @@
 Metadata-Version: 2.1
 Name: boneio
-Version: 0.1.0.dev13
+Version: 0.1.0.dev15
 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.dev13.zip
+Download-URL: https://github.com/maciejk1984/boneIO/archive/0.1.0.dev15.zip
 Platform: UNKNOWN
 Classifier: Programming Language :: Python
 Classifier: Programming Language :: Python :: 3.7

{boneio-0.1.0.dev13 → boneio-0.1.0.dev15}/boneio/bonecli.py

@@ -6,9 +6,9 @@ from functools import wraps
 import click
 from colorlog import ColoredFormatter
 
-from .const import (
+from boneio.const import (
     ENABLED,
-    GPIO_INPUT,
+    INPUT,
     HA_DISCOVERY,
     HOST,
     MCP23017,
@@ -19,11 +19,12 @@ from .const import (
     PASSWORD,
     TOPIC_PREFIX,
     USERNAME,
+    LM75,
 )
-from .helper import CustomValidator, load_yaml_file
-from .manager import Manager
-from .mqtt_client import MQTTClient
-from .version import __version__
+from boneio.helper import CustomValidator, load_yaml_file
+from boneio.manager import Manager
+from boneio.mqtt_client import MQTTClient
+from boneio.version import __version__
 
 _LOGGER = logging.getLogger(__name__)
 logging.basicConfig(level=logging.INFO)
@@ -133,12 +134,12 @@ async def run(ctx, debug: int, config: str, mqttpassword: str = ""):
     manager = Manager(
         send_message=client.send_message,
         topic_prefix=_config[MQTT][TOPIC_PREFIX],
-        relay_pins=_config[OUTPUT],
-        input_pins=_config[GPIO_INPUT],
+        relay_pins=_config.get(OUTPUT, []),
+        input_pins=_config.get(INPUT, []),
         ha_discovery=_config[MQTT][HA_DISCOVERY][ENABLED],
         ha_discovery_prefix=_config[MQTT][HA_DISCOVERY][TOPIC_PREFIX],
-        mcp23017=_config[MCP23017],
-        lm75=_config.get("lm75"),
+        mcp23017=_config.get(MCP23017, []),
+        lm75=_config.get(LM75),
         oled=_config.get(OLED),
     )
     tasks = set()

{boneio-0.1.0.dev13 → boneio-0.1.0.dev15}/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,27 @@ 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"
+
+# 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,10 +47,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"
+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.dev15/boneio/helper/__init__.py

@@ -0,0 +1,41 @@
+"""Helper dir for BoneIO."""
+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.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,
+)
+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_sensor_temp_availibilty_message",
+    "ha_binary_sensor_availibilty_message",
+    "GPIOInputException",
+    "I2CError",
+    "GpioBaseClass",
+    "configure_pin",
+]

boneio-0.1.0.dev15/boneio/helper/exceptions.py

@@ -0,0 +1,13 @@
+"""BoneIO Errors"""
+
+
+class BoneIOException(Exception):
+    """BoneIO standard exception."""
+
+
+class GPIOInputException(BoneIOException):
+    """GPIOInput Exception."""
+
+
+class I2CError(BoneIOException):
+    """I2C Exception."""

boneio-0.1.0.dev15/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.dev13 → boneio-0.1.0.dev15}/boneio/helper/ha_discovery.py

@@ -1,7 +1,7 @@
-from ..version import __version__
+from boneio.version import __version__
 
 
-from ..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"):
@@ -43,6 +43,25 @@ def ha_sensor_availibilty_message(id: str, name: str, topic: str = "boneio"):
     }
 
 
+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}",
+    }
+
+
 def ha_sensor_temp_availibilty_message(id: str, name: str, topic: str = "boneio"):
     """Create availability topic for HA."""
     return {

{boneio-0.1.0.dev13 → boneio-0.1.0.dev15}/boneio/helper/oled.py

@@ -2,7 +2,7 @@ import os
 
 from PIL import ImageFont
 
-from ..const import FONTS
+from boneio.const import FONTS
 
 
 def make_font(name: str, size: int, local: bool = False):

{boneio-0.1.0.dev13 → boneio-0.1.0.dev15}/boneio/helper/stats.py

@@ -7,7 +7,7 @@ from typing import Callable
 
 import psutil
 
-from ..const import (
+from boneio.const import (
     CPU,
     DISK,
     GIGABYTE,
@@ -16,10 +16,9 @@ from ..const import (
     MEMORY,
     NETWORK,
     SWAP,
-    TEMPERATURE,
     UPTIME,
 )
-from ..sensor.lm75 import LM75
+from boneio.sensor import LM75Sensor
 
 intervals = (("d", 86400), ("h", 3600), ("m", 60))
 
@@ -132,7 +131,7 @@ class HostData:
 
     data = {UPTIME: {}, NETWORK: {}, CPU: {}, DISK: {}, MEMORY: {}, SWAP: {}}
 
-    def __init__(self, output: dict, callback: Callable, lm75: LM75) -> None:
+    def __init__(self, output: dict, callback: Callable, lm75: LM75Sensor) -> None:
         """Initialize HostData."""
         self._hostname = socket.gethostname()
         self.data[UPTIME] = {HOST: self._hostname, UPTIME: 0}

{boneio-0.1.0.dev13 → boneio-0.1.0.dev15}/boneio/helper/yaml.py

@@ -1,7 +1,7 @@
 from typing import Any
 import os
 from cerberus import Validator
-from ..const import ID, OLED, OUTPUT
+from boneio.const import ID, OLED, OUTPUT
 from yaml import load, YAMLError, SafeLoader
 
 

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

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

{boneio-0.1.0.dev13 → boneio-0.1.0.dev15}/boneio/input/gpio.py

@@ -1,50 +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 ..const import (
-    CONFIG_PIN,
+from boneio.const import (
     DEBOUNCE_DURATION,
     DELAY_DURATION,
     DOUBLE,
-    GPIO,
     LONG,
     LONG_PRESS_DURATION,
     SECOND_DELAY_DURATION,
     SINGLE,
-    ClickTypes,
 )
-from ..helper.gpio 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,
-    )
-
-
-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
@@ -52,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:
@@ -84,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
@@ -108,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)
                 )
@@ -128,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(
@@ -136,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.dev13 → boneio-0.1.0.dev15}/boneio/manager.py

@@ -7,7 +7,7 @@ from adafruit_mcp230xx.mcp23017 import MCP23017
 from board import SCL, SDA
 from busio import I2C
 
-from .const import (
+from boneio.const import (
     ACTION,
     ACTIONS,
     ADDRESS,
@@ -28,17 +28,26 @@ from .const import (
     RELAY,
     STATE,
     ClickTypes,
+    InputTypes,
+    SENSOR,
+    SHOW_HA,
+    BINARY_SENSOR,
+    INPUT_SENSOR,
 )
-from .helper import (
+from boneio.helper import (
     HostData,
     ha_relay_availibilty_message,
     ha_sensor_availibilty_message,
     ha_sensor_temp_availibilty_message,
+    ha_binary_sensor_availibilty_message,
     host_stats,
+    GPIOInputException,
+    I2CError,
 )
-from .input import GpioInputButton
-from .oled import Oled
-from .relay import GpioRelay, MCPRelay
+from boneio.input import GpioInputButton
+
+from boneio.relay import GpioRelay, MCPRelay
+from boneio.sensor import GpioInputSensor
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -76,38 +85,46 @@ class Manager:
 
         def create_lm75_sensor():
             """Create LM sensor in manager."""
-            from .sensor.lm75 import LM75
+            from .sensor.lm75 import LM75Sensor
 
             name = lm75.get(ID)
             id = name.replace(" ", "")
-            self._lm75 = LM75(
-                id=id,
-                name=name,
-                i2c=self._i2cbusio,
-                address=lm75[ADDRESS],
-                send_message=self.send_message,
-                topic_prefix=topic_prefix,
-            )
-            self.send_ha_autodiscovery(
-                id=id,
-                name=name,
-                ha_type="sensor",
-                prefix=ha_discovery_prefix,
-                availibilty_msg_func=ha_sensor_temp_availibilty_message,
-            )
-            self._tasks.append(asyncio.create_task(self._lm75.send_state()))
+            try:
+                self._lm75 = LM75Sensor(
+                    id=id,
+                    name=name,
+                    i2c=self._i2cbusio,
+                    address=lm75[ADDRESS],
+                    send_message=self.send_message,
+                    topic_prefix=topic_prefix,
+                )
+                self.send_ha_autodiscovery(
+                    id=id,
+                    name=name,
+                    ha_type="sensor",
+                    prefix=ha_discovery_prefix,
+                    availibilty_msg_func=ha_sensor_temp_availibilty_message,
+                )
+                self._tasks.append(asyncio.create_task(self._lm75.send_state()))
+            except I2CError as err:
+                _LOGGER.error("Can't configure LM75 sensor. %s", err)
+                pass
 
         def create_mcp23017():
             """Create MCP23017."""
             for mcp in mcp23017:
                 id = mcp[ID] or mcp[ADDRESS]
-                self._mcp[id] = MCP23017(i2c=self._i2cbusio, address=mcp[ADDRESS])
-                sleep_time = mcp.get(INIT_SLEEP, 0)
-                _LOGGER.debug(
-                    f"Sleeping for {sleep_time}s while MCP {id} is initializing."
-                )
-                time.sleep(sleep_time)
-                self._grouped_outputs[id] = {}
+                try:
+                    self._mcp[id] = MCP23017(i2c=self._i2cbusio, address=mcp[ADDRESS])
+                    sleep_time = mcp.get(INIT_SLEEP, 0)
+                    _LOGGER.debug(
+                        f"Sleeping for {sleep_time}s while MCP {id} is initializing."
+                    )
+                    time.sleep(sleep_time)
+                    self._grouped_outputs[id] = {}
+                except TimeoutError as err:
+                    _LOGGER.error("Can't connect to MCP %s. %s", id, err)
+                    pass
 
         if lm75:
             create_lm75_sensor()
@@ -167,25 +184,60 @@ class Manager:
                 out.send_state,
             )
 
-        def configure_button(gpio):
-            pin = gpio[PIN]
-            button = GpioInputButton(
-                pin=pin,
-                press_callback=lambda x, i: self.press_callback(x, i, gpio[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,
-            )
-            return button
+        def configure_input(gpio):
+            try:
+                pin = gpio[PIN]
+                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_sensor_availibilty_message
+                    ha_type = SENSOR
+                if gpio.get(SHOW_HA, True):
+                    print(
+                        "INPUT sending disco",
+                        ha_type,
+                        ha_discovery_prefix,
+                        availibilty_msg_func,
+                    )
+                    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
 
-        self.buttons = [configure_button(gpio=gpio) for gpio in self._input_pins]
+        for gpio in self._input_pins:
+            configure_input(gpio=gpio)
 
         if oled:
+            from boneio.oled import Oled
+
             self._host_data = HostData(
                 output=self._grouped_outputs,
                 lm75=self._lm75,
@@ -194,9 +246,12 @@ class Manager:
             for f in host_stats.values():
                 self._tasks.append(asyncio.create_task(f(self._host_data)))
             _LOGGER.debug("Gathering host data enabled.")
-            self._oled = Oled(
-                host_data=self._host_data, output_groups=list(self._grouped_outputs)
-            )
+            try:
+                self._oled = Oled(
+                    host_data=self._host_data, output_groups=list(self._grouped_outputs)
+                )
+            except GPIOInputException as err:
+                _LOGGER.error("Can't configure OLED display. %s", err)
 
         self.send_message(topic=f"{topic_prefix}/{STATE}", payload=ONLINE)
         _LOGGER.info("BoneIO manager is ready.")
@@ -208,18 +263,20 @@ 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:
             if action[ACTION] == OUTPUT:
                 """For now only output type is supported"""
-                output_gpio = self.output.get(action[PIN])
-                if output_gpio:
-                    output_gpio.toggle()
+                relay = self.output.get(action[PIN].replace(" ", ""))
+                if relay:
+                    relay.toggle()
         # This is similar how Z2M is clearing click sensor.
         # self._loop.call_later(1, self.send_message, topic, "")
 

{boneio-0.1.0.dev13 → boneio-0.1.0.dev15}/boneio/mqtt_client.py

@@ -12,7 +12,7 @@ from asyncio_mqtt import MqttError
 from paho.mqtt.properties import Properties
 from paho.mqtt.subscribeoptions import SubscribeOptions
 
-from .const import PAHO
+from boneio.const import PAHO
 
 _LOGGER = logging.getLogger(__name__)
 

{boneio-0.1.0.dev13 → boneio-0.1.0.dev15}/boneio/oled.py

@@ -7,9 +7,8 @@ from luma.core.render import canvas
 from luma.oled.device import sh1106
 from PIL import ImageDraw
 
-from .const import CPU, DISK, MEMORY, NETWORK, OLED_PIN, SWAP, UPTIME, WHITE
-from .helper import HostData, edge_detect, make_font, setup_input
-from .input import configure_pin
+from boneio.const import CPU, DISK, MEMORY, NETWORK, OLED_PIN, SWAP, UPTIME, WHITE
+from boneio.helper import HostData, configure_pin, edge_detect, make_font, setup_input
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -38,7 +37,7 @@ 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)
+        edge_detect(pin=OLED_PIN, callback=self._handle_press, bounce=50)
         serial = i2c(port=2, address=0x3C)
         self._device = sh1106(serial)
         _LOGGER.debug("Configuring OLED screen.")

boneio-0.1.0.dev15/boneio/relay/__init__.py

@@ -0,0 +1,5 @@
+"""Relay module."""
+from boneio.relay.gpio import GpioRelay
+from boneio.relay.mcp import MCPRelay
+
+__all__ = ["MCPRelay", "GpioRelay"]

{boneio-0.1.0.dev13 → boneio-0.1.0.dev15}/boneio/relay/basic.py

@@ -4,7 +4,7 @@ import asyncio
 import logging
 from typing import Callable, Union
 
-from ..const import OFF, ON, RELAY, STATE, SWITCH
+from boneio.const import OFF, ON, RELAY, STATE, SWITCH
 
 _LOGGER = logging.getLogger(__name__)
 

{boneio-0.1.0.dev13 → boneio-0.1.0.dev15}/boneio/relay/gpio.py

@@ -5,8 +5,9 @@ Created just in case.
 
 import logging
 
-from ..helper.gpio import HIGH, LOW, read_input, setup_output, write_output
-from .basic import BasicRelay
+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.dev13 → boneio-0.1.0.dev15}/boneio/relay/mcp.py

@@ -4,7 +4,7 @@ import logging
 
 from adafruit_mcp230xx.mcp23017 import MCP23017
 
-from .basic import BasicRelay
+from boneio.relay.basic import BasicRelay
 
 _LOGGER = logging.getLogger(__name__)
 

{boneio-0.1.0.dev13 → boneio-0.1.0.dev15}/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,27 @@ 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

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

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

boneio-0.1.0.dev15/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.dev13 → boneio-0.1.0.dev15}/boneio/sensor/lm75.py

@@ -3,10 +3,12 @@
 import asyncio
 from adafruit_pct2075 import PCT2075
 from typing import Callable, Union
-from ..const import STATE, SENSOR
+from boneio.const import STATE, SENSOR, LM75
 
+from boneio.helper.exceptions import I2CError
 
-class LM75:
+
+class LM75Sensor:
     """Represent LM75 sensor in BoneIO."""
 
     def __init__(
@@ -16,14 +18,17 @@ class LM75:
         topic_prefix: str,
         name: str,
         send_message: Callable[[str, Union[str, dict]], None],
-        id: str = "lm75",
+        id: str = LM75,
     ):
         """Initialize LM75 class."""
         self._id = id
         self._name = name
         self._send_message = send_message
         self._send_topic = f"{topic_prefix}/{SENSOR}/{self._id}"
-        self._pct = PCT2075(i2c_bus=i2c, address=address)
+        try:
+            self._pct = PCT2075(i2c_bus=i2c, address=address)
+        except ValueError as err:
+            raise I2CError(err)
 
     @property
     def name(self):

boneio-0.1.0.dev15/boneio/version.py

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

{boneio-0.1.0.dev13 → boneio-0.1.0.dev15}/boneio.egg-info/PKG-INFO

@@ -1,10 +1,10 @@
 Metadata-Version: 2.1
 Name: boneio
-Version: 0.1.0.dev13
+Version: 0.1.0.dev15
 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.dev13.zip
+Download-URL: https://github.com/maciejk1984/boneIO/archive/0.1.0.dev15.zip
 Platform: UNKNOWN
 Classifier: Programming Language :: Python
 Classifier: Programming Language :: Python :: 3.7

{boneio-0.1.0.dev13 → boneio-0.1.0.dev15}/boneio.egg-info/SOURCES.txt

@@ -18,6 +18,7 @@ boneio.egg-info/requires.txt
 boneio.egg-info/top_level.txt
 boneio/fonts/danube__.ttf
 boneio/helper/__init__.py
+boneio/helper/exceptions.py
 boneio/helper/gpio.py
 boneio/helper/ha_discovery.py
 boneio/helper/oled.py
@@ -30,4 +31,5 @@ boneio/relay/basic.py
 boneio/relay/gpio.py
 boneio/relay/mcp.py
 boneio/sensor/__init__.py
+boneio/sensor/gpio.py
 boneio/sensor/lm75.py

boneio-0.1.0.dev13/boneio/helper/__init__.py

@@ -1,23 +0,0 @@
-"""Helper dir for BoneIO."""
-from .gpio import edge_detect, setup_input
-from .oled import make_font
-from .stats import HostData, host_stats
-from .yaml import CustomValidator, load_yaml_file
-from .ha_discovery import (
-    ha_relay_availibilty_message,
-    ha_sensor_availibilty_message,
-    ha_sensor_temp_availibilty_message,
-)
-
-__all__ = [
-    "CustomValidator",
-    "load_yaml_file",
-    "HostData",
-    "host_stats",
-    "setup_input",
-    "edge_detect",
-    "make_font",
-    "ha_relay_availibilty_message",
-    "ha_sensor_availibilty_message",
-    "ha_sensor_temp_availibilty_message",
-]

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

@@ -1,30 +0,0 @@
-from Adafruit_BBIO import GPIO
-from Adafruit_BBIO.GPIO import HIGH, LOW
-
-
-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."""
-    GPIO.setup(pin, GPIO.IN, GPIO.PUD_DOWN if pull_mode == "DOWN" else GPIO.PUD_UP)
-
-
-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."""
-
-    GPIO.add_event_detect(pin, GPIO.FALLING, callback=callback, bouncetime=bounce)

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

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

boneio-0.1.0.dev13/boneio/relay/__init__.py

@@ -1,5 +0,0 @@
-"""Relay module."""
-from .gpio import GpioRelay
-from .mcp import MCPRelay
-
-__all__ = ["MCPRelay", "GpioRelay"]

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

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

boneio-0.1.0.dev13/boneio/version.py

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