LoRa-basierte LED-Lichtsteuerung: direkte Sicht nicht erforderlich

In einer Zeit, in der Energieeffizienz und individuelle Wohnumgebungen immer wichtiger werden, hat die herkömmliche Beleuchtungssteuerung mit Infrarotlicht erhebliche Einschränkungen, darunter die Notwendigkeit einer Sichtverbindung und die Anfälligkeit für Störungen. Dieser Beitrag geht diese Herausforderungen mit einer innovativen LoRa-basierten LED-Lichtsteuerung an.
 LEDs sind effizienter als herkömmliche Lampen. Daher haben wir ein System entwickelt, mit dem wir die Lichtintensität von LEDs innerhalb der Herstellerspezifikationen variieren können, ohne ihre Effizienz zu verringern. Die Bedienung könnte mit einem Potentiometer realisiert werden, aber wir fanden eine Fernbedienung praktischer. Eine Möglichkeit war die Verwendung einer IR-Fernbedienung, aber – wie im Teaser erwähnt – funktioniert diese nur bei direkter Sicht. Deshalb haben wir uns für die LoRa (Long Range)-Technologie entschieden, die sowohl beim Senden als auch beim Empfangen diese Einschränkung überwindet. LoRa funktioniert unter allen Bedingungen, in der Nähe, in der Ferne und bei baulichen Barrieren.
 Es handelt sich um eine drahtlose Punkt-zu-Punkt-Kommunikationstechnologie, die in Europa das freie Frequenzband bei 868 MHz nutzt. Es gibt mehrere 868 MHz-LoRa-Transceivermodulen auf dem Markt, die wir für unsere Zwecke verwenden könnten. Aufgrund des Preises, der einfachen Bedienung und der geringen Größe haben wir uns für das Breakout-Board RFM95W entschieden. Um die Lichtintensität zu variieren, ohne die Spezifikationen der LEDs zu verletzen, haben wir die Pulsbreitenmodulation (PWM) gewählt.

RTX-Blockdiagramm

Bild 1 zeigt das Blockdiagramm des TX- und RX-Teils des Projekts. Da es sich bei dem Sender um eine Fernsteuerung handelt, muss dieser zwangsläufig mit einer Batterie (BT1) betrieben werden. Hierfür verwenden wir eine wiederaufladbare Lithiumzelle (ICR14500). Die Spannung einer Lithium-Akku kann von 3 V (leer) bis 4,2 V (geladen) betragen. Die Versorgungsspannung des LoRa-Moduls (U3) liegt zwischen 1,8 V und 3,7 V. Ein 3,3 V Spannungsregler (U2) sorgt für die richtige Spannung auch während des Aufladens des Akkus. Das LoRa-Modul wird von einem ATmega328-Mikrocontroller (U1) gesteuert. Ein OLED-Display zeigt den Prozentsatz der LED-Lichtintensität an. Die Intensität wird durch Drücken einer der beiden Mini-Tasten S1 und S2 erhöht oder verringert.

Die Versorgungsspannung des Empfängers am Eingang J2 sollte zwischen 9...12 V liegen. Die Spannungsregler U3 (5 V) und U4 (3,3 V) liefern die Spannungen für das PWM-Modul bzw. das LoRa-Modul (U2). Der 3,3 V-Regler versorgt auch den ATmega328-Mikrocontroller. Dieser steuert das LoRa-Modul und liefert das PWM-Signal.
 Die Daten, die wir vom Sender erhalten – sie bestimmen die Lichtintensität der LEDs – werden in einem EEPROM-Speicher (IC1) abgelegt. So ist die Intensität der LEDs beim Einschalten die gleiche wie beim Ausschalten. Da der Strom durch die LEDs etwa 80 mA beträgt, kann der Mikrocontroller die LEDs nicht direkt ansteuern. Die Blöcke PWM und IC2 bilden eine Treiberschaltung.

Sender

