boneIO 0.1.5__tar.gz → 0.2.0.dev9__tar.gz

{boneio-0.1.5 → boneio-0.2.0.dev9}/MANIFEST.in

@@ -2,4 +2,5 @@ include README.md
 include requirements.txt
 include LICENSE
 recursive-include boneio *.yaml
+recursive-include boneio *.json
 recursive-include boneio *.ttf

{boneio-0.1.5/boneio.egg-info → boneio-0.2.0.dev9}/PKG-INFO

@@ -1,10 +1,10 @@
 Metadata-Version: 2.1
 Name: boneio
-Version: 0.1.5
+Version: 0.2.0.dev9
 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.5.zip
+Download-URL: https://github.com/boneIO-eu/app_bbb/archive/0.2.0.dev9.zip
 Platform: UNKNOWN
 Classifier: Programming Language :: Python
 Classifier: Programming Language :: Python :: 3.7

boneio-0.2.0.dev9/boneio/bonecli.py

@@ -0,0 +1,103 @@
+"""Bonecli script."""
+import argparse
+import asyncio
+import logging
+import os
+import sys
+
+from colorlog import ColoredFormatter
+
+from boneio.const import ACTION
+from boneio.helper import load_config_from_file
+from boneio.runner import async_run, configure_logger
+from boneio.version import __version__
+
+TASK_CANCELATION_TIMEOUT = 1
+
+_LOGGER = logging.getLogger(__name__)
+logging.basicConfig(level=logging.INFO)
+fmt = "%(asctime)s %(levelname)s (%(threadName)s) [%(name)s] %(message)s"
+datefmt = "%Y-%m-%d %H:%M:%S"
+colorfmt = f"%(log_color)s{fmt}%(reset)s"
+logging.getLogger().handlers[0].setFormatter(
+    ColoredFormatter(
+        colorfmt,
+        datefmt=datefmt,
+        reset=True,
+        log_colors={
+            "DEBUG": "cyan",
+            "INFO": "green",
+            "WARNING": "yellow",
+            "ERROR": "red",
+            "CRITICAL": "red",
+        },
+    )
+)
+
+
+def get_arguments() -> argparse.Namespace:
+    """Get parsed passed in arguments."""
+
+    parser = argparse.ArgumentParser(
+        description="boneIO app for BeagleBone Black.",
+    )
+    parser.add_argument(ACTION, type=str, default="run")
+    parser.add_argument("--version", action="version", version=__version__)
+    parser.add_argument(
+        "-c",
+        "--config",
+        metavar="path_to_config_dir",
+        default="./config.yaml",
+        help="File which contains boneIO configuration",
+    )
+    parser.add_argument(
+        "--debug", "-d", action="count", help="Start boneIO in debug mode", default=0
+    )
+    parser.add_argument(
+        "--mqttusername", help="Mqtt username to use if you don't want provide in file."
+    )
+    parser.add_argument(
+        "--mqttpassword", help="Mqtt password to use if you don't want provide in file."
+    )
+    arguments = parser.parse_args()
+
+    return arguments
+
+
+def run(config: str, debug: int, mqttusername: str = "", mqttpassword: str = ""):
+    """Run BoneIO."""
+    _LOGGER.info("BoneIO starting.")
+    _config = load_config_from_file(config_file=config)
+    if not _config:
+        return
+    configure_logger(log_config=_config.get("logger"), debug=debug)
+    return asyncio.run(
+        async_run(
+            config=_config,
+            config_path=os.path.split(config),
+            mqttusername=mqttusername,
+            mqttpassword=mqttpassword,
+        ),
+    )
+
+
+def main() -> int:
+    """Start boneIO."""
+
+    args = get_arguments()
+    debug = args.debug
+
+    exit_code = 0
+    if args.action == "run":
+        exit_code = run(
+            config=args.config,
+            mqttusername=args.mqttusername,
+            mqttpassword=args.mqttpassword,
+            debug=debug,
+        )
+
+    return exit_code
+
+
+if __name__ == "__main__":
+    sys.exit(main())

{boneio-0.1.5 → boneio-0.2.0.dev9}/boneio/const.py

