From d2550c2e9a442013978beb942934956711863605 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Ebbe=20Ba=C3=9F?= Date: Tue, 27 Dec 2022 18:51:26 +0100 Subject: [PATCH] added pico lib's and moved old code in other file MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: Ebbe Baß --- code.py | 22 +++++ lib/neopixel.mpy | Bin 0 -> 1313 bytes lib/netman.py | 51 ++++++++++ lib/umqttsimple.py | 215 +++++++++++++++++++++++++++++++++++++++++ main.py => main-old.py | 0 requirements.txt | 7 -- 6 files changed, 288 insertions(+), 7 deletions(-) create mode 100644 code.py create mode 100644 lib/neopixel.mpy create mode 100644 lib/netman.py create mode 100644 lib/umqttsimple.py rename main.py => main-old.py (100%) delete mode 100644 requirements.txt diff --git a/code.py b/code.py new file mode 100644 index 0000000..0b375ad --- /dev/null +++ b/code.py @@ -0,0 +1,22 @@ +import netman +import time +from umqttsimple import MQTTClient +from machine import Pin +from datetime import datetime +from random import * + +country = 'DE' +ssid = 'EbbesOPNsense' +password = 'Umpigaming2019' + +wifi_connection = netman.connectWiFi(ssid,password,country) + +mqtt_server = 'homeassistant.ping-mee.local' +client_id = 'ServerRackLED' +user_t = 'mqtt' +password_t = 'picopassword' + +def mqtt_on_connect(client, userdata, flags, rc): + client.subscribe("server-rack-led/power") + client.subscribe("server-rack-led/mode") + client.subscribe("server-rack-led/rgb") \ No newline at end of file diff --git a/lib/neopixel.mpy b/lib/neopixel.mpy new file mode 100644 index 0000000000000000000000000000000000000000..08130aa3bd20a5692b3f7ed0bd3c6d3bb13e310a GIT binary patch literal 1313 zcmZ8hTW=dh6h33em!ysv@4B0`&c!r0CpdQE8W-A%HqJ&(N@?uWA+@S%vtEzmRUPkY zcihwniGhgHA|7}^0wItPRDu^Iy9Gjco$NlF!158V-LxgdmA;apT4hHS z%KDa0)tYW_6AvAgQg$qzk{J|1Lr6kJo^wVms}-xEQ^i@U)Tl^kISmZsRg>yQU9Dk% zp=pvCS0q52re5C~@<^!j6&XHVuvCqdRPBxvf+Br9gxEvwZtan6U9$|$s8h?R)rcjb ztNpMMg2}(-9#*`H;5P2dB+e$zNs^-6C6>+CQOJb zjgI6dmxUC<_&PCiohgNeMeHcqMkVc*Jb4Wv`%;xs(>|X}@?lgPrG#c|CyxLp7mkoG z>XybQkZaN^Z{Vn4g6HgBj?Sa$j}q*Bb#sS}yzeLc{m@4?0YWe!@lM?moW2oqUel2&G(7piK0-PE)*AAk`y5 zf6604B!o@NFo{K*DQ_A{u6oKR!K0L45)^8wb$eTDy+FY?C@wJH!x!hdajBKloEF^HLkaCB7X? ztGSh%OV{#g_v2^s4ae;s^K@Nl!7aHqzTyl~vkAiSa*YKd+W$sFSwL$kY zs6F^XTSVcgy`xjDs_ zJv{YO<~}M4{o(${ow8m|X2By0vThO0K@?bBFXYw>ZP7Q#8#?snH5UR8JakXbpA_fq zfg^xQZgpd6OzjH(Q7r9K}D|GRbwXu#g;e_?sepp+{apc7;bLmJLwPO zy+H_^V4p$DF|U2s6NG-mzT%aRgNDdGjX0-S>737zWAm6cse6jwo(@8!mwf}+ zbqn{zqnrsT)JmfaI>4^m2O1!FNEd=mhyy3U;lQWuG~$5%=>n2Nc*4!T-2?&d@YHTw qAqY1bjr0Kb|l#QGNn{dA82 literal 0 HcmV?d00001 diff --git a/lib/netman.py b/lib/netman.py new file mode 100644 index 0000000..5bbab90 --- /dev/null +++ b/lib/netman.py @@ -0,0 +1,51 @@ +# .';:cc;. +# .,',;lol::c. +# ;';lddddlclo +# lcloxxoddodxdool:,. +# cxdddxdodxdkOkkkkkkkd:. +# .ldxkkOOOOkkOO000Okkxkkkkx:. +# .lddxkkOkOOO0OOO0000Okxxxxkkkk: +# 'ooddkkkxxkO0000KK00Okxdoodxkkkko +# .ooodxkkxxxOO000kkkO0KOxolooxkkxxkl +# lolodxkkxxkOx,. .lkdolodkkxxxO. +# doloodxkkkOk .... .,cxO; +# ddoodddxkkkk: ,oxxxkOdc'..o' +# :kdddxxxxd, ,lolccldxxxkkOOOkkkko, +# lOkxkkk; :xkkkkkkkkOOO000OOkkOOk. +# ;00Ok' 'O000OO0000000000OOOO0Od. +# .l0l.;OOO000000OOOOOO000000x, +# .'OKKKK00000000000000kc. +# .:ox0KKKKKKK0kdc,. +# ... +# +# Author: peppe8o +# Date: Jul 24th, 2022 +# Version: 1.0 +# https://peppe8o.com + +import network, rp2 +import time + +def connectWiFi(ssid,password,country): + rp2.country(country) + wlan = network.WLAN(network.STA_IF) + wlan.config(pm = 0xa11140) + wlan.active(True) + wlan.connect(ssid, password) + # Wait for connect or fail + max_wait = 10 + while max_wait > 0: + if wlan.status() < 0 or wlan.status() >= 3: + break + max_wait -= 1 + print('waiting for connection...') + time.sleep(1) + + # Handle connection error + if wlan.status() != 3: + raise RuntimeError('network connection failed') + else: + print('connected') + status = wlan.ifconfig() + print( 'ip = ' + status[0] ) + return status diff --git a/lib/umqttsimple.py b/lib/umqttsimple.py new file mode 100644 index 0000000..d5d0f66 --- /dev/null +++ b/lib/umqttsimple.py @@ -0,0 +1,215 @@ +import usocket as socket +import ustruct as struct +from ubinascii import hexlify + + +class MQTTException(Exception): + pass + + +class MQTTClient: + def __init__( + self, + client_id, + server, + port=0, + user=None, + password=None, + keepalive=0, + ssl=False, + ssl_params={}, + ): + if port == 0: + port = 8883 if ssl else 1883 + self.client_id = client_id + self.sock = None + self.server = server + self.port = port + self.ssl = ssl + self.ssl_params = ssl_params + self.pid = 0 + self.cb = None + self.user = user + self.pswd = password + self.keepalive = keepalive + self.lw_topic = None + self.lw_msg = None + self.lw_qos = 0 + self.lw_retain = False + + def _send_str(self, s): + self.sock.write(struct.pack("!H", len(s))) + self.sock.write(s) + + def _recv_len(self): + n = 0 + sh = 0 + while 1: + b = self.sock.read(1)[0] + n |= (b & 0x7F) << sh + if not b & 0x80: + return n + sh += 7 + + def set_callback(self, f): + self.cb = f + + def set_last_will(self, topic, msg, retain=False, qos=0): + assert 0 <= qos <= 2 + assert topic + self.lw_topic = topic + self.lw_msg = msg + self.lw_qos = qos + self.lw_retain = retain + + def connect(self, clean_session=True): + self.sock = socket.socket() + addr = socket.getaddrinfo(self.server, self.port)[0][-1] + self.sock.connect(addr) + if self.ssl: + import ussl + + self.sock = ussl.wrap_socket(self.sock, **self.ssl_params) + premsg = bytearray(b"\x10\0\0\0\0\0") + msg = bytearray(b"\x04MQTT\x04\x02\0\0") + + sz = 10 + 2 + len(self.client_id) + msg[6] = clean_session << 1 + if self.user is not None: + sz += 2 + len(self.user) + 2 + len(self.pswd) + msg[6] |= 0xC0 + if self.keepalive: + assert self.keepalive < 65536 + msg[7] |= self.keepalive >> 8 + msg[8] |= self.keepalive & 0x00FF + if self.lw_topic: + sz += 2 + len(self.lw_topic) + 2 + len(self.lw_msg) + msg[6] |= 0x4 | (self.lw_qos & 0x1) << 3 | (self.lw_qos & 0x2) << 3 + msg[6] |= self.lw_retain << 5 + + i = 1 + while sz > 0x7F: + premsg[i] = (sz & 0x7F) | 0x80 + sz >>= 7 + i += 1 + premsg[i] = sz + + self.sock.write(premsg, i + 2) + self.sock.write(msg) + # print(hex(len(msg)), hexlify(msg, ":")) + self._send_str(self.client_id) + if self.lw_topic: + self._send_str(self.lw_topic) + self._send_str(self.lw_msg) + if self.user is not None: + self._send_str(self.user) + self._send_str(self.pswd) + resp = self.sock.read(4) + assert resp[0] == 0x20 and resp[1] == 0x02 + if resp[3] != 0: + raise MQTTException(resp[3]) + return resp[2] & 1 + + def disconnect(self): + self.sock.write(b"\xe0\0") + self.sock.close() + + def ping(self): + self.sock.write(b"\xc0\0") + + def publish(self, topic, msg, retain=False, qos=0): + pkt = bytearray(b"\x30\0\0\0") + pkt[0] |= qos << 1 | retain + sz = 2 + len(topic) + len(msg) + if qos > 0: + sz += 2 + assert sz < 2097152 + i = 1 + while sz > 0x7F: + pkt[i] = (sz & 0x7F) | 0x80 + sz >>= 7 + i += 1 + pkt[i] = sz + # print(hex(len(pkt)), hexlify(pkt, ":")) + self.sock.write(pkt, i + 1) + self._send_str(topic) + if qos > 0: + self.pid += 1 + pid = self.pid + struct.pack_into("!H", pkt, 0, pid) + self.sock.write(pkt, 2) + self.sock.write(msg) + if qos == 1: + while 1: + op = self.wait_msg() + if op == 0x40: + sz = self.sock.read(1) + assert sz == b"\x02" + rcv_pid = self.sock.read(2) + rcv_pid = rcv_pid[0] << 8 | rcv_pid[1] + if pid == rcv_pid: + return + elif qos == 2: + assert 0 + + def subscribe(self, topic, qos=0): + assert self.cb is not None, "Subscribe callback is not set" + pkt = bytearray(b"\x82\0\0\0") + self.pid += 1 + struct.pack_into("!BH", pkt, 1, 2 + 2 + len(topic) + 1, self.pid) + # print(hex(len(pkt)), hexlify(pkt, ":")) + self.sock.write(pkt) + self._send_str(topic) + self.sock.write(qos.to_bytes(1, "little")) + while 1: + op = self.wait_msg() + if op == 0x90: + resp = self.sock.read(4) + # print(resp) + assert resp[1] == pkt[2] and resp[2] == pkt[3] + if resp[3] == 0x80: + raise MQTTException(resp[3]) + return + + # Wait for a single incoming MQTT message and process it. + # Subscribed messages are delivered to a callback previously + # set by .set_callback() method. Other (internal) MQTT + # messages processed internally. + def wait_msg(self): + res = self.sock.read(1) + #self.sock.setblocking(True) + if res is None: + return None + if res == b"": + raise OSError(-1) + if res == b"\xd0": # PINGRESP + sz = self.sock.read(1)[0] + assert sz == 0 + return None + op = res[0] + if op & 0xF0 != 0x30: + return op + sz = self._recv_len() + topic_len = self.sock.read(2) + topic_len = (topic_len[0] << 8) | topic_len[1] + topic = self.sock.read(topic_len) + sz -= topic_len + 2 + if op & 6: + pid = self.sock.read(2) + pid = pid[0] << 8 | pid[1] + sz -= 2 + msg = self.sock.read(sz) + self.cb(topic, msg) + if op & 6 == 2: + pkt = bytearray(b"\x40\x02\0\0") + struct.pack_into("!H", pkt, 2, pid) + self.sock.write(pkt) + elif op & 6 == 4: + assert 0 + + # Checks whether a pending message from server is available. + # If not, returns immediately with None. Otherwise, does + # the same processing as wait_msg. + def check_msg(self): + self.sock.setblocking(False) + return self.wait_msg() \ No newline at end of file diff --git a/main.py b/main-old.py similarity index 100% rename from main.py rename to main-old.py diff --git a/requirements.txt b/requirements.txt deleted file mode 100644 index e50619e..0000000 --- a/requirements.txt +++ /dev/null @@ -1,7 +0,0 @@ -numpy==1.23.1 -paho_mqtt==1.6.1 -Pillow==9.2.0 -python-dotenv==0.20.0 -requests==2.28.1 -spotipy==2.20.0 -rpi_ws281x==4.3.4