Kann ich vier Ws2812-Strips ansteuern?

Hallöle.
Bastele da grad an was- das soll am Ende vier Lampen haben.
Da man alt und bequem wird, sollen die per Handy-Ap angesteuert werden, also kommt ein NodeMCU ins Elektronikfach.

Nun sind da tatsächlich vier räumlich getrennte Lampen zu verbauen, jede besteht aus zwei, max. drei Ws2812-RGB-Led's.
Normalerweise nimmt man da nen Streifen und verbindet alles...alles klar.
Mir aber würd das die Verkabelung deutlich erschweren.
Praktischer wärs, vier einzelne, dreiadrige Stränge ziehen zu können.
Und: weiter hat der NodeMCU nix zu tun, ausser, beim Start nach Firmware-Updates zu suchen- die vier Pins wären also frei.
Der Levelshifter hat sowieso vier Ports, also könnte man das doch machen- ODER?

Falls es wichtig ist: es ist eins der berüchtigten LOLIN-Boards "NodeMCU V3" steht drauf.....
Programmiert wird mit Arduino.

Mit Arduino die Farbe auf die LEDs verteilen geht bequem

Bei 4 einzelnen Strängen kannst du nur keine signifikante "Framerate" erwarten.

Animationen berechnen und darstellen klappte bei mir mit ca. 300 LEDs in einem Strang gerade so flimmerfrei und auch nur einfache Muster

PS: aber nur mit bare-metal (arduino kommt dem am nöchsten, bei Micropython war schon mit einem wandernden Regenbogen bei 150LEDs schluss mit 20FPS)

Es kommen insgesamt nicht mehr als 12 zum Einsatz- höchstens drei pro "Strang".
Auch Animationen müssen nicht, lediglich ein bisschen blinken, alles nix wildes.
Mir ging es mehr darum, ob das mit nem NodeMCU überhaupt geht.

Wenn ich die vier Lampen an _einen_ Strang lege, muss ich die Datenleitung durch das ganze Gebastel schleifen- was in dem Fall eher schlecht geht...

Im Prinzip ist das kein Problem. Es hängt vielmehr davon ab, wie flexibel die Library ist, die du einsetzt. Ws2812 hat ein eigen(willig)es Signaltiming. Wenn die Library beliebige Pins ansteuern kann, geht das ohne Probleme. Wenn du auf bestimmte Pins festgelegt bist und es weniger als vier sind, müsstest du die Ansteuerunng selbst programmieren. Ich vermute aber, dass es eine Library gibt, die flexible Pinzuweisungen erlaubt.

Das nodeMCU hat 4 PWM-Ausgänge (D2, D5, D6 und D8.). Also könntst Du theoretisch vier WS2812 betreiben. Wenn Du die Pins für nichts anderes brauchst. Musst vielleicht auf Besonderheiten beim Startvorgang achten.

Link zum Bild auf mikrocontroller-elektronik.de:
https://www.mikrocontroller-elektron...belegung-1.png


Noch ein Link, wie die WS2812 betrieben werden: https://www.arduino-tutorial.de/viel...teuern-ws2812/

Und was Gnom67 eben sagt...

MfG

@Moppi: Welchen Zusammenhang siehst du zwischen PWM und WS2812?

Werden die nicht per PWM gesteuert?
](*,)
Wenn nicht, war es ein Irrtum vom Amt. - Danke für den Hinweis!



MfG


PS: https://www.mikrocontroller.net/arti...12_Ansteuerung

Nein, die werden digital angesteuert. Jede LED bekommt digitale Werte für R, G, und B gesendet mit einem speziellen Protokoll.
PWM kannst du bei den "langeweile"-Stripes einsetzen, wo alle LEDs in der gleichen Farbe leuchten. Ich denke auch nicht, dass die WS2912-Libraries aus irgendwelchen technischen Gründen auf die PWM-Pins beschränkt sind.
Diese hier ist auf zwei Pins beschränkt, weil sie die seriellen Ports benutzt - davon gibts nur zwei auf dem NodeMCU.
Vielleicht gehts mit der hier - da kann man einen Pin definieren...
Du wirst sicher verschiedene Libraries ausprobieren müssen.

Zitat:

---

Zitat von Moppi

Das nodeMCU hat 4 PWM-Ausgänge (D2, D5, D6 und D8 ).
MfG

---