Der Sender – dessen Prototyp in Bild 2 dargestellt ist – wird von einem 3,6 V, 800 mAh Akku (BT1) gespeist. Dieser kann über den Micro-USB-Anschluss J1 aufgeladen werden, der an ein handelsübliches USB-Ladegerät angeschlossen werden kann – siehe das Schaltbild in Bild 3. Die LED LD1 zeigt in Verbindung mit dem Aufleuchten von LD3 an, dass der Sender mit Strom versorgt wird und dass der Akku geladen wird. Wenn der Akku geladen ist, erlischt LD3.

Der Ladestrom, der durch den Wert von R2 bestimmt wird, wird von U2 gesteuert. Anhand der Formel im Datenblatt (IREG = 1000V/RPROG) können wir mit dem Wert von R2 den Ladestrom bestimmen, der normalerweise etwa ein Zehntel der Batteriekapazität beträgt. Der Spannungsregler IC1 liefert 3,3 V für den Mikrocontroller (U1), das OLED-Display und das RFM95W-Modul.

Das 0,91" große OLED-Display mit einer Auflösung von 128 × 32 Pixeln zeigt die gesendete Einstellung. Die Anzeige ist in zwei Zeilen unterteilt: Die obere Zeile zeigt einen Lichtbalken, dessen Länge proportional zur Lichtintensität ist. Die zweite Zeile zeigt den Prozentsatz mit Power daneben an. 0 % entspricht der minimalen, 100 % der maximalen Lichtintensität (Bild 4).

Die Programmierung der LoRa-Kommunikation und des 0,91“ OLED Displays für den ATmega328-Mikrocontroller wurde in der Arduino-Entwicklungsumgebung (IDE) mithilfe dessen Bibliotheken getan. Für die Kompilierung und Programmierung haben wir jedoch die Microchip Studio IDE bevorzugt. Das PICkit4-Programmiergerät von Microchip haben wir zum Laden der Firmware verwendet. Der SPI-Port wird sowohl für die Programmierung mit dem PICKit4 als auch für die Steuerung des LoRa-Moduls verwendet. Mit dem Dip-Schalter SW2 zwischen Mikrocontroller und Lora-Modul unterbrechen wir die SPI-Busverbindung zum LoRa-Modul während der Programmierung. Auf diese Weise vermeiden wir mögliche Fehlfunktionen
 Die Tasten S1 und S2 dienen zum Erhöhen (S1) oder Verringern (S2) der PWM-Modulation, die wir der Einfachheit halber Power nennen. Dies führt zum Senden der Daten, die es dem Empfänger ermöglichen, die Lichtintensität der LEDs zu ändern. Die Antenne AE1 kann recht einfach sein, wenn man in Innenräumen arbeitet. Sie sollte auf 868 MHz abgestimmt sein. Ein Stück Kupferdraht mit einer Länge von etwa 8,6 cm – oder ¼ der Wellenlänge, 34,56 cm/4 - ist ausreichend.
 LD2 zeigt an, wenn der Akku fast leer ist (3,35 V). Wir messen den Spannungswert über die Widerstände R4 und R5, die an den PC2-Eingang des Mikrocontrollers angeschlossen sind. Um den Akku so wenig wie möglich zu belasten, lassen wir die Anzeige nach jeder Änderung der Lichtintensität nur während einer kurzen Zeit aufleuchten. 26 Sekunden erwiesen sich als eine gute Zeitspanne, um die Informationen dem Benutzer zu übermitteln. Nach Ablauf dieser Zeit wird die Stromversorgung des Displays mit Q2 unterbrochen. Das LoRa-Modul bietet die Funktion sleep. Mit dieser Funktion können wir den Stromverbrauch des Moduls minimieren. Mit den beiden genannten Funktionen sinkt der Gesamtstromverbrauch von etwa 15 mA auf etwa 3 mA.
 Mit S1 kann man nicht nur die Lichtintensität erhöhen, sondern auch das OLED-Display und das LoRa-Modul aus dem Ruhezustand aktivieren. Ein kurzer Druck genügt.

Empfänger

Die Programmierung des ATmega328-Mikrocontrollers (U1) sowie die Funktion der DIP-Schalter SW1 (siehe Schaltbild in Bild 5) ist die gleiche wie beim Sender. Da die PWM-Modulation die beste Methode zur Steuerung der LED-Lichtintensität ist, wurden diese mit den folgenden Werten entworfen:
 

