diff --git a/SiliconTorch/DecoratorTest.py b/SiliconTorch/DecoratorTest.py
new file mode 100644
index 0000000000000000000000000000000000000000..e646809d752b2fd5c761d24f63cd444aa3c94324
--- /dev/null
+++ b/SiliconTorch/DecoratorTest.py
@@ -0,0 +1,41 @@
+
+
+class MyDec:
+
+ def __init__(*args, **kwargs):
+ print(f'__init__ed with: {args} aaand: {kwargs}')
+
+ def __call__(self, *args, **kwargs):
+ print(f'called with: {args} aaand: {kwargs}')
+
+ if callable(args[0]):
+ print('used as decorated with arguments')
+ return self.execute
+ else:
+ print('used as decorator WITHOUT arguments (a long time ago ;) )')
+ self.execute()
+
+ def execute(*args, **kwargs):
+ print(f'executed with: {args} aaand: {kwargs}')
+
+
+
+class C:
+
+ @MyDec
+ def decorated0(self, *args):
+ print(f'decorated0 called with: {args}')
+ return 'decorated0'
+
+print('\n' + '-'*120 + '\n')
+
+class D:
+
+ @MyDec(name='ctor-test')
+ def decorated42(self, *args):
+ print(f'decorated42 called with: {args}')
+ return 'decorated42'
+
+
+c = C()
+d = D()
diff --git a/SiliconTorch/Device.py b/SiliconTorch/Device.py
index 20c4c4441066bc93e35885dd15813bf41590cdc6..de441e3be2f7a356775c5ff025c7504cd871a8c7 100644
--- a/SiliconTorch/Device.py
+++ b/SiliconTorch/Device.py
@@ -1,20 +1,106 @@
+from MQTT import Topic
+from typing import Any, Callable
+
+
+
+# TODO: dev is stalled!
+# at first, we'll design easier things to not loose focus on the project
+# Just use simple properties and triggers to get the same (write-only) behavior
+#
+# TODO ^2: use functools.wraps to copy the annotations of decorated functions
+class MQTTProperty:
+
+ def __init__(self, name: str = None, initialValue: Any = None, getConvert: Callable[[str], Any] = None, setConvert: Callable[[Any], str] = None, readOnly = False):
+
+ self.__ro = readOnly
+ self.__value = initialValue
+
+ self.__mqtt = None
+
+ if getConvert is not None:
+ self.__name = getConvert.__name__
+ self.__getConvert = getConvert
+ else:
+ self.__getConvert = lambda x: x
+
+ if setConvert is not None:
+ self.__setConvert = setConvert
+ else:
+ self.__setConvert = lambda x: x
+
+ if name is not None:
+ self.__name = name
+
+
+ def __call__(self, getConvert: Callable[[str], Any]):
+ self.__getConvert = getConvert
+
+ if self.__name is not None:
+ self.__name = getConvert.__name__
+
+ def __get__(self, obj, cls):
+ if self.__value is not None:
+ return self.__value
+ else:
+ raise AttributeError('not in sync')
+
+ def __set__(self, obj, value):
+ if self.__ro: raise AttributeError(f'MQTTProperty[ {self.__name} ] is read-only')
+
+ # TODO: publish value!
+
+ def __del__(*ignored):
+ raise AttributeError('deletion not supported')
+
+
+
+from inspect import signature
+
+class MQTTTrigger:
+
+ # TODO: should we check message's type instead to decide if it is binary? evaluate!
+ def __init__(self, topic: str = None, message: str = None, binaryMessage: bytes = None):
+
+ if topic is not None:
+ self.__topic = Topic(topic)
+ else:
+ raise AttributeError('topic is mandatory') # TODO: correct exception…?
+
+ if binaryMessage is not None:
+ self.__message = binaryMessage
+ elif message is not None:
+ self.__message = bytes(message, 'UTF-8')
+ else:
+ self.__message = b''
+
+ # ###################
+ # ### TODO: !!! ###
+ # ###################
+ def __call__(self, func) -> Callable[[Any], Any]:
+ print(f'__call__ with {signature(func)}')
+ self.__function = func
+ return self
+
class Device:
- def __init__(self, torch, name, online = True):
+ def __init__(self, torch, name: str, online: bool = True):
self._torch = torch
- self._name = name
+ self.__name = name
self.__online = online
@property
def name(self):
- return self._name
+ return self.__name
@property
def online(self):
return self.__online
+ @MQTTTrigger(topic='{NameSpace}/{DeviceName}/command', message='restart')
+ def restart(self): pass
+
class Extension:
diff --git a/SiliconTorch/MQTT.py b/SiliconTorch/MQTT.py
new file mode 100644
index 0000000000000000000000000000000000000000..9089175196ad8947c2d29ce72c1655282b37363d
--- /dev/null
+++ b/SiliconTorch/MQTT.py
@@ -0,0 +1,466 @@
+
+from typing import Callable
+import yaml
+import json
+import random
+import logging
+import paho.mqtt.client as mqtt
+
+
+########################################
+#### ####
+#### Code from fxk8y/SpiderMQTT ####
+#### ####
+#### Will be replaced with import ####
+#### when SpiderMQTT matures! ####
+#### ####
+########################################
+
+# - Topic was taken as is
+# - Message was taken as is (and will be debugged here!)
+# - Executor was taken as is, but won't be used for threaded execution
+# - SpiderMQTT will lose its request-feature, other bugs will be fixed here
+
+class Topic(str):
+ """A str-type for interaction with MQTT topics.
+
+ Behaves like a normal str object except:
+ - can't have leading or trailing slashes
+ - can't contain double slashes
+ - addition is only defined for adding other Topic() objects"""
+
+ def __new__(cls, data=''):
+ data = str(data)
+
+ if len(data) < 1:
+ raise ValueError('Topic cannot be constructed from empty str')
+
+ while '//' in data:
+ data = data.replace('//', '/')
+
+ if data.startswith('/'):
+ data = data[1:]
+
+ if data.endswith('/'):
+ data = data[:-1]
+
+ return super().__new__(cls, data)
+
+ def __add__(self, other):
+ if isinstance(other, Topic):
+ return Topic(str(self) + '/' + str(other))
+ else:
+ return NotImplemented
+
+ def containsWildcard(self):
+ return self.count('+') > 0 or self.count('#') > 0
+
+ def compare(self, other):
+ """Compares two topics according to the MQTT specification
+
+ One argument may contain topic wildcards.
+ Can be called both as a class method or instance method.
+
+ Arguments:
+ self -- The Topic object itself when called as an instance method, or any Topic/str object in case of a class method call
+ other -- The other Topic or string to compare to"""
+
+ if (self.count('+') > 0 or self.count('#') > 0) and (other.count('+') > 0 or other.count('#') > 0):
+ raise ValueError('Only one topic may contain wildcards')
+
+ x_parts = self.split('/')
+ y_parts = other.split('/')
+
+ lx = len(x_parts)
+ ly = len(y_parts)
+
+ result = True
+
+ for i in range(min(lx, ly)):
+ x = x_parts[i]
+ y = y_parts[i]
+
+ if x == y:
+ continue
+ elif x == '+' or y == '+':
+ continue
+ elif x == '#' or y == '#':
+ return True
+ elif x != y:
+ return False
+ else:
+ if lx == ly:
+ return True
+ elif lx < ly and x_parts[-1] == '#':
+ return True
+ elif ly < lx and y_parts[-1] == '#':
+ return True
+ else:
+ return False
+
+
+class Message:
+ """Fancy MQTT message container
+
+ Implements various conversions to python-native types.
+ The conversion results are cached internally.
+ Every conversion method takes a parameter called default whose value is returned as-is.
+ Default values are not cached in case of conversion failure.
+ """
+
+ class DEFAULT:
+ """Marker object for caching failed conversions"""
+ pass
+
+ def __init__(self, topic: str, payload: bytearray):
+ self.cache = {}
+ self.topic = topic
+ self.payload = payload
+
+ def raw(self):
+ """Get the raw payload as bytearray"""
+
+ return self.payload
+
+ def bool(self, default=False):
+ """Coerce payload to bool
+
+ 'true', 'yes', 'ja', and '1' are treated as True.
+ 'false', 'no', 'nope', 'nein' and '0' are treated as False.
+ The conversion is case-insensitive."""
+
+ def convert():
+ payload = self.payload.lower()
+
+ if payload in ['true', 'yes', 'ja', '1']:
+ return True
+ elif payload in ['false', 'no', 'nope', 'nein', '0']:
+ return False
+ else:
+ return Message.DEFAULT
+
+ return self._getOrElseUpdate(bool, convert, default)
+
+ def int(self, default=0):
+ """Coerce payload to int"""
+
+ def convert():
+ try:
+ return int(self.payload)
+ except:
+ return Message.DEFAULT
+
+ return self._getOrElseUpdate(int, convert, default)
+
+ def float(self, default=0.0):
+ """Coerce payload to float"""
+
+ def convert():
+ try:
+ return float(self.payload)
+ except:
+ return Message.DEFAULT
+
+ return self._getOrElseUpdate(float, convert, default)
+
+ def complex(self, default=0j):
+ """Coerce payload to complex"""
+
+ def convert():
+ try:
+ return complex(self.payload)
+ except:
+ return Message.DEFAULT
+
+ return self._getOrElseUpdate(complex, convert, default)
+
+ def str(self, default=''):
+ """Decodes the payload as UTF-8"""
+
+ def convert():
+ try:
+ return self.payload.decode('utf-8')
+ except:
+ return Message.DEFAULT
+
+ return self._getOrElseUpdate(str, convert, default)
+
+ def json(self, default={}):
+ """Parses the payload as a JSON object"""
+
+ def convert():
+ try:
+ return json.loads(self.payload.decode('utf-8'))
+ except:
+ return Message.DEFAULT
+
+ return self._getOrElseUpdate("json", convert, default)
+
+ def yaml(self, default={}):
+ """Parses the payload as a YAML document"""
+
+ def convert():
+ try:
+ return yaml.safe_load(self.payload.decode('utf-8'))
+ except:
+ return Message.DEFAULT
+
+ return self._getOrElseUpdate("yaml", convert, default)
+
+ def _getOrElseUpdate(self, key, f, default):
+ if key in self.cache:
+ out = self.cache[key]
+
+ if out is Message.DEFAULT:
+ return default
+ else:
+ return out
+ else:
+ out = f()
+ self.cache[key] = out
+
+ if out is Message.DEFAULT:
+ return default
+ else:
+ return out
+
+ def __str__(self):
+ return 'Message[topic=\'{}\' payload=\'{}\']'.format(self.topic, self.str(default='<binary garbage>'))
+
+
+class Executor:
+
+ __instance = None
+
+ def __new__(cls, *args, **kwargs):
+ if cls.__instance is None:
+ cls.__instance = super(Executor, cls).__new__(cls)
+ return cls.__instance
+
+ def __init__(self, callback, *args, **kwargs):
+ if isinstance(callback, (list, set)):
+ cbs = callback
+ else:
+ cbs = [callback]
+
+ for cb in cbs:
+ try:
+ cb(*args, **kwargs)
+ except Exception as ex:
+ pass # TODO: logging!!!
+
+
+# TODO: Move into SpiderMQTT class!
+class Subscription:
+
+ class ACTIVE: pass
+ class PENDING: pass
+ class CLEANUP: pass
+
+ def __init__(self, spider, topic: str, callback=None, subscribeCallback=None):
+ self.spider = spider
+ self.topic = Topic(topic)
+ self.state = self.PENDING
+ self.callbacks = set()
+ self.subscribeCallbacks = set()
+
+ if callback is not None:
+ self.addCallback(callback)
+
+ if subscribeCallback is not None:
+ self.addSubscribeCallback(subscribeCallback)
+
+ self.__sub()
+
+ def __sub(self):
+ if self.state is self.PENDING and self.spider.isConnected():
+ self.sub_mid = self.spider.mqtt.subscribe(self.topic, self.spider.sub_qos)[1]
+
+ def __unsub(self):
+ pass # TODO: implement!
+
+ def onSubscribe(self, mid):
+ print('onSubscribe[mid={}]: self.mid={} matching={}'.format(mid, self.sub_mid, self.sub_mid == mid))
+ if hasattr(self, 'sub_mid') and self.sub_mid == mid:
+ self.state = self.ACTIVE
+ del self.sub_mid
+ Executor(self.subscribeCallbacks)
+
+ def onMessage(self, msg: Message):
+ if self.topic.compare(msg.topic):
+ Executor(self.callbacks, msg)
+
+ def onConnect(self):
+ self.__sub()
+
+ def onDisconnect(self):
+ self.state = self.PENDING
+
+ def addCallback(self, callback: Callable[[Message], None]):
+ self.callbacks.add(callback)
+
+ def removeCallback(self, callback: Callable[[Message], None]):
+ if callback in self.callbacks:
+ self.callbacks.remove(callback)
+ if self.callbacks == set():
+ self.state = self.CLEANUP
+ self.__unsub()
+
+ def addSubscribeCallbacks(self, callback: Callable[[Message], None]):
+ self.subscribeCallbacks.add(callback)
+ if self.state is self.ACTIVE:
+ Executor(callback)
+
+ def removeSubscribeCallbacks(self, callback: Callable[[Message], None]):
+ if callback in self.subscribeCallbacks:
+ self.subscribeCallbacks.remove(callback)
+
+
+class SpiderMQTT:
+
+ def __init__(self, broker: str = 'localhost', port: int = 1883, user: str = None, password: str = None, sub_qos: int = 0,
+ will_topic: str = None, will_payload = None, will_qos: int = 0, will_retain: bool = False, backgroundTask: bool = True) -> None:
+ """backgroundTask: True for run in Task, False for run blocking. TODO: write proper docstring!!!!"""
+
+ self.sub_qos = sub_qos
+ self.connected = False
+ # self.requests = set()
+ self.subscriptions = {}
+ self.pendingMessages = []
+
+ logging.basicConfig(format='[{asctime:s}][{levelname:s}] {name:s} in {funcName:s}(): {message:s}', datefmt='%H:%M:%S %d.%m.%Y', style='{', level=logging.DEBUG)
+
+ self.log = logging.getLogger(__name__)
+
+ client_id = 'SpiderMQTT[{:X}]'.format(random.randint(0x100000000000, 0xFFFFFFFFFFFF))
+ self.mqtt = mqtt.Client(client_id=client_id, clean_session=True)
+ self.mqtt.enable_logger(self.log)
+ self.mqtt.reconnect_delay_set(1, 1)
+
+ if user is not None:
+ self.mqtt.username_pw_set(user, password)
+
+ if will_topic is not None:
+ self.mqtt.will_set(will_topic, will_payload, will_qos, will_retain)
+
+ # self.mqtt.on_log = self.__onLog
+ self.mqtt.on_message = self.__onMessage
+ self.mqtt.on_publish = self.__onPublish
+ self.mqtt.on_connect = self.__onConnect
+ self.mqtt.on_subscribe = self.__onSubscribe
+ self.mqtt.on_disconnect = self.__onDisconnect
+ self.mqtt.on_unsubscribe = self.__onUnSubscribe
+
+ self.mqtt.connect(broker, port)
+
+ if backgroundTask:
+ def _shutdown():
+ self.mqtt.loop_stop()
+ self.__shutdownFunc = _shutdown
+
+ self.mqtt.loop_start()
+ else:
+ def _shutdown():
+ self.running = False
+ self.__shutdownFunc = _shutdown
+
+ self.running = True
+ while self.running:
+ self.mqtt.loop()
+
+ def isConnected(self) -> bool:
+ return self.connected
+
+ def publish(self, topic, payload=None, qos=0, retain=False, prettyPrintYAML=False) -> None:
+ if isinstance(payload, str):
+ pl = payload.encode('utf-8')
+ elif isinstance(payload, (bool, int, float, complex)):
+ pl = str(payload).encode('utf-8')
+ elif isinstance(payload, (list, set, dict)):
+ pl = yaml.dump(payload, default_flow_style=not prettyPrintYAML).encode('utf-8')
+ else:
+ pl = payload
+
+ if self.isConnected():
+ self.mqtt.publish(topic, pl, qos, retain)
+ else:
+ msg = Message(topic, pl)
+ msg.qos = qos
+ msg.retain = retain
+
+ self.pendingMessages += [msg]
+
+ def __onMessage(self, _cl, _ud, msg):
+ message = Message(msg.topic, msg.payload)
+
+ for sub in self.subscriptions.values():
+ sub.onMessage(message)
+
+ def __onConnect(self, *ignored):
+ self.connected = True
+
+ for sub in self.subscriptions.values():
+ sub.onConnect()
+
+ for msg in self.pendingMessages:
+ msg.mid = self.mqtt.publish(msg.topic, msg.payload, msg.qos, msg.retain).mid
+
+ def __onDisconnect(self, *ignored):
+ self.connected = False
+
+ for sub in self.subscriptions.values():
+ sub.onDisconnect()
+
+ def __onSubscribe(self, _cl, _ud, mid, _gq):
+ for sub in self.subscriptions.values():
+ sub.onSubscribe(mid)
+
+ def __onUnSubscribe(self, _cl, _ud, mid):
+ for sub in self.subscriptions.values():
+ sub.onUnSubscribe(mid)
+
+ def __onPublish(self, _cl, _ud, mid):
+ for msg in self.pendingMessages:
+ if hasattr(msg, 'mid') and msg.mid == mid:
+ self.pendingMessages.remove(msg)
+
+ def __onLog():
+ pass
+
+ def addCallback(self, topic, callback, subscribeCallback=None):
+ if topic in self.subscriptions:
+ self.subscriptions[topic].addCallback(callback)
+ self.subscriptions[topic].addSubscribeCallback(callback)
+ else:
+ self.subscriptions[topic] = Subscription(self, topic, callback, subscribeCallback)
+
+ def subscribe(self, topic, callback):
+ self.addCallback(topic, callback)
+
+ def removeCallback(self, callback, subscribeCallback=None):
+ for sub in self.subscriptions:
+ sub.removeCallback(callback)
+ sub.removeSubscribeCallback(subscribeCallback)
+
+ if sub.callbacks == {}:
+ self.mqtt.unsubscribe(sub.topic)
+ del self.subscriptions[sub.topic]
+
+ def shutdown(self):
+ self.mqtt.disconnect()
+ self.__shutdownFunc()
+
+
+mq = SpiderMQTT()
+
+def callback(name):
+ def _cb(msg):
+ print(f'callback[ {name} ] called on topic[ {msg.topic} ] with message[ {msg.str()} ]')
+ return _cb
+
+mq.addCallback('#', callback('#firehose#'))
+mq.addCallback('+/+/+', callback('~TRIPLE~TOPIC~'))
+
+mq.publish('1', 'EINS!')
+mq.publish('1/2', 'eins… zwei… BÄM!')
+mq.publish('1/2/3', 'uno, dos tres BUHH JA!')
diff --git a/SiliconTorch/PropTest.py b/SiliconTorch/PropTest.py
new file mode 100644
index 0000000000000000000000000000000000000000..afcf79c86d070b84cd3a6f8afcc94df48c787266
--- /dev/null
+++ b/SiliconTorch/PropTest.py
@@ -0,0 +1,52 @@
+
+from inspect import signature
+
+
+
+class MQTTTrigger:
+
+ def __init__(self, message: str = None, binaryMessage: bytes = None):
+
+ self.__function = None
+
+ if binaryMessage is not None:
+ self.__message = binaryMessage
+ elif message is not None:
+ self.__message = bytes(message, 'UTF-8')
+ else:
+ self.__message = b''
+
+ # ###################
+ # ### TODO: !!! ###
+ # ###################
+ def __call__(self, func=None):
+ print(f'__CALL__: self is of type {type(self)} and evaluates to str[ {self} ]')
+
+ if func is not None:
+
+ print(f'storing function[ {signature(func)} ]')
+ self.__function = func
+
+ return self.__execute
+ else:
+ print(f'__call__: executing business logic :)')
+ print(f'__call__: self is of type {type(self)} and evaluates to str[ {self} ]')
+ if self.__function is not None:
+ return self.__function(self) # TODO: is this the right self we supply?!
+
+ def __execute(self):
+ print(f'__execute: executing business logic :)')
+ print(f'__execute: self is of type {type(self)} and evaluates to str[ {self} ]')
+ if self.__function is not None:
+ return self.__function(self) # TODO: is this the right self we supply?!
+
+
+class TestDevice:
+
+ @MQTTTrigger(message='restart')
+ def restart(self): print(f'self[ {self} ] RESTART!!!')
+
+ OTA = MQTTTrigger(message='otää otää')
+
+
+dev = TestDevice()
diff --git a/SiliconTorch/fxCyan.py b/SiliconTorch/fxCyan.py
new file mode 100644
index 0000000000000000000000000000000000000000..dc9cd063252955080c490493d2fb89c52dff1459
--- /dev/null
+++ b/SiliconTorch/fxCyan.py
@@ -0,0 +1,149 @@
+
+from __future__ import annotations
+
+import struct
+from threading import Thread
+from inspect import signature
+from socket import socket, AF_INET, SOCK_DGRAM
+
+
+class fxCyanDefaults:
+ port = 4213
+
+ @staticmethod
+ def header(suffix: str): return bytes(f'fxCyan{suffix}', 'ASCII')
+
+ listenAddr = '0.0.0.0'
+
+
+class Sender:
+
+ _socket = socket(AF_INET, SOCK_DGRAM)
+
+ def __init__(self, host: str = 'localhost', port: int = fxCyanDefaults.port):
+ self._host = host
+ self._port = port
+
+ @staticmethod
+ def _convertData(data):
+ channels = []
+
+ for item in data:
+ f = float(item)
+
+ if f > 1.0: f = 1.0
+ if f < 0.0: f = 0.0
+
+ channels += [f]
+
+ return struct.pack('f' * len(channels), *channels)
+
+ @classmethod
+ def _sendUDP(cls, data: bytearray, host: str, port: int = fxCyanDefaults.port):
+ try:
+ cls._socket.sendto(data, (host, port))
+ except:
+ # TODO: logging…?
+ pass
+
+ @classmethod
+ def sendTo(cls, channels: list, host: str, port: int = fxCyanDefaults.port):
+ data = fxCyanDefaults.header('F')
+ data += Sender._convertData(channels)
+
+ cls._sendUDP(data, host, port)
+
+ def send(self, channels: list):
+ Sender.sendTo(channels, self._host, self._port)
+
+
+class Receiver:
+
+ def __init__(self, host: str = fxCyanDefaults.listenAddr, port: int = fxCyanDefaults.port):
+
+ self._socket = socket(AF_INET, SOCK_DGRAM)
+ self._socket.bind((host, port))
+
+ self._callbacks = {}
+
+ t = Thread(target=self._recvLoop)
+ t.daemon = True
+ t.start()
+
+ def addCallback(self, callback) -> Receiver:
+ """Register a new callback
+
+ The callback may take 2 parameters, but must take at least 1.
+ If it takes more than one it will get the sender's address too.
+
+ Signature should look like:
+ `def callback(channels, address): pass`
+ where channels takes a list of floats and adress will be the senders address.
+ The address parameter may be ommitted."""
+
+ params = len(signature(callback).parameters)
+
+ if params < 1:
+ raise AttributeError(f'callback must take at least param#[ 1 ], takes param#[ {params} ]')
+ else:
+ self._callbacks[callback] = params
+ return self
+
+ # TODO: write a decorator which copies se docstring from the other function
+ def __iadd__(self, callback) -> Receiver:
+ return self.addCallback(callback)
+
+ def removeCallback(self, callback) -> Receiver:
+ if callback in self._callbacks:
+ del self._callbacks[callback]
+ return self
+
+ # TODO: write a decorator which copies se docstring from the other function
+ def __isubb__(self, callback) -> Receiver:
+ return self.removeCallback(callback)
+
+ def _recvLoop(self):
+
+ header = fxCyanDefaults.header('F')
+ headerLen = len(header)
+
+ while True:
+ data, addr = self._socket.recvfrom(2048)
+
+ if data.startswith(header):
+ data = data[ headerLen : ]
+ else:
+ continue
+
+ if len(data) % 4 != 0:
+ # TODO: logging…?
+ continue
+
+ chCnt = int(len(data) / 4)
+ _chs = struct.unpack('f' * chCnt, data)
+
+ channels = []
+ for ch in _chs:
+ if ch > 1.0: ch = 1.0
+ if ch < 0.0: ch = 0.0
+ channels += [ch]
+
+ for callback, params in self._callbacks.items():
+ try:
+ if params == 1:
+ callback(channels)
+ elif params >= 2:
+ callback(channels, addr)
+ except:
+ # TODO: logging…?
+ pass
+
+
+
+tx = Sender()
+rx = Receiver()
+
+def _rcv(ch, addr, something=None):
+ print(f'Got ch#[ {len(ch)} ] from host[ {addr} ] with data[ {ch} ]')
+
+rx.addCallback(_rcv)
diff --git a/SiliconTorch/fxCyanF.py b/SiliconTorch/fxCyanF.py
deleted file mode 100644
index 8cd4f1a8809ef47a14ff038e780b953c7be81803..0000000000000000000000000000000000000000
--- a/SiliconTorch/fxCyanF.py
+++ /dev/null
@@ -1,99 +0,0 @@
-
-import struct
-from threading import Thread
-from socket import socket, AF_INET, SOCK_DGRAM
-
-
-class DEFAULT:
- port = 4213
- header = b'fxCyanF'
-
- listenAddr = '0.0.0.0'
-
-
-class Sender:
-
- _socket = socket(AF_INET, SOCK_DGRAM)
-
- def __init__(self, host: str, port: int = DEFAULT.port):
- self._host = host
- self._port = port
-
- @staticmethod
- def _convertData(data):
- channels = []
-
- for item in data:
- f = float(item)
-
- if f > 1.0: f = 1.0
- if f < 0.0: f = 0.0
-
- channels += [f]
-
- return struct.pack('f' * len(channels), *channels)
-
- @classmethod
- def _sendUDP(cls, data: bytearray, host: str, port: int = DEFAULT.port):
- try:
- cls._socket.sendto(data, (host, port))
- except:
- # TODO: logging…?
- pass
-
- @classmethod
- def sendTo(cls, channels: list, host: str, port: int = DEFAULT.port):
- data = DEFAULT.header
- data += Sender._convertData(channels)
-
- cls._sendUDP(data, host, port)
-
- def send(self, channels: list):
- Sender.sendTo(channels, self._host, self._port)
-
-
-class Receiver:
-
- def __init__(self, host: str = DEFAULT.listenAddr, port: int = DEFAULT.port):
-
- self._socket = socket(AF_INET, SOCK_DGRAM)
- self._socket.bind((host, port))
-
- self._callbacks = Set()
-
- t = Thread(target=self._recvLoop)
- t.daemon = True
- t.start()
-
- def _recvLoop(self):
-
- header = DEFAULT.header
- headerLen = len(header)
-
- while True:
- data = self._socket.recv(2048)
-
- if data.startswith(header):
- data = data[ headerLen : ]
- else:
- continue
-
- if len(data) % 4 != 0:
- # TODO: logging…?
- continue
-
- _chs = struct.unpack('f' * len(data), data)
-
- channels = []
- for ch in _chs:
- if ch > 1.0: ch = 1.0
- if ch < 0.0: ch = 0.0
- channels += [ch]
-
- for callback in self._callbacks:
- try:
- callback(channels)
- except:
- # TODO: logging…?
- pass
-
diff --git a/mosquitto.conf b/mosquitto.conf
new file mode 100644
index 0000000000000000000000000000000000000000..d3bfb1e37aed3df7d5d697b2431caba1dbb3b396
--- /dev/null
+++ b/mosquitto.conf
@@ -0,0 +1,901 @@
+# Config file for mosquitto
+#
+# See mosquitto.conf(5) for more information.
+#
+# Default values are shown, uncomment to change.
+#
+# Use the # character to indicate a comment, but only if it is the
+# very first character on the line.
+
+# =================================================================
+# General configuration
+# =================================================================
+
+# Use per listener security settings.
+#
+# It is recommended this option be set before any other options.
+#
+# If this option is set to true, then all authentication and access control
+# options are controlled on a per listener basis. The following options are
+# affected:
+#
+# acl_file
+# allow_anonymous
+# allow_zero_length_clientid
+# auto_id_prefix
+# password_file
+# plugin
+# plugin_opt_*
+# psk_file
+#
+# Note that if set to true, then a durable client (i.e. with clean session set
+# to false) that has disconnected will use the ACL settings defined for the
+# listener that it was most recently connected to.
+#
+# The default behaviour is for this to be set to false, which maintains the
+# setting behaviour from previous versions of mosquitto.
+#per_listener_settings false
+
+
+# This option controls whether a client is allowed to connect with a zero
+# length client id or not. This option only affects clients using MQTT v3.1.1
+# and later. If set to false, clients connecting with a zero length client id
+# are disconnected. If set to true, clients will be allocated a client id by
+# the broker. This means it is only useful for clients with clean session set
+# to true.
+#allow_zero_length_clientid true
+
+# If allow_zero_length_clientid is true, this option allows you to set a prefix
+# to automatically generated client ids to aid visibility in logs.
+# Defaults to 'auto-'
+#auto_id_prefix auto-
+
+# This option affects the scenario when a client subscribes to a topic that has
+# retained messages. It is possible that the client that published the retained
+# message to the topic had access at the time they published, but that access
+# has been subsequently removed. If check_retain_source is set to true, the
+# default, the source of a retained message will be checked for access rights
+# before it is republished. When set to false, no check will be made and the
+# retained message will always be published. This affects all listeners.
+#check_retain_source true
+
+# QoS 1 and 2 messages will be allowed inflight per client until this limit
+# is exceeded. Defaults to 0. (No maximum)
+# See also max_inflight_messages
+#max_inflight_bytes 0
+
+# The maximum number of QoS 1 and 2 messages currently inflight per
+# client.
+# This includes messages that are partway through handshakes and
+# those that are being retried. Defaults to 20. Set to 0 for no
+# maximum. Setting to 1 will guarantee in-order delivery of QoS 1
+# and 2 messages.
+#max_inflight_messages 20
+
+# For MQTT v5 clients, it is possible to have the server send a "server
+# keepalive" value that will override the keepalive value set by the client.
+# This is intended to be used as a mechanism to say that the server will
+# disconnect the client earlier than it anticipated, and that the client should
+# use the new keepalive value. The max_keepalive option allows you to specify
+# that clients may only connect with keepalive less than or equal to this
+# value, otherwise they will be sent a server keepalive telling them to use
+# max_keepalive. This only applies to MQTT v5 clients. The default, and maximum
+# value allowable, is 65535.
+#
+# Set to 0 to allow clients to set keepalive = 0, which means no keepalive
+# checks are made and the client will never be disconnected by the broker if no
+# messages are received. You should be very sure this is the behaviour that you
+# want.
+#
+# For MQTT v3.1.1 and v3.1 clients, there is no mechanism to tell the client
+# what keepalive value they should use. If an MQTT v3.1.1 or v3.1 client
+# specifies a keepalive time greater than max_keepalive they will be sent a
+# CONNACK message with the "identifier rejected" reason code, and disconnected.
+#
+#max_keepalive 65535
+
+# For MQTT v5 clients, it is possible to have the server send a "maximum packet
+# size" value that will instruct the client it will not accept MQTT packets
+# with size greater than max_packet_size bytes. This applies to the full MQTT
+# packet, not just the payload. Setting this option to a positive value will
+# set the maximum packet size to that number of bytes. If a client sends a
+# packet which is larger than this value, it will be disconnected. This applies
+# to all clients regardless of the protocol version they are using, but v3.1.1
+# and earlier clients will of course not have received the maximum packet size
+# information. Defaults to no limit. Setting below 20 bytes is forbidden
+# because it is likely to interfere with ordinary client operation, even with
+# very small payloads.
+#max_packet_size 0
+
+# QoS 1 and 2 messages above those currently in-flight will be queued per
+# client until this limit is exceeded. Defaults to 0. (No maximum)
+# See also max_queued_messages.
+# If both max_queued_messages and max_queued_bytes are specified, packets will
+# be queued until the first limit is reached.
+#max_queued_bytes 0
+
+# Set the maximum QoS supported. Clients publishing at a QoS higher than
+# specified here will be disconnected.
+#max_qos 2
+
+# The maximum number of QoS 1 and 2 messages to hold in a queue per client
+# above those that are currently in-flight. Defaults to 1000. Set
+# to 0 for no maximum (not recommended).
+# See also queue_qos0_messages.
+# See also max_queued_bytes.
+#max_queued_messages 1000
+#
+# This option sets the maximum number of heap memory bytes that the broker will
+# allocate, and hence sets a hard limit on memory use by the broker. Memory
+# requests that exceed this value will be denied. The effect will vary
+# depending on what has been denied. If an incoming message is being processed,
+# then the message will be dropped and the publishing client will be
+# disconnected. If an outgoing message is being sent, then the individual
+# message will be dropped and the receiving client will be disconnected.
+# Defaults to no limit.
+#memory_limit 0
+
+# This option sets the maximum publish payload size that the broker will allow.
+# Received messages that exceed this size will not be accepted by the broker.
+# The default value is 0, which means that all valid MQTT messages are
+# accepted. MQTT imposes a maximum payload size of 268435455 bytes.
+#message_size_limit 0
+
+# This option allows persistent clients (those with clean session set to false)
+# to be removed if they do not reconnect within a certain time frame.
+#
+# This is a non-standard option in MQTT V3.1 but allowed in MQTT v3.1.1.
+#
+# Badly designed clients may set clean session to false whilst using a randomly
+# generated client id. This leads to persistent clients that will never
+# reconnect. This option allows these clients to be removed.
+#
+# The expiration period should be an integer followed by one of h d w m y for
+# hour, day, week, month and year respectively. For example
+#
+# persistent_client_expiration 2m
+# persistent_client_expiration 14d
+# persistent_client_expiration 1y
+#
+# The default if not set is to never expire persistent clients.
+#persistent_client_expiration
+
+# Write process id to a file. Default is a blank string which means
+# a pid file shouldn't be written.
+# This should be set to /var/run/mosquitto/mosquitto.pid if mosquitto is
+# being run automatically on boot with an init script and
+# start-stop-daemon or similar.
+#pid_file
+
+# Set to true to queue messages with QoS 0 when a persistent client is
+# disconnected. These messages are included in the limit imposed by
+# max_queued_messages and max_queued_bytes
+# Defaults to false.
+# This is a non-standard option for the MQTT v3.1 spec but is allowed in
+# v3.1.1.
+#queue_qos0_messages false
+
+# Set to false to disable retained message support. If a client publishes a
+# message with the retain bit set, it will be disconnected if this is set to
+# false.
+#retain_available true
+
+# Disable Nagle's algorithm on client sockets. This has the effect of reducing
+# latency of individual messages at the potential cost of increasing the number
+# of packets being sent.
+#set_tcp_nodelay false
+
+# Time in seconds between updates of the $SYS tree.
+# Set to 0 to disable the publishing of the $SYS tree.
+#sys_interval 10
+
+# The MQTT specification requires that the QoS of a message delivered to a
+# subscriber is never upgraded to match the QoS of the subscription. Enabling
+# this option changes this behaviour. If upgrade_outgoing_qos is set true,
+# messages sent to a subscriber will always match the QoS of its subscription.
+# This is a non-standard option explicitly disallowed by the spec.
+#upgrade_outgoing_qos false
+
+# When run as root, drop privileges to this user and its primary
+# group.
+# Set to root to stay as root, but this is not recommended.
+# If set to "mosquitto", or left unset, and the "mosquitto" user does not exist
+# then it will drop privileges to the "nobody" user instead.
+# If run as a non-root user, this setting has no effect.
+# Note that on Windows this has no effect and so mosquitto should be started by
+# the user you wish it to run as.
+#user mosquitto
+
+# =================================================================
+# Listeners
+# =================================================================
+
+# Listen on a port/ip address combination. By using this variable
+# multiple times, mosquitto can listen on more than one port. If
+# this variable is used and neither bind_address nor port given,
+# then the default listener will not be started.
+# The port number to listen on must be given. Optionally, an ip
+# address or host name may be supplied as a second argument. In
+# this case, mosquitto will attempt to bind the listener to that
+# address and so restrict access to the associated network and
+# interface. By default, mosquitto will listen on all interfaces.
+# Note that for a websockets listener it is not possible to bind to a host
+# name.
+#
+# On systems that support Unix Domain Sockets, it is also possible
+# to create a # Unix socket rather than opening a TCP socket. In
+# this case, the port number should be set to 0 and a unix socket
+# path must be provided, e.g.
+# listener 0 /tmp/mosquitto.sock
+#
+# listener port-number [ip address/host name/unix socket path]
+listener 1883 0.0.0.0
+
+# By default, a listener will attempt to listen on all supported IP protocol
+# versions. If you do not have an IPv4 or IPv6 interface you may wish to
+# disable support for either of those protocol versions. In particular, note
+# that due to the limitations of the websockets library, it will only ever
+# attempt to open IPv6 sockets if IPv6 support is compiled in, and so will fail
+# if IPv6 is not available.
+#
+# Set to `ipv4` to force the listener to only use IPv4, or set to `ipv6` to
+# force the listener to only use IPv6. If you want support for both IPv4 and
+# IPv6, then do not use the socket_domain option.
+#
+#socket_domain
+
+# Bind the listener to a specific interface. This is similar to
+# the [ip address/host name] part of the listener definition, but is useful
+# when an interface has multiple addresses or the address may change. If used
+# with the [ip address/host name] part of the listener definition, then the
+# bind_interface option will take priority.
+# Not available on Windows.
+#
+# Example: bind_interface eth0
+#bind_interface
+
+# When a listener is using the websockets protocol, it is possible to serve
+# http data as well. Set http_dir to a directory which contains the files you
+# wish to serve. If this option is not specified, then no normal http
+# connections will be possible.
+#http_dir
+
+# The maximum number of client connections to allow. This is
+# a per listener setting.
+# Default is -1, which means unlimited connections.
+# Note that other process limits mean that unlimited connections
+# are not really possible. Typically the default maximum number of
+# connections possible is around 1024.
+#max_connections -1
+
+# The listener can be restricted to operating within a topic hierarchy using
+# the mount_point option. This is achieved be prefixing the mount_point string
+# to all topics for any clients connected to this listener. This prefixing only
+# happens internally to the broker; the client will not see the prefix.
+#mount_point
+
+# Choose the protocol to use when listening.
+# This can be either mqtt or websockets.
+# Certificate based TLS may be used with websockets, except that only the
+# cafile, certfile, keyfile, ciphers, and ciphers_tls13 options are supported.
+#protocol mqtt
+
+# Set use_username_as_clientid to true to replace the clientid that a client
+# connected with with its username. This allows authentication to be tied to
+# the clientid, which means that it is possible to prevent one client
+# disconnecting another by using the same clientid.
+# If a client connects with no username it will be disconnected as not
+# authorised when this option is set to true.
+# Do not use in conjunction with clientid_prefixes.
+# See also use_identity_as_username.
+#use_username_as_clientid
+
+# Change the websockets headers size. This is a global option, it is not
+# possible to set per listener. This option sets the size of the buffer used in
+# the libwebsockets library when reading HTTP headers. If you are passing large
+# header data such as cookies then you may need to increase this value. If left
+# unset, or set to 0, then the default of 1024 bytes will be used.
+#websockets_headers_size
+
+# -----------------------------------------------------------------
+# Certificate based SSL/TLS support
+# -----------------------------------------------------------------
+# The following options can be used to enable certificate based SSL/TLS support
+# for this listener. Note that the recommended port for MQTT over TLS is 8883,
+# but this must be set manually.
+#
+# See also the mosquitto-tls man page and the "Pre-shared-key based SSL/TLS
+# support" section. Only one of certificate or PSK encryption support can be
+# enabled for any listener.
+
+# Both of certfile and keyfile must be defined to enable certificate based
+# TLS encryption.
+
+# Path to the PEM encoded server certificate.
+#certfile
+
+# Path to the PEM encoded keyfile.
+#keyfile
+
+# If you wish to control which encryption ciphers are used, use the ciphers
+# option. The list of available ciphers can be optained using the "openssl
+# ciphers" command and should be provided in the same format as the output of
+# that command. This applies to TLS 1.2 and earlier versions only. Use
+# ciphers_tls1.3 for TLS v1.3.
+#ciphers
+
+# Choose which TLS v1.3 ciphersuites are used for this listener.
+# Defaults to "TLS_AES_256_GCM_SHA384:TLS_CHACHA20_POLY1305_SHA256:TLS_AES_128_GCM_SHA256"
+#ciphers_tls1.3
+
+# If you have require_certificate set to true, you can create a certificate
+# revocation list file to revoke access to particular client certificates. If
+# you have done this, use crlfile to point to the PEM encoded revocation file.
+#crlfile
+
+# To allow the use of ephemeral DH key exchange, which provides forward
+# security, the listener must load DH parameters. This can be specified with
+# the dhparamfile option. The dhparamfile can be generated with the command
+# e.g. "openssl dhparam -out dhparam.pem 2048"
+#dhparamfile
+
+# By default an TLS enabled listener will operate in a similar fashion to a
+# https enabled web server, in that the server has a certificate signed by a CA
+# and the client will verify that it is a trusted certificate. The overall aim
+# is encryption of the network traffic. By setting require_certificate to true,
+# the client must provide a valid certificate in order for the network
+# connection to proceed. This allows access to the broker to be controlled
+# outside of the mechanisms provided by MQTT.
+#require_certificate false
+
+# cafile and capath define methods of accessing the PEM encoded
+# Certificate Authority certificates that will be considered trusted when
+# checking incoming client certificates.
+# cafile defines the path to a file containing the CA certificates.
+# capath defines a directory that will be searched for files
+# containing the CA certificates. For capath to work correctly, the
+# certificate files must have ".crt" as the file ending and you must run
+# "openssl rehash <path to capath>" each time you add/remove a certificate.
+#cafile
+#capath
+
+
+# If require_certificate is true, you may set use_identity_as_username to true
+# to use the CN value from the client certificate as a username. If this is
+# true, the password_file option will not be used for this listener.
+#use_identity_as_username false
+
+# -----------------------------------------------------------------
+# Pre-shared-key based SSL/TLS support
+# -----------------------------------------------------------------
+# The following options can be used to enable PSK based SSL/TLS support for
+# this listener. Note that the recommended port for MQTT over TLS is 8883, but
+# this must be set manually.
+#
+# See also the mosquitto-tls man page and the "Certificate based SSL/TLS
+# support" section. Only one of certificate or PSK encryption support can be
+# enabled for any listener.
+
+# The psk_hint option enables pre-shared-key support for this listener and also
+# acts as an identifier for this listener. The hint is sent to clients and may
+# be used locally to aid authentication. The hint is a free form string that
+# doesn't have much meaning in itself, so feel free to be creative.
+# If this option is provided, see psk_file to define the pre-shared keys to be
+# used or create a security plugin to handle them.
+#psk_hint
+
+# When using PSK, the encryption ciphers used will be chosen from the list of
+# available PSK ciphers. If you want to control which ciphers are available,
+# use the "ciphers" option. The list of available ciphers can be optained
+# using the "openssl ciphers" command and should be provided in the same format
+# as the output of that command.
+#ciphers
+
+# Set use_identity_as_username to have the psk identity sent by the client used
+# as its username. Authentication will be carried out using the PSK rather than
+# the MQTT username/password and so password_file will not be used for this
+# listener.
+#use_identity_as_username false
+
+
+# =================================================================
+# Persistence
+# =================================================================
+
+# If persistence is enabled, save the in-memory database to disk
+# every autosave_interval seconds. If set to 0, the persistence
+# database will only be written when mosquitto exits. See also
+# autosave_on_changes.
+# Note that writing of the persistence database can be forced by
+# sending mosquitto a SIGUSR1 signal.
+#autosave_interval 1800
+
+# If true, mosquitto will count the number of subscription changes, retained
+# messages received and queued messages and if the total exceeds
+# autosave_interval then the in-memory database will be saved to disk.
+# If false, mosquitto will save the in-memory database to disk by treating
+# autosave_interval as a time in seconds.
+#autosave_on_changes false
+
+# Save persistent message data to disk (true/false).
+# This saves information about all messages, including
+# subscriptions, currently in-flight messages and retained
+# messages.
+# retained_persistence is a synonym for this option.
+#persistence false
+
+# The filename to use for the persistent database, not including
+# the path.
+#persistence_file mosquitto.db
+
+# Location for persistent database.
+# Default is an empty string (current directory).
+# Set to e.g. /var/lib/mosquitto if running as a proper service on Linux or
+# similar.
+#persistence_location
+
+
+# =================================================================
+# Logging
+# =================================================================
+
+# Places to log to. Use multiple log_dest lines for multiple
+# logging destinations.
+# Possible destinations are: stdout stderr syslog topic file dlt
+#
+# stdout and stderr log to the console on the named output.
+#
+# syslog uses the userspace syslog facility which usually ends up
+# in /var/log/messages or similar.
+#
+# topic logs to the broker topic '$SYS/broker/log/<severity>',
+# where severity is one of D, E, W, N, I, M which are debug, error,
+# warning, notice, information and message. Message type severity is used by
+# the subscribe/unsubscribe log_types and publishes log messages to
+# $SYS/broker/log/M/susbcribe or $SYS/broker/log/M/unsubscribe.
+#
+# The file destination requires an additional parameter which is the file to be
+# logged to, e.g. "log_dest file /var/log/mosquitto.log". The file will be
+# closed and reopened when the broker receives a HUP signal. Only a single file
+# destination may be configured.
+#
+# The dlt destination is for the automotive `Diagnostic Log and Trace` tool.
+# This requires that Mosquitto has been compiled with DLT support.
+#
+# Note that if the broker is running as a Windows service it will default to
+# "log_dest none" and neither stdout nor stderr logging is available.
+# Use "log_dest none" if you wish to disable logging.
+#log_dest stderr
+
+# Types of messages to log. Use multiple log_type lines for logging
+# multiple types of messages.
+# Possible types are: debug, error, warning, notice, information,
+# none, subscribe, unsubscribe, websockets, all.
+# Note that debug type messages are for decoding the incoming/outgoing
+# network packets. They are not logged in "topics".
+#log_type error
+#log_type warning
+#log_type notice
+#log_type information
+
+
+# If set to true, client connection and disconnection messages will be included
+# in the log.
+#connection_messages true
+
+# If using syslog logging (not on Windows), messages will be logged to the
+# "daemon" facility by default. Use the log_facility option to choose which of
+# local0 to local7 to log to instead. The option value should be an integer
+# value, e.g. "log_facility 5" to use local5.
+#log_facility
+
+# If set to true, add a timestamp value to each log message.
+#log_timestamp true
+
+# Set the format of the log timestamp. If left unset, this is the number of
+# seconds since the Unix epoch.
+# This is a free text string which will be passed to the strftime function. To
+# get an ISO 8601 datetime, for example:
+# log_timestamp_format %Y-%m-%dT%H:%M:%S
+#log_timestamp_format
+
+# Change the websockets logging level. This is a global option, it is not
+# possible to set per listener. This is an integer that is interpreted by
+# libwebsockets as a bit mask for its lws_log_levels enum. See the
+# libwebsockets documentation for more details. "log_type websockets" must also
+# be enabled.
+#websockets_log_level 0
+
+
+# =================================================================
+# Security
+# =================================================================
+
+# If set, only clients that have a matching prefix on their
+# clientid will be allowed to connect to the broker. By default,
+# all clients may connect.
+# For example, setting "secure-" here would mean a client "secure-
+# client" could connect but another with clientid "mqtt" couldn't.
+#clientid_prefixes
+
+# Boolean value that determines whether clients that connect
+# without providing a username are allowed to connect. If set to
+# false then a password file should be created (see the
+# password_file option) to control authenticated client access.
+#
+# Defaults to false, unless there are no listeners defined in the configuration
+# file, in which case it is set to true, but connections are only allowed from
+# the local machine.
+allow_anonymous true
+
+# -----------------------------------------------------------------
+# Default authentication and topic access control
+# -----------------------------------------------------------------
+
+# Control access to the broker using a password file. This file can be
+# generated using the mosquitto_passwd utility. If TLS support is not compiled
+# into mosquitto (it is recommended that TLS support should be included) then
+# plain text passwords are used, in which case the file should be a text file
+# with lines in the format:
+# username:password
+# The password (and colon) may be omitted if desired, although this
+# offers very little in the way of security.
+#
+# See the TLS client require_certificate and use_identity_as_username options
+# for alternative authentication options. If a plugin is used as well as
+# password_file, the plugin check will be made first.
+#password_file
+
+# Access may also be controlled using a pre-shared-key file. This requires
+# TLS-PSK support and a listener configured to use it. The file should be text
+# lines in the format:
+# identity:key
+# The key should be in hexadecimal format without a leading "0x".
+# If an plugin is used as well, the plugin check will be made first.
+#psk_file
+
+# Control access to topics on the broker using an access control list
+# file. If this parameter is defined then only the topics listed will
+# have access.
+# If the first character of a line of the ACL file is a # it is treated as a
+# comment.
+# Topic access is added with lines of the format:
+#
+# topic [read|write|readwrite|deny] <topic>
+#
+# The access type is controlled using "read", "write", "readwrite" or "deny".
+# This parameter is optional (unless <topic> contains a space character) - if
+# not given then the access is read/write. <topic> can contain the + or #
+# wildcards as in subscriptions.
+#
+# The "deny" option can used to explicity deny access to a topic that would
+# otherwise be granted by a broader read/write/readwrite statement. Any "deny"
+# topics are handled before topics that grant read/write access.
+#
+# The first set of topics are applied to anonymous clients, assuming
+# allow_anonymous is true. User specific topic ACLs are added after a
+# user line as follows:
+#
+# user <username>
+#
+# The username referred to here is the same as in password_file. It is
+# not the clientid.
+#
+#
+# If is also possible to define ACLs based on pattern substitution within the
+# topic. The patterns available for substition are:
+#
+# %c to match the client id of the client
+# %u to match the username of the client
+#
+# The substitution pattern must be the only text for that level of hierarchy.
+#
+# The form is the same as for the topic keyword, but using pattern as the
+# keyword.
+# Pattern ACLs apply to all users even if the "user" keyword has previously
+# been given.
+#
+# If using bridges with usernames and ACLs, connection messages can be allowed
+# with the following pattern:
+# pattern write $SYS/broker/connection/%c/state
+#
+# pattern [read|write|readwrite] <topic>
+#
+# Example:
+#
+# pattern write sensor/%u/data
+#
+# If an plugin is used as well as acl_file, the plugin check will be
+# made first.
+#acl_file
+
+# -----------------------------------------------------------------
+# External authentication and topic access plugin options
+# -----------------------------------------------------------------
+
+# External authentication and access control can be supported with the
+# plugin option. This is a path to a loadable plugin. See also the
+# plugin_opt_* options described below.
+#
+# The plugin option can be specified multiple times to load multiple
+# plugins. The plugins will be processed in the order that they are specified
+# here. If the plugin option is specified alongside either of
+# password_file or acl_file then the plugin checks will be made first.
+#
+# If the per_listener_settings option is false, the plugin will be apply to all
+# listeners. If per_listener_settings is true, then the plugin will apply to
+# the current listener being defined only.
+#
+# This option is also available as `auth_plugin`, but this use is deprecated
+# and will be removed in the future.
+#
+#plugin
+
+# If the plugin option above is used, define options to pass to the
+# plugin here as described by the plugin instructions. All options named
+# using the format plugin_opt_* will be passed to the plugin, for example:
+#
+# This option is also available as `auth_opt_*`, but this use is deprecated
+# and will be removed in the future.
+#
+# plugin_opt_db_host
+# plugin_opt_db_port
+# plugin_opt_db_username
+# plugin_opt_db_password
+
+
+# =================================================================
+# Bridges
+# =================================================================
+
+# A bridge is a way of connecting multiple MQTT brokers together.
+# Create a new bridge using the "connection" option as described below. Set
+# options for the bridges using the remaining parameters. You must specify the
+# address and at least one topic to subscribe to.
+#
+# Each connection must have a unique name.
+#
+# The address line may have multiple host address and ports specified. See
+# below in the round_robin description for more details on bridge behaviour if
+# multiple addresses are used. Note that if you use an IPv6 address, then you
+# are required to specify a port.
+#
+# The direction that the topic will be shared can be chosen by
+# specifying out, in or both, where the default value is out.
+# The QoS level of the bridged communication can be specified with the next
+# topic option. The default QoS level is 0, to change the QoS the topic
+# direction must also be given.
+#
+# The local and remote prefix options allow a topic to be remapped when it is
+# bridged to/from the remote broker. This provides the ability to place a topic
+# tree in an appropriate location.
+#
+# For more details see the mosquitto.conf man page.
+#
+# Multiple topics can be specified per connection, but be careful
+# not to create any loops.
+#
+# If you are using bridges with cleansession set to false (the default), then
+# you may get unexpected behaviour from incoming topics if you change what
+# topics you are subscribing to. This is because the remote broker keeps the
+# subscription for the old topic. If you have this problem, connect your bridge
+# with cleansession set to true, then reconnect with cleansession set to false
+# as normal.
+#connection <name>
+#address <host>[:<port>] [<host>[:<port>]]
+#topic <topic> [[[out | in | both] qos-level] local-prefix remote-prefix]
+
+# If you need to have the bridge connect over a particular network interface,
+# use bridge_bind_address to tell the bridge which local IP address the socket
+# should bind to, e.g. `bridge_bind_address 192.168.1.10`
+#bridge_bind_address
+
+# If a bridge has topics that have "out" direction, the default behaviour is to
+# send an unsubscribe request to the remote broker on that topic. This means
+# that changing a topic direction from "in" to "out" will not keep receiving
+# incoming messages. Sending these unsubscribe requests is not always
+# desirable, setting bridge_attempt_unsubscribe to false will disable sending
+# the unsubscribe request.
+#bridge_attempt_unsubscribe true
+
+# Set the version of the MQTT protocol to use with for this bridge. Can be one
+# of mqttv50, mqttv311 or mqttv31. Defaults to mqttv311.
+#bridge_protocol_version mqttv311
+
+# Set the clean session variable for this bridge.
+# When set to true, when the bridge disconnects for any reason, all
+# messages and subscriptions will be cleaned up on the remote
+# broker. Note that with cleansession set to true, there may be a
+# significant amount of retained messages sent when the bridge
+# reconnects after losing its connection.
+# When set to false, the subscriptions and messages are kept on the
+# remote broker, and delivered when the bridge reconnects.
+#cleansession false
+
+# Set the amount of time a bridge using the lazy start type must be idle before
+# it will be stopped. Defaults to 60 seconds.
+#idle_timeout 60
+
+# Set the keepalive interval for this bridge connection, in
+# seconds.
+#keepalive_interval 60
+
+# Set the clientid to use on the local broker. If not defined, this defaults to
+# 'local.<clientid>'. If you are bridging a broker to itself, it is important
+# that local_clientid and clientid do not match.
+#local_clientid
+
+# If set to true, publish notification messages to the local and remote brokers
+# giving information about the state of the bridge connection. Retained
+# messages are published to the topic $SYS/broker/connection/<clientid>/state
+# unless the notification_topic option is used.
+# If the message is 1 then the connection is active, or 0 if the connection has
+# failed.
+# This uses the last will and testament feature.
+#notifications true
+
+# Choose the topic on which notification messages for this bridge are
+# published. If not set, messages are published on the topic
+# $SYS/broker/connection/<clientid>/state
+#notification_topic
+
+# Set the client id to use on the remote end of this bridge connection. If not
+# defined, this defaults to 'name.hostname' where name is the connection name
+# and hostname is the hostname of this computer.
+# This replaces the old "clientid" option to avoid confusion. "clientid"
+# remains valid for the time being.
+#remote_clientid
+
+# Set the password to use when connecting to a broker that requires
+# authentication. This option is only used if remote_username is also set.
+# This replaces the old "password" option to avoid confusion. "password"
+# remains valid for the time being.
+#remote_password
+
+# Set the username to use when connecting to a broker that requires
+# authentication.
+# This replaces the old "username" option to avoid confusion. "username"
+# remains valid for the time being.
+#remote_username
+
+# Set the amount of time a bridge using the automatic start type will wait
+# until attempting to reconnect.
+# This option can be configured to use a constant delay time in seconds, or to
+# use a backoff mechanism based on "Decorrelated Jitter", which adds a degree
+# of randomness to when the restart occurs.
+#
+# Set a constant timeout of 20 seconds:
+# restart_timeout 20
+#
+# Set backoff with a base (start value) of 10 seconds and a cap (upper limit) of
+# 60 seconds:
+# restart_timeout 10 30
+#
+# Defaults to jitter with a base of 5 and cap of 30
+#restart_timeout 5 30
+
+# If the bridge has more than one address given in the address/addresses
+# configuration, the round_robin option defines the behaviour of the bridge on
+# a failure of the bridge connection. If round_robin is false, the default
+# value, then the first address is treated as the main bridge connection. If
+# the connection fails, the other secondary addresses will be attempted in
+# turn. Whilst connected to a secondary bridge, the bridge will periodically
+# attempt to reconnect to the main bridge until successful.
+# If round_robin is true, then all addresses are treated as equals. If a
+# connection fails, the next address will be tried and if successful will
+# remain connected until it fails
+#round_robin false
+
+# Set the start type of the bridge. This controls how the bridge starts and
+# can be one of three types: automatic, lazy and once. Note that RSMB provides
+# a fourth start type "manual" which isn't currently supported by mosquitto.
+#
+# "automatic" is the default start type and means that the bridge connection
+# will be started automatically when the broker starts and also restarted
+# after a short delay (30 seconds) if the connection fails.
+#
+# Bridges using the "lazy" start type will be started automatically when the
+# number of queued messages exceeds the number set with the "threshold"
+# parameter. It will be stopped automatically after the time set by the
+# "idle_timeout" parameter. Use this start type if you wish the connection to
+# only be active when it is needed.
+#
+# A bridge using the "once" start type will be started automatically when the
+# broker starts but will not be restarted if the connection fails.
+#start_type automatic
+
+# Set the number of messages that need to be queued for a bridge with lazy
+# start type to be restarted. Defaults to 10 messages.
+# Must be less than max_queued_messages.
+#threshold 10
+
+# If try_private is set to true, the bridge will attempt to indicate to the
+# remote broker that it is a bridge not an ordinary client. If successful, this
+# means that loop detection will be more effective and that retained messages
+# will be propagated correctly. Not all brokers support this feature so it may
+# be necessary to set try_private to false if your bridge does not connect
+# properly.
+#try_private true
+
+# Some MQTT brokers do not allow retained messages. MQTT v5 gives a mechanism
+# for brokers to tell clients that they do not support retained messages, but
+# this is not possible for MQTT v3.1.1 or v3.1. If you need to bridge to a
+# v3.1.1 or v3.1 broker that does not support retained messages, set the
+# bridge_outgoing_retain option to false. This will remove the retain bit on
+# all outgoing messages to that bridge, regardless of any other setting.
+#bridge_outgoing_retain true
+
+# If you wish to restrict the size of messages sent to a remote bridge, use the
+# bridge_max_packet_size option. This sets the maximum number of bytes for
+# the total message, including headers and payload.
+# Note that MQTT v5 brokers may provide their own maximum-packet-size property.
+# In this case, the smaller of the two limits will be used.
+# Set to 0 for "unlimited".
+#bridge_max_packet_size 0
+
+
+# -----------------------------------------------------------------
+# Certificate based SSL/TLS support
+# -----------------------------------------------------------------
+# Either bridge_cafile or bridge_capath must be defined to enable TLS support
+# for this bridge.
+# bridge_cafile defines the path to a file containing the
+# Certificate Authority certificates that have signed the remote broker
+# certificate.
+# bridge_capath defines a directory that will be searched for files containing
+# the CA certificates. For bridge_capath to work correctly, the certificate
+# files must have ".crt" as the file ending and you must run "openssl rehash
+# <path to capath>" each time you add/remove a certificate.
+#bridge_cafile
+#bridge_capath
+
+
+# If the remote broker has more than one protocol available on its port, e.g.
+# MQTT and WebSockets, then use bridge_alpn to configure which protocol is
+# requested. Note that WebSockets support for bridges is not yet available.
+#bridge_alpn
+
+# When using certificate based encryption, bridge_insecure disables
+# verification of the server hostname in the server certificate. This can be
+# useful when testing initial server configurations, but makes it possible for
+# a malicious third party to impersonate your server through DNS spoofing, for
+# example. Use this option in testing only. If you need to resort to using this
+# option in a production environment, your setup is at fault and there is no
+# point using encryption.
+#bridge_insecure false
+
+# Path to the PEM encoded client certificate, if required by the remote broker.
+#bridge_certfile
+
+# Path to the PEM encoded client private key, if required by the remote broker.
+#bridge_keyfile
+
+# -----------------------------------------------------------------
+# PSK based SSL/TLS support
+# -----------------------------------------------------------------
+# Pre-shared-key encryption provides an alternative to certificate based
+# encryption. A bridge can be configured to use PSK with the bridge_identity
+# and bridge_psk options. These are the client PSK identity, and pre-shared-key
+# in hexadecimal format with no "0x". Only one of certificate and PSK based
+# encryption can be used on one
+# bridge at once.
+#bridge_identity
+#bridge_psk
+
+
+# =================================================================
+# External config files
+# =================================================================
+
+# External configuration files may be included by using the
+# include_dir option. This defines a directory that will be searched
+# for config files. All files that end in '.conf' will be loaded as
+# a configuration file. It is best to have this as the last option
+# in the main file. This option will only be processed from the main
+# configuration file. The directory specified must not contain the
+# main configuration file.
+# Files within include_dir will be loaded sorted in case-sensitive
+# alphabetical order, with capital letters ordered first. If this option is
+# given multiple times, all of the files from the first instance will be
+# processed before the next instance. See the man page for examples.
+#include_dir
diff --git a/mosquitto.sh b/mosquitto.sh
new file mode 100755
index 0000000000000000000000000000000000000000..6886d7289c1a7518abc15216a37231ec0f53e8e5
--- /dev/null
+++ b/mosquitto.sh
@@ -0,0 +1,4 @@
+#!/usr/bin/env nix-shell
+#!nix-shell -i sh -p mosquitto
+
+mosquitto -c mosquitto.conf
diff --git a/scripting/CyanLightSparkling.py b/scripting/CyanLightSparkling.py
index f07c0c5853d9e0c615c1fd5a6f52f0af2eea5fb1..c771bf46926b1168058b9c6548c9d6750009f267 100755
--- a/scripting/CyanLightSparkling.py
+++ b/scripting/CyanLightSparkling.py
@@ -7,7 +7,7 @@ import random
from socket import *
-fps = 3
+fps = 4
pixels = 50
port = 4213