Über den Beitrag

In diesem Beitrag behandele ich das 433 MHz LoRa Funkmodul HC-14. Man könnte es als Nachfolger oder als Alternative zum HC-12 Funkmodul, über das ich hier berichtet habe, ansehen. Auf den ersten Blick haben das HC-14 und das HC-12 Modul gewisse Ähnlichkeiten, die zugrundeliegende Technik ist jedoch sehr verschieden.

Über die LoRa Funktechnik hatte ich schon einmal in meinem Beitrag über die E22-, E32- und E220-Module berichtet. Diese Module sind dem HC-14 in ihrer Funktionalität weit überlegen. Dafür besticht das HC-14 Modul durch seine überaus einfache Ansteuerung. Zudem ist es ein ganzes Stück kleiner.

Genug Gründe also, dem HC-14 Modul einen eigenen Beitrag zu widmen. Dabei war eine gewisse Herausforderung, dass das HC-14 Modul noch relativ neu ist, aus China kommt und daher wenig Informationen in englischer Sprache verfügbar sind. Das chinesische Manual habe ich, so gut es ging, mithilfe von DeepL übersetzt. Das Resultat findet ihr hier. 

Das kommt auf euch zu:

• Rechtliches
• Bezugsquellen
• Technische Eigenschaften
  • Pinout
• Anschluss an das Mikrocontroller-Board
• Das HC-14 Modul konfigurieren
  • Das HC-14 Modul in den Einstellmodus bringen
  • Der Einstellsketch
  • AT-Befehle
• Senden und Empfangen
  • Zwei HC-14 Module verbinden
  • Mehr als zwei HC-14 Module verbinden
  • Senden und Empfangen von Strukturen
• Strom sparen
  • Den empfangenden Mikrocontroller wecken
  • Mehr Strom sparen – Den sendenden Mikrocontroller wecken
• Reichweitentest
• Firmware 1.0 vs. Firmware 1.1
• Anhang – Strom sparen mit dem ESP32

Rechtliches

Wichtig zu wissen:

• Funk ist in fast allen Ländern dieser Welt rechtlich geregelt, und zwar u. a. hinsichtlich erlaubter Frequenzen, der Sendeleistung oder dem Duty-Cycle (prozentualer Anteil tatsächlicher Sendezeit).
• Nicht alles, was man kaufen kann, darf man auch ohne Einschränkungen betreiben – manches auch gar nicht!

In Deutschland werden die Regeln für den Funk durch die Bundesnetzagentur festgelegt. Die relevanten Details findet ihr hier im Abschnitt „Funkanlagen mit geringer Reichweite“. Von Hobbyisten werden vor allem die Frequenzen um 433 MHz, 868 MHz und 2.4 GHz genutzt – aber nicht frei von Einschränkungen. Ihr seid selbst dafür verantwortlich, die gültigen Vorschriften in eurem Land einzuhalten.

Bezugsquellen

Das HC-14 Modul ist bei mehreren Anbietern auf AliExpress für ca. 5 Euro pro Stück erhältlich. Wenn ihr aus Europa bestellt, dann erhaltet ihr eure Ware normalerweise innerhalb von drei Wochen. Auf Amazon, Ebay oder den gängigen Elektronikshops habe ich das HC-14 Modul bisher nicht gesehen.

Wenn ihr Module bestellt, dann solltet ihr darauf achten, dass es sich um welche mit der Firmware >= V1.1 handelt. Wie ihr sie unterscheidet, erfahrt ihr weiter unten. Ich hoffe, dass die Version 1.0 auf Dauer ausstirbt. Nicht alles in diesem Beitrag funktioniert mit der den V1.0 Modulen!

Technische Eigenschaften

Das HC-14 Modul wird von der Firma Guangzhou Huicheng Information Technology Co., Ltd hergestellt und scheint – so entnehme ich es der Datenblatthistorie – seit September 2022 auf dem Markt zu sein. Das Modul basiert auf dem LoRa-Chip SX1278, der auch in den Modulen der Ebyte E32-Serie zum Einsatz kommt. Zusätzlich ist das Modul mit dem leistungsfähigen Prozessor N32S032 der Firma Nation Technology ausgestattet (siehe hier), der die überaus einfache Ansteuerung per Serial ermöglicht.

Einige Daten im Überblick:

• Versorgungsspannung: 3.0 – 5.5 Volt
• Stromverbrauch:
  • Nicht-sendend: 18 mA (Modus S1) – 23 mA (Modus S8)
  • Sendend: maximal ca. 130 mA (eigene Messung)
  • Einstellmodus: ca. 11 mA
