Physical computing/Signalen en events

Inleiding

Een Physical Computing systeem bestaat uit sensoren, actuatoren, een (micro)controller, communicatieverbindingen (en een energiebron). De software van de microcontroller verwerkt de inputs (sensoren, communicatie) en stuurt daarmee de outputs (actuatoren, communicatie) aan.

In dit gedeelte behandelen we de volgende vragen:

• hoe ontwerp je de verwerking van inputs naar outputs?
• hoe zet je dit ontwerp om in een programma?

Signalen en events

We onderscheiden twee soorten inputs: signalen en events.

• Een signaal heeft op elk moment een waarde, zoals het signaal van een microfoon of van een temperatuursensor.
• Een event is een gebeurtenis die op een bepaald, ondeelbaar moment plaatsvindt, zoals het indrukken van een drukknop, of het ontvangen van een bericht.

Fysisch gezien is een event niet ondeelbaar: deze zal altijd een zekere tijd in beslag nemen. Maar in de software beschouwen we een event als "instantaan" en speelt de duur daarvan geen rol.

In het voorbeeld hierboven zie je het signaal van een drukknop: dit is laag als de drukknop in rust is, en hoog als de drukknop ingedrukt is. Daaronder zie je de bijbehorende events die overeenkomen met het indrukken van de drukknop. Deze events kun je in het signaal detecteren als de overgang van laag naar hoog. (In de software: 0->1)

Verwerken van signalen

Een input-signaal kun je op verschillende manieren verwerken:

• je kunt de huidige signaalwaarde direct omzetten in een output-signaal;
• je kunt de huidige signaalwaarde combineren met de geschiedenis van dit signaal, en dat verwerken tot een output-signaal;
• je kunt in het signaal events detecteren (zoals het indrukken van een knop).

We werken deze mogelijkheden verderop uit.

Detecteren van events

Het detecteren van een event kan op verschillende manieren: in de hardware, in een onderliggende software-laag, of in de eigenlijke besturingssoftware. Voor de verdere verwerking van de events maakt dat geen verschil.

Verwerken van een event: event-handler

De verwerking van een event bestaat uit een actie die aan deze event gekoppeld is. Deze actie wordt steeds uitgevoerd als de betreffende event optreedt. In een programma heeft deze actie vaak de vorm van een functie (blok code) die als event-handler aan de betreffende event gekoppeld wordt.

Voorbeeld: met twee drukknoppen kun je een lamp aan- en uitzetten: de event van het indrukken van de ene knop zet de lamp aan, het indrukken van de andere knop zet de lamp uit. In tabelvorm:

2-button LED control

Event	Action
Button A pushed (0->1)	LED on
Button B pushed (0->1)	LED off

Events en toestanden

De actie van een event is soms afhankelijk van de toestand. Bijvoorbeeld: het indrukken van een drukknop geeft als actie om de lamp aan te zetten, als deze uit was; en omgekeerd. In de actie moeten we dan deze toestand ook inspecteren en weer aanpassen.

Signalen

Een signaal heeft op elk moment een waarde. Voorbeelden van signalen:

• het signaal van een drukknop (button);
• het signaal van een temperatuursensor;
• het signaal van een hart (electrocardiogram, ECG);
• het signaal van een versnellingsmeter (accelerometer);

<<figuur van een signalen>>

Een drukknop levert een tweewaardig of "logisch" signaal; elektrisch gezien een lage spanning (0V) of een "hoge" spanning (meestal 5V of 3.3V). In de software komt dat overeen met de getallen 0 en 1, of de logische waarden False en True.

Veel andere sensoren leveren een analoog signaal, zoals bijvoorbeeld een temperatuursensor. Dit analoge signaal wordt op discrete momenten in de tijd bemonsterd; de analoge waarde van een monster wordt omgezet in een getal (gediscretiseerd) door een Analoog/Digitaal (A/D) omzetter.

• Opmerking: het resultaat van de A/D omzetting is meestal een geheel getal (integer), in een beperkt bereik; bijvoorbeeld 0..1023 voor een 10-bits A/D omzetter. Deze waarde kun je vervolgens omrekenen naar een fysieke eenheid, bijvoorbeeld "°C"; daarvoor heb je meestal een floating point getal nodig. Soms is het handiger om met de oorspronkelijke gehele getallen te rekenen; soms werk je met de fysieke eenheden, als floating point getal. (Het werken met floating point getallen heeft enkele nadelen: (i) je krijgt mogelijk wat precisie-verlies; (ii) het kost meer rekenkracht - wat vooral voor microcontrollers een punt kan zijn.)

