easycoder 250826.1__tar.gz → 250915.1__tar.gz

{easycoder-250826.1 → easycoder-250915.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: easycoder
-Version: 250826.1
+Version: 250915.1
 Summary: Rapid scripting in English
 Keywords: compiler,scripting,prototyping,programming,coding,python,low code,hypertalk,computer language,learn to code
 Author-email: Graham Trott <gtanyware@gmail.com>

easycoder-250915.1/RBRNow copy/README.md

@@ -0,0 +1,89 @@
+# RBR-Now #
+
+**RBR-Now** is a networked control system based on the ESP32 microcontroller, designed for ESP32-based devices such as a radiator TRV or a DHT22 thermometer, and uses ESP-Now to implement chained networking allowing any device to run its own subnetwork to overcome range and capacity issues.
+
+All the software in RBR-Now is MicroPython (uPython) and every device in the RBR-Now network is equipped with the same set of files. The behaviour of each device is determined by a small JSON configuration file.
+
+The system can be deployed simply by loading devices with the core file set and a suitable configuration file, but is best managed by the RBRConf program; a Python GUI application for Linux computers. (It cannot run on Windows because it relies on networking commands that are not available on that OS.) RBRConf allows any device on the network to be interrogated, controlled and have its firmware updated remotely without any need to remove it from service.
+
+An RBR-Now network comprises a hub (master) device and a number of slaves. A control system using RBR-Now connects solely to the hub device and controls the slaves through it. This documentation will first describe the slave functionality as this is the simpler device..
+
+## The RBR-Now Slave device
+
+An ESP-Now slave unit only receives; it doesn't initiate messages as it has no information about where to send any. To send a message to one we have to know its MAC address. This can be found by setting up the device as a wifi hotspot and arrange for the SSID to include the MAC address. To make things simpler, the RBR-Now system automates this process as follows.
+
+When the device starts it looks for its configuration file, but this will not initially exist. So it drops into slave mode and creates a hotspot whose SSID is based on its MAC address but with a specific RBR prefix. When the configuration program is told to scan for slave devices it looks for this prefix and offers a list of all devices that match. The user selects one (there usually is only one, as I'll explain shortly) and the program notes the relevant MAC address. The new device is added to the list in the Slaves panel as an untitled device. When the user clicks that item, all relevant details for the device can be added in a panel on the UI screen. These details comprise the name by which the device will be known (usually the room name) and pin numbers for the onboard LED, the relay and the thermometer (if either of these are present). With this information, a JSON structure is created and sent to the device as its config file, so that next time it starts up it can configure itself appropriately.
+
+The hotspot is basically open (otherwise the device couldn't be connected) so this is an obvious vulnerability. To overcome this, the hotspot is disabled after 2 minutes. (It cannot be removed entirely because this would prevent ESP-Now from working, so it's given an SSID comprising a single dash and a randomly generated numeric password, making it virtually impossible to get into and rendering the MAC address inaccessible.) So by the time a second device is to be configured, existing ones are unlikely to appear in a search.
+
+Apart from initial configuration, all comms with a slave is done using ESP-Now, which only requires the MAC address to be known. The device indicates which mode it's in by flashing its onboard LED on-off with a 1-second cycle for the initial 2 minutes, then a brief flash every 5 seconds after that.
+
+The slave code waits for messages to arrive and acts on them. Messages will only arrive from the system controller, although in some cases they may be relayed via another slave device. Each message is acknowledged and any requested data is passed back. This includes such things as the relay state, the up time (seconds from startup) and thermometer readings.
+
+The device also runs concurrent code that monitors BLE transmissions, looking for the signature of a Mijia thermometer. Every time one is seen, its advertising packet is read and the relevant data extracted. This will be returned as part of the response to the next message from the controller. Queuing is not implemented, so if several Mijias are detected at the same time, only one of them will be captured on this occasion.
+
+Among the commands that can be sent are some that permit any file on the device to be updated. (This does not include MicroPython itself.) The configurator has the ability to update one or all the files on a device.
+
+## The RBR-Now Master device
+
+The Master (or Hub) device is the gateway between the system controller and the network of RBR-Now devices. It can itself be one of those devices, or it can be a separate module placed centrally where it can easily be seen by all the others, which are all Slave devices as described above. The Master has no knowledge of the other devices, nor of the system controller; it just responds to requests. Most of the functionality of the Slave is also shared by the Master.
+
+The Master must be the first device set up by the configurator, which treats it specially. As with the slaves, the device initially has no configuration file, so as above it publishes a hotspot and waits for a connection. The configurator creates a JSON configuration file similar to that for a slave but additionally containing the SSID and password of the home network router and identifying the device as the master, then sends the file to the device and asks it to reset itself. When it restarts, the device will connect to the router and will get an IP address. The configurator waits for 10 seconds to allow this to complete, then sends another message to the hotspot requesting the IP address. From then on, all communication is done through this IP address. As with the slave, after 2 minutes the hotspot is disabled and the LED cycle changes, this time to a double flash every 5 seconds.
+
+## System messaging
+
+All messages from the system controller to an RBR-Now device are sent to the Master/Hub device at its IP address on the home network. Messages are prefixed by the MAC address of the target device, as recorded by the configurator when the device was added to the system.
+
+When the Master device receives a message it checks to see who the message is addressed to. If it's the master device itself the message is handled and a reply sent. If it's any other address the message is forwarded to that device via the ESP-Now network,and the reply from that device is returned to the system controller.
+
+In some cases a device is too far away from the hub to receive messages reliably. In such cases the device can piggy-back off another, closer device. Here, the MAC address given has a special prefix and identifies the path to the target device, going via as many intermediates as necessary. The path is part of the configuration for a device; in most cases it is empty.
+
+The messages understood by devices are as follows:
+
+### on
+
+Turns on the device relay. It returns 'OK' then the up time of the device (in seconds) and the most recent Mijia reading it has received (if any).
+
+### off
+
+Turns off the device relay. The reply is the same as for **on**.
+
+### relay
+
+Returns the current state of the relay.
+
+### temp
+
+Returns the current temperature, if the device is a thermometer.
+
+### reset
+
+Causes the device to reset itself.
+
+### ipaddr
+
+Returns the IP address of the device (master only).
+
+### pause
+
+Requests the device to pause all operations that may interfere with actions such as updating files.
+
+### resume
+
+Requests the device to resume operations as normal.
+
+### part
+
+Signals that the attached data (up to 100 characters) is part of a file to be saved by the device. The file content is sent in hex format, 100 bytes at a time, each with a part number starting with zero, and the device saves each part as it arrives. Part numbers must be in the correct sequence or an error occurs.
+
+### save
+
+Saves the accumulated parts into the file whose name is given. The device saves the file then reads it back to check it matches what was received by the **part** requests.
+
+### delete
+
+Deletes the file whose full path is given.
+
+## mkdir
+
+Creates a directory with the name given.

easycoder-250915.1/RBRNow copy/ap.py

@@ -0,0 +1,24 @@
+import network,binascii,asyncio,random
+
+class AP():
+    
+    def __init__(self,config):
+        self.config=config
+        config.setAP(self)
+        ap=network.WLAN(network.AP_IF)
+        ap.active(True)
+        self.ap=ap
+        mac=binascii.hexlify(self.ap.config('mac')).decode()
+        self.config.setMAC(mac)
+        self.ssid=f'RBR-Now-{mac}'
+        ap.config(essid=self.ssid,password='00000000')
+        ap.config(channel=config.getChannel())
+        ap.ifconfig(('192.168.9.1','255.255.255.0','192.168.9.1','8.8.8.8'))
+        print(mac,config.getName()) 
+
+    def stop(self):
+        password=str(random.randrange(100000,999999))
+        print(password)
+        self.ap.config(essid='-',password=password)
+
+    def getChannel(self): return self.ap.config('channel')

easycoder-250915.1/RBRNow copy/blescan.py

@@ -0,0 +1,31 @@
+import asyncio
+import aioble
+from binascii import hexlify
+
+class BLEScan():
+    
+    def __init__(self):
+        self.values=''
+
+    async def scan(self):
+        print("Scanning for BLE devices...")
+        while True:
+            async with aioble.scan(duration_ms=20000) as scanner:
+                async for result in scanner:
+                    addr = result.device.addr_hex()
+                    if addr.find('a4:c1:38:') == 0:
+                        rssi = result.rssi
+                        data = hexlify(result.adv_data).decode()
+                        if len(data) > 28:
+                            temp = int(data[20:24], 16)
+                            hum = int(data[24:26], 16)
+                            batt = int(data[26:28], 16)
+                            print(f'{addr[9:]} {rssi} {temp} {hum} {batt}')
+                            self.values = f'{addr[9:]};{rssi};{temp};{hum};{batt}'
+#                    else: print(f'{addr} - no')
+            await asyncio.sleep(0.1)
+
+    def getValues(self):
+        values=self.values
+        self.values=''
+        return values

easycoder-250915.1/RBRNow copy/boot.py

@@ -0,0 +1,5 @@
+# This file is executed on every boot (including wake-boot from deepsleep)
+#import esp
+#esp.osdebug(None)
+#import webrepl
+#webrepl.start()

easycoder-250915.1/RBRNow copy/config.py

@@ -0,0 +1,117 @@
+import json,asyncio,time
+from files import readFile,writeFile,fileExists
+from pin import PIN
+from server import Server
+from dht22 import DHT22
+from blescan import BLEScan
+
+class Config():
+
+    def __init__(self):
+        if fileExists('config.json'):
+            self.config=json.loads(readFile('config.json'))
+        else:
+            self.config={}
+            self.config['name']='(none)'
+            self.config['master']=False
+            self.config['channel']=1
+            self.config['path']=''
+            self.config['pins']={}
+            pin={}
+            pin['pin']=''
+            pin['invert']=False
+            self.config['pins']['led']=pin
+            pin={}
+            pin['pin']=''
+            pin['invert']=False
+            self.config['pins']['relay']=pin
+            pin={}
+            pin['pin']=''
+            self.config['pins']['dht22']=pin
+            writeFile('config.json',json.dumps(self.config))
+        pin,invert=self.getPinInfo('led')
+        self.led=PIN(self,pin,invert)
+        pin,invert=self.getPinInfo('relay')
+        self.relay=PIN(self,pin,invert)
+        pin,_=self.getPinInfo('dht22')
+        if pin=='': self.dht22=None
+        else:
+            self.dht22=DHT22(pin)
+            asyncio.create_task(self.dht22.measure())
+        print('path:',self.config['path'])
+        self.ipaddr=None
+        self.uptime=0
+        self.resetRequested=False
+        self.server=Server(self)
+        asyncio.create_task(self.runWatchdog())
+        self.bleScan=BLEScan()
+
+    async def respond(self,response,writer):
+        await self.server.respond(response,writer)
+    async def sendDefaultResponse(self,writer):
+        await self.server.sendDefaultResponse(writer)
+    async def handleClient(self,reader,writer):
+        await self.server.handleClient(reader,writer)
+
+    async def send(self,peer,espmsg): return await self.espComms.send(peer,espmsg)
+
+    def reset(self):
+        print('Reset requested')
+        self.resetRequested=True
+    
+    def pause(self):
+        if self.dht22!=None: self.dht22.pause()
+    
+    def resume(self):
+        if self.dht22!=None: self.dht22.resume()
+
+    def setAP(self,ap): self.ap=ap
+    def setSTA(self,sta): self.sta=sta
+    def setMAC(self,mac): self.mac=mac
+    def setChannel(self,channel):
+        self.config['channel']=channel
+        writeFile('config.json',json.dumps(self.config))
+    def setIPAddr(self,ipaddr): self.ipaddr=ipaddr
+    def setHandler(self,handler): self.handler=handler
+    def setESPComms(self,espComms): self.espComms=espComms
+    def addUptime(self,t): self.uptime+=t
+    
+    def isMaster(self): return self.config['master']
+    def isESP8266(self): return False
+    def getDevice(self): return self.config['device']
+    def getName(self): return self.config['name']
+    def getSSID(self): return self.config['hostssid']
+    def getPassword(self): return self.config['hostpass']
+    def getMAC(self): return self.mac
+    def getAP(self): return self.ap
+    def getSTA(self): return self.sta
+    def stopAP(self): self.ap.stop()
+    def startServer(self): self.server.startup()
+    def getIPAddr(self): return self.ipaddr
+    def getChannel(self): return self.ap.getChannel()
+    def getHandler(self): return self.handler
+    def getESPComms(self): return self.espComms
+    def getBLEScan(self): return self.bleScan
+    def getRBRNow(self): return self.rbrNow
+    def getPinInfo(self,name):
+        pin=self.config['pins'][name]
+        print(name,pin)
+        if 'invert' in pin: invert=pin['invert']
+        else: invert=False
+        return pin['pin'],invert
+    def getLED(self): return self.led
+    def getRelay(self): return self.relay
+    def getUptime(self): return int(round(self.uptime))
+    def getTemperature(self): return self.dht22.getTemperature()
+
+    async def runWatchdog(self):
+        while True:
+            self.active=False
+            await asyncio.sleep(180)
+            if not self.active:
+                print('No activity - reset')
+                asyncio.get_event_loop().stop()
+        pass
+
+    def kickWatchdog(self):
+        self.active=True

easycoder-250915.1/RBRNow copy/dht22.py

@@ -0,0 +1,45 @@
+import asyncio,dht
+from machine import Pin,reset
+
+class DHT22():
+
+    def __init__(self,sensorpin,verbose=False):
+        if verbose:
+            print('Initialise sensor on pin',sensorpin)
+        if sensorpin is '': self.sensor=None
+        else: self.sensor=dht.DHT22(Pin(int(sensorpin)))
+        self.verbose=verbose
+        self.temp=0
+        self.errors=0
+        self.paused=False
+
+    async def measure(self):
+        if self.sensor==None: return
+        msg=None
+        print('Run the temperature sensor')
+        while True:
+            if not self.paused:
+                try:
+                    self.sensor.measure()
+                    temperature=self.sensor.temperature()
+                    if temperature>50: temperature=0
+                    self.temp=round(temperature*10)
+                    if self.verbose:
+                        print('Temperature:',temperature)
+                    self.errors=0
+                except OSError as e:
+                    if self.verbose:
+                        msg=f'Failed to read sensor: {str(e)}'
+                        print(msg)
+                    self.errors+=1
+                    if self.errors>50: reset()
+            await asyncio.sleep(5)
+    
+    def pause(self):
+        self.paused=True
+    
+    def resume(self):
+        self.paused=False
+
+    def getTemperature(self):
+        return self.temp

easycoder-250915.1/RBRNow copy/espcomms.py

@@ -0,0 +1,76 @@
+import asyncio
+from binascii import hexlify,unhexlify
+from espnow import ESPNow as E
+
+class ESPComms():
+    
+    def __init__(self,config):
+        self.config=config
+        config.setESPComms(self)
+        E().active(True)
+        self.peers=[]
+        print('ESP-Now initialised')
+    
+    def checkPeer(self,peer):
+        if not peer in self.peers:
+            self.peers.append(peer)
+            E().add_peer(peer)
+
+    async def send(self,mac,espmsg):
+        peer=unhexlify(mac.encode())
+        # Flush any incoming messages
+        while E().any(): _,_ = E().irecv()
+        self.checkPeer(peer)
+        try:
+#            print(f'Send {espmsg[0:20]}... to {mac}')
+            result=E().send(peer,espmsg)
+#            print(f'Result: {result}')
+            if result:
+                counter=50
+                while counter>0:
+                    if E().any():
+                        mac,response = E().irecv()
+                        if response:
+#                            print(f"Received response: {response.decode()}")
+                            result=response.decode()
+                            break
+                    await asyncio.sleep(.1)
+                    counter-=1
+                if counter==0:
+                    result='Response timeout'
+            else: result='Fail (no result)'
+        except Exception as e:
+            print(e)
+            result=f'Fail ({e})'
+        return result
+
+    async def receive(self):
+        print('Starting ESPNow receiver on channel',self.config.getChannel())
+        self.waiting=False
+        while True:
+            if E().any():
+                mac,msg=E().recv()
+                sender=hexlify(mac).decode()
+                msg=msg.decode()
+#                print(f'Message from {sender}: {msg[0:30]}...')
+                if msg[0]=='!':
+                    # It's a message to be relayed
+                    comma=msg.index(',')
+                    slave=msg[1:comma]
+                    msg=msg[comma+1:]
+#                    print(f'Slave: {slave}, msg: {msg}')
+                    response=await self.send(slave,msg)
+                else:
+                    # It's a message for me
+                    response=self.config.getHandler().handleMessage(msg)
+                    response=f'{response} {self.getRSS(sender)}'
+                print(f'Response to {sender}: {response}')
+                self.checkPeer(mac)
+                E().send(mac,response)
+            await asyncio.sleep(.1)
+            self.config.kickWatchdog()
+
+    def getRSS(self,mac):
+        peer=unhexlify(mac.encode())
+        try: return E().peers_table[peer][0]
+        except: return 0

easycoder-250915.1/RBRNow copy/files.py

@@ -0,0 +1,46 @@
+import os
+
+def fileExists(filename):
+    try:
+        os.stat(filename)
+        return True
+    except OSError:
+        return False
+
+def readFile(name):
+    try:
+        f=open(name,'r')
+        value=f.read()
+        f.close()
+    except:
+        value=None
+    return value
+
+def writeFile(name,text):
+    f=open(name,'w')
+    f.write(text)
+    f.close()
+
+def appendFile(name,text):
+    f=open(name,'a')
+    f.write(text)
+    f.close()
+
+def createDirectory(path):
+    try:
+        os.mkdir(path)
+    except OSError as e:
+        if e.args[0] != 17: return False
+    return True
+
+def clearFile(name):
+    open(name,'w').close()
+
+def deleteFile(file):
+    try:
+        os.remove(file)
+        return True
+    except: return False
+
+def renameFile(oldName,newName):
+    os.rename(oldName,newName)

easycoder-250915.1/RBRNow copy/files.txt

@@ -0,0 +1,13 @@
+ap.py
+blescan.py
+boot.py
+config.py
+dht22.py
+espcomms.py
+files.py
+handler.py
+main.py
+pin.py
+server.py
+sta.py
+

easycoder-250915.1/RBRNow copy/files2.txt

@@ -0,0 +1,23 @@
+lib/
+lib/aioble/
+lib/aioble/central.py
+lib/aioble/client.py
+lib/aioble/core.py
+lib/aioble/device.py
+lib/aioble/__init__.py
+lib/aioble/l2cap.py
+lib/aioble/peripheral.py
+lib/aioble/security.py
+lib/aioble/server.py
+ap.py
+blescan.py
+boot.py
+config.py
+dht22.py
+espcomms.py
+files.py
+handler.py
+main.py
+pin.py
+server.py
+sta.py

easycoder-250915.1/RBRNow copy/handler.py

@@ -0,0 +1,124 @@
+import asyncio,machine
+from binascii import unhexlify
+from files import readFile,writeFile,renameFile,deleteFile,createDirectory
+
+class Handler():
+    
+    def __init__(self,config):
+        self.config=config
+        config.setHandler(self)
+        self.relay=config.getRelay()
+
+    def checkFile(self, buf, file):
+        try:
+            with open(file, 'r') as f:
+                i = 0  # index in lst
+                pos = 0  # position in current list item
+                while True:
+                    c = f.read(1)
+                    if not c:
+                        # End of file: check if we've also finished the list
+                        while i < len(buf) and pos == len(buf[i]):
+                            i += 1
+                            pos = 0
+                        return i == len(buf)
+                    if i >= len(buf) or pos >= len(buf[i]) or c != buf[i][pos]:
+                        return False
+                    pos += 1
+                    if pos == len(buf[i]):
+                        i += 1
+                        pos = 0
+        except OSError:
+            return False
+
+    def handleMessage(self,msg):
+#        print('Message:',msg)
+        response=f'OK {self.config.getUptime()} :{self.config.getBLEScan().getValues()}'
+        if msg == 'uptime':
+            pass
+        elif msg == 'on':
+            response=f'{response} ON' if self.relay.on() else 'No relay'
+        elif msg == 'off':
+            response=f'{response} OFF' if self.relay.off() else 'No relay'
+        elif msg == 'relay':
+            try:
+                response=f'OK {self.relay.getState()}'
+            except:
+                response='No relay'
+        elif msg=='reset':
+            self.config.reset()
+            response='OK'
+        elif msg == 'ipaddr':
+            response=f'OK {self.config.getIPAddr()}'
+        elif msg=='channel':
+            response=f'OK {self.config.getChannel()}'
+        elif msg[0:8]=='channel=':
+            channel=msg[8:]
+            self.config.setChannel(channel)
+            response=f'OK {channel}'
+        elif msg=='temp':
+            response=f'OK {self.config.getTemperature()}'
+        elif msg=='pause':
+            self.config.pause()
+            response=f'OK paused'
+        elif msg=='resume':
+            self.config.resume()
+            response=f'OK resumed'
+        elif msg[0:6]=='delete':
+            file=msg[7:]
+            response='OK' if deleteFile(file) else 'Fail'
+        elif msg[0:4]=='part':
+        # Format is part:{n},text:{text}
+            part=None
+            text=None
+            items=msg.split(',')
+            for item in items:
+                item=item.split(':')
+                label=item[0]
+                value=item[1]
+                if label=='part': part=int(value)
+                elif label=='text': text=value
+            if part!=None and text!=None:
+                text=text.encode('utf-8')
+                text=unhexlify(text)
+                text=text.decode('utf-8')
+                if part==0:
+                    self.buffer=[]
+                    self.pp=0
+                    self.saveError=False
+                else:
+                    if self.saveError:
+                        return 'Error'
+                    else:
+                        if part==self.pp+1:
+                            self.pp+=1
+                        else:
+                            self.saveError=True
+                            print('Sequence error')
+                            return 'Sequence error'
+                self.buffer.append(text)
+                response=f'{part} {str(len(text))}'
+        elif msg[0:4]=='save':
+            if len(self.buffer[0])>0:
+                file=msg[5:]
+                print(f'Save {file}')
+                size=0
+                f = open(file,'w')
+                for n in range(0, len(self.buffer)):
+                    f.write(self.buffer[n])
+                    size+= len(self.buffer[n])
+                f.close()
+                # Check the file against the buffer
+                if self.checkFile(self.buffer, file): response=str(size) 
+                else: response='Bad save'
+            else: response='No update'
+            text=None
+        elif msg[0:5]=='mkdir':
+            path=msg[6:]
+            print(f'mkdir {path}')
+            response='OK' if createDirectory(path) else 'Fail'
+        else: response=f'Unknown message: {msg}'
+#        print('Handler:',response)
+        return response
+
+

easycoder-250915.1/RBRNow copy/lib/aioble/__init__.py

@@ -0,0 +1,32 @@
+# MicroPython aioble module
+# MIT license; Copyright (c) 2021 Jim Mussared
+
+from micropython import const
+
+from .device import Device, DeviceDisconnectedError
+from .core import log_info, log_warn, log_error, GattError, config, stop
+
+try:
+    from .peripheral import advertise
+except:
+    log_info("Peripheral support disabled")
+
+try:
+    from .central import scan
+except:
+    log_info("Central support disabled")
+
+try:
+    from .server import (
+        Service,
+        Characteristic,
+        BufferedCharacteristic,
+        Descriptor,
+        register_services,
+    )
+except:
+    log_info("GATT server support disabled")
+
+
+ADDR_PUBLIC = const(0)
+ADDR_RANDOM = const(1)