50_ppdd.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "experienced-breeding",
   "metadata": {},
   "outputs": [],
   "source": [
    "# default_exp ppdd"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "likely-assurance",
   "metadata": {},
   "source": [
    "# pico_pi_controller.ppdd\n",
    "> System daemon"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "vulnerable-beads",
   "metadata": {},
   "outputs": [],
   "source": [
    "# hide\n",
    "# from nbdev.showdoc import *"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "accepted-belfast",
   "metadata": {},
   "outputs": [],
   "source": [
    "# export\n",
    "\n",
    "from sys import byteorder\n",
    "from os import getloadavg\n",
    "from platform import node\n",
    "from uptime import uptime\n",
    "import threading, _thread\n",
    "import argparse, logging\n",
    "import pigpio, atexit\n",
    "import datetime, time\n",
    "import uuid, socketserver\n",
    "import queue\n",
    "from CircuitPython_pico_pi_common.codes import *\n",
    "\n",
    "logger = logging.getLogger()\n",
    "logging.basicConfig(level = logging.DEBUG)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "following-apparatus",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:root:ppdd run: Must run as root.                          |\n"
     ]
    }
   ],
   "source": [
    "# export\n",
    "\n",
    "tcp_address = ('127.0.0.1', 16164)\n",
    "hostname = bytearray(node(), \"utf-8\")\n",
    "\n",
    "def log_txn(fname, message, msg=None, i2c_addr=None):\n",
    "        \"\"\"Wrapper for logger.\"\"\"\n",
    "        id_str = ID_CODE.decode()\n",
    "        hex_addr = ''\n",
    "        if i2c_addr:\n",
    "            hex_addr = str(hex(i2c_addr))\n",
    "        i2c_str = '|'\n",
    "        logger.info('%-4s %-47s %s' % (id_str, fname+': '+hex_addr+message+str(msg or ''), i2c_str))\n",
    "\n",
    "class PwrLedFlicker(threading.Thread):\n",
    "    def __init__(self, duration):\n",
    "        threading.Thread.__init__(self)\n",
    "        self.duration = duration\n",
    "        \n",
    "    def run(self):\n",
    "        fname='run'\n",
    "        try:\n",
    "            with open(\"/sys/class/leds/led1/brightness\", \"w\") as sys_pwr_led:\n",
    "                for x in range(self.duration * 2):\n",
    "                    sys_pwr_led.write(\"0\")\n",
    "                    sys_pwr_led.flush()\n",
    "                    time.sleep(0.1)\n",
    "                    sys_pwr_led.write(\"1\")\n",
    "                    sys_pwr_led.flush()\n",
    "                    time.sleep(0.4)\n",
    "            sys_pwr_led.close()\n",
    "        except PermissionError:\n",
    "            log_txn(fname,\"Must run as root.\")\n",
    "            _thread.interrupt_main()\n",
    "            \n",
    "class PPCcHandler(socketserver.BaseRequestHandler):\n",
    "    def handle(self):\n",
    "        \"\"\"Handle commands from ppcc; some processed iternally, some sent to PPC\"\"\"\n",
    "        fname='handle'\n",
    "        global cmd_queue, awt_queue, cfm_queue\n",
    "        #log_txn(fname,\"recvd request from {}\".format(self.client_address[0]),\n",
    "        #        \" on {}\".format(threading.current_thread().name))\n",
    "        cmd_len = bytearray(1)\n",
    "        cmd_len = int.from_bytes( self.request.recv(1), byteorder=byteorder)\n",
    "        \n",
    "        #log_txn(fname,\"recvd command from {}, len: \".format(self.client_address[0]),str(cmd_len)+\" bytes:\")\n",
    "        \n",
    "        command = bytearray(cmd_len)\n",
    "        command = self.request.recv(cmd_len)\n",
    "        \n",
    "        cmd_code, i2c_addr, cmdargs, cmd_uid, valid_status = parse_cmd(command)\n",
    "        \n",
    "        if valid_status:\n",
    "        \n",
    "            log_txn(fname,'',\n",
    "                str(hex(i2c_addr))+' '+CMD_NAME[cmd_code]+' 0'+str(cmdargs)[3:-1]+\"  UID \"+str(hex(int.from_bytes(cmd_uid, byteorder)))[2:])\n",
    "        \n",
    "            cmd_queue.put(command)\n",
    "            log_txn(fname,\"command queue size:\", cmd_queue.qsize() )\n",
    "            # blocking, wait for confirmation of i2c_event_handler acting on command\n",
    "            # todo: implement a timeout if confirm never appears in awt_queue\n",
    "            confirm = bytearray(0)\n",
    "            while confirm != command:\n",
    "                log_txn(fname,\"awaitng confirmation...\")\n",
    "                confirm = awt_queue.get(block=True,timeout=2)\n",
    "                # put it back if it's not the confirm we're looking for, or if it's only a \n",
    "                # partial confirm, then log it & delete it.\n",
    "                if confirm != command:\n",
    "                # todo: handle partial confirms (only one 2c_addr from 0xFF)\n",
    "                    awt_queue.put(confirm)\n",
    "                log_txn(fname,\"awaitng queue size:\", awt_queue.qsize() )\n",
    "            if confirm == command:\n",
    "                cfm_queue.put(command)\n",
    "                num_bytes_sent = self.request.send(command)\n",
    "                log_txn(fname,\"confirm queue size:\", cfm_queue.qsize() )\n",
    "        else:\n",
    "            pass #handle error\n",
    "        self.request.close()\n",
    "\n",
    "@atexit.register\n",
    "def goodbye():\n",
    "    \"\"\"Cancel pigpio event handler, close I2C peripheral & connection to pigpio\"\"\"\n",
    "    global e, pi, ppdd_server\n",
    "    fname='goodbye'\n",
    "    if 'e' in globals():\n",
    "        try:\n",
    "            e.cancel()\n",
    "            log_txn(fname,\"bsc_i2c event handler cleanup completed.\")\n",
    "        except:\n",
    "            log_txn(fname,\"bsc_i2c error on event handler cleanup.\")\n",
    "    if 'pi' in globals():\n",
    "        try:\n",
    "            pi.stop()\n",
    "            log_txn(fname,\"pigpio cleanup completed.\")\n",
    "        except:\n",
    "            log_txn(fname,\"pigpio error on cleanup.\")\n",
    "    if 'ppdd_server' in globals():\n",
    "        try:\n",
    "            ppdd_server.server_close()\n",
    "            log_txn(fname,\"TCP serversocket cleanup completed.\")\n",
    "        except:\n",
    "            log_txn(fname,\"TCP serversocket error on cleanup.\")\n",
    "    log_txn(fname,\"Exiting.\")\n",
    "\n",
    "def i2c_event_handler(id, tick):\n",
    "    \"\"\"Handle register probes.\"\"\"\n",
    "    fname='i2c_event_handler'\n",
    "    global pi, i2c_addr, bosmang, flicker, cmd_queue, cfm_queue\n",
    "\n",
    "    def reg_idf():\n",
    "        fname='reg_idf'\n",
    "        try:\n",
    "            mcu_uid = d[1:8]\n",
    "        except:\n",
    "            mcu_uid = bytearray(8)\n",
    "        log_txn(fname, \"recvd identity: \", mcu_uid.decode())\n",
    "        log_txn(fname, \"sendn identity: \", ID_CODE.decode())\n",
    "        s, b, d = pi.bsc_i2c(i2c_addr, ID_CODE)\n",
    "\n",
    "    def reg_bos():\n",
    "        fname='reg_bos'\n",
    "        log_txn(fname, \"sending bosmang status: \", str(bool(int.from_bytes(bosmang, byteorder=byteorder))))\n",
    "        s, b, d = pi.bsc_i2c(i2c_addr, bosmang)\n",
    "\n",
    "    def reg_tim():\n",
    "        fname='reg_tim'\n",
    "        dt = datetime.datetime.now()\n",
    "        # send local time converted from UTC of system time\n",
    "        dt = dt.replace(\n",
    "            tzinfo=datetime.timezone(datetime.timedelta(0), \"UTC\") )  \n",
    "        ts = dt.timestamp()\n",
    "        log_txn(fname, \"sending time.time(): \", int(ts) )\n",
    "        s, b, d = pi.bsc_i2c(i2c_addr, bytearray(int(ts).to_bytes(4, byteorder)))\n",
    "\n",
    "    def reg_cmd():\n",
    "        fname='reg_cmd'\n",
    "        global cmd_queue, awt_queue\n",
    "        #log_txn(fname,\"checking command queue\")\n",
    "        if cmd_queue.qsize() > 0:\n",
    "            command=cmd_queue.get()\n",
    "            if command[0] in CMD_NAME.keys(): \n",
    "                #log_txn(fname,\"sending queud command: \", command )\n",
    "                s, b, d = pi.bsc_i2c(i2c_addr, command)\n",
    "                # place the command in the queue for awaiting confirmation\n",
    "                awt_queue.put(command)\n",
    "            else:\n",
    "                log_txn(fname,\"invalid command found in queue: \", command )\n",
    "        else:\n",
    "            s, b, d = pi.bsc_i2c(i2c_addr, bytearray([0]))\n",
    "            #log_txn(fname,\"no command\")\n",
    "            \n",
    "\n",
    "    def reg_cfm():\n",
    "        fname='cfm_cmd'\n",
    "        global awt_queue \n",
    "        i2c_addr = d[0] # address of the ppd acted upon by the command\n",
    "        if d[1] in CMD_INT:\n",
    "            # add PPDevice CFM received to awt_queue (awaiting ppdd confirm); it may be\n",
    "            # only 1 of many i2c_addrs. logic in handle.\n",
    "            awt_queue.add(d[1:]) # CFM includes echo of entire command\n",
    "            log_txn(fname,str(hex(i2c_addr))+\" recvd confirm: \", CMD_NAME[d[0]])\n",
    "            \n",
    "    def reg_hos():\n",
    "        fname='reg_hos'\n",
    "        log_txn(fname,\n",
    "            \"sending hostname: \", hostname.decode())\n",
    "        s, b, d = pi.bsc_i2c(i2c_addr, bytes([len(hostname)]) + hostname)\n",
    "\n",
    "    def reg_lod():\n",
    "        fname='reg_lod'\n",
    "        load = bytearray(\"{:04.2f}\".format(getloadavg()[0]), \"utf-8\")\n",
    "        log_txn(fname, \"sending loadavg: \", load.decode())\n",
    "        s, b, d = pi.bsc_i2c(i2c_addr, load)\n",
    "\n",
    "    def reg_upt():\n",
    "        fname='reg_upt'\n",
    "        # so the PPC can pause and wait for the long-ish uptime fetch\n",
    "        s, b, d = pi.bsc_i2c(i2c_addr, bytearray(1) )\n",
    "        uptimeba = bytearray(int(uptime()).to_bytes(4, byteorder))\n",
    "        log_txn(fname, \"sending uptime: \", int.from_bytes(bytes(uptimeba), byteorder)\n",
    "        )\n",
    "        s, b, d = pi.bsc_i2c(i2c_addr, uptimeba)\n",
    "\n",
    "    def reg_tzn():\n",
    "        fname='reg_tzn'\n",
    "        log_txn(fname, \"sending time.timezone(): \", time.timezone, )\n",
    "        s, b, d = pi.bsc_i2c(i2c_addr, bytearray(time.timezone.to_bytes(3, byteorder)))\n",
    "\n",
    "    def reg_flk():\n",
    "        fname='reg_flk'\n",
    "        nonlocal d\n",
    "        log_txn(fname, \"Flickering PWR LED for \"+str(d[1])+\" seconds.\")\n",
    "        flicker = PwrLedFlicker(duration=d[1])\n",
    "        flicker.start()\n",
    "        # if FLK was from a command, d will hold that command. echo it back to confirm execution.\n",
    "        if len(d) > REG_VAL_LEN['FLK']:\n",
    "            if d[REG_VAL_LEN['FLK']+1] in CMD_INT:\n",
    "                s, b, d = pi.bsc_i2c(i2c_addr, d[REG_VAL_LEN['FLK']:] )\n",
    "\n",
    "    def reg_clr():\n",
    "        fname='reg_clr'\n",
    "        #log_txn(fname, \"CLR recieved, FIFO buffer to be emptied.\")\n",
    "        s, b, d = pi.bsc_i2c(i2c_addr, bytearray(0) )\n",
    "\n",
    "    s, b, d = pi.bsc_i2c(i2c_addr)\n",
    "    if b:\n",
    "        #log_txn(fname, \"Register probe recvd, status:\",s)\n",
    "        if d[0] in REG_NAME.keys():\n",
    "            reg_hndlr = locals()['reg_'+REG_NAME[d[0]].lower()]\n",
    "            #log_txn(fname, \": reg_\"+REG_NAME[d[0]].lower())\n",
    "            reg_hndlr()\n",
    "        else:\n",
    "            log_txn(fname, \": unrecognized REG probed: \",d[0])\n",
    "\n",
    "\n",
    "def main():\n",
    "    fname='main'\n",
    "    global cmd_queue, awt_queue, cfm_queue, i2c_addr, id_str, e, pi, ppdd_server, flicker, bosmang\n",
    "    \n",
    "    cmd_queue = queue.Queue() #command queue (commands recvd from ppcc, outgoing to PPC)\n",
    "    awt_queue = queue.Queue() #awaiting confirmation of execution of command queue\n",
    "    cfm_queue = queue.Queue() #confirmed execution of command queue\n",
    "    \n",
    "    # flicker power LED on startup, checking for root access\n",
    "    flicker = PwrLedFlicker(duration=2)\n",
    "    flicker.start()\n",
    "    time.sleep(0.1)\n",
    "    \n",
    "    # setup pigpio, checking that it's running\n",
    "    pi = pigpio.pi()\n",
    "    if not pi.connected:\n",
    "        log_txn(fname,\"pigpiod not running.\")\n",
    "        exit()\n",
    "\n",
    "    # handle command-line arguments\n",
    "    parser = argparse.ArgumentParser(description='ppdd argument parser')\n",
    "    parser.add_argument(\"-a\", default='0x13', type=str, help=\"Default I2C address: 0x13\")\n",
    "    parser.add_argument(\"-b\", action=\"store_true\", help=\"Set bosmang status to True\")\n",
    "    \n",
    "    args, unknown = parser.parse_known_args()\n",
    "    \n",
    "    if unknown:\n",
    "        log_txn(fname,\"unrecognized command line arguments: \",unknown)\n",
    "    \n",
    "    # didn't comment before. what does this do if no args.a?\n",
    "    i2c_addr = int(args.a,0)\n",
    "    \n",
    "    if args.b:\n",
    "        bosmang = bytearray(int(1).to_bytes(1, byteorder))\n",
    "    else:\n",
    "        bosmang = bytearray(int(0).to_bytes(1, byteorder))\n",
    "        \n",
    "    # setup socket server for incoming commands from ppcc\n",
    "    try:\n",
    "        ppdd_server = socketserver.ThreadingTCPServer(tcp_address, PPCcHandler)\n",
    "        log_txn(fname,\"Listening for ppcc commands on TCP port \", tcp_address[1])\n",
    "    except OSError:\n",
    "        log_txn(fname,\"TCP Error. Socket in use?\")\n",
    "        exit()\n",
    "    \n",
    "    threading.Thread(target=ppdd_server.serve_forever).start()\n",
    "        \n",
    "    log_txn(fname,\"Initializing I2C peripheral on address: \", hex(i2c_addr))\n",
    "    log_txn(fname,\"--> hostname: \", hostname.decode())\n",
    "    log_txn(fname,\"--> bosmang:  \", str(bool(int.from_bytes(bosmang, byteorder=byteorder))))\n",
    "\n",
    "    # setup event handler for incoming I2C messages from PPController\n",
    "    e = pi.event_callback(pigpio.EVENT_BSC, i2c_event_handler)\n",
    "    pi.bsc_i2c(i2c_addr)\n",
    "\n",
    "    while True:\n",
    "        time.sleep(120)\n",
    "        # heartbeat\n",
    "        log_txn(fname,\"koradewu \",datetime.datetime.now().isoformat())\n",
    "        \n",
    "if __name__ == '__main__':\n",
    "    try:\n",
    "        main()\n",
    "    except KeyboardInterrupt as e:\n",
    "        # handled by atexit\n",
    "        #exit(str('Exiting.'))\n",
    "        pass"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "renewable-burlington",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "No traceback available to show.\n"
     ]
    }
   ],
   "source": [
    "%tb"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "dying-auditor",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/javascript": [
       "IPython.notebook.save_checkpoint();"
      ],
      "text/plain": [
       "<IPython.core.display.Javascript object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Converted 00_core.ipynb.\n",
      "Converted 50_ppdd.ipynb.\n",
      "Converted 60_ppcc.ipynb.\n",
      "Converted index.ipynb.\n"
     ]
    }
   ],
   "source": [
    "# hide\n",
    "try:\n",
    "    from IPython.display import display, Javascript\n",
    "    display(Javascript('IPython.notebook.save_checkpoint();'))\n",
    "    from time import sleep\n",
    "    sleep(0.3)\n",
    "    from nbdev.export import notebook2script\n",
    "    notebook2script()\n",
    "except ModuleNotFoundError:\n",
    "    pass\n",
    "    \"\"\"CircuitPython kernel has no nbdev\"\"\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "conceptual-birthday",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}