• Ansteuerung: Serial, 1200 – 115200 Baud
• Reichweite: bis 3 km (Herstellerangabe)
• Funktechnologie: LoRa / Transparenter Modus
• Funkfrequenz: 415 – 450 MHz (50 Kanäle)
• Sendeleistung: 4 bis 100 mW (6 – 20 dBm)
  • Einstellbar nur ab Firmware V1.1
• Einstellung: über AT-Befehle

Pinout

Das HC-14 Modul hat folgende Ein- bzw. Ausgänge:

• VCC / GND: Spannungsversorgung, 3.0 – 5.5 V DC. Lt. Datenblatt sollte die Spannungsversorgung in der Lage sein, mindestens 250 mA zu liefern.
• RX: Serial Eingang, verfügt über eigenen Pull-Up. Der Spannungslevel entspricht VCC.
• TX: Serial Ausgang. Spannungslevel entspricht VCC.
• KEY: stellt den Betriebsmodus ein. Der Pin ist mit einem internen Widerstand auf HIGH gezogen.
  • Verbunden mit GND: Einstellmodus (über AT-Befehle).
  • Verbunden mit HIGH oder unverbunden: Funkmodus.
• STA: zeigt den Status des Moduls an.
  • HIGH (max. 3.3 Volt): Modul kann Daten senden oder empfangen.
  • LOW: Das Modul ist beschäftigt.
  • Der Ausgang besitzt einen internen 1 kΩ Widerstand.
• WKUP: Was so verheißungsvoll nach einem Wake-Up Pin aussieht, hat leider (noch?) keine Funktion.
• ANT: Hier könnt ihr die mitgelieferte, kleine Spiralantenne anlöten. Wenn es euch auf Reichweite ankommt, dann empfehle ich eine 433 MHz Standantenne. Da diese normalerweise einen SMA Anschluss haben, braucht ihr noch einen SMA auf U.FL IPEX Adapter.

Anschluss an das Mikrocontroller-Board

Für die meisten meiner Beispielsketche kam die folgende Schaltung zum Einsatz:

Da der Nano nur einen einzigen HardwareSerial Port besitzt, habe ich mich für die Verwendung von SoftwareSerial entschieden und dafür die Pins 10 und 11 ausgewählt.

Den KEY-Pin steuern wir in dieser Konfiguration per Software, indem wir PIN 5 auf INPUT/LOW (KEY ist HIGH) oder OUTPUT/LOW (KEY ist LOW) einstellen. Alternativ könntet ihr KEY über einen Schalter mit GND verbinden. Wenn ihr die Einstellungen nicht ändern wollt, dann könnt ihr den Pin auch unverbunden lassen.

Den STA-Pin nutzen wir später, um den Mikrocontroller zu wecken oder um den Status des HC-14 Moduls abzufragen. Ihr könnt ihn bis dahin auch unverbunden lassen. Oder ihr hängt eine LED dran, um den Status optisch verfolgen zu können. Ein Vorwiderstand ist schon intern vorhanden.

Das HC-14 Modul konfigurieren

Das HC-14 Modul in den Einstellmodus bringen

Um das HC-14 Modul in den Einstellmodus zu bringen, muss der KEY-Pin auf LOW gezogen werden. Dafür gibt es 2 Möglichkeiten:

1. KEY auf LOW, nachdem das HC-14 Modul an die Spannungsversorgung angeschlossen wurde.
   • In diesem Fall wird die eingestellte Baudrate verwendet.
2. KEY auf LOW, während bzw. bevor das HC-14 Modul an die Spannungsversorgung angeschlossen wurde.
   • In diesem Fall wird temporär die Baudrate 9600 verwendet.
   • Firmware V1.0: Geänderte Einstellungen bleiben dauerhaft erhalten.
   • Ab Firmware V1.1: Geänderte Einstellungen gehen nach Trennung vom Strom verloren.

Die Methode 2 ist hilfreich, falls ihr vergessen haben solltet, welche Baudrate ihr im HC-14 Modul eingestellt habt.

Der Einstellsketch

Zum Einstellen des HC-14 Moduls ladet ihr den folgenden Sketch hoch:

#include <SoftwareSerial.h>
const int keyPin = 5;

SoftwareSerial hc14(10,11); // RX, TX

void setup() {
  Serial.begin(9600);
  hc14.begin(9600);
  pinMode(keyPin, OUTPUT); // Setting Mode, change to INPUT for normal mode
  hc14.print("AT+RX");
  Serial.println("Current Settings of the HC-14 module: ");
  while(!hc14.available()){} // wait for HC-14 to answer
  Serial.println(hc14.readString());
  Serial.println("Now, enter your settings. Choose \"No Line Ending\" in the IDE!");
}

