HC-14 – das simple LoRa Modul

Ü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:

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.

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

Antennen für das HC-14 Modul

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:

Anschluss des HC-14 Moduls an einen Arduino Nano
Anschluss des HC-14 Moduls an einen Arduino Nano

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:

Ausgabe hc14_settings.ino
Ausgabe hc14_settings.ino

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:

Die Kanäle des HC-14 Moduls
Die Kanäle des HC-14 Moduls

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.

Empfangsempfindlichkeit des HC-14 Moduls vs. Übertragungszeit
Empfangsempfindlichkeit des HC-14 Moduls vs. Übertragungszeit

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:

STA vs. TX (HC-14) bei Empfindlichkeitseinstellung S3
STA vs. TX (HC-14) bei Empfindlichkeitseinstellung S3
STA vs. TX (HC-14) bei Empfindlichkeitseinstellung S3
STA vs. TX (HC-14) bei Empfindlichkeitseinstellung S1

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:

HC-14 Modul am ESP32
HC-14 Modul am ESP32

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:

Energiesparschaltung für den HC-14 als Sender am ATtiny85
Energiesparschaltung für den HC-14 als Sender am ATtiny85

Wichtig ist dabei, dass die Gate-Source Threshold Spannung VGS(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 (ID = Continuous Drain Current). Das hat bei mir mit einem BS170 funktioniert. Seine maximale VGS(th) beträgt 3 Volt.

Besser ist es einen MOSFET mit noch kleinerer VGS(th) zu nehmen, wie z.B. den IRLML6244 (max. VGS(th) = 1.1 Volt) oder den IRLML2502 (max. VGS(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:

STA-Signal vs. RX (HC-14) beim Senden
STA-Signal vs. RX (HC-14) beim Senden

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: 

Reichweitentest

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 VGS(th) ist zu nah an den 3.3 Volt des ESP32. Wohl aber funktionierte die Schaltung mit dem IRLML6244 und dem IRLML2502.

Energiesparschaltung für den HC-14 als Sender am ESP32
Energiesparschaltung für den HC-14 als Sender am ESP32

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:

Energiesparschaltung für den HC-14 als Sender am ESP32 (5 Volt Version)

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.

Energiesparschaltung für den HC-14 als Sender am ESP32 (5 Volt Version / P-Kanal MOSFET)

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() { }

 

23 thoughts on “HC-14 – das simple LoRa Modul

  1. Hallo,
    ich habe unten ein paar ergänzende Infos zum Thema „Das HC-14 Modul in den Einstellmodus bringen“. Auch hier unterscheiden sich die Boards mit Firmware V1.0 und V1.1 etwas :
    … 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.1: In diesem Zustand können alle Parameter, incl. der für den Normalbetrieb eingestellten Baudrate angezeigt, jedoch nicht bleibend geändert werden. Änderungen der Parameter sind nur nach einem Start gemäß Methode 1 bleibend möglich. Also im Prinzip ein „ReadOnly Zugriff“ !
    ○ Firmware V1.0: Ein Start entsprechend Methode 2 setzt hier die Baudrate des HC-14 Boards bleibend auf 9600 Bd, d.h. bei Bedarf muss man sie wieder ändern.
    ##############################

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

    1. Hallo Ulrich,

      vielen Dank. Ich habe den Beitrag ergänzt. Ich werde mich mit der Version 1.0 auch noch näher beschäftigen. Das mache ich zusammen mit der HC-14 Modulversion, die Markus verwendet. Die sind anscheinend wieder anders.

      VG, Wolfgang

  2. Hallo Wolfgang,
    Ich hätte auch großes Interesse mal ein V1.1 zu probieren, weil mich gerade das Thema Reduktion der Sendeleistung interessiert (habe nur eine sehr kleine Distanz zu überbrücken) !
    Wir können gerne mal eins postalisch tauschen, meine Kontakt Email hast du ja !
    VG Ulrich

    P.S. Vielleicht noch zur allgemeinen Info: ich habe die V1.0 Boards über Aliexpress bei dem Händler „Wavgat Official Store“ erworben. Es gibt dort noch 2 weitere Anbieter – vielleicht liefern die ja Version V1.1 !?
    (Ich habe mal gezielt bei einem nach der V1.1 gefragt und darauf den freundlichen Hinweis “ dear friend see picture“ bekommen ! 🙂 ) es bleibt also vermutlich bei try and error!

  3. Hallo Wolfgang,
    mal wieder ein super Artikel zu einem Produkt, über das man sonst noch nicht so viele Informationen findet !
    Ich habe mir via AliExpress ein paar Module bestellt.
    Bei der Inbetriebnahme habe ich festgestellt, daß die Einstellung der Sendeleistung bzw. deren Abfrage mit dem „AT+P…“ Kommando nicht funktionieren bzw. mit „Parameter error“ quittiert werden. Bei der Abfrage der Firmwareversion wird mir „www.hc01.com HC-14V1.0 2022.09.26“ zurückgemeldet !
    D.h. ich habe hier offenbar eine etwas ältere Version erwischt, als die, welche du in deinem Artikel und auch im übersetzten Manual (www.hc01.com HC-14V1.1 2022.12.12) des Herstellers genannt hast. Ich versuche mal über AliExpress einen aktuelleren Stand zu bekommen – mache mir hier aber nicht so viel Hoffnung.
    Ansonsten funktioniert alles super, bloß brauche ich eigentlich die hohe Sendeleistung nicht!
    Beste Grüße Ulrich

    1. Hallo Ulrich,

      ja, da hast du die Version 1.0 erwischt. Im Datenblatt der ersten Version taucht „AT+P“ auch nicht auf.
      Wäre schön, wenn man die Firmware aktualisieren könnte, aber das scheint nicht der Fall zu sein.

      VG, Wolfgang

    2. Hallo Ulrich und Wolfgang
      ich erhalte bei der Abfrage AT+P? auch einen ‚Parameter error‘.
      AT+RX zeigt aber OK+P:+20dBm an.
      AT+P6 (z. Bsp.) ergibt wieder einen Parameter error, ich kann die Leistung nicht setzen.

      Komischerweise erhalte ich auch bei AT+V? einen Parameter error, ich kenne also meine Firmwareversion nicht, im Gegensatz zu Ulrich.

      @Wolfgang: Mein Kompliment und Dank für Deine ausgezeichneten Beiträge! Gut geschrieben und sauber dargestellt.

      Beste Grüsse
      Markus

      1. Hallo Markus!
        Dies sieht verdächtig nach meinen Rrlebnissen aus… Bitte prüfen, ob Du vielleicht hinter dem AT-Kommsndo ein NewLine angehängt hast…
        Wie ich auch schon beschrieben habe: es darf KEIN NewLine hinter dem Kommanfo stehen. Da ist dieses Modul empfindlich und antwortet mit „Parameter Error“..
        Auch Wolfgan hat in seinem Artikel schon darauf hingewiesen, dass MSN sein Terminal-Programm umstellen muss, damit kein NewLine sngehängt wird…
        Liebe Grüße

      2. Erst einmal danke an Johann, für die Beantwortung. Ich wollte nur noch ergänzen, dass das Phänomen bei Ulrich ein Versionsproblem ist und das andere mit dem Abfrageformat (New Line) zusammenhängt. Zwei Paar Schuhe.

        VG, Wolfgang

        1. Hallo Wolfgang
          das mit den zwei Phänomenen versteh ich nich richtig:
          (Zitat Ulrich): Bei der Inbetriebnahme habe ich festgestellt, daß die Einstellung der Sendeleistung bzw. deren Abfrage mit dem „AT+P…“ Kommando nicht funktionieren bzw. mit „Parameter error“ quittiert werden. Bei der Abfrage der Firmwareversion wird mir „www.hc01.com HC-14V1.0 2022.09.26“ zurückgemeldet !

          Er spricht doch vom Problem, dass er weder Sendeleistung einstellen noch abfragen kann. Und dann erwähnt er noch seine Versionsnummer.

          Genau die gleichen probleme habe ich mit AT+P. Zusätzlich kann ich aber die Versionsnummer nicht auslesen (dies im gegensatz zu Ulrich).

          Ich habe in der Arduino-IDE (2.3.2) im Serial Monitor ‚No Line Ending‘ gewählt, das sollte doch richtig sein?

          Grüsse Markus

          1. Hallo Markus,

            das Problem von Ulrich ist ein reines Versionsproblem. Sein HC014-Modul ist Version 1.0 und bei der kann man die laut Datenblatt (für Version 1.0) die Leistung mit AT+RX? auslesen, nicht aber mit AT+P? und man kann sie auch nicht einstellen mit AT+Px mit x = 6 bis 20.
            Das andere, davon unabhängige Phänomen ist, dass die meisten AT-Kommandos es nicht tolerieren, wenn man ihnen ein Zeilenende spendiert, und zwar unabhängig von der Version. In deinem ersten Kommentar hast du geschrieben, dass AT+V? nicht funktioniert. Nun konntest du die Versionsnummer auslesen. Und da sie 1.0 ist, ist das Verhalten deines Moduls genau das, was das Datenblatt 1.0 voraussagt.

            Du kannst wahrscheinlich genauso wenig Chinesisch wie ich, aber man sieht, dass bei der Version 1.0 die Einstellung und Abfrage AT+P fehlt:
            https://www.hc01.com/downloads/HC-14V1.0_220926.pdf

            Außer der fehlenden Einstellung für die Leistung könnte sich der STA Pin noch anders verhalten als von mir beschrieben. Im Datenblatt der Version 1 steht (übersetzt mit DeepL):

            „Die High-Level-Spannung ist im Allgemeinen etwas niedriger als die VCC-Spannung und beträgt bis zu 3,3 V.
            3,3V; der interne 1K-Widerstand kann an den MCU-Eingangspin oder direkt an die LED angeschlossen werden (die Funktion dieses Pins ändert sich mit der Softwareversion).
            Der interne K-Widerstand kann an den MCU-Eingangspin oder direkt an eine externe LED angeschlossen werden (die Funktion dieses Pins ändert sich mit der Softwareversion, bitte verwenden Sie ihn entsprechend der entsprechenden Funktion der Softwareversion).“

            Andere Unterschiede scheint es nicht zu geben.

            Wie weit die Module der Version 1.0 verbreitet sind, kann ich nicht sagen. Ich hatte gehofft, dass die Verbreitung gering ist und sah mich bestätigt, weil ich je drei Module aus zwei Shops bestellt habe und alle waren Version 1.0.

            Ich würde mir gerne mal ein Modell 1.0 anschauen. Wenn du möchtest, dann können wir eines postalisch tauschen.

            VG, Wolfgang

  4. Hallo Wolfgang!
    DANKE für den interessanten Artikel. Ich habe parallel ebenfalls mit zwei HC-14 Modulen (auf ESP32) getestet. Bis zu Deinem dedizierten Hinweis – habe ich relativ lange mit den AT-Kommandos gekämpft, da bei manchen Kommandos ein NewLine hinter dem Kommando NICHT schadet. Aber es gibt bei wichtigen Kommandos das Problem, dass hinter einem richtigen Kommando direkt nachfolgende NewLines nur mit „parameter error“ beantwortet werden. (z.B.“AT+V\n“ ergibt Fehler).
    Vielen Dank für den Hinweis mit dem WakeUp-Pin – das möchte ich noch testen und verwenden, aber ich bin mehr der Programmierer und meine Elektronik-Kenntnisse sind eher „Bausatz-Löten“.
    Ein Ergebnis, welches ich auch noch teilen möchte: Die Übertragung funktioniert – ebenfalls wie beim HC-12 – nur HALB-Duplex. Falls beide Seiten gleichzeitig senden, kommt auf beiden Seiten nur Müll raus. Falls man also in beide Richtungen übertragen möchte, sollte man das entsprechend in seiner Software berücksichtigen.
    Liebe Grüße aus Wien
    Johann

  5. Hi Wolfgang,

    „Ich bin mir nicht sicher, ob das HC-14 Modul bei 3.3 Volt Spannungsversorgung dieselbe Reichweite erzielt wie bei 5 Volt.“ … hast Du einen Unterschied feststellen können?

    Auf dem HC-14 ist ein SOT23 mit der Aufschrift „662K“ zu sehen, das ist ein 3.3V LDO. Das können 2 verschiedene Typen sein, ein TOREX LDO mit 1µA GND-Strom oder zu 99% ein LM6206N3 mit ca. 7µA GND-Strom. Alles aus Cn mit Aufdruck 662K ist eher letzteres …

    Gruß André

    1. Hallo André,
      hätte ich es ausprobiert, dann würde ich ja nicht schreiben, dass ich mir nicht sicher bin ;-). Aber ich muss die Aussage wohl noch etwas präzisieren. Ich beziehe mich auf die von mir verwendete Schaltung, bei der die Spannungsversorgung über den 3.3 Volt Pin des ESP32 erfolgt. Im unbelasteten Zustand liefert der Pin tatsächlich saubere 3.3 Volt. Wenn der HC-14 wach wird, dann geht die Spannung ein kleines bisschen runter. Wenn der HC-14 sendet, dann knickt die Spannung auf unter 3 Volt ein. Ein wenig geht noch am MOSFET verloren und ein weiteres bisschen am LDO des HC-14. Hinter dem LDO des HC-14 habe ich nur noch ca. 2.6 Volt gemessen. Trotzdem funktioniert die Übertragung auf meinem Schreibtisch von Modul zu Modul. Gehe ich mit 5 Volt rein, bekomme ich 3.3 Volt hinter dem LDO. Ich denke schon, dass das Unterschiede in der Reichweite machen könnte, nur hatte ich keine Lust mehr, das auszuprobieren.
      VG, Wolfgang

      1. Hi Wolfgang,
        ich habe gestern noch geschaut was das Datenblatt vom SX1278 hergibt:

        „3.1. Power Supply Strategy
        The SX1276/77/78/79 employs an internal voltage regulation scheme which provides stable operating voltage, and hence device characteristics, over the full industrial temperature and operating voltage range of operation. This includes up to +17 dBm of RF output power which is maintained from 1.8 V to 3.7 V and +20 dBm from 2.4 V to 3.7 V.“

        Demnach wäre die volle Funktionalität bis 2.4V am SX1278, also nach dem LDO gegeben.
        Das käme mir sehr entgegen, da man nur 3.3V benötigt, und keine Leveleshifter.

        Gruß André

        1. Hallo André,
          ja, das klingt verheißungsvoll und demnach müsste es funktionieren, wenn auch zwischen 2.6 und 2.4 Volt nicht viel „Luft“ ist. Der Hersteller des HC-14 gibt für das Modul eine Spannungsversorgung von 3 bis 5.5 Volt vor. Warum er das tut, das weiß ich nicht. Mit meinem Aufbau war ich da zwischenzeitlich außerhalb der Spezifikation. Trotzdem funktionierte es auf meinem Schreibtisch. Ich bevorzuge immer die einfachen Lösungen und sage auch immer: Versuch macht klug. Oft hat mein kein Problem auch leicht außerhalb der Spezifikation.
          Ich zeige hier nur eine Lösung auf, falls es Probleme bezüglich der Spannung gibt. Der eine oder andere hat vielleicht ein ESP32 Board mit schlechterem Spannungsregler, vielleicht eine weniger potente Spannungsquelle, einen MOSFET mit höherem VGS, an dem dann eine größere Spannung abfällt (sofern die Weck-/Stromsparoption von Interesse ist), weitere Bauteile am 3.3 V Stromkreis, etc. Und dann könnte es noch enger werden.
          Du kannst ja mal herumprobieren und es deine Erfahrungen hier teilen. Würde mich freuen!
          VG, Wolfgang

  6. Hallo Wolfgang,

    du hast mehrere 433/868 MHz Module getestet. Welches hat die größte Reichweite? Das HC-14?

    mfg Harald

    1. Hallo Harald,
      bei meinen Reichweitentests hat der HC-14 am besten abgeschnitten. Komischerweise besser als das Ebyte E220-900T22D, das eigentlich lt. Datenblatt eine höhere Reichweite hat (5 km). Aber ich würde nicht gerade sagen, dass ein Vergleich dieser Testergebnisse wissenschaftlichen Anforderungen genügt. Die Ergebnisse sollen nur die Dimension wiedergeben. Das Ebyte E220-900T22D ist auch nicht das leistungsstärkste Modul. Das Ebyte E220-900T30D soll beispielsweise bis zu 16 km senden können.
      Mit anderen Worten: ich kann zu den Reichweiten kein verlässliches Ranking angeben, muss aber sagen, dass mich das HC-14 Modul sehr positiv überrascht hat.
      VG, Wolfgang

  7. Hallo Wolfgang,

    ein sehr guter und ausführlicher Artikel. Gehe ich recht in der Annahme, dass ich mit dem hier vorgestellten Modul kein TheThingsNetwork nutzen kann?

    1. Richtig, ein HC-14 Modul kann nur mit einem anderen HC-14 Modul kommunizieren.

  8. Hallo Wolfgang.
    Wieder ein sehr guter Artikel. Ausführlich und die Erklärungen sind verständlich. Klasse.

    Meine Frage ist ob du bei dem Punkt 3. „Eingabe der Baudrate: Beispiel Eingabe “ vor der Rate ein „B“ machen musst oder brauchst man es da nicht. Alle anderen Eingaben müssen ja mit den entsprechenden Buchstaben eingegeben werden.

    1. Hallo Veit, vielen Dank, das „B“ habe ich unterschlagen! Werde es gleich nachliefern.
      VG, Wolfgang

Schreibe einen Kommentar

Deine E-Mail-Adresse wird nicht veröffentlicht. Erforderliche Felder sind mit * markiert