„Ich habe Feuer gemacht“ sagt Tom Hanks stolz in dem Film „Cast Away - Verschollen“. Das gleiche Gefühl hatte ich, als ich vor einigen Wochen meine erste Smartphone App für eine Robot Car Fernsteuerung mit dem MIT APP INVENTOR entwickelt hatte. Da heute gefühlt fast alle ein Smartphone besitzen, kann man mit dessen Möglichkeiten häufig eine preiswertere Lösung für Fernsteuerungen finden, denn man kann auf einen Mikrocontroller und die Transceiver verzichten. Also wage ich einen zweiten Versuch mit einer eigenen Smartphone App zum Schalten eines Relais-Moduls.

Das Schalten von Relais-Modulen haben wir in der Vergangenheit schon mehrfach auf verschiedene Art und Weise gezeigt, z.B. 

• ESP8266-01 Relais mit Website steuern

• Relais mit SMS schalten

• Smarthome Zentrale mit ArduiTouch Teil 3 - Aktor Device mit D1Mini und Relais

• Relais fernschalten mit nRF24L01

• IR Fernbedienung mit Relais Modul und Portexpander MCP23017

Relais sind sehr wichtige Bauelemente, wenn unterschiedliche Spannungen oder hohe Ströme zu schalten sind oder aus anderen Gründen eine galvanische Trennung von Laststromkreis und Steuerkreis notwendig ist. Das Beispiel Modelleisenbahn hatte ich in einem anderen Blog schon erwähnt. Andere Anwendungen in der Advents- und Weihnachtszeit sind Lichterketten oder z.B. ein Schrittmotor für die Weihnachtspyramide, wenn auf Kerzen für den Antrieb verzichtet werden soll. Aber auch Besitzer von Aquarien oder Terrarien können damit Beleuchtung, Heizung, Pumpe usw. ein- oder ausschalten.

Hier nun die kostengünstigste Lösung: Außer dem Relais-Modul mit Spannungsversorgung werden nur ein Raspberry Pi Pico W und einige Jumperkabel benötigt.

Verwendete Hardware

Zunächst noch einmal ein Blick auf das Relais-Modul. Wie die verschiedenen Motortypen sind auch Relais mit ihren elektromagnetischen Eigenschaften nicht wirklich unbedenkliche Verbraucher wie z.B. LEDs. Gerade beim Ein- und Ausschalten fließen deutlich höhere Ströme als unsere Mikrocontroller vertragen. Das bedeutet bei mehr als einem Relais unbedingt eine externe Spannungsversorgung, galvanische Trennung und für den Ausschaltvorgang eine Freilaufdiode (engl. flyback diode) verwenden. Dafür ist bei den Modulen Vorsorge getroffen.

Auf dem folgenden Bild erkennt man (von oben nach unten)

• die Anschlüsse für den externen (zu schaltenden) Stromkreis mit NC (=normally closed, meist freibleibend), CO (=Common, der gemeinsame Eingang) und NO (=normally open, der Ausgang für die Stromversorgung, wenn das Relais eingeschaltet wird),
• die eigentlichen Magnetschalter (die blauen Blöcke),
• Steuerelektronik mit Freilaufdiode, Optokoppler (weitere galvanische Trennung), Widerständen und Anzeige-LED,
• Anschlüsse zu den GPIOs des Mikrocontrollers und der externen Spannungsversorgung

Bei der Spannungsversorgung des Relais-Moduls muss man unterscheiden zwischen den Steuerstromkreisen und den Elektromagneten. Die insgesamt 10 Pins in der Mitte sind GND, Eingänge IN1 bis IN8 und VCC (Spannungseingang der Steuerelektronik), die drei Pins rechts im Bild sind GND und Spannungseingang für die Magnete. Wenn, wie hier im Bild, ein Kurzschlussstecker (Jumper) zwischen VCC und JD-VCC anliegt, sind beide Versorgungsspannungen identisch und - man kann es nicht oft genug sagen - kommen aus einer externen Spannungsquelle, nicht aus dem Mikrocontroller(!). Und zu den Eingängen IN1 bis IN8 ist zu sagen, dass bei den meisten Modulen das Relais anzieht, wenn das Signal vom Mikrocontroller auf LOW gesetzt wird. Aber es gibt auch Ausnahmen, einfach ausprobieren, wann es Klick macht.