• PWM-Frequenz 120 Hz
• Maximaler LED-Strom 1,3 A
• Eingangsspannung 9...12 V

 

Wie das Schaltbild zeigt, besteht die Stromversorgung aus drei Teilen: Zunächst wird der Eingangsstrom über J2 zugeführt. Die 9 V Spannung wird für die an J3 angeschlossenen LEDs benötigt. Der maximale Strom, den wir liefern können, beträgt 1,3 A. Damit können wir, je nach Stromstärke der verwendeten LEDs (80 mA), bis zu sechzehn LEDs parallel schalten. Der zweite Teil mit dem Spannungsregler U3 liefert 5 V für den PWM-Treiber, bestehend aus Q2, Q3, Q4 usw. Regler U4 schließlich liefert 3,3 V an U1, U2 und IC1. Das EEPROM (IC1) speichert den zuletzt empfangenen Intensitätswert. Wenn der Empfänger eingeschaltet wird, wird der gespeicherte Wert abgerufen und geladen, somit die gleiche Lichtintensität wie vor dem Ausschalten eingestellt werden kann.
Das PWM-Signal wird vom ATmega328-Mikrocontroller (U1) unter Verwendung seines internen TIMER 0 erzeugt. Am Ausgang von Pin PD5 finden wir eine Blockspannung mit einer Frequenz von 120 Hz bei 3,3 V. Wie wir oben gesehen haben, können wir die LEDs nicht direkt über den PD5-Ausgang des Mikrocontrollers ansteuern, sondern benötigen einen Treiber, der den hohen Strom zu den LEDs steuern und die Frequenz der PWM-Modulation stabil halten kann. Bild 6 zeigt den Prototyp des Empfängers.

Mit den Bauteilen Q1, Q2, Q3 und Q4 steuern wir die LEDs mit einer stabilen Frequenz ohne unerwünschte Spitzen an (siehe Bild 7), die der MOSFET (Q4) und der Strombegrenzer, bestehend aus IC2, eventuell erzeugen. Der maximale LED-Strom wird durch die beiden Widerstände R3 und R4 bestimmt. Wir schalten zwei Widerstände parallel, da niedrige Werte von SMD-Widerständen mit Leistungen über 2 W schwer zu bekommen sind. Besondere Aufmerksamkeit sollte dem Strombegrenzer IC2 (ein LM338 von Texas Instruments) gewidmet werden, der mit einem Kühlkörper ausgestattet ist, um die Verlustleistung über seinen Höchstwert (1 W) hinaus abzuführen. Da der Eingangsspannungsbereich 9...12 V betragen kann, ergibt sich im ungünstigsten Fall eine Verlustleistung von 8,6 W, sodass die Verwendung eines Kühlkörpers unumgänglich ist. Um die maximale Betriebstemperatur der Sperrschicht von IC2 (T_j) unter 125 °C zu halten, ist es notwendig, einen Kühlkörper mit einem Wert von mindestens 6 °C/W oder weniger zu verwenden (je niedriger der Wert, desto besser die Wärmeableitung).

Microchip Studio IDE

Wie bereits erwähnt, wurden die Programme für den LoRaSender und den LoRaReceiver mit der Arduino IDE entwickelt, aber für die Programmierung haben wir die Microchip Studio IDE verwendet. Die Arbeit mit Microchip Studio ist wie die Arbeit in der Arduino-Entwicklungsumgebung. Für die Programmierung der Mikrocontroller Senders und des Empfängers könnten wir das Arduino UNO-Board verwenden, wie es in der Anleitung beschrieben wird, was für uns jedoch aufgrund der TQFP-Gehäuse der Mikrocontroller auf dem Board unpraktisch ist.

Viel praktischer ist es, einen Programmierer zu verwenden, wie z. B.:

• ATMEL-ICE(AVR) – funktional, aber ziemlich teuer. Es kann direkt in der Arduino-IDE verwendet werden, aber nur mit AVR-Mikrocontrollern.
• PICkit4 - Programmiergerät von Microchip. Dieser ist viel billiger und, was noch wichtiger ist, vielseitiger.