void loop() {
  if (hc14.available()) {
    Serial.write(hc14.read());
  }
  if (Serial.available()) {
    hc14.write(Serial.read());
  }
}

Hier die Ausgabe:

Was das im Einzelnen bedeutet, besprechen wir gleich.

AT-Befehle

Die Einstellung des HC-14 Moduls erfolgt über AT-Befehle. Diese könnt ihr über den seriellen Monitor eingeben, oder als Teil eures Codes. AT-Befehle wurden übrigens von dem Modemhersteller Hayes Anfang der 1980er-Jahre entwickelt. „AT“ steht dabei für „come to ATtention“. Beim Versenden der AT-Befehle ist wichtig, dass ihr in der Arduino IDE „Kein Zeilenende“ eingestellt habt. 

1. Bereitschaftstest

Tippt „AT“ (ohne die Anführungsstriche) als Nachricht in den seriellen Monitor und drückt Enter. Als Antwort solltet ihr ein „OK“ bekommen.

2. Das Modul zurücksetzen

Um das Modul auf die Standardeinstellungen zurückzusetzen, verwendet ihr den folgenden AT-Befehl:

Eingabe: AT+DEFAULT

Antwort: OK+DEFAULT

3. Die Baudrate einstellen oder abfragen

Ihr stellt die Baudrate ein mit:

AT+Bxxxx mit xxxx = 1200, 2400, 4800, 9600, 19200, 38400, 57600 oder 115200. Die Voreinstellung ist 9600.

Beispiel:

Eingabe: AT+B19200

Ausgabe: OK+B:19200

Die Abfrage erfolgt mittels AT+B?.

4. Den Kanal einstellen oder abfragen

Ihr habt die Wahl zwischen 50 verschiedenen Frequenzen (Kanäle):

AT+Cxxx – dabei ist xxx der Kanal gem. der Tabelle weiter unten.

Beispiel:

Eingabe für Kanal 28: AT+C028

Ausgabe: OK+C:28

Ihr müsst grundsätzlich drei Zeichen für den Kanal eingeben, indem ihr ein oder zwei Nullen voranstellt.

Abfrage: AT+C?

Hier noch die Tabelle mit den verschiedenen Kanälen:

5. Die Empfangsempfindlichkeit einstellen

Je höher die Empfangsempfindlichkeit, desto höher die Reichweite, aber desto geringer die Übertragungsrate „over the air“.

Die folgende Tabelle zeigt euch, wie lange es dauert, eine bestimmte Anzahl an Bytes zu übertragen. Wird die für die Empfangsempfindlichkeit spezifische Paketgröße überschritten, werden die zusätzlichen Bytes entsprechend in Pakete aufgeteilt.

Die Einstellung nehmt ihr folgendermaßen vor:

AT+Sx mit x = Rate

Beispiel:

Eingabe: AT+S3

Ausgabe: OK+S:3

Abfrage: AT+S?

6. Die Firmware-Version abfragen

Die Version der Firmware fragt ihr folgendermaßen ab:

Eingabe: AT+V?

Ausgabe: www.hc01.com HC-14V1.1 2022.12.12 → Version 1.1 vom 12.12.2022

7. Die Sendeleistung einstellen oder abfragen

Die Sendeleistung stellt ihr so ein:

AT+Pxx mit x = Leistung in dBm, erlaubt sind ganzzahlige Werte zwischen 6 und 20.

Beispiel:

Eingabe: AT+P20

Ausgabe: OK+P:+20dBm

Abfrage: AT+P?

Die Einstellung der Sendeleistung erst ab der Firmware V1.1 möglich!

8. Abfrage der wichtigsten Einstellungen

Wie ihr die Baudrate, den Kanal, die Empfangsempfindlichkeit und die Sendeleistung in einem Rutsch abfragt, hatte ich (einschließlich Ausgabe) beim Einstellsketch weiter oben schon vorweggenommen.

Abfrage: AT+RX

Senden und Empfangen

Zwei HC-14 Module verbinden

Jetzt kommen wir zum eigentlichen Kern des Beitrages, nämlich dem Senden und Empfangen von Daten per Funk. Das ist erstaunlich einfach. Dupliziert die Schaltung von oben und ladet den gleich folgenden Sketch auf beide Mikrocontroller. Wenn ihr die Arduino IDE 2.x verwendet, dann benennt ihr den Sketch für einen der Mikrocontroller am besten um, damit ihr zwei serielle Monitore zur Verfügung habt.  

Um die Nachrichten besser lesen zu können, solltet ihr die Option „Neue Zeile“ oder „Sowohl NL oder CR“ auswählen.