@moppi: nur zur Richtigstellung:
das ist nicht korrekt, pwm auf NodeMCU geht auf allen Pins D1-D8 (und ggf auch D12):
Bild hier  

https://www.electronicwings.com/node...th-arduino-ide

zu WS2812 Neopixel siehe u.a. hier: https://learn.adafruit.com/adafruit-...ic-connections

mir sind ehrlich gesagt keine WS2812 Libs bekannt, die DMA auf multiplen PWM Kanälen beherrschen

die mir geläufigen sind bitbang mit timer (viel zu lahm), bitbang mit DMA (fadecandy, mein favorit, erscheint mir am sinnvollsten) und ein paar spezielle mit PWM aber davon habe ich nur wenige probiert (weil die meisten erst an das board angepasst werden mussten, außerdem haben die nur ein PWM kanal genutzt)

bin am ende auf einen rpi zero gewechselt um mittels OPC server und usb-netzwerkbrücke die Muster am PC zu generieren und mit ~25FPS auf meine 300 LEDs zu beamen ... später dann mit APA102 auf >100FPS XD ... das WS2812 Protokoll ist einfach murksig, lieber APA102 mit clock Leitung das nächste mal nehemn (APA107 ist der Nachfolger, APA102 bekommt man noch aber die werden nicht mehr offiziell produziert und APA107 findet man kaum)

Zitat:

---

Zitat von Ceos

bin am ende auf einen rpi zero gewechselt um mittels OPC server und usb-netzwerkbrücke die Muster am PC zu generieren und mit ~25FPS auf meine 300 LEDs zu beamen

---

Zitat:

---

Zitat von Rabenauge

Es kommen insgesamt nicht mehr als 12 zum Einsatz- höchstens drei pro "Strang".

---

Zitat:

---

Zitat von Rabenauge

Und: weiter hat der NodeMCU nix zu tun, ausser, beim Start nach Firmware-Updates zu suchen- die vier Pins wären also frei.

---

Und hier hat sich jemand ausgiebig mit dem Timing von WS2812 und Co auseinadergesetzt.

MfG Klebwax

Da in diesem Fall keine gleichzeitige Ansteuerung der vier Stripes nötig ist, die Stripes mit nur drei LEDs sehr kurz und die Schaltfolgen wenig komplex sind, sollte es jede Library tun, mit der du vier verschiedene Pins in wechselnder Folge ansteuern kannst. Wenn du vier lange Stripes "gleichzeitig" mit komplexeren Mustern ansteuern wolltest, wäre das sicher schwieriger und du müsstest die Libraries sorgfältiger unter die Lupe nehmen.

Grundsätzlich erst mal kann der ESP meines Wissens kein Hardware-PWM - das ist alles nur Software-PWM. Letztlich stößt man hinischtlich der Anzahl Kanäle, Frequenz und Auflösung relativ bald an Grenzen. Wie weit PWM hier überhaupt relevant ist, ist ne andere Frage...

@Ceos: Wo ist der Zusammenhang zwischen PWM und WS2812? Der WS wird ja nicht mit PWM angesteuert. Da der ESP sowieso nur SoftPWM kann, erscheint es mir sinnlos, eine Lib auf SoftPWm aufzusetzuen. Die Libs sind, wenn ich das nicht völlig falsch einschätze, doch eher mit Timer-Interrupts programmiert. (Wobei SoftPWM letztlich auch nichts anderes ist als ein Timer Interrupt.) Am Ende läuft das doch eh auf Bitbanging und Timer hinaus, weil es für das Timing des WS2812-Protokolls keine Hardware-Schnittstelle gibt. (Würde mich mal interessieren, wie die eine oben genannte Library die UART-Schnittstelle für den WS-Chip zurechtbiegt...) Ich würde die Begriffe (Hard/Soft)-PWM, Timer und Bitbanging hier jedenfalls nicht so leichtfertig nebeneinander benutzen.

@Klebwax danke für den Hinweis, habe ich in meinem weiter oben ligeenden Post schon erwähnt dass es ihn wohl nicht betrifft es aber trotzdem Einschränkungen gibt, ich wollte hier nur mal einen aus dem Nähkästchen holen um die Grenzen mal zu benennen ... das war einfach nur weiterführend gemeint, falls jemand von 12 LEDs auf 120LEDs hochrüstet und dann hier ein einfaches "Ja geht!" hinein interpretiert