Mit dem PICkit4-Programmiergerät können wir mit Microchip Studio eine Vielzahl von Mikrocontrollern aus der Microchip-Familie und mit AVR- und SAM-Architekturen programmieren.
 Zunächst installieren wir nun die Microchip Studio Software, die auf der Microchip Website https://tinyurl.com/547afpdn zu finden ist. Öffnen Sie diese, um die mit der Arduino IDE erstellte Software zu laden. Beim Starten gelangt man auf die Startseite (Bild 8), klickt auf New project und das Fenster erscheint wie in Bild 9 dargestellt. Klicken Sie auf Create project from Arduino sketch und es erscheinen einige Felder, die Sie ausfüllen müssen:
 

• Name: Geben Sie den Titel der zu erstellenden Datei ein (LoRaSender oder LoRaReceiver). Das Feld Solution name wird automatisch mit demselben Titel ausgefüllt.
• Location: ist die Adresse, unter der die Datei gespeichert werden soll
• Solution: Lassen Sie dieses Feld unverändert, da es sich um eine neue Datei handelt.
   

 

Klicken Sie auf OK, um fortzufahren. Das nächste Fenster, das erscheint, ist in Bild 10 dargestellt. Füllen Sie wieder die Felder wie folgt aus:

• Sketch-File: Klicken Sie auf das Symbol mit den drei Punkten, um den Ordner zu öffnen, in dem die Sketch-Datei gespeichert ist, die wir mit der Arduino IDE erstellt haben. Die ausgewählte Datei wird für die Erstellung unseres Programms in der Microchip Studio IDE verwendet.
• Arduino IDE Path: Dies ist der Ort, an dem sich die Arduino-Software befindet.
• Board: Obwohl es keine Rolle spielt, haben wir uns für das Arduino UNO Board entschieden.
• Device: Natürlich wählen wir hier den ATmega328.

 

Wenn Sie auf OK klicken, wird die Arduino-Sketch-Datei in die Microchip Studio IDE importiert. Wie bereits erwähnt, verfügt die Microchip Studio-Umgebung über die gleichen Funktionen wie die Arduino-IDE, jedoch mit mehr Besonderheiten, die zu weiteren Untersuchungen einladen, wenn wir die Funktionalität der in der neuen Entwicklungsumgebung gespeicherten Sketch-Datei überprüft haben.
 Damit unser Sketch funktioniert, fehlt noch ein letzter Schritt: Wir müssen die erforderlichen Bibliotheken laden. Klicken Sie dazu mit der rechten Maustaste auf das rot markierte Fenster (siehe Bild 11); es erscheint ein Dropdown-Menü, in dem Sie die Option Include Arduino-library finden. Wählen Sie diese aus und wählen Sie aus der Liste die für unser Projekt benötigten Bibliotheken.

Für den LoRaSender sind die folgenden Bibliotheken auszuwählen:

• Wire.h
• SPI.h
• Adafruit_GFX.h
• Adafruit_Sensor.h
• Adafruit_SSD1306.h
• LoRa.h

Und für den LoRaReceiver:

• Wire.h>
• SPI.h>
• LoRa.h>

Hinweis: Um die Bibliotheken in der obigen Liste zu sehen, müssen sie über die Bibliotheksladefunktion in der Arduino-IDE installiert werden. An diesem Punkt haben wir alles getan, um den Sketch in unseren ATmega328-Mikrocontroller zu laden. Um die Firmware zu laden, verwenden wir das PICkit4-Programmiergerät.

Laden der Firmware

Auf den beiden Platinen befindet sich ein 6-poliger Anschluss (J2 für den Sender und J1 für den Empfänger), den wir mit dem PICkit4-Programmiergerät verwenden, um die Firmware in den Mikrocontroller zu laden, indem wir ihn wie in Bild 12 gezeigt anschließen.