Wichtig ist, dass ihr bei beiden HC-14 Modulen dieselbe Empfangsempfindlichkeit und denselben Kanal eingestellt habt.

#include <SoftwareSerial.h>
int keyPin = 5;

SoftwareSerial hc14(10,11); // RX, TX

void setup() {
  Serial.begin(9600);
  hc14.begin(9600);
  /* Uncomment the following lines if you want to check the settings
  pinMode(keyPin, OUTPUT); // Setting Mode, change to INPUT for normal mode
  hc14.print("AT+RX");
  Serial.println("Current Settings of the HC-14 module: ");
  while(!hc14.available()){} // wait for HC-14 to answer
  Serial.println(hc14.readString());
  Serial.println("Changing to normal mode - Enter your messages"); */
  pinMode(keyPin, INPUT);  
}

void loop() {
  if (hc14.available()) {
    Serial.write(hc14.read());
  }
  if (Serial.available()) {
    hc14.write(Serial.read());
  }
}

Wenn ihr jetzt auf dem einen seriellen Monitor eine Nachricht eingebt, wird sie auf dem anderen ausgegeben und umgekehrt. Es wirkt, als seien die beiden Mikrocontroller direkt per SoftwareSerial verbunden. Damit stehen euch auch die zahlreichen komfortablen Serial-Funktionen zur Verfügung, wie ich sie in meinem letzten Beitrag beschrieben habe.

Wenn ihr eine Nachricht übermittelt, die größer als die Paketgröße ist, dann werdet ihr sehen, dass die Pakete zeitversetzt ankommen.

Mehr als zwei HC-14 Module verbinden

Wenn ihr mehr als zwei Mikrocontroller über HC-14 Module miteinander kommunizieren lasst, dann wird eine gesendete Nachricht von allen HC-14 Modulen empfangen, die auf denselben Kanal und dieselbe Empfangsempfindlichkeit eingestellt sind. Um Module individuell anzusprechen, könntet ihr genau diese Einstellungen nutzen. Eine gezielte Adressierung, so wie beim Fixed Transmission Mode der Ebyte LoRa-Module (siehe hier) gibt es leider nicht bei den HC-14 Modulen. Das ist der Preis für die Einfachheit.

Senden und Empfangen von Strukturen

In der praktischen Anwendung müsst ihr vielleicht Datensätze verschicken, die aus unterschiedlichen Datentypen bestehen. Hier bemühe ich – mal wieder – das Beispiel einer Wetterstation, der die Luftfeuchte (ein Integer), die Temperatur (ein Float) und der Regenstatus (ein Bool) übertragen werden soll. Dafür bietet sich eine Struktur als Datencontainer an.

Hier der Sendersketch:

#include <SoftwareSerial.h>
#define INTERVAL 5000
unsigned long lastMillis = 0;

const int keyPin = 5;

struct weatherData {
  int humidity;
  float temperature;
  bool rain;
};

weatherData currentWeather = { 32, 25.0, false };
SoftwareSerial hc14(10,11);

void setup() {
  pinMode(keyPin, INPUT);
  Serial.begin(9600);
  hc14.begin(9600);
}

void loop() { 
  if( millis()-lastMillis >= INTERVAL ){ 
    lastMillis = millis(); 
    hc14.write((byte*)&currentWeather, sizeof(currentWeather));
    Serial.println("Data sent");
  } 
}

Und hier der Empfängersketch:

#include <SoftwareSerial.h>
#define INTERVAL 5000
unsigned long lastMillis = 0;

int keyPin = 5;

struct weatherData {
  int humidity;
  float temperature;
  bool rain;
};

weatherData currentWeather = { 0, 0.0, false };
SoftwareSerial hc14(10,11);

void setup() {
  pinMode(keyPin, INPUT);
  Serial.begin(9600);
  hc14.begin(9600);
}

void loop() { // run over and over
  if(hc14.available()){ 
    hc14.readBytes((byte*)&currentWeather, sizeof(currentWeather));
    Serial.print("Humidity [%]: ");
    Serial.println(currentWeather.humidity);
    Serial.print("Temperature [°C]: ");
    Serial.println(currentWeather.temperature, 1);
    if(currentWeather.rain){
      Serial.println("It's raining.");
    }
    else{
      Serial.println("It doesn't rain.");
    }
    Serial.println();
  } 
}

Da wir hier ein wenig das eigentliche Thema verlassen, möchte ich hier lediglich auf einen Aspekt hinweisen, und zwar dass die Struktur mit

hc14.write((byte*)&currentWeather, sizeof(currentWeather));

versendet und mit

hc14.readBytes((byte*)&currentWeather, sizeof(currentWeather));