@Gnom67 ich habe einige durchaus funktionierende Implementationen aus (hardware)PWM Ausgängen mit DMA gefunden, bei denen der Timer für jeden bit-Puls per DMA bespielt wird um die nachfolgende Pulsbreite zu variieren für 0 oder 1 ... aber dafür braucht man hohe Basis Taktraten

und zu deiner Frage über UART/SPI habe ich es auch mal selber gebastelt. Du nimmst einfach eine Busfrequenz von 4x800kHz und codierst eine 0 mit binär 0b1000 und eine 1 mit binär 0b1110, bei UART und SPI bekommst du dann einen langen oder kurzen Puls jeweils heraus der gerade so in die Toleranz passt

Zitat:

---

Zitat von Ceos

@Gnom67 ich habe einige durchaus funktionierende Implementationen aus (hardware)PWM Ausgängen mit DMA gefunden, bei denen der Timer für jeden bit-Puls per DMA bespielt wird um die nachfolgende Pulsbreite zu variieren für 0 oder 1 ... aber dafür braucht man hohe Basis Taktraten

und zu deiner Frage über UART/SPI habe ich es auch mal selber gebastelt. Du nimmst einfach eine Busfrequenz von 4x800kHz und codierst eine 0 mit binär 0b1000 und eine 1 mit binär 0b1110, bei UART und SPI bekommst du dann einen langen oder kurzen Puls jeweils heraus der gerade so in die Toleranz passt

---

In der Tat natürlich naheliegend, die Pulsbreite vom PWM machen zu lassen, statt sich ein zweites Timersignal für die zweite Flanke aufzuhalsen. Richtig sinnvoll wird das allerdings erst mit Hardware-PWM. Ein Soft-PWM wird letztlich auch nichts anderes machen, als die Timerabstände entsprechend den duty cycles zu variieren und somit abwechselnd lange Timerzeiten einzustellen.
Mit DMA meinst du sicher, dass die Timergrenzen im Speicher direkt manipuliert werden und nicht über die Funktionen der Library. Das ist wohl auch geboten. Trotzdem wäre es meiner Meinung nach performanter, die Timer gleich in der WS-Lib zu programmieren, als auf eine Soft-PWM-Lib aufzusetzen. Sicher gibts auch verschiedene Libs die es mal so oder mal so machen... Wäre sicher interessant, welche die beste Performance hat.

UART hab ich mir auch genau so vorgestellt, wie du es beschreibst. Etwas rückwärts durch die Brust ins Auge..., aber immerhin nimmt einem dann die Hardware die Arbeit ab - aber wenn nur zwei Pins alternativ zuweisbar sind, ist das hier leider keine Lösung.

nein nein, soft pwm habe ich nie gemeint :) da musst du mich falsch verstanden haben XD

bitbagn mit DMA war hier auf eine etwas kuriose ausnutzung des DMA bezogen, ich glaube dabei wurde die UART und der DMA mit 2 konfigurationen missbraucht und abhängig von dem nächsten bit der eine oder andere wert geladen um das passende bit zu produzieren, aber das ist länger her XD ich bin ein APA jünger geworden :P

Für was steht denn DMA? Da denk ich an direct memory access?
Und was anderes als SoftPWM kann der ESP nicht. Auf was beziehst du dich also?

Zitat:

---

Zitat von Gnom67

In der Tat natürlich naheliegend, die Pulsbreite vom PWM machen zu lassen, statt sich ein zweites Timersignal für die zweite Flanke aufzuhalsen.

---

Hier geht es um Zeiten von 350ns für ein 0-Bit bzw. 700ns für ein 1-Bit. Da geht auf den üblichen µC mit Timern gar nichts. Auch die üblichen HW-PWMs kriegen einen 800kHz PWM-Takt nicht hin. Auf einem PIC16 mit 8MHz Befehlstakt hab ich das so gelöst:

Code:

---

#define NEOPIX LATCbits.LATC4