Verwerking van signalen

In principe kun je met een input-signaal twee dingen doen: (i) omzetten in een output-signaal; (ii) detecteren van events - die verder als event verwerkt worden.

Een signaal kun je op verschillende manieren verwerken tot een output-signaal:

• de huidige signaalwaarde direct omzetten in een output-signaalwaarde;
• de huidige signaalwaarde combineren met de historie van het signaal tot een output-signaalwaarde.

Deze laatste aanpak wordt gebruikt bij besturingsalgoritmes zoals een PID-regeling (zie https://en.wikipedia.org/wiki/PID_controller).

We beschrijven hier de directe besturing, zonder gebruik van de historie van het signaal.

Ontwerp

Voorbeeld: potmeter-regeling

In dit voorbeeld gebruiken we een potmeter voor analoge invoer, waarmee we het PWM-signaal voor een LED (of voor een motor) sturen.

(Dit is al behandeld bij analoge invoer en PWM-uitvoer?)

Voorbeeld: drukknop-regeling

Met behulp van twee drukknoppen kunnen we 4 verschillende niveau's bepalen, bijvoorbeeld 0, 1/4, 1/2, 1, voor de lichtsterkte van een LED, of voor de snelheid van een motor. We werken met een directe besturing: de huidige stand van de drukknoppen bepaalt de lichtsterkte of de snelheid. Als je de knoppen loslaat, is het niveau 0.

Lichtsterkte regeling

KnopA	Knop B	Lichtsterkte
0	0	0
1	0	1/4
1	1	1/2
0	1	1

Opmerkingen:

• de verschillende lichtsterktes geven steeds een verdubbeling: dat is omdat ons oog de lichtsterktes logaritmisch ervaart.
• we hebben de volgorde van de knoppen zo gekozen, dat je voor opeenvolgende niveaus maar één knop hoeft te veranderen. Dit heet ook wel: de Hamming-afstand tussen de verschillende standen (codes) is 1.

Programmeren: MakeCode blokken

Regeling voor de lichtsterkte (of motorsnelheid) met 2 drukknoppen. De actuele stand van de drukknoppen bepaalt de actuele lichtsterkte (of snelheid).

Merk op dat het bovenstaande steeds herhaald wordt: er is geen sprake van events.

Programmeren: Python

from machine import Pin, PWM, ADC
from machine import ADC, Pin

pot = ADC(Pin(26))     # create ADC object on ADC pin (GPIO 26, 27, 28)
pot.read_u16()         # read value, 0-65535 across voltage range 0.0v - 3.3v

led = PWM(Pin(0))      # create PWM object from a pin
led.freq(1000)         # set frequency

while True:
  level = pot.read_u16()
  pwm.duty_u16(level)
  time.sleep(0.1)

Drukknop-besturing van levels

from machine import Pin, PWM
from utime import sleep

buttonA = Pin(20, Pin.IN)
buttonB = Pin(21, Pin.IN)

led = PWM(Pin(9))   # create PWM object from a pin
led.freq(1000)      # set frequency
max_level = 65535   # max PWM level

while True:
    if buttonA.value() == 1 and buttonB.value() == 0:
        led.duty_u16(max_level // 4)
    elif buttonA.value() == 1 and buttonB.value() == 1:
        led.duty_u16(max_level // 2)
    elif buttonA.value() == 0 and buttonB.value() == 1:
        led.duty_u16(max_level)
    else:  # buttonA == 0, buttonB == 0
        led.duty_u16(0)

    sleep(0.1)

Opmerkingen:

• voor de Raspberry Pi Pico is het maximale PWM-niveau 65535 (16 bits)
• a // b staat in Python voor geheeltallige (integer) deling, waarbij a , b en het resultaat gehele getallen zijn.
• je kunt deze if met 4 takken ook schrijven als tweemaal twee geneste if-statements.

Events

<< figuur van een event>>

Een event vindt plaats op één enkel ondeelbaar moment. De waarde van de event is alleen op dat moment gedefinieerd. Voorbeelden van events:

• het indrukken van een drukknop (of: het loslaten daarvan)
• eem muisklik
• het schudden van de microbit
• een beweging zoals gedetecteerd door een infrarood-sensor
• een hartslag
• een stap
• het ontvangen van een radiobericht

In de grafische gebruikersinterface (GUI) van een computer spelen events een grote rol: het indrukken van een toets, een muis-klik, het aanraken van een touchscreen, zijn allemaal voorbeelden van input-events die door de interface-software afgehandeld worden.

Als de duur van een "event" wel een rol speelt dan kun je ook afzonderlijke events gebruiken voor het begin en het einde. Voorbeeld: het indrukken en het loslaten van een drukknop.

Detecteren van een event in een signaal

Als je events nodig hebt, terwijl de sensor alleen maar een signaal levert, dan heb je signaalverwerking nodig om de events in het signaal te detecteren. Dit kan heel eenvoudig zijn, bijvoorbeeld het detecteren van het indrukken van een knop. In andere gevallen, zoals het detecteren van de hartslagen in een ECG, is dit lastiger. Voor het detecteren van een event in een signaal heb je een stukje van de historie van het signaal nodig. Voor het detecteren van het indrukken van een drukknop is dat alleen de waarde van het signaal op het vorige tijdstip. Voor het betrouwbaar detecteren van een "stap" in het signaal van een accellerometer (versnellingsmeter) heb je meer waarden uit de historie nodig.

De microbit-software bevat al de nodige event-detectie. Je kunt zo voor de versnellingsmeter events gebruiken als "schudden", "logo omhoog", "logo omlaag", "vrije val".

code voor het detecteren van het indrukken van een drukknop - met figuur

figuur daarbij

Verwerken van een event: event-handler

We maken eerst een ontwerp voor de verwerking van de events, en zetten dat daarna om in een programma.

Ontwerp: koppel event aan actie

Een event kun je koppelen aan een actie. Bijvoorbeeld: het indrukken van een drukknop aan het aan- of uitzetten van een lamp. Het volgende schema is dan een ontwerp voor een aan- uit besturing van een lamp met twee knoppen:

2-button LED control

Event	Action
Button A pushed	LED on
Button B pushed	LED off

Met Button A pushed bedoelen we hier: de event van het indrukken van knop A. Steeds als je A (opnieuw) indrukt, zet je de LED aan. Met het indrukken van knop B zet je de LED uit.

Merk op dat er geen verschil is of je knop A één keer indrukt, of meerdere keren achter elkaar. Zo'n operatie noemen we ook wel "idempotent". Dit is bijvoorbeeld handig als de knoppen niet helemaal betrouwbaar zijn, of als er een grote vertraging is tussen de event en de actie: als er geen reactie komt, probeer je het nog een keer. Dat levert in dit geval geen problemen op.

Programma: event-handlers

In een programma kun je deze koppeling tussen event en actie vormgeven met behulp van een event handler: dat is een functie of een stuk programmacode met daarin de actie die je koppelt aan de event.

Programma: MakeCode blokjestaal

In de Makecode blokjestaal voor de microbit heb je apart blokken voor deze event-handlers: "wanneer knop A wordt ingedrukt", "bij schudden", of "wanneer pin0 wordt aangeraakt". De code binnen dit blok is de handler die uitgevoerd wordt als de event optreedt.

Het programma voor de bovenstaande 2-knops besturing van een LED ziet er dan als volgt uit:

Programma: microPython

In Python definieer je voor een event-handler als een functie. Deze functie koppel je vervolgens aan een event: de functie wordt dan steeds aangeroepen als de event gedetecteerd wordt.

Voorbeeld van deze functie (microPyton RP2):

def buttonA_handler():
    led.value(1)

def buttonB_handler():
    led.value(0)

In MakeCode Python koppel je een event-handler op de volgende manier aan een event:

input.on_button_pressed(Button.A, buttonA_handler)

In microPython moet je zelf het detectie van de button-events programmeren, in een niet-eindigende "event loop". Na het detecteren van een event moet de bijbehorende handler aangeroepen worden.

prev_levelA = 0
prev_levelB = 0

while True:
    cur_levelA = buttonA.value()
    if cur_levelA == 1 and prev_levelA == 0:
        buttonA_handler()
    prev_levelA = cur_levelA

    cur_levelB = buttonB.value()
    if cur_levelB == 1 and prev_levelB == 0:
        buttonB_handler()
    prev_levelB = cur_levelB

Het complete programma wordt dan (hier voor de Raspberry Pi Pico):

from machine import Pin, PWM
from utime import sleep

buttonA = Pin(20, Pin.IN)
buttonB = Pin(21, Pin.IN)

led = Pin(9, Pin.OUT)

def buttonA_handler():
    led.value(1)

def buttonB_handler():
    led.value(0)
    
prev_levelA = 0
prev_levelB = 0

while True:
    cur_levelA = buttonA.value()
    if cur_levelA == 1 and prev_levelA == 0:
        buttonA_handler()
    prev_levelA = cur_levelA

    cur_levelB = buttonB.value()
    if cur_levelB == 1 and prev_levelB == 0:
        buttonB_handler()
    prev_levelB = cur_levelB

Events en toestanden

De actie van een event is soms afhankelijk van de toestand. Bijvoorbeeld: het indrukken van een drukknop geeft als actie om de lamp aan te zetten, als deze uit was; en omgekeerd. In de actie moeten we dan deze toestand ook inspecteren en weer aanpassen. We kunnen dit gedrag beschrijven met een eindige automaat.

We beschrijven een dergelijke automaat met behulp van toestandsdiagrammen en tabellen. Dit ontwerp zetten we vervolgens op een systematische manier om in een programma.

Ontwerp

Als eenvoudigste voorbeeld gebruiken we het aan- en uitzetten van een LED met één enkele drukknop. De automaat bestaat uit twee toestanden: 0: de lED is uit; en 1: de LED is aan. Zie het onderstaande toestandsdiagram:

De overgangen kunnen we ook als tabel weergeven:

LED besturing met één drukknop

Input A	Toestand	-->	Actie	Toestand
button A pushed (0->1)	state 0	-->	led ON	state 1
button A pushed (0->1)	state 1	-->	led OFF	state 0

Programma (MakeCode blokjes)

Het bovenstaande ontwerp zetten we als volgt om in een programma:

• we combineren alle overgangen rijen met dezelfde input-event
  • in het bovenstaande geval is er maar 1 event: button A pushed
• in de event-handler onderscheiden we vervolgens de verschillende toestanden

Programma (microPython)

We gebruiken dezelfde regels voor het omzetten van een automaat-ontwerp in een programma:

• we combineren alle overgangen (rijen) met dezelfde input-event
  • in het bovenstaande geval is er maar 1 event: button A pushed
• in de event-handler onderscheiden vervolgens we de verschillende toestanden

led_state = 0

def buttonA_handler():
  if led_state == 0:
    led_state = 1
    led.value(1)
  else:  # led_state == 1
    led_state = 0
    led_value(0)

Het totale programma wordt dan:

from machine import Pin
from utime import sleep

buttonA = Pin(20, Pin.IN)

led = Pin(9, Pin.OUT)
led_state = 0

def buttonA_handler():
    if led_state == 0:
        led.value(1)    # action
        led_state = 1   # next state
    else:  # led_state == 1
        led_value(0)    # action
        led_state = 0   # next state
 

prev_levelA = 0

while True:
    cur_levelA = buttonA.value()
    if cur_levelA == 1 and prev_levelA == 0:
        buttonA_handler()
    prev_levelA = cur_levelA
    sleep(0.1)

Berichten

Deelsystemen kunnen met elkaar communiceren met behulp van berichten, eventueel via (radio)communicatie. Een inkomend bericht kun je dan ook weer als een event beschouwen. Het versturen van een bericht is een actie die dan door een ander (deel)systeem verwerkt wordt.

rest

In dit gedeelte behandelen we een aanpak voor de verwerking, in het bijzonder die van events. Met deze aanpak kun je op een systematische manier je programma maken. Voor niet al te complexe problemen levert dit snel een werkend programma.

Een belangrijk uitgangspunt is dat elke input-event op elk moment kan plaatsvinden. Je programma moet dan ook op elk moment op elk input-event kunnen reageren. Je kunt er niet vanuit gaan dat de omgeving de events in de gewenste volgorde of op het gewenste moment aanbiedt

Denk bijvoorbeeld aan een robot die een lijn volgt: deze kan op elk moment een obstakel tegenkomen, of een besturingsbericht ontvangen via de afstandsbediening.

In een Python-programma betekent dit dat we een event koppelen aan een functie: deze functie wordt telkens aangeroepen als de bijbehorende event optreedt. Zo'n functie noemen we een event-handler.

De betekenis is dan: WHEN event THEN handler()

In de Makecode blokjestaal voor de microbit heb je apart blokken voor deze event-handlers: "wanneer knop A wordt ingedrukt", "bij schudden", of "wanneer pin0 wordt aangeraakt". De code binnen dit blok is de handler die uitgevoerd wordt als de event optreedt.

Opmerking. Een bekend programma voor regels met deze structuur is "IFTTT" - "if this then that". Met de "if" hierin wordt niet de "if" van een programmeertaal bedoeld, maar een event of trigger die op elk moment plaats kan vinden. "when", of eigenlijk "whenever", zou een betere naam geweest zijn.

Analoge en digitale signalen; bemonstering

Een analoog signaal is continu: dit heeft op elk moment in de tijd een waarde in een continu domein.

We noemen een signaal "analoog" omdat de waarde van het signaal analoog is met een fysieke grootheid. Bijvoorbeeld: het elektrische signaal van een microfoon is analoog met de geluidstrillingen in de lucht. Of, de weerstand van een lichtgevoelige weerstand is analoog met de lichtsterkte op elk moment.

Meestal werken we met elektrische signalen: die zijn het gemakkelijks te verwerken (versterken, filteren, enz.)

Een digitaal signaal is discreet: dit heeft alleen op bepaalde momenten in de tijd een waarde, in een discreet (geheeltallig) domein.

Een digitale computer werkt met eindige getallen;

Getallen van het type "floating point" zijn zwevende-komma getallen met een eindig aantal significate cijfers: in de meeste gevallen (voor 32-bit floats) "slechts" 23 bits, ofwel ongeveer 7 decimalen.

Voor sensoren en actuatoren hebben we vaak aan 16-bits gehele getallen voldoende: vaak is een sensor niet nauwkeuriger dan 1%.

Hoeveel decimalen heb je nodig voor een temperatuursensor van 0..100 graden, met een nauwkeurigheid van 1/10 graad?

Over nauwkeurigheid en precisie

• toevallige fouten ("ruis") en systematische fouten
• herhaalbaarheid
• doeltreffendheid

Dit betreft vnl. eigenschappen van sensoren.

Sturen met signalen

Soms stuur je een output-signaal direct vanuit een input-signaal: signaal -> bewerking -> signaal.

De eenvoudigste vorm hiervan is een directe besturing, bijvoorbeeld als je een potmeter (analoge input) gebruikt voor het regelen van de snelheid van een motor, of van de lichtsterkte van een lamp.

from machine import ADC, PWM, Pin

potmeter = ADC(Pin(26)) # create potmeter object on ADC pin
motor = PWM(Pin(0))     # create motor object on PWM pin

while True:
  level = potmeter.read_u16()
  motor.duty_cycle(level)

We kunnen de opdrachten in de lus in dit geval zelfs combineren tot motor.duty_cycle(potmeter.read_u16()).

Vaak moeten we het input-signaal omrekenen naar een waarde die geschikt is voor de uitvoer. Deze berekening komt dan tussen het inlezen van de input-waarde en het schrijven van de output-waarde.

Het wordt iets complexer als we op basis van de input-waarde de output-waarde bij moeten sturen (proportionele regeling).

from machine import ADC, PWM, Pin

speed = ADC(Pin(26))    # create potmeter object on ADC pin
motor = PWM(Pin(0))     # create motor object on PWM pin
goal = 123              # preset speed

while True:
  level = speed.read_u16()
  motor.duty_cycle(level )

Een stap verder is het gebruik van een volledige PID-regeling (zie: https://en.wikipedia.org/wiki/PID_controller).

?Detecteren van events

Voor het detecteren van een event in een signaal hebben we, naast de huidige waarde van het signaal, een stukje van de signaal-historie nodig. In het eenvoudige geval van het indrukken van een drukknop hebben we aan de vorige waarde genoeg.

Speciale gevallen van eventdetectie:

• temperatuurregeling: temperatuur komt boven (of onder) een bepaalde grens
  • de regeling is vaak een hysterese-regeling: de grens voor het uitschakelen ligt anders dan voor het inschakelen.
  • de event-detectie doe je eigenlijk op basis van de toestand van de schakeling (niet van de temperatuur alleen): als de temperatuur onder een bepaalde grens komt, en de CV is nog niet ingeschakeld, dan schakel je deze in.
  • bij een CV komt daar nog een effect bij: je compenseert voor een zekere "overshoot", er is nog de nodige warmte in de installatie als je de brander uitschakelt. (Je laat de pomp dan ook langer lopen.) (Voor zover ik weet schakelt de thermostaat alleen de CV; de schakeling van de pomp gebeurt vanuit de ketel.)
  • vgl. het koken van melk op een elektrisch fornuis...

Afhandelen van events

De "normale" manier om een event af te handelen is door de bijbehorende handler-functie ("on event") uit te voeren. Dit is het model dat bijvoorbeeld bij grafische gebruikersinterfaces gebruikt wordt, zoals met JavaScript in de browser.

Er zijn een paar zaken om rekening mee te houden:

• elke input-event kan in principe op elk moment optreden: je hebt de buitenwereld niet in de hand. Hooguit kun je op basis van fysieke eigenschappen aangeven met welke snelheid processen plaatsvinden.
• maar: je bent mogelijk niet op elk moment in elke input geïnteresseerd. Afhankelijk van de huidige toestand (mode) zijn sommige inputs relevant, andere niet.
• ook al heb je met de buitenwereld een bepaald protocol afgesproken, je kunt er niet vanuit gaan dat de buitenwereld zich aan deze regels houdt. (En: je kunt er niet op rekenen dan de buitenwereld in andere opzichten betrouwbaar is.)

Events en automaten

Bij besturingstoepassingen maken we vaak gebruik van eindige automaten. De invoer- en uitvoertekens van een automaat komen dan overeen met invoer- en uitvoer-events.

Een eenvoudig voorbeeld is het aan- en uitschakelen van een LED met een drukknop. Bij elke druk op de knop schakelt de LED om: van uit naar aan en omgekeerd.

De automaat hiervoor heeft twee toestanden, 0 (LED uit) en 1 (LED aan). Er is 1 input-symbool: "push". Dit zorgt voor een overgang naar de andere toestand. Bij deze overgang hoort een output-symbol: van 0 naar 1: "led-on", van 1 naar 0: "led-off".

<<fig>>

Dit kunnen we op de volgende manier in een programma omzetten:

Events en messages (berichten)

Een andere manier om met events om te gaan is om deze om te zetten in messages (berichten). Deze berichten kunnen lokaal afgehandeld worden, of ze kunnen gecommuniceerd worden naar andere systemen, om daar af te handelen.

Een voordeel van messages is dat deze compleet asynchroon afgehandeld kunnen worden, zoals in het geval van NodeRed.

Een "blok" (node, thing?) voor het afhandelen van een message kan een (strikte) functie zijn, maar ook een automaat, met een eigen toestand. Een dergelijke automaat-blok kan meerdere event-streams als input hebben, of als output.

NodeRed

NodeRed is een grafisch programmeersysteem voor dataflow/event/messageflow. Een "normaal" blok heeft message/event-inputs en message/event-outputs.

NodeRed is gebaseerd op een message-model; dat verschilt op een aantal punten van een event-model. Messages zijn niet globaal, maar worden alleen via verbindingen tussen knopen gecommuniceerd. Op elk moment kunnen meerdere messages van eenzelfde type onderweg zijn. Bij events is dat niet (altijd) het geval; maar je kunt ook in dat geval een event-queue gebruiken voor het bufferen van events.

Events hebben een globaal karakter, en een "publish/subscribe" karakter. Elk programmaonderdeel kan zich abonneren op een event.

NodeRed is gebaseerd op Node.js.

ThingFlow

• https://thingflow.io
• https://thingflow-python.readthedocs.io/en/latest/
• https://github.com/mpi-sws-rse/thingflow-python
• https://micropython-iot-hackathon.readthedocs.io/en/latest/

Opmerking: de laatste activiteiten rond thingflow lijken van 2017. Dat lijkt niet gunstig voor de continuïteit. Maar: de hele implementatie is niet erg groot, dit is relatief eenvoudig te onderhouden of aan te passen.

Thingflow voor de microbit? De implementatie is niet erg groot of ingewikkeld, het lijkt mij dat dit zou moeten werken.

Ik vind de naamgeving van ThingFlow in een aantal opzichten niet handig: (i) ik zou (in een IoT-omgeving) nodes voor de verwerking nooit "things" noemen; (ii) ik zou een OutputThing eerder "inputNode" noemen.

Ik heb nog geen ervaring met het gebruik van deze aanpak voor een microcontroller; ik ben benieuwd welke voor- en nadelen dit heeft.