@@ -1,6 +1,10 @@
 # from typing import Literal
 from datetime import timedelta
-from Adafruit_BBIO.GPIO import HIGH, LOW, BOTH, FALLING
+
+try:
+    from Adafruit_BBIO.GPIO import HIGH, LOW, BOTH, FALLING
+except ModuleNotFoundError:
+    pass
 from typing_extensions import Literal
 
 BONEIO = "boneIO"
@@ -33,7 +37,8 @@ MODBUS = "modbus"
 UART = "uart"
 RX = "rx"
 TX = "tx"
-
+RESTORE_STATE = "restore_state"
+MODEL = "model"
 UARTS = {
     "uart1": {ID: "/dev/ttyS1", TX: "P9.24", RX: "P9.26"},
     "uart4": {ID: "/dev/ttyS4", TX: "P9.13", RX: "P9.11"},
@@ -48,7 +53,6 @@ SECOND_DELAY_DURATION = 0.3
 # HA CONSTS
 HOMEASSISTANT = "homeassistant"
 HA_DISCOVERY = "ha_discovery"
-HA_TYPE = "ha_type"
 OUTPUT_TYPE = "output_type"
 SHOW_HA = "show_in_ha"
 
@@ -85,6 +89,7 @@ USERNAME = "username"
 PASSWORD = "password"
 ONLINE = "online"
 OFFLINE = "offline"
+TOPIC = "topic"
 TOPIC_PREFIX = "topic_prefix"
 
 # I2C and MCP CONST
@@ -101,15 +106,24 @@ BINARY_SENSOR = "binary_sensor"
 LM75 = "lm75"
 MCP_TEMP_9808 = "mcp9808"
 INPUT_SENSOR = "inputsensor"
-SDM630 = "sdm630"
 
 BASE = "base"
 LENGTH = "length"
 REGISTERS = "registers"
 
+COVER = "cover"
+IDLE = "idle"
+OPENING = "opening"
+CLOSING = "closing"
+CLOSED = "closed"
+OPEN = "open"
+CLOSE = "close"
+STOP = "stop"
+
 # 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]
+DEVICE_CLASS = "device_class"

boneio-0.2.0.dev9/boneio/cover.py

@@ -0,0 +1,256 @@
+"""Cover module."""
+import asyncio
+import logging
+from typing import Any, Callable
+from boneio.const import CLOSE, COVER, IDLE, OPEN, OPENING, CLOSING, CLOSED, STOP
+from boneio.helper.events import EventBus
+from boneio.helper.mqtt import BasicMqtt
+from boneio.relay import MCPRelay
+
+_LOGGER = logging.getLogger(__name__)
+
+COVER_COMMANDS = {
+    OPEN: "open_cover",
+    CLOSE: "close_cover",
+    STOP: "stop",
+    "toggle": "toggle",
+    "toggle_open": "toggle_open",
+}
+
+
+class RelayHelper:
+    """Relay helper for cover either open/close."""
+
+    def __init__(self, relay: MCPRelay, time: int) -> None:
+        """Initialize helper."""
+        self._relay = relay
+        self._steps = 100 / time
+
+    @property
+    def relay(self) -> MCPRelay:
+        """Get relay."""
+        return self._relay
+
+    @property
+    def steps(self) -> int:
+        """Get steps for each time."""
+        return self._steps
+
+
+class Cover(BasicMqtt):
+    """Cover class of boneIO"""
+
+    def __init__(
+        self,
+        id: str,
+        open_relay: Any,
+        close_relay: MCPRelay,
+        state_save: Callable,
+        open_time: int,
+        close_time: int,
+        event_bus: EventBus,
+        restored_state: int = 100,
+        **kwargs,
+    ) -> None:
+        """Initialize cover class."""
+        self._loop = asyncio.get_event_loop()
+        self._id = id
+        super().__init__(id=id, name=id, topic_type=COVER, **kwargs)
+        self._lock = asyncio.Lock()
+        self._state_save = state_save
+        self._open = RelayHelper(relay=open_relay, time=open_time)
+        self._close = RelayHelper(relay=close_relay, time=close_time)
+        self._set_position = None
+        self._current_operation = IDLE
+        self._position = restored_state
+        self._requested_closing = True
+        self._event_bus = event_bus
+        self._timer_handle = None
+        if self._position is None:
+            self._closed = True
+        else:
+            self._closed = self._position <= 0
+        self._event_bus.add_sigterm_listener(self.on_exit)
+        self._loop.call_soon_threadsafe(
+            self._loop.call_later,
+            0.5,
+            self.send_state,
+        )
+
+    async def run_cover(
+        self,
+        current_operation: str,
+    ) -> None:
+        """Run cover engine."""
+        if self._current_operation != IDLE:
+            self._stop_cover()
+        self._current_operation = current_operation
+
+        def get_relays():
+            if current_operation == OPENING:
+                return (self._open.relay, self._close.relay)
+            else:
+                return (self._close.relay, self._open.relay)
+
+        (relay, inverted_relay) = get_relays()
+        async with self._lock:
+            if inverted_relay.is_active:
+                inverted_relay.turn_off()
+            self._timer_handle = self._event_bus.add_listener(
+                f"{COVER}{self.id}", self.listen_cover
+            )
+            relay.turn_on()
+
+    def on_exit(self) -> None:
+        """Stop on exit."""
+        self._stop_cover(on_exit=True)
+
+    @property
+    def cover_state(self):
+        """Current state of cover."""
+        return CLOSED if self._closed else OPEN
+
+    def stop(self):
+        """Public Stop cover graceful."""
+        _LOGGER.info("Stopping cover %s.", self._id)
+        if self._current_operation != IDLE:
+            self._stop_cover(on_exit=False)
+
+    def send_state(self):
+        """Send state of cover to mqtt."""
+        self._send_message(topic=f"{self._send_topic}/state", payload=self.cover_state)
+        pos = round(self._position, 0)
+        self._send_message(topic=f"{self._send_topic}/pos", payload=str(pos))
+        self._state_save(position=pos)
+
+    def _stop_cover(self, on_exit=False):
+        """Stop cover."""
+        self._open.relay.turn_off()
+        self._close.relay.turn_off()
+        if self._timer_handle is not None:
+            self._event_bus.remove_listener(f"{COVER}{self.id}")
+            self._timer_handle = None
+            self._set_position = None
+            if not on_exit:
+                self.send_state()
+        self._current_operation = IDLE
+
+    @property
+    def current_cover_position(self):
+        """Return the current position of the cover."""
+        return round(self._position, 0)
+
+    def listen_cover(self, *args):
+        """Listen for change in cover."""
+        if self._current_operation == IDLE:
+            return
+
+        def get_step():
+            """Get step for current operation."""
+            if self._requested_closing:
+                return -self._close.steps
+            else:
+                return self._open.steps
+
+        step = get_step()
+        self._position += step
+        rounded_pos = round(self._position, 0)
+        if self._set_position:
+            # Set position is only working for every 10%, so round to nearest 10.
+            # Except for start moving time
+            if (self._requested_closing and rounded_pos < 95) or rounded_pos > 5:
+                rounded_pos = round(self._position, -1)
+        else:
+            if rounded_pos > 100:
+                rounded_pos = 100
+            elif rounded_pos < 0:
+                rounded_pos = 0
+        self._send_message(topic=f"{self._send_topic}/pos", payload=rounded_pos)
+        if rounded_pos == self._set_position or (
+            self._set_position is None and (rounded_pos >= 100 or rounded_pos <= 0)
+        ):
+            self._position = rounded_pos
+            self._closed = self.current_cover_position <= 0
+            self._stop_cover()
+            return
+
+        self._closed = self.current_cover_position <= 0
+
+    async def close_cover(self):
+        """Close cover."""
+        if self._position == 0:
+            return
+        if self._position is None:
+            self._closed = True
+            return
+        _LOGGER.info("Closing cover %s.", self._id)
+
+        self._requested_closing = True
+        self._send_message(topic=f"{self._send_topic}/state", payload=CLOSING)
+        await self.run_cover(
+            current_operation=CLOSING,
+        )
+
+    async def open_cover(self):
+        """Open cover."""
+        if self._position == 100:
+            return
+        if self._position is None:
+            self._closed = False
+            return
+        _LOGGER.info("Opening cover %s.", self._id)
+
+        self._requested_closing = False
+        self._send_message(topic=f"{self._send_topic}/state", payload=OPENING)
+        await self.run_cover(
+            current_operation=OPENING,
+        )
+
+    async def set_cover_position(self, position: int):
+        """Move cover to a specific position."""
+        set_position = round(position, -1)
+        if self._position == position or set_position == self._set_position:
+            return
+        if self._set_position:
+            self._stop_cover(on_exit=True)
+        _LOGGER.info("Setting cover at position %s.", set_position)
+        self._set_position = set_position
+
+        self._requested_closing = set_position < self._position
+        current_operation = CLOSING if self._requested_closing else OPENING
+        _LOGGER.debug(
+            "Requested set position %s. Operation %s", set_position, current_operation
+        )
+        self._send_message(topic=f"{self._send_topic}/state", payload=current_operation)
+        await self.run_cover(
+            current_operation=current_operation,
+        )
+
+    def open(self):
+        _LOGGER.debug("Opening cover %s.", self._id)
+        asyncio.create_task(self.open_cover())
+
+    def close(self):
+        _LOGGER.debug("Closing cover %s.", self._id)
+        asyncio.create_task(self.close_cover())
+
+    def toggle(self):
+        _LOGGER.debug("Toggle cover %s from input.", self._id)
+        if self.cover_state == CLOSED:
+            self.close()
+        else:
+            self.open()
+
+    def toggle_open(self):
+        _LOGGER.debug("Toggle open cover %s from input.", self._id)
+        if self._current_operation != IDLE:
+            self.stop()
+        else:
+            self.open()
+
+    def toggle_close(self):
+        _LOGGER.debug("Toggle close cover %s from input.", self._id)
+        if self._current_operation != IDLE:
+            self.stop()
+        else:
+            self.close()

boneio-0.2.0.dev9/boneio/example_config/cover.yaml

@@ -0,0 +1,8 @@
+cover:
+  - id: kitchen
+    open_relay: test1
+    close_relay: test2
+    open_time: 20
+    close_time: 22
+    show_in_ha: yes
+    restore_state: yes

{boneio-0.1.5 → boneio-0.2.0.dev9}/boneio/example_config/output24x16A.yaml

@@ -1,139 +1,120 @@
-
-- id: mcp1-gpa0
+- id: OUT_01
   kind: mcp
-  mcp_id: mcp1
-  pin: 0
-  ha_type: light
-- id: mcp1-gpa1
+  mcp_id: mcp2
+  pin: 9
+  output_type: light
+- id: OUT_02
+  kind: mcp
+  mcp_id: mcp2
+  pin: 8
+  output_type: light
+- id: OUT_03
   kind: mcp
   mcp_id: mcp1
   pin: 1
-  ha_type: light
-
-- id: mcp1-gpb0
+  output_type: light
+- id: OUT_04
   kind: mcp
   mcp_id: mcp1
-  pin: 8
-  ha_type: light
-- id: mcp1-gpb1
+  pin: 0
+  output_type: switch
+- id: OUT_05
   kind: mcp
-  mcp_id: mcp1
-  pin: 9
-  ha_type: light
-- id: mcp1-gpb2
+  mcp_id: mcp2
+  pin: 13
+  output_type: light
+- id: OUT_06
   kind: mcp
-  mcp_id: mcp1
-  pin: 10
-  ha_type: light
-- id: mcp1-gpb3
+  mcp_id: mcp2
+  pin: 12
+  output_type: light
+- id: OUT_07
   kind: mcp
-  mcp_id: mcp1
+  mcp_id: mcp2
   pin: 11
-  ha_type: light
-- id: mcp1-gpb4
+  output_type: light
+- id: OUT_08
+  kind: mcp
+  mcp_id: mcp2
+  pin: 10
+  output_type: light
+- id: OUT_09
   kind: mcp
   mcp_id: mcp1
-  pin: 12
-  ha_type: light
-- id: mcp1-gpb5
+  pin: 14
+  output_type: light
+- id: OUT_10
   kind: mcp
   mcp_id: mcp1
-  pin: 13
-  ha_type: light
-- id: mcp1-gpb6
+  pin: 15
+  output_type: light
+- id: OUT_11
   kind: mcp
   mcp_id: mcp1
-  pin: 14
-  ha_type: light
-- id: mcp1-gpb7
+  pin: 13
+  output_type: light
+- id: OUT_12
   kind: mcp
   mcp_id: mcp1
-  pin: 15
-  ha_type: light
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-- id: mcp2-gpa0
+  pin: 12
+  output_type: light
+- id: OUT_13
   kind: mcp
   mcp_id: mcp2
-  pin: 0
-  ha_type: switch
-- id: mcp2-gpa1 
+  pin: 6
+  output_type: light
+- id: OUT_14
   kind: mcp
   mcp_id: mcp2
-  pin: 1
-  ha_type: switch
-- id: mcp2-gpa2
+  pin: 5
+  output_type: light
+- id: OUT_15
   kind: mcp
   mcp_id: mcp2
-  pin: 2
-  ha_type: switch
-- id: mcp2-gpa3
+  pin: 4
+  output_type: light
+- id: OUT_16
   kind: mcp
   mcp_id: mcp2
   pin: 3
-  ha_type: switch
-- id: mcp2-gpa4
+  output_type: light
+- id: OUT_17
   kind: mcp
   mcp_id: mcp2
-  pin: 4
-  ha_type: switch
-- id: mcp2-gpa5
+  pin: 2
+  output_type: light
+- id: OUT_18
   kind: mcp
   mcp_id: mcp2
-  pin: 5
-  ha_type: switch
-- id: mcp2-gpa6
+  pin: 0
+  output_type: light
+- id: OUT_19 
   kind: mcp
   mcp_id: mcp2
-  pin: 6
-  ha_type: switch
-- id: mcp2-gpa7
+  pin: 1
+  output_type: light
+- id: OUT_20
   kind: mcp
   mcp_id: mcp2
   pin: 7
-  ha_type: switch
-
-
-- id: mcp2-gpb0
+  output_type: light
+- id: OUT_21
   kind: mcp
-  mcp_id: mcp2
+  mcp_id: mcp1
   pin: 8
-  ha_type: switch
-- id: mcp2-gpb1
+  output_type: light
+- id: OUT_22
   kind: mcp
-  mcp_id: mcp2
+  mcp_id: mcp1
   pin: 9
-  ha_type: switch
-- id: mcp2-gpb2
+  output_type: light
+- id: OUT_23
   kind: mcp
-  mcp_id: mcp2
-  pin: 10
-  ha_type: switch
-- id: mcp2-gpb3
-  kind: mcp
-  mcp_id: mcp2
+  mcp_id: mcp1
   pin: 11
-  ha_type: switch
-- id: mcp2-gpb4
+  output_type: light
+- id: OUT_24
   kind: mcp
-  mcp_id: mcp2
-  pin: 12
-  ha_type: switch
-- id: mcp2-gpb5
-  kind: mcp
-  mcp_id: mcp2
-  pin: 13
-  ha_type: switch
-
+  mcp_id: mcp1
+  pin: 10
+  output_type: light

{boneio-0.1.5 → boneio-0.2.0.dev9}/boneio/helper/__init__.py

@@ -18,6 +18,7 @@ from boneio.helper.yaml import (
     load_config_from_string,
     load_config_from_file,
 )
+from boneio.helper.state_manager import StateManager
 from boneio.helper.ha_discovery import (
     ha_relay_availabilty_message,
     ha_sensor_temp_availabilty_message,
@@ -50,6 +51,7 @@ __all__ = [
     "GPIOInputException",
     "I2CError",
     "GpioBaseClass",
+    "StateManager",
     "configure_pin",
     "BasicMqtt",
     "UniqueQueue",