void SetPIX(uint8_t red, uint8_t green, uint8_t blue) {
    uint8_t colorbit;
    for (colorbit = 8; colorbit; colorbit--) {
        if (green & 0x80) {
            NEOPIX = 1;
            NEOPIX = 1;
            NEOPIX = 1;
            NEOPIX = 1;
        } else {
            NEOPIX = 1;
            NEOPIX = 1;
            NEOPIX = 0;  // !
            NEOPIX = 0;  // !
        }
        NEOPIX = 0;
        green <<= 1;
    }
    for (colorbit = 8; colorbit; colorbit--) {
        if (red & 0x80) {
            NEOPIX = 1;
            NEOPIX = 1;
            NEOPIX = 1;
            NEOPIX = 1;
        } else {
            NEOPIX = 1;
            NEOPIX = 1;
            NEOPIX = 0;
            NEOPIX = 0;
        }
        NEOPIX = 0;
        red <<= 1;
    }
    for (colorbit = 8; colorbit; colorbit--) {
        if (blue & 0x80) {
            NEOPIX = 1;
            NEOPIX = 1;
            NEOPIX = 1;
            NEOPIX = 1;
        } else {
            NEOPIX = 1;
            NEOPIX = 1;
            NEOPIX = 0;
            NEOPIX = 0;
        }
        NEOPIX = 0;
        blue <<= 1;
    }
}

---

Ich bin hier davon ausgegangen, daß, wie im Link oben gesagt, die Low-Zeit des Signals nicht so wichtig ist. Bisher hat das auch mit allen meinen WS geklappt. Das Ganze muß mit gesperrten Interrupten laufen. Entsprechendes sollte man auf jedem µC hinkriegen. Für viele Pixel mit hoher Framerate taugt das natürlich nicht, aber 4 mal für drei Pixel wird das kein Problem sein.

MfG Klebwax

Was spräche denn dagegen, mit "Adafruit_NeoPixel" mehrere Instanzen zu erstellen. Jede mit ihrem eigenen Pin?

(Leider kann ich das nicht ausprobieren.)

MfG

Das stimmt natürlich - bei 8 MHz ist ja ein einziger Zählschritt schon 125 ns lang - da gibts nicht viel zu PWMen... umso weniger versteh ich, warum hier dauernd von PWM die Rede ist.

Die Port-Bits direkt im Prozessortakt mit Befehlen anzusprechen, ist natürlich schneller.
Beim WS2812B ist die Zykluszeit 1250 ns (900 ns high + 350 ns low für 1 und 350 ns high + 900 ns low für 0) - das entspräche 10 Prozessortakten. In deinem Code hätte ich jetzt jeweils 10 Befehle erwartet, die das Portbit auf 1,1,1,1,1,1,1,0,0,0 oder 1,1,1,0,0,0,0,0,0,0 setzen. Stattdessen seh ich nur 1,1,1,1 und 1,1,0,0.
Wird der Pin für die restliche Zeit, die durch Schleifen und Bedingungen verbraucht wird auf 0 gehalten?

Etwas mehr zeit hat man ja - laut Datenblatt bis zu 50 µs Low-Time, bevor ein Reset ausgelöst wird. In meinem Link oben hat das jemand getestet und bekam den Reset bei knapp 9 µs. Na, immerhin sind das ja einige Taktzyklen.

Wie machen das denn die Libraries? Wenn die alle mit solchem Bitgeschubse arbeiten, kann das eigentlich mit einem µC nicht wirklich sauber laufen, oder?

- - - Aktualisiert - - -

Zitat:

---

Zitat von Moppi

Was spräche denn dagegen, mit "Adafruit_NeoPixel" mehrere Instanzen zu erstellen. Jede mit ihrem eigenen Pin?
MfG

---

Das würd ich auch probieren. Undfalls sie sich in die Quere kommen, kann man sie ja auch immer wieder löschen und für den gewünschten Pin neu erstellen...

Zitat:

---

Zitat von Gnom67

Die Port-Bits direkt im Prozessortakt mit Befehlen anzusprechen, ist natürlich schneller.
Beim WS2812B ist die Zykluszeit 1250 ns (900 ns high + 350 ns low für 1 und 350 ns high + 900 ns low für 0) - das entspräche 10 Prozessortakten. In deinem Code hätte ich jetzt jeweils 10 Befehle erwartet, die das Portbit auf 1,1,1,1,1,1,1,0,0,0 oder 1,1,1,0,0,0,0,0,0,0 setzen. Stattdessen seh ich nur 1,1,1,1 und 1,1,0,0.
Wird der Pin für die restliche Zeit, die durch Schleifen und Bedingungen verbraucht wird auf 0 gehalten?

---

Lies erstmal das hier: Neopixel Timing. Und der Code ist aus einem Projekt von mir kopiert, er funktioniert.