empfangen wird.

Strom sparen

Bei batteriebetriebenen Projekten ist Strom kostbares Gut. Zumindest wenn ihr, wie bei der Wetterstation, nur in eine Richtung kommuniziert, gibt es Optionen den Stromverbrauch zu reduzieren.

Den empfangenden Mikrocontroller wecken

Die Stromspar-Optionen sind auf der Empfängerseite insofern begrenzt, als das HC-14 Modul empfangsbereit bleiben muss und um die 20 mA Strom verbraucht. Es besitzt bedauerlicherweise keinen Schlafmodus, aus dem es durch eine eingehende Nachricht geweckt wird. Das machen die Ebyte LoRa Module (und andere) definitiv besser.

Zumindest aber könnt ihr den Mikrocontroller zwischenzeitlich in den Schlaf schicken und das STA-Signal des HC-14 nutzen, um ihn wieder aufzuwecken. Wenn das HC-14 Modul Daten empfängt, dann geht STA auf LOW. Das passiert einige Zeit, bevor die Daten über den TX-Pin des HC-14 Moduls an den Mikrocontroller übertragen werden. Die Verzögerung hängt von der Übertragungsrate ab, die ihr indirekt über die Empfangsempfindlichkeit festlegt:

Ob diese Zeit ausreicht, um den Mikrocontroller empfangsbereit zu machen, hängt vom Mikrocontroller und dem Schlafmodus ab. Die folgenden Beispiele habe ich erfolgreich mit der Einstellung S3 getestet.

Beispiel 1: AVR basiertes Arduino Board

Das erste Beispiel habe ich an einem Arduino Nano ausprobiert. Der Nano wird in den Power-Down versetzt, aus dem er durch einen externen Interrupt geweckt wird (Details zu den Schlafmodi findet ihr hier). Als Trigger dient das STA-Signal. Die eingehende Nachricht wird mit Serial.readStringUntil('\n'); ausgelesen, um das Warten auf den Timeout zu umgehen. Dazu ist es notwendig, die Nachricht auf der Senderseite mit Serial.println(), also mit Zeilenvorschub zu senden. Oder ihr wählt die Einstellung „Neue Zeile“ oder „Sowohl NL als auch CR“ beim Versenden per seriellem Monitor. Mehr zu Serial findet ihr hier.

Der Empfängersketch:

#include <avr/sleep.h>
#include <SoftwareSerial.h>
const int keyPin = 5;
const int intPin = 2;

SoftwareSerial hc14(10,11);

void wakeUpISR() {
  delay(0); // add code if you want
}

void setup() {
  pinMode(keyPin, INPUT);
  pinMode(intPin, INPUT);
  attachInterrupt(digitalPinToInterrupt(intPin), wakeUpISR, FALLING);
  Serial.begin(9600);
  hc14.begin(9600);
  Serial.println("I am going to sleep now...");
  Serial.flush(); // without flush() the output might not be fully displayed
  set_sleep_mode(SLEEP_MODE_PWR_DOWN); // define sleep mode
  sleep_mode();  // now sleep
}

void loop() { 
  if(hc14.available()){
    String messageIn = hc14.readStringUntil('\n');
    Serial.println(messageIn);
    Serial.println("I am going to sleep again...");
    Serial.flush();
    sleep_mode();
  }
}

Ein Arduino Nano verbraucht auch im Power-Down Modus recht viel Strom. Schuld sind die Board-LED, der USB-zu-TTL Chip und der Spannungsregler. Eine bessere Wahl wäre der Arduino Pro Mini oder ein „nackter“ AVR-Chip.

Beispiel 2: ESP32 Development Board

Den ESP32 versetzen wir in den Deep Sleep Modus. Im Unterschied zum letzten Beispiel löst das Wecken einen Reset aus.

Da für den ESP32 kein SoftwareSerial implementiert ist, nehmen wir Serial1 für die Kommunikation mit dem HC-14.

Diese Schaltung kam zum Einsatz:

Und hier der zugehörige Sketch:

const int rx1Pin = 18;
const int tx1Pin = 19;
const int keyPin = 23;

void setup() {
  pinMode(keyPin, INPUT);
  Serial.begin(9600);
  delay(500);
  Serial1.begin(9600, SERIAL_8N1, rx1Pin, tx1Pin); // using Serial1 since the ESP32 has no SoftwareSerial
  esp_sleep_enable_ext0_wakeup(GPIO_NUM_33, LOW); // wake up by low Signal at GPIO 33
}

void loop() { 
  if(Serial1.available()){
    String messageIn = Serial1.readStringUntil('\n');
    Serial.println(messageIn);
    Serial.println("I am going to sleep again...");
    Serial.flush();
    esp_deep_sleep_start();
  }
}

