boneIO 0.1.2__tar.gz → 0.1.4__tar.gz

{boneio-0.1.2/boneio.egg-info → boneio-0.1.4}/PKG-INFO

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

{boneio-0.1.2 → boneio-0.1.4}/boneio/bonecli.py

@@ -26,7 +26,7 @@ from boneio.const import (
     TOPIC_PREFIX,
     USERNAME,
 )
-from boneio.helper import CustomValidator, load_yaml_file
+from boneio.helper import load_config_from_file
 from boneio.manager import Manager
 from boneio.mqtt_client import MQTTClient
 from boneio.version import __version__
@@ -124,13 +124,9 @@ async def run(ctx, debug: int, config: str, mqttpassword: str = ""):
         logging.getLogger("pymodbus.client").setLevel(logging.DEBUG)
     else:
         logging.getLogger(PAHO).setLevel(logging.WARN)
-    schema = load_yaml_file(os.path.join(MAINPATH, "schema.yaml"))
-    v = CustomValidator(schema, purge_unknown=True)
-    config_yaml = load_yaml_file(config)
-    if not config_yaml:
-        _LOGGER.info("Missing file.")
+    _config = load_config_from_file(config_file=config)
+    if not _config:
         return
-    _config = v.normalized(config_yaml)
     _LOGGER.info("Connecting to MQTT.")
     client = MQTTClient(
         host=_config[MQTT][HOST],

{boneio-0.1.2 → boneio-0.1.4}/boneio/const.py

@@ -3,6 +3,8 @@ from datetime import timedelta
 from Adafruit_BBIO.GPIO import HIGH, LOW, BOTH, FALLING
 from typing_extensions import Literal
 
+BONEIO = "boneIO"
+NONE = "none"
 
 # MISCELLANEOUS CONSTS
 RELAY = "relay"
@@ -15,6 +17,7 @@ PIN = "pin"
 ID = "id"
 KIND = "kind"
 GPIO = "gpio"
+GPIO_MODE = "gpio_mode"
 ACTIONS = "actions"
 ACTION = "action"
 OUTPUT = "output"
@@ -46,6 +49,7 @@ SECOND_DELAY_DURATION = 0.3
 HOMEASSISTANT = "homeassistant"
 HA_DISCOVERY = "ha_discovery"
 HA_TYPE = "ha_type"
+OUTPUT_TYPE = "output_type"
 SHOW_HA = "show_in_ha"
 
 # OLED CONST

{boneio-0.1.2 → boneio-0.1.4}/boneio/example_config/input.yaml

@@ -1,5 +1,5 @@
-- id: J1_2
-  pin: P9_29
+- id: IN_01
+  pin: P8_37
   actions:
     single:
       action: output
@@ -7,8 +7,8 @@
     double:
       action: output
       pin: switch 1
-- id: J1_3
-  pin: P9_30
+- id: IN_02
+  pin: P8_38
   actions:
     single:
       action: output
@@ -16,8 +16,8 @@
     double:
       action: output
       pin: switch 2
-- id: J1_4
-  pin: P9_31
+- id: IN_03
+  pin: P8_39
   actions:
     single:
       action: output
@@ -25,8 +25,8 @@
     double:
       action: output
       pin: switch 3
-- id: J1_5
-  pin: P9_42
+- id: IN_04
+  pin: P8_40
   actions:
     single:
       action: output
@@ -34,8 +34,8 @@
     double:
       action: output
       pin: switch 4
-- id: J1_6
-  pin: P8_46
+- id: IN_05
+  pin: P8_41
   actions:
     single:
       action: output
@@ -43,8 +43,8 @@
     double:
       action: output
       pin: switch 5
-- id: J1_7
-  pin: P8_45
+- id: IN_06
+  pin: P8_42
   actions:
     single:
       action: output
@@ -52,149 +52,153 @@
     double:
       action: output
       pin: switch 6
-- id: J1_8
-  pin: P8_44
+- id: IN_07
+  pin: P8_43
   actions:
     single:
       action: output
       pin: light 7
 
-- id: J2_2
-  pin: P8_36
+- id: IN_08
+  pin: P8_44
   actions:
     single:
       action: output
       pin: light 8
-- id: J2_3
-  pin: P8_35
+- id: IN_09
+  pin: P8_45
   actions:
     single:
       action: output
       pin: light 9
-- id: J2_4
-  pin: P8_34
+- id: IN_10
+  pin: P8_46
   actions:
     single:
       action: output
       pin: light 10
-- id: J2_5
-  pin: P8_33
+- id: IN_11
+  pin: P9_42
   actions:
     single:
       action: output
       pin: light 11
-- id: J2_6
-  pin: P8_32
+- id: IN_12
+  pin: P9_31
   actions:
     single:
       action: output
       pin: light 12
-- id: J2_7
-  pin: P8_31
+- id: IN_13
+  pin: P9_30
   actions:
     single:
       action: output
       pin: light 13
-- id: J2_8
-  pin: P8_30
+- id: IN_14
+  pin: P9_29
   actions:
     single:
       action: output
       pin: light 14
 
-- id: J3_2
-  pin: P8_43
+- id: IN_15
+  pin: P9_28
   actions:
     single:
       action: output
       pin: light 15
-- id: J3_3
-  pin: P8_42
+- id: IN_16
+  pin: P9_27
   actions:
     single:
       action: output
       pin: light 16
-- id: J3_4
-  pin: P8_41
+- id: IN_17
+  pin: P9_25
   actions:
     single:
       action: output
       pin: light 4
-- id: J3_5
-  pin: P8_40
-- id: J3_6
-  pin: P8_39
-- id: J3_7
-  pin: P8_38
-- id: J3_8
-  pin: P8_37
+- id: IN_18
+  pin: P9_23
+- id: IN_19
+  pin: P9_22
+- id: IN_20
+  pin: P9_21
+- id: IN_21
+  pin: P9_18
+
+- id: IN_22
+  pin: P9_17
+- id: IN_23
+  pin: P9_16
+- id: IN_24
+  pin: P9_15
+- id: IN_25
+  pin: P9_14
+- id: IN_26
+  pin: P9_13
+- id: IN_27
+  pin: P9_12
+- id: IN_28
+  pin: P9_11
 
-- id: J4_2
+- id: IN_29
+  pin: P8_36
+- id: IN_30
+  pin: P8_35
+- id: IN_31
+  pin: P8_34
+- id: IN_32
+  pin: P8_33
+
+- id: IN_33
+  pin: P8_32
+- id: IN_34
+  pin: P8_31
+- id: IN_35
+  pin: P8_30
+- id: IN_36
   pin: P8_29
-- id: J4_3
+- id: IN_37
   pin: P8_28
-- id: J4_4
+- id: IN_38
   pin: P8_27
-- id: J4_5
+- id: IN_39
   pin: P8_26
-- id: J4_6
+
+- id: IN_40
   pin: P8_19
-- id: J4_7
+- id: IN_41
   pin: P8_18
-- id: J4_8
+- id: IN_42
   pin: P8_17
-
-- id: J5_2
-  pin: P9_18
-- id: J5_3
-  pin: P9_21
-- id: J5_4
-  pin: P9_22
-- id: J5_5
-  pin: P9_23
-- id: J5_6
-  pin: P8_25 #MMC1_DAT0
-- id: J5_7
-  pin: P8_27 #LCD VSYNC
-- id: J5_8
-  pin: P8_28 #LCD_PCLK
-
-- id: J6_2
+- id: IN_43
   pin: P8_16
-- id: J6_3
+- id: IN_44
   pin: P8_15
-- id: J6_4
+- id: IN_45
   pin: P8_14
-- id: J6_5
+- id: IN_46
   pin: P8_13
-- id: J6_6
+
+- id: IN_47
   pin: P8_12
-- id: J6_7
+  kind: sensor
+- id: IN_48
   pin: P8_11
-- id: J6_8
+  kind: sensor
+- id: IN_49
   pin: P8_10
+  kind: sensor
 
-- id: J7_2
-  pin: P9_11
-- id: J7_3
-  pin: P9_12
-- id: J7_4
-  pin: P9_13
-- id: J7_5
-  pin: P9_14
-- id: J7_6
-  pin: P9_15
-- id: J7_7
-  pin: P9_16
-- id: J7_8
-  pin: P9_17
-
-- id: J8_2
-  pin: P8_9
+- id: IN_50
+  pin: P8_12
   kind: sensor
-- id: J8_3
+- id: IN_51
   pin: P8_8
   kind: sensor
-- id: J8_4
+- id: IN_52
   pin: P8_7
   kind: sensor

{boneio-0.1.2 → boneio-0.1.4}/boneio/helper/__init__.py

@@ -11,7 +11,13 @@ from boneio.helper.gpio import (
 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.yaml import (
+    CustomValidator,
+    load_yaml_file,
+    schema_file,
+    load_config_from_string,
+    load_config_from_file,
+)
 from boneio.helper.ha_discovery import (
     ha_relay_availabilty_message,
     ha_sensor_temp_availabilty_message,
@@ -47,4 +53,7 @@ __all__ = [
     "configure_pin",
     "BasicMqtt",
     "UniqueQueue",
+    "schema_file",
+    "load_config_from_string",
+    "load_config_from_file",
 ]

{boneio-0.1.2 → boneio-0.1.4}/boneio/helper/gpio.py

@@ -10,6 +10,7 @@ import subprocess
 from boneio.const import (
     CONFIG_PIN,
     GPIO as GPIO_STR,
+    GPIO_MODE,
     ClickTypes,
 )
 
@@ -27,13 +28,13 @@ def configure_pin(pin: str, mode: str = GPIO_STR) -> None:
     )
 
 
-def setup_output(pin: str):
+def setup_output(pin: str) -> None:
     """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"):
+def setup_input(pin: str, pull_mode: str = "UP") -> None:
     """Set up a GPIO as input."""
     try:
         GPIO.setup(pin, GPIO.IN, GPIO.PUD_DOWN if pull_mode == "DOWN" else GPIO.PUD_UP)
@@ -41,20 +42,20 @@ def setup_input(pin: str, pull_mode: str = "UP"):
         raise GPIOInputException(err)
 
 
-def write_output(pin: str, value: str):
+def write_output(pin: str, value: str) -> None:
     """Write a value to a GPIO."""
 
     GPIO.output(pin, value)
 
 
-def read_input(pin: str, on_state: Gpio_States = LOW):
+def read_input(pin: str, on_state: Gpio_States = LOW) -> None:
     """Read a value from a GPIO."""
     return GPIO.input(pin) is on_state
 
 
 def edge_detect(
     pin: str, callback: Callable, bounce: int = 0, edge: Gpio_Edges = FALLING
-):
+) -> None:
     """Add detection for RISING and FALLING events."""
     try:
         GPIO.add_event_detect(gpio=pin, edge=edge, callback=callback, bouncetime=bounce)
@@ -70,10 +71,11 @@ class GpioBaseClass:
     ) -> None:
         """Setup GPIO Input Button"""
         self._pin = pin
-        configure_pin(pin)
+        gpio = kwargs.get("rest_pin", {GPIO_MODE: GPIO_STR})
+        configure_pin(pin=pin, mode=gpio.get(GPIO_MODE, GPIO_STR))
         self._loop = asyncio.get_running_loop()
         self._press_callback = press_callback
-        setup_input(self._pin)
+        setup_input(pin=self._pin)
 
     @property
     def is_pressed(self):

{boneio-0.1.2 → boneio-0.1.4}/boneio/helper/ha_discovery.py

@@ -4,16 +4,16 @@ from boneio.version import __version__
 from boneio.const import INPUT, OFF, ON, RELAY, STATE, SENSOR, INPUT_SENSOR
 
 
-def ha_relay_availabilty_message(id: str, name: str, topic: str = "boneio"):
+def ha_relay_availabilty_message(id: str, name: str, topic: str = "boneIO"):
     """Create availability topic for HA."""
     return {
         "availability": [{"topic": f"{topic}/{STATE}"}],
         "command_topic": f"{topic}/relay/{id}/set",
         "device": {
             "identifiers": [topic],
-            "manufacturer": "BoneIO",
-            "model": "BoneIO Relay Board",
-            "name": f"BoneIO {topic}",
+            "manufacturer": "boneIO",
+            "model": "boneIO Relay Board",
+            "name": f"boneIO {topic}",
             "sw_version": __version__,
         },
         "name": name,
@@ -26,16 +26,16 @@ def ha_relay_availabilty_message(id: str, name: str, topic: str = "boneio"):
 
 
 def ha_availabilty_message(
-    id: str, name: str, topic: str = "boneio", sensor_type: str = INPUT
+    id: str, name: str, topic: str = "boneIO", sensor_type: str = INPUT
 ):
     """Create availability topic for HA."""
     return {
         "availability": [{"topic": f"{topic}/{STATE}"}],
         "device": {
             "identifiers": [topic],
-            "manufacturer": "BoneIO",
-            "model": "BoneIO Relay Board",
-            "name": f"BoneIO {topic}",
+            "manufacturer": "boneIO",
+            "model": "boneIO Relay Board",
+            "name": f"boneIO {topic}",
             "sw_version": __version__,
         },
         "icon": "mdi:gesture-double-tap",
@@ -63,15 +63,15 @@ def ha_sensor_availabilty_message(unit_of_measurement: str = None, **kwargs):
         return msg
 
 
-def ha_binary_sensor_availabilty_message(id: str, name: str, topic: str = "boneio"):
+def ha_binary_sensor_availabilty_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}",
+            "manufacturer": "boneIO",
+            "model": "boneIO Relay Board",
+            "name": f"boneIO {topic}",
             "sw_version": __version__,
         },
         "payload_on": "pressed",
@@ -82,15 +82,15 @@ def ha_binary_sensor_availabilty_message(id: str, name: str, topic: str = "bonei
     }
 
 
-def ha_sensor_temp_availabilty_message(id: str, name: str, topic: str = "boneio"):
+def ha_sensor_temp_availabilty_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}",
+            "manufacturer": "boneIO",
+            "model": "boneIO Relay Board",
+            "name": f"boneIO {topic}",
             "sw_version": __version__,
         },
         "name": name,
@@ -107,6 +107,7 @@ def sdm630_availabilty_message(
     id: str,
     sensor_id: str,
     name: str,
+    state_topic_base: str,
     topic: str = "sdm630",
     sensor_type: str = SENSOR,
     **kwargs,
@@ -115,14 +116,14 @@ def sdm630_availabilty_message(
     return {
         "availability": [{"topic": f"{topic}/{id}{STATE}"}],
         "device": {
-            "identifiers": [topic, id],
-            "manufacturer": "BoneIO",
+            "identifiers": [id],
+            "manufacturer": "boneIO",
             "model": "SDM630",
-            "name": f"BoneIO {name.upper()}",
+            "name": f"boneIO {name.upper()}",
             "sw_version": __version__,
         },
         "name": sensor_id,
-        "state_topic": f"{topic}/{sensor_type}/{id}/{sensor_id}",
+        "state_topic": f"{topic}/{sensor_type}/{id}/{state_topic_base}",
         "unique_id": f"{topic}{sensor_id.replace('_', '').lower()}",
         **kwargs,
     }

{boneio-0.1.2 → boneio-0.1.4}/boneio/helper/stats.py

@@ -23,6 +23,7 @@ from boneio.const import (
     NONE,
 )
 from boneio.sensor import LM75Sensor, MCP9808Sensor
+from boneio.version import __version__
 
 
 intervals = (("d", 86400), ("h", 3600), ("m", 60))
@@ -153,7 +154,7 @@ class HostData:
     ) -> None:
         """Initialize HostData."""
         self._hostname = socket.gethostname()
-        self.data[UPTIME] = {HOST: self._hostname, UPTIME: 0}
+        self.data[UPTIME] = {HOST: self._hostname, UPTIME: 0, "version": __version__}
         self._temp_sensor = temp_sensor
         self._output = output
         self._callback = callback

{boneio-0.1.2 → boneio-0.1.4}/boneio/helper/yaml.py

@@ -1,9 +1,13 @@
+import logging
 from typing import Any
 import os
 from cerberus import Validator
 from boneio.const import ID, OUTPUT
 from yaml import load, YAMLError, SafeLoader
 
+schema_file = os.path.join(os.path.dirname(__file__), "../schema.yaml")
+_LOGGER = logging.getLogger(__name__)
+
 
 class Loader(SafeLoader):
     """Loader which support for include in yaml files."""
@@ -33,6 +37,20 @@ def load_yaml_file(filename: str) -> Any:
             raise exception
 
 
+def load_config_from_string(config_yaml: str):
+    schema = load_yaml_file(schema_file)
+    v = CustomValidator(schema, purge_unknown=True)
+    return v.normalized(config_yaml)
+
+
+def load_config_from_file(config_file: str):
+    config_yaml = load_yaml_file(config_file)
+    if not config_yaml:
+        _LOGGER.info("Missing file.")
+        return None
+    return load_config_from_string(config_yaml)
+
+
 class CustomValidator(Validator):
     """Custom validator of cerberus"""
 

{boneio-0.1.2 → boneio-0.1.4}/boneio/manager.py

@@ -12,8 +12,9 @@ from boneio.const import (
     ACTION,
     ACTIONS,
     ADDRESS,
+    BONEIO,
     GPIO,
-    HA_TYPE,
+    OUTPUT_TYPE,
     HOMEASSISTANT,
     ID,
     INIT_SLEEP,
@@ -23,6 +24,7 @@ from boneio.const import (
     MCP,
     MCP_ID,
     MCP_TEMP_9808,
+    NONE,
     OFF,
     ON,
     ONLINE,
@@ -66,15 +68,15 @@ class Manager:
     def __init__(
         self,
         send_message: Callable[[str, Union[str, dict]], None],
-        topic_prefix: str,
-        relay_pins: List,
-        input_pins: List,
+        relay_pins: List = [],
+        input_pins: List = [],
         sensors: dict = {},
+        topic_prefix: str = BONEIO,
         modbus: dict = None,
         ha_discovery: bool = True,
         ha_discovery_prefix: str = HOMEASSISTANT,
         mcp23017: Optional[List] = None,
-        oled: bool = False,
+        oled: dict = {},
         adc_list: Optional[List] = None,
     ) -> None:
         """Initialize the manager."""
@@ -239,7 +241,7 @@ class Manager:
                     topic_prefix=topic_prefix,
                     mcp=mcp,
                     mcp_id=mcp_id,
-                    ha_type=gpio[HA_TYPE],
+                    output_type=gpio[OUTPUT_TYPE].lower(),
                     callback=lambda: self._host_data_callback(mcp_id),
                 )
                 self._grouped_outputs[mcp_id][relay_id] = mcp_relay
@@ -257,26 +259,26 @@ class Manager:
                 self._grouped_outputs[GPIO][relay_id] = gpio_relay
                 return gpio_relay
 
-        self.output = {
+        self._output = {
             gpio[ID].replace(" ", ""): configure_relay(gpio) for gpio in relay_pins
         }
-        for out in self.output.values():
-            self.send_ha_autodiscovery(
-                id=out.id,
-                name=out.name,
-                ha_type=out.ha_type,
-                ha_discovery_prefix=ha_discovery_prefix,
-                availabilty_msg_func=ha_relay_availabilty_message,
-            )
+        for out in self._output.values():
+            if out.output_type != NONE:
+                self.send_ha_autodiscovery(
+                    id=out.id,
+                    name=out.name,
+                    ha_type=out.output_type,
+                    ha_discovery_prefix=ha_discovery_prefix,
+                    availabilty_msg_func=ha_relay_availabilty_message,
+                )
             self._loop.call_soon_threadsafe(
                 self._loop.call_later,
                 0.5,
                 out.send_state,
             )
 
-        def configure_input(gpio):
+        def configure_input(gpio: dict, pin: str) -> str:
             try:
-                pin = gpio[PIN]
                 input_type = gpio.get(KIND)
                 if input_type == SENSOR:
                     GpioInputSensor(
@@ -312,15 +314,21 @@ class Manager:
                         ha_discovery_prefix=ha_discovery_prefix,
                         availabilty_msg_func=availabilty_msg_func,
                     )
+                return pin
             except GPIOInputException as err:
                 _LOGGER.error("This PIN %s can't be configured. %s", pin, err)
                 pass
 
         _LOGGER.info("Initializing inputs. This will take a while.")
+        input_pins = set()
         for gpio in self._input_pins:
-            configure_input(gpio=gpio)
+            pin = gpio[PIN]
+            if pin in input_pins:
+                _LOGGER.warn("This PIN %s is already configured. Omitting it.", pin)
+                continue
+            input_pins.add(configure_input(gpio=gpio, pin=pin))
 
-        if oled:
+        if oled.get("enabled", False):
             from boneio.oled import Oled
 
             self._host_data = HostData(
@@ -333,7 +341,9 @@ class Manager:
             _LOGGER.debug("Gathering host data enabled.")
             try:
                 self._oled = Oled(
-                    host_data=self._host_data, output_groups=list(self._grouped_outputs)
+                    host_data=self._host_data,
+                    output_groups=list(self._grouped_outputs),
+                    sleep_timeout=oled.get("screensaver_timeout", 60),
                 )
             except (GPIOInputException, I2CError) as err:
                 _LOGGER.error("Can't configure OLED display. %s", err)
@@ -359,7 +369,7 @@ class Manager:
         if action:
             if action[ACTION] == OUTPUT:
                 """For now only output type is supported"""
-                relay = self.output.get(action[PIN].replace(" ", ""))
+                relay = self._output.get(action[PIN].replace(" ", ""))
                 if relay:
                     relay.toggle()
         # This is similar how Z2M is clearing click sensor.
@@ -370,8 +380,8 @@ class Manager:
         id: str,
         name: str,
         ha_discovery_prefix: str,
+        ha_type: str,
         availabilty_msg_func: Callable,
-        ha_type: str = "switch",
         topic_prefix: str = None,
         **kwargs,
     ) -> None:
@@ -390,9 +400,14 @@ class Manager:
         extracted_relay = topic.replace(f"{self._topic_prefix}/{RELAY}/", "").replace(
             "/set", ""
         )
-        target_device = self.output.get(extracted_relay)
+        target_device = self._output.get(extracted_relay)
         if target_device:
             if message == ON:
                 target_device.turn_on()
             elif message == OFF:
                 target_device.turn_off()
+
+    @property
+    def output(self) -> dict:
+        """Get list of output."""
+        return self._output

{boneio-0.1.2 → boneio-0.1.4}/boneio/oled.py

@@ -1,3 +1,4 @@
+import asyncio
 import logging
 from itertools import cycle
 from typing import List
@@ -22,27 +23,34 @@ _LOGGER = logging.getLogger(__name__)
 
 
 fontBig = make_font("DejaVuSans.ttf", 12)
-fontSmall = make_font("DejaVuSans.ttf", 10)
+fontSmall = make_font("DejaVuSans.ttf", 9)
 fontExtraSmall = make_font("DejaVuSans.ttf", 7)
 danube = make_font("danube__.ttf", 15, local=True)
 
 screen_order = [UPTIME, NETWORK, CPU, DISK, MEMORY, SWAP]
 
 STANDARD_ROWS = [17, 32, 47]
-UPTIME_ROWS = list(range(25, 50, 10))
+UPTIME_ROWS = list(range(22, 60, 10))
 OUTPUT_ROWS = list(range(14, 60, 6))
-OUTPUT_COLS = range(0, 101, 50)
+OUTPUT_COLS = range(0, 113, 56)
 
 
 class Oled:
     """Oled display class."""
 
-    def __init__(self, host_data: HostData, output_groups: List[str]) -> None:
+    def __init__(
+        self, host_data: HostData, output_groups: List[str], sleep_timeout: int
+    ) -> None:
         """Initialize OLED screen."""
+        self._loop = asyncio.get_running_loop()
         self._screen_order = cycle(screen_order + output_groups)
         self._output_groups = output_groups
         self._current_screen = next(self._screen_order)
         self._host_data = host_data
+        if sleep_timeout:
+            self._sleep = False
+            self._sleep_handle = None
+            self._sleep_timeout = sleep_timeout
         configure_pin(OLED_PIN)
         setup_input(OLED_PIN)
         edge_detect(pin=OLED_PIN, callback=self._handle_press, bounce=80)
@@ -66,10 +74,15 @@ class Oled:
             )
             i += 1
 
+    def _sleeptime(self):
+        with canvas(self._device) as draw:
+            draw.rectangle(self._device.bounding_box, outline="black", fill="black")
+        self._sleep = True
+
     def _draw_uptime(self, data: dict, draw: ImageDraw) -> None:
         """Draw uptime screen with boneIO logo."""
-        draw.text((3, 5), "bone", font=danube, fill=WHITE)
-        draw.text((53, 5), "iO", font=danube, fill=WHITE)
+        draw.text((3, 3), "bone", font=danube, fill=WHITE)
+        draw.text((53, 3), "iO", font=danube, fill=WHITE)
         i = 0
         for k in data:
             draw.text(
@@ -106,13 +119,25 @@ class Oled:
                     self._draw_uptime(data, draw)
                 else:
                     self._draw_standard(data, draw)
+        if not self._sleep_handle and self._sleep_timeout > 0:
+            self._sleep_handle = self._loop.call_soon_threadsafe(
+                self._loop.call_later,
+                self._sleep_timeout,
+                self._sleeptime,
+            )
 
     def handle_data_update(self, type: str):
         """Callback to handle new data present into screen."""
-        if type == self._current_screen:
+        if type == self._current_screen and not self._sleep:
             self.render_display()
 
     def _handle_press(self, pin: any) -> None:
         """Handle press of PIN for OLED display."""
-        self._current_screen = next(self._screen_order)
+        if self._sleep_handle:
+            self._sleep_handle.cancel()
+            self._sleep_handle = None
+        if not self._sleep:
+            self._current_screen = next(self._screen_order)
+        else:
+            self._sleep = False
         self.render_display()

{boneio-0.1.2 → boneio-0.1.4}/boneio/relay/basic.py

@@ -4,7 +4,7 @@ import asyncio
 import logging
 from typing import Callable
 
-from boneio.const import OFF, ON, RELAY, STATE, SWITCH
+from boneio.const import OFF, ON, RELAY, STATE, SWITCH, NONE
 from boneio.helper import BasicMqtt
 
 _LOGGER = logging.getLogger(__name__)
@@ -14,11 +14,11 @@ class BasicRelay(BasicMqtt):
     """Basic relay class."""
 
     def __init__(
-        self, callback: Callable, id: str = None, ha_type=SWITCH, **kwargs
+        self, callback: Callable, id: str = None, output_type=SWITCH, **kwargs
     ) -> None:
         """Initialize Basic relay."""
         super().__init__(id=id, name=id, topic_type=RELAY, **kwargs)
-        self._ha_type = ha_type
+        self._output_type = output_type
         self._state = False
         self._callback = callback
         self._loop = asyncio.get_running_loop()
@@ -28,6 +28,11 @@ class BasicRelay(BasicMqtt):
         """Check if relay is mcp type."""
         return False
 
+    @property
+    def output_type(self) -> str:
+        """HA type."""
+        return self._output_type
+
     @property
     def id(self) -> bool:
         """Id of the relay.
@@ -48,10 +53,11 @@ class BasicRelay(BasicMqtt):
         """Send state to Mqtt on action."""
         state = ON if self.is_active else OFF
         self._state = state
-        self._send_message(
-            topic=self._send_topic,
-            payload={STATE: state},
-        )
+        if self.output_type != NONE:
+            self._send_message(
+                topic=self._send_topic,
+                payload={STATE: state},
+            )
         self._loop.call_soon_threadsafe(self._callback)
 
     def toggle(self) -> None:

{boneio-0.1.2 → boneio-0.1.4}/boneio/relay/mcp.py

@@ -25,6 +25,11 @@ class MCPRelay(BasicRelay):
         """Check if relay is mcp type."""
         return True
 
+    @property
+    def pin_id(self) -> str:
+        """Return PIN id."""
+        return self._pin_id
+
     @property
     def mcp_id(self) -> str:
         """Retrieve parent MCP ID."""
@@ -40,11 +45,6 @@ class MCPRelay(BasicRelay):
         """PIN of the relay"""
         return self._pin
 
-    @property
-    def ha_type(self) -> str:
-        """HA type."""
-        return self._ha_type
-
     def turn_on(self) -> None:
         """Call turn on action."""
         self.pin.value = True

{boneio-0.1.2 → boneio-0.1.4}/boneio/schema.yaml

@@ -49,8 +49,20 @@ mqtt:
             label: Prefix topic of HA discovery.
 
 oled:
-  type: boolean
-  coerce: to_bool
+  type: dict
+  default: {}
+  required: True
+  schema:
+    enabled:
+      type: boolean
+      default: False
+      meta:
+        label: Disable builtin screen.
+    screensaver_timeout:
+      type: integer
+      default: 60
+      meta:
+        label: How many seconds to wait to enable screensaver. 0 means disable screensaver.
 
 modbus:
   type: dict
@@ -174,13 +186,13 @@ output:
         required: True
         meta:
           label: PIN to use.
-      ha_type:
+      output_type:
         type: string
         required: True
-        allowed: ['switch', 'light']
+        allowed: ['switch', 'light', 'none']
         default: 'switch'
         meta:
-          label: If HA discovery is used device if relay is light or switch.
+          label: If HA discovery is used device if relay is light or switch. If None is declared then any state is not published to MQTT (used for cover).
 
 
 input:
@@ -200,6 +212,13 @@ input:
         required: True
         meta:
           label: PIN to use.
+      gpio_mode:
+        type: string
+        required: True
+        default: "gpio"
+        allowed: ["gpio", "gpio_pu", "gpio_pd", "gpio_input"]
+        meta:
+          label: What mode to use in config PIN.
       show_in_ha:
         type: boolean
         required: True

{boneio-0.1.2 → boneio-0.1.4}/boneio/sensor/sdm630.py

@@ -135,7 +135,7 @@ class Sdm630(BasicMqtt):
         _LOGGER.debug("Sending HA discovery for sensor %s %s.", sdm_name, sensor_id)
         self._send_message(
             topic=(
-                f"{self._ha_discovery_prefix}/{SENSOR}/{self._topic_prefix}"
+                f"{self._ha_discovery_prefix}/{SENSOR}/{self._topic_prefix}{id}"
                 f"/{id}{sensor_id.replace('_', '').lower()}/config"
             ),
             payload=sdm630_availabilty_message(
@@ -155,13 +155,16 @@ class Sdm630(BasicMqtt):
                     kwargs = {
                         "unit_of_measurement": getattr(register, "unit_of_measurement"),
                         "state_class": getattr(register, "state_class"),
-                        "value_template": "{{ value | round(2)}}",
+                        "value_template": f'{{{{ value_json.{getattr(register, "sensor_id")} | round(2) }}}}',
                         "sensor_id": getattr(register, "sensor_id"),
                     }
                     if getattr(register, "device_class"):
                         kwargs["device_class"] = getattr(register, "device_class")
                     self._send_ha_autodiscovery(
-                        id=self._id, sdm_name=self._name, **kwargs
+                        id=self._id,
+                        sdm_name=self._name,
+                        state_topic_base=data[BASE],
+                        **kwargs,
                     )
             return True
         return False
@@ -183,11 +186,13 @@ class Sdm630(BasicMqtt):
                         topic=f"{self._topic_prefix}/{self._id}{STATE}",
                         payload=payload_online,
                     )
+                output = {}
                 for register in data["registers"]:
-                    self._send_message(
-                        topic=f'{self._send_topic}/{getattr(register, "sensor_id")}',
-                        payload=float32(
-                            values, data[BASE], getattr(register, "address")
-                        ),
+                    output[getattr(register, "sensor_id")] = float32(
+                        values, data[BASE], getattr(register, "address")
                     )
+                self._send_message(
+                    topic=f"{self._send_topic}/{data[BASE]}",
+                    payload=output,
+                )
             await asyncio.sleep(self._update_interval)

boneio-0.1.4/boneio/version.py

@@ -0,0 +1,2 @@
+# flake8: noqa
+__version__ = "0.1.4"

{boneio-0.1.2 → boneio-0.1.4/boneio.egg-info}/PKG-INFO

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

boneio-0.1.2/boneio/version.py

@@ -1,2 +0,0 @@
-# flake8: noqa
-__version__ = "0.1.2"