Statt 1-1-0-0 und einem 0 am Ende hätte ich auch 1-NOP-0-NOP- NOP schreiben können. Dauert genausolange. Ich fand aber so ist es übersichtlicher. Mit dem Timing, der Anzahl der Takte habe ich mit dem LA und dem Neopixel rumgespielt. Mit drei Takten High für eine Null gehts auch noch, mit nur einem nicht. Hab mich als Kompromiss für 2 entschieden. Die Low-Zeit ist nach Datenblatt zu lang (Shift und Loop), wie im Link beschrieben passt das aber. Und natürlich bleibt ein Portbit so stehen, wie es war.

Zitat:

---

Wie machen das denn die Libraries? Wenn die alle mit solchem Bitgeschubse arbeiten, kann das eigentlich mit einem µC nicht wirklich sauber laufen, oder?

---

Der Code in meinem Link macht das ähnlich. Der benutzt ein Macro fürs Timing, der am Ende auch nichts anderes macht, als NOPs einzufügen. Und der Code sieht auch nicht viel anders aus, wenn man I2C, SPI oder Uart mit Bitbanging macht. Alles was schneller als 20-30µs ist, ist für einen Interrupt auf den 8-Bittern zu schnell. Und selbstverständlich kann das so sauber laufen. Code ist deterministisch.

MfG Klebwax

@Moppi: so ungefähr war das auch gedacht, hehe.

Die Frage zielte eher dahin, ob ein NodeMCU dafür überhaupt geeignet ist, ich hab bisher _einen_ von den Dingern im Einsatz (und somit nicht viel Erfahrung damit).
Der zweite, der hier verwendet werden sollte, ist leider Schrott: da haben die freundlichen Chinesen schlichtweg eine der beiden Schottky-Dioden vergessen, somit kann ich den nich programmieren- sonst hätte ich das inzwischen probiert *grummel

Doch, dass sollte mit einem nodeMCU funktionieren.
Aber mal so, warum nochmal 4 einzelne LED-Streifen ansteuern?

Was ist, wenn man Einen viertelt, die miteinander per Drähte verbindet und nur als eins ansteuert?

Zitat:

---

Praktischer wärs, vier einzelne, dreiadrige Stränge ziehen zu können.

---

Nochmal drüber nachdenken.

Da der NodeMCU mit 80 Mhz wesentlich schneller ist, als ein Arduino, sollte das überhaupt kein Problem sein. Mehr Speicher hat er auch...
Für die Paar LEDs, die du ansteuern willst, reichts allemale.

Zitat:

---

Doch, dass sollte mit einem nodeMCU funktionieren.
Aber mal so, warum nochmal 4 einzelne LED-Streifen ansteuern?

Was ist, wenn man Einen viertelt, die miteinander per Drähte verbindet und nur als eins ansteuert?

---

wurde eingangs doch erklärt, sehr lange Leitungen weil die 4 "Lampen" an unterschiedlcihen Stellen verbaut wurden

und wenn die Leitung zu lang wird schleichen sich Signalfehler ein

wollte mal 2 Streifen gegenüber im Zimmer installieren, habe also Band aufgetrennt und Leitungen dazwischen gelötet, Ergebnis war, der 2te Streifen bekam immer wieder falsche Farben oder die LEDs leuchteten nicht alle
Vielleicht könnte man da was mit Signalaufbereitung retten oder besser geschirmtes Kabel oder oder oder ...

ggf. einfach probieren und messen, wäre zumindest mal den Versuch wert, sind dann ja nur 4 Leitungen pro Lampe +, -, DI, DO (am besten GND als Abschirmung zwischen DI und DO legen)

Zitat:

---

Zitat von Gnom67

Da der NodeMCU mit 80 Mhz wesentlich schneller ist, als ein Arduino, sollte das überhaupt kein Problem sein. Mehr Speicher hat er auch...
Für die Paar LEDs, die du ansteuern willst, reichts allemale.

---

Ein Problem mit dem nodeMCU kann sein, dass er einen eingebauten Scheduler hat, mit dem er immer automatisch zwischendurch zum WiFi-Controller umschaltet und dadurch den Sketch-Code verlässt: das kann zu timing Problemen führen, insb. für verschiedene Datenbusse, bei denen es auf timing ankommt.
Ich wäre also vorsichtig, grundsätzlich einen Arduino-Code unbesehen für den nodeMCU als "lauffähig" zu deklarieren, wenn man es nicht überprüft hat, und wenn es auch im Fall dieses Neopixel-Problems nicht unbedingt auftreten muss.