Auch für diesen Sketch sollte die ausgehende Nachricht auf der Senderseite mit einem New Line Zeichen abgeschlossen werden.

Mehr Strom sparen – Den sendenden Mikrocontroller wecken

Effektiver können wir auf der sendenden Seite Strom sparen, indem wir den Mikrocontroller in den Schlaf schicken und regelmäßig wecken. Die Stromversorgung des HC-14 Moduls schalten wir über einen MOSFET zu. Ich zeige das hier am Beispiel eines ATtiny85. Wie ihr beim ESP32 vorgeht, habe ich in den Anhang ausgelagert, da die Ausführungen etwas länglich geworden sind.

Zum Wecken verwenden wir den Watchdog Timer, da dieses die einzige zeitgesteuerte Weckmethode für den Power-Down Modus ist. 

Die folgende Schaltung kam zum Einsatz:

Wichtig ist dabei, dass die Gate-Source Threshold Spannung V_GS(th) des MOSFETs (also die Gate-Spannung, bei der er zu leiten beginnt) nicht zu hoch ist. Sucht nach „Logic Level MOSFETs“. Außerdem muss der MOSFET den maximal zu erwartenden Strom vertragen (I_D = Continuous Drain Current). Das hat bei mir mit einem BS170 funktioniert. Seine maximale V_GS(th) beträgt 3 Volt.

Besser ist es einen MOSFET mit noch kleinerer V_GS(th) zu nehmen, wie z.B. den IRLML6244 (max. V_GS(th) = 1.1 Volt) oder den IRLML2502 (max. V_GS(th) = 1.2 Volt). Beide habe ich erfolgreich getestet. Allerdings gibt es sie nur in der Bauform SOT-23, weshalb ihr sie für Breadboard-Experimente auf eine Adpaterplatine löten müsst (Beispiel siehe rechts).

Programmablauf

Hier zunächst der Sketch:

#include<SoftwareSerial.h>
#include <avr/wdt.h>
#include <avr/sleep.h>
volatile int wdCounts = 0;
const int rxPin = 3;
const int txPin = 4;
const int staPin = 1;
const int hc14EnablePin = 2;

SoftwareSerial hc14(3,4);

void setup() {
  pinMode(hc14EnablePin, OUTPUT);
  digitalWrite(hc14EnablePin, HIGH);
  hc14.begin(9600);
  delay(500);
  watchdogSetup();
  set_sleep_mode(SLEEP_MODE_PWR_DOWN);
  hc14.println("ATtiny85 has started");
}

void loop() { 
  if(wdCounts >= 2){ // send only every second wake up
    digitalWrite(hc14EnablePin, HIGH);
    delay(1000); // give HC14 time to get ready   
    while(!digitalRead(staPin)){} // ensure HC14 is ready to receive commands
    hc14.println("Greetings from ATtiny85!");
    while(digitalRead(staPin)){} // wait for sending procedure
    while(!digitalRead(staPin)){} // wait until message is sent
    digitalWrite(hc14EnablePin, LOW);
    wdCounts = 0;
  }
  sleep_mode();
}

void watchdogSetup(void){
  cli();
  wdt_reset();
  WDTCR |= (1<<WDCE) | (1<<WDE);
  WDTCR |= (1<<WDIE) | (1<<WDE) | (1<<WDP3) | (1<<WDP0);  // Watchdog every 8s 
  sei();
}

ISR(WDT_vect){
  wdCounts++;
  WDTCR |= (1<<WDIE); // avoid system reset
}

Zunächst binden wir die benötigten Bibliotheken ein, definieren die relevanten Pins und stellen einen Watchdog Timer auf das Maximum von acht Sekunden ein. Da acht Sekunden keine besonders lange Zeit sind, führen wir den Zähler wdCounts ein, mit dem wir steuern können, nach dem wievielten Aufwachen eine Nachricht verschickt wird (hier: 2). Die kurzen Wachzeiten ohne Senden einer Nachricht fallen energetisch kaum ins Gewicht.

Ist es an der Zeit eine Nachricht zu verschicken, „schaltet“ der ATtiny85 den MOSFET, sodass der HC-14 mit Strom versorgt wird. Wir geben ihm eine Sekunde, um hochzufahren (das lässt sich ggf. noch optimieren). Der weitere zeitliche Verlauf wird über STA gesteuert. So verhält sich das STA Signal zum RX-Pin des HC-14:

Ihr seht, wie die Nachricht über den RX-Pin des HC-14 Moduls eingeht. Danach beginnt der Sendevorgang, währenddessen STA auf LOW geht. Wenn STA wieder HIGH ist, schalten wir dem HC-14 Modul den Strom ab und schicken den ATtiny85 in den Schlaf.

Mit diesem Aufbau lag der Stromverbrauch während der Schlafenszeit bei 0.31 Milliampere. Damit kommen wir in Bereiche, die einen Dauerbatteriebetrieb erlauben.

Reichweitentest für das HC-14 Modul

Der Reichweitentest war ausgesprochen erfreulich. Ich habe ihn mit stärkster Empfangsempfindlichkeit (S1), höchster Sendeleistung (P20) und unter Verwendung von 433 MHz Standantennen durchgeführt. Sender und Empfänger wurden über einen Arduino Nano gesteuert. Der Sender wurde über USB vom PC mit Strom versorgt und stand in meinem Arbeitszimmer. Die Stromversorgung des Empfängers war ein 9 Volt Lithium-Akku an VIN des Arduino Nano.

Der Sender sendete alle zehn Sekunden die Nachricht „Hallo Receiver“. Auf der Empfängerseite kam der folgende Sketch zum Einsatz:

#include <SoftwareSerial.h>
const int ledPin = 13;

SoftwareSerial hc14(10,11);

void setup() {
  pinMode(ledPin, OUTPUT);
  hc14.begin(9600);
}

void loop() {
  if(hc14.available()) {
    String messageIn = hc14.readString();
    if(messageIn == "Hello Receiver!"){
      for(int i=0; i<10; i++){
        digitalWrite(ledPin,!digitalRead(ledPin));
        delay(50);
      }
    }
  }
}

Bei erfolgreichem Empfang blinkt die Board-LED fünfmal. So bin ich dann mit dem Empfänger über die Felder gezogen und habe die Reichweite ermittelt. Abgesehen von einem zwischenzeitlichen Funkloch in Form einer Senke habe ich noch in fast 3 Kilometern Empfang gehabt und das, obwohl der Sender im Haus positioniert war und auf den ersten Metern ein paar Häuser im Weg standen: 

Firmware V1.0 vs. Firmware V1.1

Die Firmware V1.0 stammt aus September 22, die Firmware 1.1 aus Dezember 22. Ich kann nicht mit Bestimmtheit sagen, ob die äußeren Merkmale in jedem Fall garantieren, die Firmware zu identifizieren, aber meine Erfahrung und die mehrerer Leser spricht dafür.

Aus meiner Sicht sind die wichtigsten Unterschiede:

• V1.0 Module senden mit -20 dBm und lassen sich nicht herunterregeln
• Der STA-Pin scheint bei den V1.0 Modulen keine Funktion zu haben. Bei mir war der STA-Pin durchgehend LOW.
• Einige AT-Kommandos sind etwas unterschiedlich. Wenn etwas nicht gehen sollte, dann probiert mal mit und ohne Fragezeichen.
• Mindestens ein Leser hatte mit der V1.0 Version Übertragungsprobleme.

Und, ganz wichtig: Mischen der Modulversionen geht nach meiner Erfahrung nicht.

Anhang – Strom sparen mit dem ESP32

Mit MOSFET

Im Prinzip können wir beim ESP32 auf dieselbe Weise mithilfe eines MOSFETs Strom sparen, so wie zuvor mit dem ATtiny85. Wegen der geringeren Spannung des ESP32 funktionierte die Schaltung jedoch nicht mit dem BS170. Sein maximaler V_GS(th) ist zu nah an den 3.3 Volt des ESP32. Wohl aber funktionierte die Schaltung mit dem IRLML6244 und dem IRLML2502.

Und hier der Sketch dazu:

const int unsigned long microSecToSec = 1000000;
const int sleepTime = 10; // in seconds 
const int rx1Pin = 18; // dummy
const int tx1Pin = 33;
const int hc14EnablePin = 22;
const int staPin = 23;

void setup() {
  pinMode(hc14EnablePin, OUTPUT);
  digitalWrite(hc14EnablePin, HIGH);
  delay(1000); // give HC14 time to get ready 
  Serial1.begin(9600, SERIAL_8N1, rx1Pin, tx1Pin);
  while(!digitalRead(staPin)){} // ensure HC14 is ready to receive commands
  Serial1.println("Hi, I just woke up! But I am tired again and will sleep for 10 seconds...");
  while(digitalRead(staPin)){} // wait for sending procedure
  while(!digitalRead(staPin)){} // wait until message is sent
  digitalWrite(hc14EnablePin, LOW);
  esp_sleep_enable_timer_wakeup(sleepTime * microSecToSec);
  esp_deep_sleep_start();
}