Bei meiner Breadboard-Schaltung habe ich den Jumper gesetzt gelassen und ein Batterie-Pack mit drei AA-Batterien (3*1,5 V = 4,5 V) an die Stromschienen angeschlossen. Wer Akkus verwenden möchte, sollte vier Akkus (4* 1,2 V = 4,8 V) verwenden. Am Ende habe ich auch den Raspberry Pi Pico W an dieser Stromschiene angeschlossen. Der Eingang VSYS verträgt Spannungen zwischen 1,8 V und 5,5 V. Zitat aus dem Datasheet: “VSYS is the main system input voltage, which can vary in the allowed range 1.8V to 5.5V, and is used by the on-board SMPS to generate the 3.3V for the RP2040 and its GPIO.“

Bis alles funktioniert, liefert jedoch der USB-Ausgang des Computers die Spannung für den Pico W, das Battery Pack die Spannung für das Relais-Modul. Erst am Ende wird das MicroPython-Programm unter dem Namen main.py auf dem Pico gespeichert, um die Autostart-Funktion zu aktivieren und der Pico wird dann auch an die externe Spannung angeschlossen.

Schaltplan

Programm-Code

Wer Thonny und MicroPython noch nicht installiert hat, kann sich die einzelnen Schritte in den Blog-Beiträgen Raspberry Pi Pico und Thonny mit MicroPython - Teil 1 und Raspberry Pi Pico W jetzt mit Bluetooth - Teil 1 anschauen. Bei MicroPython bitte daran denken, die aktuelle Datei mit der Endung .uf2 zu verwenden, da Bluetooth erst im Juni diesen Jahres implementiert wurde.

Download

# 8 relays controlled by Raspberry Pi Pico W BLE and Smartphone
# Modified from Official Rasp Pi example here:
# https://github.com/micropython/micropython/tree/master/examples/bluetooth
# by Bernd54Albrecht for AZ-Delivery 2023
​
​
import bluetooth
import random
import struct
import time
from ble_advertising import advertising_payload
from micropython import const
from machine import Pin, PWM
import rp2
​
​
# initialize relay pins
r1 = Pin(6, Pin.OUT,value=1)
r2 = Pin(7, Pin.OUT,value=1)
r3 = Pin(8, Pin.OUT,value=1)
r4 = Pin(9, Pin.OUT,value=1)
r5 = Pin(10, Pin.OUT,value=1)
r6 = Pin(11, Pin.OUT,value=1)
r7 = Pin(12, Pin.OUT,value=1)
r8 = Pin(13, Pin.OUT,value=1)
​
​
## taken from ble_simple_peripheral.py
_IRQ_CENTRAL_CONNECT = const(1)
_IRQ_CENTRAL_DISCONNECT = const(2)
_IRQ_GATTS_WRITE = const(3)
​
​
_FLAG_READ = const(0x0002)
_FLAG_WRITE_NO_RESPONSE = const(0x0004)
_FLAG_WRITE = const(0x0008)
_FLAG_NOTIFY = const(0x0010)
​
​
_UART_UUID = bluetooth.UUID("6E400001-B5A3-F393-E0A9-E50E24DCCA9E")
_UART_TX = (
    bluetooth.UUID("6E400003-B5A3-F393-E0A9-E50E24DCCA9E"),
    _FLAG_READ | _FLAG_NOTIFY,
)
_UART_RX = (
    bluetooth.UUID("6E400002-B5A3-F393-E0A9-E50E24DCCA9E"),
    _FLAG_WRITE | _FLAG_WRITE_NO_RESPONSE,
)
_UART_SERVICE = (
    _UART_UUID,
    (_UART_TX, _UART_RX),
)
​
​
​
​
class BLESimplePeripheral:
    def __init__(self, ble, name="PicoW"):
        self._ble = ble
        self._ble.active(True)
        self._ble.irq(self._irq)
        ((self._handle_tx, self._handle_rx),) = self._ble.gatts_register_services((_UART_SERVICE,))
        self._connections = set()
        self._write_callback = None
        self._payload = advertising_payload(name=name, services=[_UART_UUID])
        self._advertise()