Der Dip-Schalter SW2 auf der Senderplatine und der Dip-Schalter SW1 auf der Empfängerplatine sollten ausgeschaltet sein. Nachdem wir das PICkit4 an die Platine angeschlossen haben, wählen wir den Mikrocontrollertyp aus, indem wir auf das Symbol in der Symbolleiste klicken, das durch den rot eingekreisten Mikrocontrollertyp dargestellt wird (Bild 13). Es öffnet sich eine Seite, auf der wir den Typ des verwendeten Mikrocontrollers auswählen.
Falls dieser noch nicht ausgewählt ist, klicken Sie auf das grün eingekreiste Symbol Change Device. Nun öffnet sich ein Dropdown-Menü mit einer Reihe von Mikrocontrollern, die von Microchip Studio unterstützt werden; wählen Sie ATmega328 und klicken Sie auf OK. Auf der gleichen Seite befindet sich eine Liste der unterstützten Programmiergeräte (siehe die lila eingekreiste Liste), die Supported Tools genannt wird. Klicken Sie auf das Programmiergerät, das Sie haben, und Sie werden auf die entsprechende Webseite weitergeleitet, auf der Sie weitere Details und Dokumentation über das Gerät finden können.
Schließen Sie das Programmiergerät über den USB-Anschluss an und wählen Sie es, wenn es richtig erkannt wird, durch Anklicken des gelb eingekreisten Symbols aus (zuvor über das Hammersymbol geöffnet). Jetzt haben wir die Tools ausgewählt, die wir zum Laden unserer Firmware benötigen. Klicken Sie nun auf das Symbol mit dem grünen Pfeil (blau eingekreist). Wenn alles korrekt ist, beginnt das Herunterladen der Firmware auf den Mikrocontroller. Nach dem Herunterladen sollte im unteren Ausgabefenster Build succeeded stehen. Das bedeutet, dass der Download erfolgreich war.

LoRaSender Sketch

Bevor wir den Sketch analysieren, der von der Elektor Labs Seite für diesen Artikel heruntergeladen werden kann, müssen wir eine kleine Klarstellung vornehmen: eine Variable namens power taucht im Sketch auf, die nichts anderes ist als der Wert, die gesendet wird, um die Pulsweitenmodulation (PWM) einzustellen, die die LED-Lichtintensität bestimmt.
 Der Setup-Teil des LoRaSender-Sketchs wird nicht besprochen, da es bereits eine kurze Erklärung neben den Funktionen gibt; außerdem sind einige Funktionen Teil der zugehörigen Bibliothek, wie z. B. die Programmierung des OLED SSD1306 Displays (Adafruit_GFX.h, Adafruit_Sensor.h und Adafruit_SSD1306.h) und das Senden von LoRa-Paketen (LoRa.h).
 Wie erwähnt, haben wir eine Zeitdauer von 26 s, in der das Display eingeschaltet bleibt. Um diese Zeit zu erreichen, verwenden wir den 16-Bit-TIMER 1 im Atmega328-Mikrocontroller. Wenn der Überlaufwert des TIMERs erreicht ist, wird die ISR-Routine TIMER1_OVF_Vector aufgerufen. Innerhalb der Routine wird das Display erst ausgeschaltet und das LoRa-Modul erst dann in den Schlafmodus versetzt, wenn eine Anzahl von 50 Überläufe (definiert durch die count-Variable) erreicht ist.
 Die wake_up-Prozedur wird in dem Moment aufgerufen, in dem S1 gedrückt und losgelassen wird, wodurch das Display wieder eingeschaltet und das LoRa-Modul aufgeweckt wird (Listing 1).

S1 und S2 steuern die Erhöhung oder Verringerung von power. Die Befehle:

LoRa.beginPacket();

LoRa.print("A");

LoRa.print(power);

LoRa.endPacket();

senden die power-Daten, um sie im Empfänger in Lichtintensität umzuwandeln. Der Buchstabe A, der den power-Daten vorangestellt ist, dient dem Empfänger als Zeichen, dass eine Meldung beginnt, sodass eventuelle Störungen ignoriert werden können.

Die Berechnung des Anstiegs oder Rückgangs des Balkens, der den Prozentsatz der Leistungsvariablen anzeigt, erfolgt wie folgt:

power--;

pct = power / 1.28;

v_pct = pct;

 