dem OP würde ich also empfehlen, erst einmal die Standard-Libs mit Standard-Verkabelung auf dem nodeMCU zu testen, und erst dann, wenn es sicher funktioniert, andere Verkabelungs- und Pinvarianten zu probieren.

So weit ich gesehen habe, existieren für ESP8266 extra Bibliotheken.


MfG

Da jeder WS2811-Chip das Signal aufbereitet, dürfte es eigentlich nur dann problematisch werden, wenn die Kabel von Ort zu Ort länger sind als die von µC zu den einzelnen Orten. Notfalls könnte man "auf halber Strecke" eine WS2812 dazwischenklemmen, die das Signal dann erneut aufbereitet. Die muss man dann halt immer auf 0x000000 schalten.
Allerdings muss auch die Spannungsversorgung garantiert sein. Bei sehr langen Leitungen wirds da irgendwann eng und man braucht zusätzliche Leitungen, evtl. mit höherer Spannung und Stepdowns...

Zitat:

---

So weit ich gesehen habe, existieren für ESP8266 extra Bibliotheken.

---

habe ich auch bereits erwähnt aber die scheitern meist an der Hürde 4 einzelner Kanäle da sie auf die Hardware Peripherie optimiert sind

Machts nicht so kompliziert. ;)

Das _würde_ auch mit nem Arduino problemlos gehen (bei denen weiss ich sogar, dass es funktionieren würde, hab ich es auch schon gemacht)- mir ging es _einzig_ um die Frage, ob die NodeMCU das pinmässig gebacken kriegen.

Und damit sich niemand Sorgen macht von wegen Timing, Kabellängen, Mondphasen:
Es wird ein Wägelchen. Keine der LED's wird weiter vom Controller entfernt sein, als 30cm- aber der Wagen hat zwei Front-und zwei Rückleuchten.
Da alles mit dem 3D-Drucker gemacht ist, hatte ich so schon gewisse Probleme, wo ich die Strippen unterbringe- und _nur_ darum will ich die nicht einfach auseinanderschneiden, und dann mit Kabeln zwischen "verlängern (kann man tun, hab ich anderswo auch gemacht, wasn Gefrickel wenn alles eingebaut wird).
Häng ich nun jede der vier Lampen (die dann aus zwei, oder drei LED's samt Controllern bestehen wird) sternförmig an den NodeMCU, ist das schlichtweg viel einfacher zu verkabeln, als wenn ich die Signal-Leitung da um den Ring legen müsste.
_Darum_ so.
Und darum werden das auch nich mehr LED's: erfahrungsgemäss produzieren die 5050 in RGB ganz gut Wärme- bei zu vielen wird zumindest PLA wieder weich, hehe...und die Lampengläser sind aus PLA, weil ich kein wirklich durchsichtiges PETG hab (der Rest ist allerdings schon PETG).
Ausserdem kommen billige Powerbänke (hab ich zwei, muss reichen) als Stromversorgung zum Einsatz- die würden mehr solcher LED's nich lange stemmen (angegeben mit 2400mAh, aber bloss eine Zelle drin, also kommt da wohl weniger als 2Ah raus bei 5V).

Von daher: alles halb so wild....

Trotzdem danke, auch für die längeren Erklärungen, die sind auch hilfreich (weniger für meine Bastelei, allgemein aber schon!).

Falls es mit dem nodeMCU nicht so funktioniert, nimmst Du eben einfach einen 328P plus die zwei Kondensatoren mit Quarz (oder was kleineres), hängst die LED-Strippen dran und legst, neben Masse, eine Verbindung vom nodeMCU zum ATmega, dort schickst Du die Daten rüber, der ATmega nimmt sie an und steuert die LEDs - fertig.

Nööö- dafür ist kein Platz in der Elektronik-Bay.
Ausserdem dauert es zu lange, das _vernünftig_ (robust, wetterfest, das Wägelchen wird im Freien zum Einsatz kommen und ggf. auch Feldwege lang müssen) aufzubauen.
Schlimmstenfalls gibts Plan B: eben die Signalleitung doch durchschleifen.
Das geht- gefällt mir aber nicht.