​
​
    def _irq(self, event, data):
        # Track connections so we can send notifications.
        if event == _IRQ_CENTRAL_CONNECT:
            conn_handle, _, _ = data
            print("New connection", conn_handle)
            self._connections.add(conn_handle)
        elif event == _IRQ_CENTRAL_DISCONNECT:
            conn_handle, _, _ = data
            print("Disconnected", conn_handle)
            self._connections.remove(conn_handle)
            # Start advertising again to allow a new connection.
            self._advertise()
        elif event == _IRQ_GATTS_WRITE:
            conn_handle, value_handle = data
            value = self._ble.gatts_read(value_handle)
            if value_handle == self._handle_rx and self._write_callback:
                self._write_callback(value)
​
​
    def send(self, data):
        for conn_handle in self._connections:
            self._ble.gatts_notify(conn_handle, self._handle_tx, data)
​
​
    def is_connected(self):
        return len(self._connections) > 0
​
​
    def _advertise(self, interval_us=500000):
        print("Starting advertising")
        self._ble.gap_advertise(interval_us, adv_data=self._payload)
​
​
    def on_write(self, callback):
        self._write_callback = callback
​
​
# This is the MAIN LOOP
def demo():    # This part modified to control 8 relays
    ble = bluetooth.BLE()
    p = BLESimplePeripheral(ble)
​
​
    def on_rx(code):  # code is what has been received
        print("code = ",code)       # Print code
        code = str(code)[2:-5]  # necessary only for Smartphone App
        code = int(code)
        print("code = ",code)       # Print code
​
​
        if code & 1 == 1:
            print("Relais1 ON")
            r1.off()   # Relay1 ON
        else:
            print("Relais1 OFF")
            r1.on()   # Relay1 OFF   
​
​
        if code & 2 == 2:
            print("Relais2 ON")
            r2.off()   # Relay2 ON
        else:
            print("Relais2 OFF")
            r2.on()   # Relay2 OFF
         
        if code & 4 == 4:
            print("Relais3 ON")
            r3.off()   # Relay3 ON
        else:
            print("Relais3 OFF")
            r3.on()   # Relay3 OFF              
            
        if code & 8 == 8:
            print("Relais4 ON")
            r4.off()   # Relay4 ON
        else:
            print("Relais4 OFF")
            r4.on()   # Relay4 OFF              
            
        if code & 16 == 16:
            print("Relais5 ON")
            r5.off()   # Relay5 ON
        else:
            print("Relais5 OFF")
            r5.on()   # Relay5 OFF              
            
        if code & 32 == 32:
            print("Relais6 ON")
            r6.off()   # Relay6 ON
        else:
            print("Relais6 OFF")
            r6.on()   # Relay6 OFF
            
        if code & 64 == 64:
            print("Relais7 ON")
            r7.off()   # Relay7 ON
        else:
            print("Relais7 OFF")
            r7.on()   # Relay7 OFF              
            
        if code & 128 == 128:
            print("Relais8 ON")
            r8.off()   # Relay8 ON
        else:
            print("Relais8 OFF")
            r8.on()   # Relay8 OFF            
            
    p.on_write(on_rx)
​
​
if __name__ == "__main__":
    demo()

Anmerkungen zum Programmcode:

Zu Beginn werden wie üblich Programm-Module (vgl. Bibliotheken/libraries bei Arduino-IDE) importiert. Von den MicroPython-Beispielen für Bluetooth, siehe:

https://github.com/micropython/micropython/tree/master/examples/bluetooth

wird das Programm ble_advertising.py unverändert als Modul auf dem Pico W abgespeichert. Aus dem Programm ble_simple_peripheral.py habe ich die wichtigen Teile kopiert und in mein Programm integriert.

Für die Initialisierung der Relais-Pins verwende ich GP 6 bis 13 und setzte den Startwert auf 1 (HIGH), denn wie gesagt schalten meine Relais, wenn der Eingang auf 0 (LOW) gesetzt werden.

Danach folgen die Bluetooth-relevanten Codeanteile, die ich aus dem Beispiel kopiert habe.

Im Hauptteil des Programms erfolgen das Auslesen der vom Smartphone gesendeten Nachricht und das Auswerten und Verwenden des Codes. Dabei habe ich den acht Relais jeweils die Wertigkeit der Zweierpotenz mit der Nummer des Relais minus 1 zugeordnet. Code 0 bedeutet alle Relais ausgeschaltet, 255 bedeutet alle eingeschaltet. Beispiel: Relais 1 (Wertigkeit 2 hoch 0), 2 (Wertigkeit 2 hoch 1) und 8 (Wertigkeit 2 hoch 7) eingeschaltet bedeutet Code 2 hoch 0 plus 2 hoch 1 plus 2 hoch 7 = 1 + 2 + 128 = 131.

In acht if/else-Abfragen wird geprüft, ob die jeweilige Zweierpotenz im Code enthalten ist und das jeweilige Relais eingeschaltet. Der Rest der eigenen Leistung liegt in der Smartphone App, die online im Browser mit dem MIT APP INVENTOR erstellt bzw. angepasst wird.

Android App erstellen

Zum Einloggen wird z.B. ein gmail - Konto verwendet. Außerdem muss Bluetooth LE als Erweiterung (Menüpunkt Import extension) eingefügt werden. Details siehe den Blog-Beitrag
Raspberry Pi Pico W jetzt mit Bluetooth - Teil 4 - Robot Car mit Blaulicht und Sirene (PIO-gesteuert).

Wenn Sie den MIT APP INVENTOR gestartet haben, einfach meine Datei BLE_controller_8Relais.aia importieren und mit der App MIT AI2 Companion ausprobieren, ggf. Änderungen vornehmen und abschließend kompilieren und als neue App installieren.

Hier dazu meine Screenshots des Browsers, zunächst die Designer-Ansicht:

Und die Blocks-Ansicht aus zwei Bildern zusammengesetzt:

Nach dem Programmstart des Pico W und Drücken der Schaltfläche Start Scanning in der App sollte der Pico W als BLE-Partner angezeigt werden und die Relais einzeln ein- bzw. ausgeschaltet werden können.

Noch einmal zur Erklärung des Codes: In der App habe ich die Relais der Einfachheit halber von 1 bis 8 nummeriert. Für die Wertigkeit und das Berechnen des Codes muss diese Zahl jeweils um 1 vermindert werden. Auf dem Bild oben links angezeigt der Code 176 = 2 hoch 4 plus 2 hoch 5 plus 2 hoch 7, also Relais 5, 6 und 8 werden geschaltet. Diese Spitzfindigkeit des Programmierers braucht der Anwender nicht zu berücksichtigen.

Sie können selbstverständlich auch kleinere Relais-Module verwenden und die nicht benötigten Code-Anteile im MicroPython-Programm und in der App löschen. Viel Spaß beim Nachbauen und Schalten Ihrer Weihnachtsdekoration.

Wir wünschen eine frohe und gesegnete Weihnacht.

Sollten Sie an dieser Stelle kein Video sehen, müssen Sie Cookies in den Browsereinstellungen zulassen.