Um den Balken und seinen prozentualen Wert zu erhöhen, müssen wir die Variable power subtrahieren, anstatt sie zu addieren. Dies ist eine Folge der Funktion, die die Länge und Höhe des Balkens steuert und die lautet: display.fillRect(0, 0, display.width()-counter, display.height()/8, INVERSE). Die Anzeigematrix hat 128 × 32 Pixel. Die Länge des Balkens wird also durch display.width()-counter und die Höhe durch display.height()/8 bestimmt. Die Länge wird also durch Subtraktion des Wertes 128 bestimmt, während die Höhe des Balkens durch den Wert 32 geteilt durch 8, also 4 Pixel, bestimmt wird. Der letzte Punkt betrifft den Wert der power-Variable, ausgedrückt als Prozentsatz: Damit die 128 Pixel, die der Breite der Anzeige entsprechen, den Wert 100 % erreichen, müssen wir sie durch 1,28 teilen. Deshalb erhalten wir zunächst einen Float-Wert (pct, Prozent) und runden ihn auf einen Integer-Wert (v_pct, Prozentwert) ab. Der Teil, in dem es geht, um den Wert des Balkens zu verringern, ist derselbe wie bei der Funktion, die wir gerade gesehen haben, nur dass wir statt die Variable power zu dekrementieren (power--) diese inkrementieren (power++).

LoRaReceiver Sketch

Der Code des Empfängers ist einfach und kurz, aber um seine Bedeutung besser zu verstehen, haben wir ihn in vier Makrobereiche unterteilt. Nach dem Einschalten lesen wir die zuletzt empfangenen PWM-Daten, die im EEPROM-IC gespeichert sind, sodass die LEDs mit der gleichen Intensität leuchten wie beim Ausschalten. Auch hier heißt die Variable, die die PWM-Modulationsdaten bestimmt, power. Entscheidend ist der Teil:

TCCR0A = 0b000000;

TCCR0B = 0b000000;

TCCR0A = 0b10000011;

TCCR0B = 0b00000100;

OCR0A = 0;

 

weil sie bestimmt, wie TIMER 0 zur Steuerung der PWM-Modulation arbeiten soll. Die PWM-Daten werden in der Variablen OCR0A gespeichert, die die Dauer bestimmt, wie lange das PWM-Signal hoch und niedrig ist. Um unkontrollierbare Spitzen in der LED-Lichtintensität zu vermeiden, haben wir eine kleine Routine eingeführt, die nur ausgeführt wird, wenn der Empfänger eingeschaltet wird:

 

if (cnt == 0){

    Wire.beginTransmission(0x50);

    Wire.write(0x00);

    Wire.write(OCR0A = power);

    Wire.endTransmission();

    cnt++;

}

 

In Listing 2 finden wir den Abschnitt zum Empfang des LoRa-Pakets, das den Wert des Variablen power bestimmt.

Da der Wert der Variable power von 0 bis 127 reicht, haben wir einen Multiplikator von 1,71 (fatt = 1,71 variable) eingeführt, um einen größeren Wert der Variablen OCR0A mit einem Maximum von 255 zu erhalten. Dadurch erhalten wir eine PWM-Modulation mit einer minimalen, durchschnittlichen und maximalen Wellenform, wie in Bild 14 dargestellt. Da das LoRa-Modul die power-Daten ständig aktualisiert, haben wir eine while-Schleife eingeführt, um die Anzahl der Datenspeicherungen im EEPROM zu minimieren. In diesem Fall werden die variablen Daten nur gespeichert, wenn sie sich von den vorherigen unterscheiden, wodurch die Anzahl der Schreib-/Lesezyklen im Speicher minimiert wird.

Schlussfolgerung

Auf dem Markt gibt es eine breite Palette von LEDs mittlerer Leistung. In diesem Artikel haben wir uns auf diejenigen beschränkt, die üblicherweise für die Beleuchtung von Objekten verwendet werden. Wir haben eine Methode zur Fernsteuerung vorgestellt, die eine Technologie mit wenigen Empfangsbeschränkungen verwendet. Alle erforderlichen Materialien für die TX- und RX-Einheiten, einschließlich Gerber, PDF-Dateien für die PCBs und Projektdateien für die Software können hier heruntergeladen werden.

---

Anmerkung der Redaktion: Interessieren Sie sich für LoRa und drahtlose Lösungen? Dieses Projekt erschien ursprünglich in Elettronica IN.