void loop() { }

Die Stromversorgung erfolgte mit 5 Volt am 5 Volt Pin (meist als VCC, VIN oder V5 bezeichnet). Ernüchtert stellte ich im Deep Sleep Modus immer noch einen Stromverbrauch von 10.9 mA fest. Das Problem ist, dass viele ESP32 Boards nicht fürs Stromsparen im Deep Sleep Modus optimiert sind. Zu viele Komponenten auf dem Board ziehen Strom. Das Entfernen der Board-LED brachte bei mir lediglich 1.5 mA Einsparung. Die Lösung lautet: besorgt euch ein optimiertes ESP32 Board, wie z. B. den Adafruit ESP32 Feather V2 oder den FireBeetle.

Mit MOSFET und Transistor

N-Kanal MOSFET Variante

Ich bin mir nicht sicher, ob das HC-14 Modul mithilfe der 3.3 Volt Spannungsversorgung des ESP32 dieselbe Reichweite erzielt wie bei Anschluss an 5 Volt. Die Spannung knickte beim Senden auf unter 3 Volt ein. Ich habe deswegen noch eine Schaltung auf 5 Volt Basis ausprobiert, die aufgrund der höheren Spannung auch mit einem BS170 oder einem 2N7000 MOSFET funktionierte:

Hier gibt es allerdings ein paar Dinge zu beachten:

• Da der RX-Pin des HC-14 Moduls auf 5 Volt Niveau liegt, brauchen wir einen Spannungsteiler oder Level-Shifter.
• Der interne Pull-Up Widerstand des RX-Pins des HC-14 Moduls wird permanent mit Spannung versorgt. Dadurch fließt ein permanenter Strom über den Spannungsteiler ab. Deswegen habe ich relativ hohe Widerstandswerte gewählt.
• Der Transistor dreht die Logik um. Ist Pin 22 (hcEnablePin) LOW, dann sperrt der Transistor und das Spannungsniveau am Gate des MOSFETs ist HIGH. Entsprechend muss PIN 22 während der Schlafphase auf HIGH Niveau sein.

Hier der Sketch dazu:

const int unsigned long microSecToSec = 1000000;
const int sleepTime = 10; 
const int rx1Pin = 18; // dummy
const int tx1Pin = 33;
const int hc14EnablePin = 22;
const int staPin = 23;

void setup() {
  gpio_hold_dis(GPIO_NUM_22);
  pinMode(hc14EnablePin, OUTPUT);
  digitalWrite(hc14EnablePin, LOW);
  delay(1000);
  Serial1.begin(9600, SERIAL_8N1, rx1Pin, tx1Pin);
  while(!digitalRead(staPin)){} // ensure HC14 is ready to receive commands
  Serial1.println("Hi, I just woke up! But I am tired again and will sleep for 10 seconds...");
  while(digitalRead(staPin)){} // wait for sending procedure
  while(!digitalRead(staPin)){} // wait until message is sent
  digitalWrite(hc14EnablePin, HIGH);
  gpio_hold_en(GPIO_NUM_22); // hold GPIO 22 HIGH during deep sleep
  esp_sleep_enable_timer_wakeup(sleepTime * microSecToSec);
  gpio_deep_sleep_hold_en();
  esp_deep_sleep_start();
}

void loop() { }

P-Kanal MOSFET Variante

Etwas vorteilhafter ist die Variante mit P-Kanal MOSFET, weil der Pull-Up Widerstand des RX-Pins des HC-14 Moduls während der Schlafphase nicht mit Strom versorgt wird. Außerdem müsst ihr hier den Pin 22 während der Schlafphase nicht auf HIGH-Niveau halten.

Der Sketch dazu ist:

const int unsigned long microSecToSec = 1000000;
const int sleepTime = 10; 
const int rx1Pin = 18; // dummy
const int tx1Pin = 33;
const int hc14EnablePin = 22;
const int staPin = 23;

void setup() {
  pinMode(hc14EnablePin, OUTPUT);
  digitalWrite(hc14EnablePin, HIGH);
  delay(1000);
  Serial1.begin(9600, SERIAL_8N1, rx1Pin, tx1Pin);
  while(!digitalRead(staPin)){} // ensure HC14 is ready to receive commands
  Serial1.println("Hi, I just woke up! But I am tired again and will sleep for 10 seconds...");
  while(digitalRead(staPin)){} // wait for sending procedure
  while(!digitalRead(staPin)){} // wait until message is sent
  digitalWrite(hc14EnablePin, LOW);
  esp_sleep_enable_timer_wakeup(sleepTime * microSecToSec);
  esp_deep_sleep_start();
}

void loop() { }