DIY Heltec LoRa32 V3 Spielereien

[ruessel]

ynTb91I0pxSkOrK5.png

Cool.... die angegebene HF Leistung des V4 Bausteins mit 27 dBm wird erreicht (sogar ein kleinwenig übertroffen). Auch auf Frequenzen die für die hohe HF Leistung (27 dBm = 500mW) nicht erlaubt ist (hier auf 868.000 Mhz).
Man(n) hat also volle Kontrolle über den V4 LoRa, keine Limitierungen. Jetzt mal schauen ob das Teil per BT die Kamera steuern kann.

[ruessel]

Habe noch zwei weitere LoRa V4 Module vermessen lassen:

0L56D4rNRLOnWdIq.png

Wie man sieht, auch hier werden die programmierten 27 dBm fast erreicht, auf einer Frequenz die in Europa auch dafür zugelassen ist. Das dritte Modul V4 habe ich mit nur 5 dBm programmiert, das konnte nicht gemessen werden. Es gab überhaupt keine messbare HF Leistung aus dem Baustein. Am seriellen Monitor wird allerdings angezeigt, das er sendet. Sollte hier ein Serien-Firmwarefehler vorliegen? Ich werde das "defekte" Modul auf 27 dBm umprogrammieren und nochmals vermessen lassen - vielleicht kommt doch was raus.
Heute kommen zwei weitere Module inkl. GPS Platine an, diese werde ich mal mit 30 dBm programmieren, bin gespannt ob da auch "nur" 27 dBm herauskommen. Denn laut Heltec Datenblatt ist die Sendeleistung 28 dBm +-1 dBm, also 29 dBm wären mit Glück möglich. Im Netz finde ich immer nur 27 dBm was so nicht richtig ist, das wäre der schlechteste Wert.

Leider kann ich kaum Informationen aus der Praxis für die V4 Version finden, der Baustein wurde erst letztes Jahr im Herbst vorgestellt und in DE ist kaum an diesen Teilen zu kommen. Ich habe die letzten 2 Bausteine noch in München bestellen können, für knapp 29,- inkl. OLED Display und GPS Zusatzplatine - die einfach auf das Board angesteckt wird. In der Bucht wird teilweise das dreifache dafür verlangt, es lohnt sich also auch mal in einen Elektronik-Shop zu suchen. https://openelab.io/de/products/heltec-wifi-lora-32-v4

Ich habe geschaut was hier vor Ort auf den Frequenzen los ist.... wie man sieht, ich funke nicht alleine, 10 Kanäle werden zur Zeit benutzt und mein LoRa ist noch gar nicht eingeschaltet...

wasserfall.png

Ich habe versucht BT codecs für die BMD Pocket 6K Pro zu programmieren, wie ich es mit anderen (M5) Mikrocontrollern schon erfolgreich gemacht habe. Leider bricht beim laden mir der Code zusammen, nur 1:1 von einen M5 auf V4 zu portieren geht anscheinend nicht - das wird komplizierter. Später versuche ich mit der KI eine Lösung zu finden. Jetzt beschäftige ich mich noch mit Grundlagen, möchte erstmal eine 15 km Verbindung mit zwei V4 hinbekommen, der angebliche Weltrekord (mit in DE nicht zugelassenen Antennen - Yagi) liegt zur Zeit bei einer 320 km Verbindung. Was ich kaum glauben kann, wegen der Erdkrümmung. Die Antennen müssen weit erhöht montiert gewesen sein. (800 MHz breitet sich schon eher wie Licht aus, jeder Baum oder Gebäude dämpft schon recht stark)

[ruessel]

der Postbote war da. Die zwei weiteren LoRa mit GPS sind da.

P1000007.JPG

das Foto zeigt den LoRa V4 Baustein mit gekoppelten GPS Empfänger. Die Münze auf dem Foto ist zum Größenvergleich, es ist eine 1 Cent Münze. Da passt fast der GPS Empfänger drauf. Die Antenne rechts ist ein weiterer Kauf in der Bucht, angeblich 5 dBi Gewinn Antennen, dass ist natürlich sehr optimistisch vom Chinesen beschriftet, 3dBi werden wohl eher stimmen. Gegenüber dem LoRa V4 die kostenlos beigelegten Stummel-Antenne werden laut Tests, die Reichweiten mit dieser Rundstrahlantenne mal eben verdoppelt. Die Antenne habe ich im 4er Pack mit Anschlusskabel inkl. Porto für 22,09 EUR in der Bucht gekauft - also ungefähr 5,50 EUR pro Antenne. Später werde ich die Antenne mal genau auf Leistung vermessen, finde bloß gerade in meinen Chaos nicht das entsprechende Messgerät......

Jetzt geht der Spaß wieder los, Code aufspielen, Seriennummer auslesen, beim Chinesen einreichen und mit dem erhaltenen Code den Chip für alle Funktionen freischalten. Das nervt!

[ruessel]

P1000009.JPG

Habe die Bausteine nun wieder mit einem Sendertest zum Messen der Sendeleistung versehen. Diesmal zeigt das OLED auch die Werte wie Frequenz + dBm Sendeleistung an. Habe 3 Bausteine mit verschiedenen Frequenzen programmiert und dabei ist auch der defekte Baustein, der mit 5dBm kein Signal ausgab.
Wird der Baustein mit 5V versorgt, sendet dann dieser folgende Worte "Hello World" mit einer aufsteigende Sendenummer - alle 0,5 Sekunden wird automatisch gesendet. So, gleich bringe ich die Teile zum Kumpel mit dem Spektrumanalyser..... und danach einen Kaffee.

Hier der verwendete Code:

Code: Alles auswählen

}CODE entfernt, da Fehlerhaft! 21.03.26 

[ruessel]

Erschütternde Nachricht an mich: alle gestern programmierten V4 haben bei der Messung keine Sendeleistung - obwohl der serielle Monitor zur Kontrolle alles i.o. anzeigt. KEINE Ahnung woran das liegt. Der Codec ohne OLED funktioniert, das haben ja die Messungen am Spektrumanalyzer gezeigt. Sobald das OLED eingebunden ist, scheint die Sendefunktion nicht mehr zu funktionieren. Das kann eigentlich nicht sein bzw. ich kann es nicht glauben.

Jetzt hilft nur noch einen geeigneten 868 MHz Empfänger auf dem Schreibtisch zu stellen, mit einer ganz unempfindlichen Antenne, damit ich auch wirklich nur mein Modul auf dem Schreibtisch empfange. Dann sehe ich sofort ob bei dieser Programmzeile der Sender stumm wird und kann so den Fehler eingrenzen.

Noch ein Wort zur KI und dem V4 Baustein:
Mit Ardunio hat die KI in der Vergangenheit schlankere und effektivere Codecs ausgegeben als ich sie überhaupt selbst programmieren könnte. Die KI codecs haben spätestens beim zweiten KI durchlauf immer funktioniert. Völlig anders hier, habe der KI einen funktionierenden V4 Codec gegeben und den Wunsch geäußert, das die Ausgabe des seriellen Monitors auf das OLED ausgegeben wird. Die KI strotzt nur so von Selbstbewusstsein und gab auch einen Codec raus. Schon beim ersten Blick war mir klar, das kann nicht funktionieren. Die KI benutzt zur Ausgabe einen Tft Bildschirm der gar nicht vorhanden ist. Auf Nachfrage ich möchte doch den auf dem Modul befestigten OLED benutzen kam ein neuer Code diesmal mit OLED Zeilen die aber mit Befehlen versehen waren die beim V4 nicht funktionieren (falsche Bibliothek). der KI auf den Fehler hingewiesen, kam wieder ein Code mit einem Tft Bildschirm - wir drehten uns im Kreis.
Selbst wenn ich die richtigen Bibliotheken vorgab, kam nur Mist raus, teilweise hat das IDE beim überprüfen des Codecs 46 Fehler gefunden, bei einer Codeclänge von 120 Zeilen. KI kannst du vergessen, beim Menschen würde man von einem Irren reden.

Eigentlich ist es auch klar, im Netz findet man zur Zeit fast überhaupt keine funktionierende Codecs für die V4 Version die von Profis erarbeitet worden sind - bis auf die Demos die Heltec mitliefert. woher soll also die KI lernen? ich hätte erwartet, das die KI so selbstbewusst ist und sagt: Sorry, da kenne ich mich nicht aus, statt wirres Zeug zu posten. Das macht mir Angst wenn KI immer mehr in unseren Leben einwirkt, besonders bei Logistik, Behörden und Sichheitskreisen.
Kleinere V3 Codecs laufen zwar auf der V4 Version, aber sobald das OLED kommt ist es vorbei. Das scheint anders angesteuert zu werden. Ich blicke da im Moment überhaupt nicht durch. Noch nicht.

[ruessel]

OLED.jpg

Es ist vollbracht. Jetzt läuft alles rund, siehe Bild oben. Ich habe allerdings nur ein älteres Skript für den Heltec V4 angepasst, lief sofort - auch mit Leistung an der Antenne. Ich habe 4 Bausteine zum messen weggebracht.

LoRa_30dBm.jpg

Aber wirklich Vorsicht, bei dem Eintrag 30dBm im Skript gibt der Baustein alles was in ihm steckt. Der Baustein verbraucht dann 750 mAh und wird dabei nach kurzer Zeit heiß!! Das liegt natürlich daran, dass er hier Dauerfeuer gibt. Das ist in DE auch gar nicht erlaubt, hier muss der Takt 1:10 eingehalten werden, 1 Teil Senden - 10 Teile Sendepause. Dann hat der Chip auch genügend Zeit wieder abzukühlen. Vielleicht mache ich Thermalaufnahmen vom V4 um zu schauen welcher Chip so heiß wird. Man könnte dort vielleicht später einen kleinen Kühlkörper aufkleben.
Die Dauersendung ist nötig um am Messgerät auch sofort messen zu können und nicht immer die Sendepausen abwarten. Damit der V4 nicht überhitzt, ist im Skript ein Zähler eingebaut, nach wenigen Minuten schaltet der Sender aus, das OLED zeigt das dann an. Den LoRa dann abkühlen lassen (vom USB oder Akku abtrennen) und wieder einschalten, er legt dann für die nächste Messung einige Minuten los.

Nochmal den Hinweis, nicht ohne Antenne anschalten, bei 30 dBm wird der Chip nach wenigen Sekunden wahrscheinlich für immer zerstört. Am Messgerät wird die Leistung am 50 Ohm Eingang verbraten und der Chip ist dadurch sicher.


Hier das Sendetestskript was auf Version V4.2 und V4.3 von mir einwandfrei getestet wurde:

Code: Alles auswählen

/* Sendertest für Heltec LoRa V4 - Vorsicht, nicht ohne Antenne betreiben. Zerstoerungsgefahr!!!!
 *
 * Ruesseltechnik 2026 
 * */

#include "LoRaWan_APP.h"
#include "Arduino.h"
#include "HT_st7735.h"
#include "HT_SSD1306Wire.h"

#if defined(WIRELESS_TRACKER_V2)
  HT_st7735 st7735;
#endif

#if defined(WIFI_LORA_32_V4) || defined(WIFI_LORA_32_V2)
  SSD1306Wire  factory_display(0x3c, 500000, SDA_OLED, SCL_OLED, GEOMETRY_128_64, RST_OLED); // addr , freq , i2c group , resolution , rst
#endif

#define RF_FREQUENCY                                868000000 // Hz - Frequenzeinstellung

#define TX_OUTPUT_POWER                             30        // dBm - HF Leistung, 30 dBm entsprechen 1 Watt Ausgangsleistung

#define LORA_BANDWIDTH                              1         // [0: 125 kHz,
                                                              //  1: 250 kHz,
                                                              //  2: 500 kHz,
                                                              //  3: Reserved]
#define LORA_SPREADING_FACTOR                       11         // [SF7..SF12]
#define LORA_CODINGRATE                             1         // [1: 4/5,
                                                              //  2: 4/6,
                                                              //  3: 4/7,
                                                              //  4: 4/8]
#define LORA_PREAMBLE_LENGTH                        8         // Same for Tx and Rx
#define LORA_SYMBOL_TIMEOUT                         0         // Symbols
#define LORA_FIX_LENGTH_PAYLOAD_ON                  false
#define LORA_IQ_INVERSION_ON                        false


#define RX_TIMEOUT_VALUE                            1000
#define BUFFER_SIZE                                 30 // Define the payload size here

char txpacket[BUFFER_SIZE];
char rxpacket[BUFFER_SIZE];

double txNumber;

bool lora_idle=true;

static RadioEvents_t RadioEvents;
void OnTxDone( void );
void OnTxTimeout( void );

void setup() {
    Serial.begin(115200);
    Mcu.begin(HELTEC_BOARD,SLOW_CLK_TPYE);
	
    txNumber=0;

    RadioEvents.TxDone = OnTxDone;
    RadioEvents.TxTimeout = OnTxTimeout;
    
    Radio.Init( &RadioEvents );
    Radio.SetChannel( RF_FREQUENCY );
    Radio.SetTxConfig( MODEM_LORA, TX_OUTPUT_POWER, 0, LORA_BANDWIDTH,
                                   LORA_SPREADING_FACTOR, LORA_CODINGRATE,
                                   LORA_PREAMBLE_LENGTH, LORA_FIX_LENGTH_PAYLOAD_ON,
                                   true, 0, 0, LORA_IQ_INVERSION_ON, 3000 ); 
#if defined(WIRELESS_TRACKER_V2)
    st7735.st7735_init();
    st7735.st7735_fill_screen(ST7735_BLACK);
    st7735.st7735_write_str(0, 0, (String)"WIRELESS_TRACKER_V2");
    st7735.st7735_write_str(30, 0, (String)RF_FREQUENCY);
#endif
#if defined(WIFI_LORA_32_V4) || defined(WIFI_LORA_32_V2)
  pinMode(Vext,OUTPUT);
  digitalWrite(Vext, LOW);
  delay(100);
	factory_display.init();
	factory_display.clear();
  factory_display.drawString(0, 0, (String)"WIFI_LORA_32_V4");
	factory_display.display();
#endif
}


uint32_t num = 0;
void loop()
{
  if(num>=500)
  {
    Serial.println("Test Ende!");
#if defined(WIFI_LORA_32_V4) || defined(WIFI_LORA_32_V2)
    factory_display.clear();
    factory_display.drawString(0, 0, (String)"Test Ende!");
    factory_display.display();
#endif
    while (1)
    {
      delay(1000);
    } 
  }

	if(lora_idle == true)
	{
    delay(100);
		txNumber += 0.01;
		sprintf(txpacket,"30dBm %d MHz Nr. %0.2f",RF_FREQUENCY/1000000,txNumber);  //start a package
#if defined(WIRELESS_TRACKER_V2)
    st7735.st7735_write_str(0, 0, (String)txpacket);
#endif
#if defined(WIFI_LORA_32_V4) || defined(WIFI_LORA_32_V2)
    factory_display.clear();
    factory_display.drawString(0, 0, (String)txpacket);
    factory_display.display();
#endif
		Serial.printf("\r\nsending packet \"%s\" , length %d\r\n",txpacket, strlen(txpacket));

		Radio.Send( (uint8_t *)txpacket, strlen(txpacket) ); //send the package out	
    lora_idle = false;
	}
  Radio.IrqProcess( );
}

void OnTxDone( void )
{
	Serial.println("TX done......");
	lora_idle = true;
  num++;
}

void OnTxTimeout( void )
{
    Radio.Sleep( );
    Serial.println("TX Timeout......");
    lora_idle = true;
}

[ruessel]

Stellt euch vor, bei euch ist Stromausfall (wie in Berlin über mehrere Tage, dann ist jede Wärmepumpe durch den Frost kaputt, wie ich gelernt habe) und es funktioniert kein Internet, Telefon oder Handy. Was dann? Ihr sitzt ohne Information zu hause, keine Info wo die nächste Nahrungsquelle ist. Oder der Staat gerät außer Kontrolle und ihr könnt nicht mehr gefahrlos kommunizieren. Dann hilft LoRa mit "Meshtastic". Wird übrings zur Zeit im Iran stark benutzt, die Nachrichten lassen sich kaum unterbinden, nur mit einen Flächendeckenten (über das ganze Land flächendeckend) Störsender.

Ich habe gestern aus Spass mal Meshtastic auf den Heltec V4 geladen. Das funktioniert völlig ohne Programmierkenntnisse in wenigen Minuten (Firefox geht nicht, aber Crome), direkt über den Browser in den Chip - funzt einwandfrei. Eine tolle Sache für Windows oder Mac - Linux weiß ich im Moment nicht. Nach dem einschalten macht ihr mit euren Handy eine BT verbindung auf und könnt sofort loslegen. Es gibt öffentliche Nachrichten die jeder mitlesen kann oder verschlüsselte Nachrichten, die ihr direkt an einen Wunschteilnehmer richtet. Es gehen nur Textnachrichten, keine Bilder, keine Videos oder podcast. Ihr sendet Stromsparend nur wenige Millisekunden (zur Not mit einen 20 Euro Solarpanel), euer Datenpacket wird von der nächsten LoRa Station (Knotenpunkt) empfangen und sofort weitergeleitet zum nächsten Knotenpunkt und so weiter bis der Empfänger die Nachricht bekommen hat. Die Reichweite könnt ihr stufenlos wählen, wie oft eure Nachricht weitergeleitet wird. das ganze ist noch im Aufbau, wenn ihr sehen wollt was an euren Wohnort los ist - hier ist die Weltkarte mit allen zur Zeit aktiven LoRa Geräten: https://meshmap.net/

Hier mal eine kurze Beschreibung:

[ruessel]

Die letzten Tage waren mit LoRa verwirrend. Die Platinenversion vom Heltec V4 wurde von 4.2 auf 4.3 angehoben. Eigentlich betrifft diese kleine Hardwareänderung nun den Empfänger, er soll nun um 6dB empfindlicher sein, wenn man das in den Foren (USA) glauben möchte. Aber nur wenn die neue Firmware von der Heltec Seite geflasht wird. Ich blicke da ehrlicherweise noch nicht richtig durch.
Fakt ist, bei mir laufen alle Module ob 4.2 oder 4.3 ohne Probleme. In die Tüte gepackt und einen Kilometer zum Kumpel damit gelaufen, funktionieren nur noch die 4.2 Versionen. Mit den "defekten" Teilen wieder zurück daheim laufen sie einwandfrei. Wieder zurück zum Kumpel, kommt angeblich keine Hochfrequnz mehr heraus. Und klar, bei mir wieder zurück läuft es, ich kann es sogar im Empfänger auf 868 MHz hören und sehen. Seltsam.

Um hier weiter zu kommen, habe ich nun das alte "PingPong" Skript vom V3 auf V4.3 umgeschrieben. Es musste nur eine Zeile geändert werden ein Kinderspiel - bis ich das aber verstanden habe, brauchte es 3 Stunden Lebenszeit. Die Bibliothek hat sich ein kleinwenig bei V4 geändert.

Nun, hier der Code für den Reichweitentest PingPong, zwei Heltc V4 spielen sich im Sekundentakt die Bälle zu und liefern auf dem OLED noch Zusatzinformationen wie die Empfangsqualität. Auch blitzt kurz die weiße LED auf der Platine auf, wenn ein Datenpaket gelesen werden konnte. Morgen muss ich in der Küchenabteilung Frischhaltedosen finden als Gehäuse für die nächsten tests.....

Code: Alles auswählen

/*
 * Heltec LoRa V4.3 PingPong Test 
 * c2026 Ruesseltechnik - Achtung!! Nicht ohne Antenne ausfuehren, Zerstoerungsgefahr!!!!
*/

#include "Arduino.h"
#include "LoRaWan_APP.h"
#include <Wire.h>  
#include "HT_SSD1306Wire.h"
/********************************* lora  *********************************************/
#define RF_FREQUENCY                                868000000 // Hz - auf angepasster Antenne achten!! Zerstörungsgefahr!!!

#define TX_OUTPUT_POWER                             27        // dBm max.30 - Antenne unbedingt anschliessen!!!

#define LORA_BANDWIDTH                              0         // [0: 125 kHz, - größte Reichweite, langsamste Übertragung.
                                                              //  1: 250 kHz,
                                                              //  2: 500 kHz,
                                                              //  3: Reserved]
                                                              
#define LORA_SPREADING_FACTOR                       7         // [SF7..SF12]Pegel, die durch das SNR (Signal Noise Ratio)noch identifiziert werden. SF7: -123 dBm, SF12: -137 dBm

#define LORA_CODINGRATE                             1         // [1: 4/5, Je kleiner die Codierungsrate ist (die kleinste ist 4/8), desto höher ist die On-Air-Zeit bei einer Übertragung, damit deutlicher.
                                                              //  2: 4/6,
                                                              //  3: 4/7,
                                                              //  4: 4/8]
                                                              
#define LORA_PREAMBLE_LENGTH                        8         // Es bedeutet, dass alle 4 Nutzbits je nach Wert durch 5, 6, 7 oder 8 Übertragungsbits codiert werden.  
                                                              
                                                              
#define LORA_SYMBOL_TIMEOUT                         0         // Bei Empangsabbruch die Zeit den Empfänger schlafen zu legen
#define LORA_FIX_LENGTH_PAYLOAD_ON                  false
#define LORA_IQ_INVERSION_ON                        false

#define RX_TIMEOUT_VALUE                            1000
#define BUFFER_SIZE                                 30 // Definiere die zu übertragende Datengröße
char txpacket[BUFFER_SIZE];
char rxpacket[BUFFER_SIZE];

static RadioEvents_t RadioEvents;
void OnTxDone( void );
void OnTxTimeout( void );
void OnRxDone( uint8_t *payload, uint16_t size, int16_t rssi, int8_t snr );

typedef enum
{
    LOWPOWER,
    STATE_RX,
    STATE_TX
}States_t;

int16_t txNumber;
int16_t rxNumber;
States_t state;
bool sleepMode = false;
int16_t Rssi,rxSize;

String rssi = "RSSI --";
String packSize = "--";
String packet;
String send_num;
String show_lora = "Empfange Daten:";

unsigned int counter = 0;
bool receiveflag = false; // Software Flag für LoRa Empfänger, empfangene Daten machen es "wahr"
long lastSendTime = 0;        // Letzte Sendezeit
int interval = 1000;          // Interval zwischen zwei Sendungen
uint64_t chipid;
int16_t RssiDetection = 0;


void OnTxDone( void )
{
	Serial.print("TX done......");
	state=STATE_RX;

}

void OnTxTimeout( void )
{
  Radio.Sleep( );
  Serial.print("TX Timeout......");
	state=STATE_TX;
}

void OnRxDone( uint8_t *payload, uint16_t size, int16_t rssi, int8_t snr )
{
	rxNumber++;
  Rssi=rssi;
  rxSize=size;
  memcpy(rxpacket, payload, size );
  rxpacket[size]='\0';
  Radio.Sleep( );
  Serial.printf("\r\nreceived packet \"%s\" with Rssi %d , length %d\r\n",rxpacket,Rssi,rxSize);
  Serial.println("Warte um naestes Paket zu senden");
	receiveflag = true;
  state=STATE_TX;
}


void lora_init(void)
{
  Mcu.begin(HELTEC_BOARD,SLOW_CLK_TPYE);
  txNumber=0;
  Rssi=0;
  rxNumber = 0;
  RadioEvents.TxDone = OnTxDone;
  RadioEvents.TxTimeout = OnTxTimeout;
  RadioEvents.RxDone = OnRxDone;

  Radio.Init( &RadioEvents );
  Radio.SetChannel( RF_FREQUENCY );
  Radio.SetTxConfig( MODEM_LORA, TX_OUTPUT_POWER, 0, LORA_BANDWIDTH,
                                 LORA_SPREADING_FACTOR, LORA_CODINGRATE,
                                 LORA_PREAMBLE_LENGTH, LORA_FIX_LENGTH_PAYLOAD_ON,
                                 true, 0, 0, LORA_IQ_INVERSION_ON, 3000 );

  Radio.SetRxConfig( MODEM_LORA, LORA_BANDWIDTH, LORA_SPREADING_FACTOR,
                                 LORA_CODINGRATE, 0, LORA_PREAMBLE_LENGTH,
                                 LORA_SYMBOL_TIMEOUT, LORA_FIX_LENGTH_PAYLOAD_ON,
                                 0, true, 0, 0, LORA_IQ_INVERSION_ON, true );
	state=STATE_TX;
}


/********************************* lora  *********************************************/

SSD1306Wire  factory_display(0x3c, 500000, SDA_OLED, SCL_OLED, GEOMETRY_128_64, RST_OLED); // addr , freq , i2c group , resolution , rst

bool resendflag=false;
bool deepsleepflag=false;
bool interrupt_flag = false;
void interrupt_GPIO0()
{
	interrupt_flag = true;
}
void interrupt_handle(void)
{
	if(interrupt_flag)
	{
		interrupt_flag = false;
		if(digitalRead(0)==0)
		{
			if(rxNumber <=2)
			{
				resendflag=true;
			}
			else
			{
				deepsleepflag=true;
			}
		}
	}

}
void VextON(void)
{
  pinMode(Vext,OUTPUT);
  digitalWrite(Vext, LOW);
  
}

void VextOFF(void) //Vext default OFF
{
  pinMode(Vext,OUTPUT);
  digitalWrite(Vext, HIGH);
}
void setup()
{
	Serial.begin(115200);
	VextON();
	delay(100);
	factory_display.init();
	factory_display.clear();

	chipid=ESP.getEfuseMac();//Die Chip-ID ist im Wesentlichen seine MAC-Adresse (Länge: 6 Bytes).
	Serial.printf("ESP32ChipID=%04X",(uint16_t)(chipid>>32));//print High 2 bytes
	Serial.printf("%08X\n",(uint32_t)chipid);//print Low 4bytes.

	attachInterrupt(0,interrupt_GPIO0,FALLING);
	lora_init();
	packet ="Warte auf Datenempfang!";
  factory_display.drawString(0, 10, packet);
  factory_display.display();
  delay(100);
  factory_display.clear();
	pinMode(LED ,OUTPUT);
	digitalWrite(LED, LOW);  
}


void loop()
{
interrupt_handle();
 if(deepsleepflag)
 {
	VextOFF();
	Radio.Sleep();
	SPI.end();
	pinMode(RADIO_DIO_1,ANALOG);
	pinMode(RADIO_NSS,ANALOG);
	pinMode(RADIO_RESET,ANALOG);
	pinMode(RADIO_BUSY,ANALOG);
	pinMode(LORA_CLK,ANALOG);
	pinMode(LORA_MISO,ANALOG);
	pinMode(LORA_MOSI,ANALOG);
	esp_sleep_enable_timer_wakeup(600*1000*(uint64_t)1000);
	esp_deep_sleep_start();
 }

 if(resendflag)
 {
	state = STATE_TX;
	resendflag = false;
 }

if(receiveflag && (state==LOWPOWER) )
{
	receiveflag = false;
	packet ="Inhalt:";
	int i = 0;
	while(i < rxSize)
	{
		packet += rxpacket[i];
		i++;
	}
	packSize = "R_Size: ";
	packSize += String(rxSize,DEC);
	packSize += " R_rssi: ";
	packSize += String(Rssi,DEC);
	send_num = "Sende Nummer: ";
	send_num += String(txNumber,DEC);
	factory_display.drawString(0, 0, show_lora);
  factory_display.drawString(0, 10, packet);
  factory_display.drawString(0, 20, packSize);
  factory_display.drawString(0, 50, send_num);
  factory_display.display();
  delay(10);
  factory_display.clear();
}

switch(state)
  {
    case STATE_TX:
      delay(1000);
      txNumber++;
      sprintf(txpacket,"Ahoi %d,Rssi:%d",txNumber,Rssi); // Sendenachricht die verschickt wird, hier ein freundliches Ahoi!
      Serial.printf("\r\nsending packet \"%s\" , length %d\r\n",txpacket, strlen(txpacket));
      Radio.Send( (uint8_t *)txpacket, strlen(txpacket) );
      state=LOWPOWER;
      break;
    case STATE_RX:
      Serial.println("into RX mode");
      Radio.Rx( 0 );
      digitalWrite(LED, HIGH);
       delay(100);
   digitalWrite(LED, LOW);
      state=LOWPOWER;
      break;
    case LOWPOWER:
      Radio.IrqProcess( );
      break;
    default:
      break;
  }
}

LoRa_pingpong.jpg

[ruessel]

Die Tage war ich mit Fehlersuche beschäftigt. Es hat ein wenig gedauert bis ich bemerkt habe, dass ab der LoRa Version 4.3 die HF Endstufe expliziert per Skript zugeschaltet werden muss und beim Empfang wieder ausgeschaltet werden soll - damit der Empfang wieder volle Empfindlichkeit hat. Ich hatte Meshtastic Probeweise auf V4.3 laufen, dort kommen dann mehr als 500mW Sendeleistung raus (mehrere Kilometer Reichweite). Bei eigener Software ist die Reichweite mit einem V4.2 Skript max. 10 Meter!

Die gute KI sagt dazu:

Antwort ChatGPT nach 9 Minuten Wartezeit:

Ja, dafür gibt es inzwischen eine ziemlich klare Erklärung. Der springende Punkt ist: bei Heltec WiFi LoRa 32 V4.3.1 wurde das HF-Frontend geändert. Heltec dokumentiert, dass der FEM von GC1109 auf KCT8103L umgestellt wurde, damit sich der RX-Pfad per Software zwischen LNA aktiv und Bypass umschalten lässt. In demselben Update wurde GPIO5 als FEM-Steuerpin eingeführt, während GPIO46 wieder frei geworden ist. Genau deshalb kann Code, der auf V4.2 noch lief, auf V4.3/4.3.1 plötzlich keinen brauchbaren Empfang mehr haben, wenn diese Umschaltung nicht explizit gemacht wird.
Meshtastic hat das bereits sauber abgebildet. In variant.h für heltec_v4 ist hinterlegt: GPIO7 schaltet die FEM-Versorgung, GPIO2 aktiviert den KCT8103L, GPIO5 wählt den RX-Modus, und SX1262 DIO2 wird als RF-Switch benutzt. Für den KCT8103L gilt dort ausdrücklich: GPIO5 LOW = RX mit LNA, GPIO5 HIGH = RX-Bypass. Außerdem ist SX126X_DIO2_AS_RF_SWITCH gesetzt, damit der SX1262 den TX/RX-Pfad passend steuert.

Noch deutlicher wird es in Meshtastics LoRaFEMInterface.cpp: Beim Initialisieren des KCT8103L setzt Meshtastic GPIO7 auf HIGH, GPIO2 auf HIGH und GPIO5 auf LOW, mit dem Kommentar „LNA enabled by default“. In einem späteren Fix für Heltec v4.3 steht sogar ausdrücklich, dass Nutzer von v4.3, die das nicht explizit setzen, schlechten RX bekommen. Menschliche Hardwarepflege eben: ein neuer Pin, ein stilles Problem, und dann rätseln alle.

-----------------------------------------------------------------------------------------------

Hier nun explizit ab der Version V4.3 mein neues Skript, das den HF Nachbrenner einschaltet. Das Skript sendet dauernd um Messungen am Modul machen zu können, nach 500 Sekunden schaltet das Modul aus Sicherheit (Wärme) ab. Hier auf dem Schreibtisch liegend mit kurzer Stummelantenne erzeugte das Skript bei einen 1 km (stark bebautes Gebiet) entfernten Kumpel ein fettes Signal, weit über das Grundrauschen!

Code: Alles auswählen

/* Sendertest für Heltec LoRa ab V4 - Vorsicht, nicht ohne Antenne betreiben. Zerstoerungsgefahr!!!!
 *
 * Ruesseltechnik 2026.3.25 
 * */

#include "LoRaWan_APP.h"
#include "Arduino.h"
#include "HT_st7735.h"
#include "HT_SSD1306Wire.h"

#if defined(WIRELESS_TRACKER_V2)
  HT_st7735 st7735;
#endif

#if defined(WIFI_LORA_32_V4) || defined(WIFI_LORA_32_V2)
  SSD1306Wire  factory_display(0x3c, 500000, SDA_OLED, SCL_OLED, GEOMETRY_128_64, RST_OLED);
#endif

#define RF_FREQUENCY                                868000000
#define TX_OUTPUT_POWER                             30

#define LORA_BANDWIDTH                              1
#define LORA_SPREADING_FACTOR                       11
#define LORA_CODINGRATE                             1
#define LORA_PREAMBLE_LENGTH                        8
#define LORA_SYMBOL_TIMEOUT                         0
#define LORA_FIX_LENGTH_PAYLOAD_ON                  false
#define LORA_IQ_INVERSION_ON                        false

#define RX_TIMEOUT_VALUE                            1000
#define BUFFER_SIZE                                 30

char txpacket[BUFFER_SIZE];
char rxpacket[BUFFER_SIZE];

double txNumber;
bool lora_idle = true;

static RadioEvents_t RadioEvents;
void OnTxDone( void );
void OnTxTimeout( void );

void ensureHighPowerPins() {
  // Set the control pins required for high power on Heltec V4.3
  pinMode(7, OUTPUT); digitalWrite(7, HIGH);
  pinMode(2, OUTPUT); digitalWrite(2, HIGH);
  pinMode(5, OUTPUT); digitalWrite(5, HIGH);
  delay(10);
}

void setup() {
    Serial.begin(115200);
    Mcu.begin(HELTEC_BOARD,SLOW_CLK_TPYE);

    txNumber = 0;

    RadioEvents.TxDone = OnTxDone;
    RadioEvents.TxTimeout = OnTxTimeout;

    // --- Wichtig: GPIOs für hohe Sendeleistung VOR Radio.Init setzen ---
    ensureHighPowerPins();
    // -------------------------------------------------------------------

    Radio.Init( &RadioEvents );
    Radio.SetChannel( RF_FREQUENCY );

    // Hinweis: das 'true' in SetTxConfig ist hier so belassen wie im Original.
    // Falls eure Radio-API eine explizite PA_BOOST-Option hat, stellt sicher, dass PA_BOOST verwendet wird.
    Radio.SetTxConfig( MODEM_LORA, TX_OUTPUT_POWER, 0, LORA_BANDWIDTH,
                                   LORA_SPREADING_FACTOR, LORA_CODINGRATE,
                                   LORA_PREAMBLE_LENGTH, LORA_FIX_LENGTH_PAYLOAD_ON,
                                   true, 0, 0, LORA_IQ_INVERSION_ON, 3000 );

#if defined(WIRELESS_TRACKER_V2)
    st7735.st7735_init();
    st7735.st7735_fill_screen(ST7735_BLACK);
    st7735.st7735_write_str(0, 0, (String)"WIRELESS_TRACKER_V2");
    st7735.st7735_write_str(30, 0, (String)RF_FREQUENCY);
#endif

#if defined(WIFI_LORA_32_V4) || defined(WIFI_LORA_32_V2)
  pinMode(Vext,OUTPUT);
  digitalWrite(Vext, LOW);
  delay(100);
  factory_display.init();
  factory_display.clear();
  factory_display.drawString(0, 0, (String)"WIFI_LORA_32_V4");
  factory_display.display();
#endif
}

uint32_t num = 0;
void loop()
{
  // Stelle sicher, dass die High-Power-Pins dauerhaft HIGH bleiben
  ensureHighPowerPins();

  if(num >= 500)
  {
    Serial.println("Test Ende!");
#if defined(WIFI_LORA_32_V4) || defined(WIFI_LORA_32_V2)
    factory_display.clear();
    factory_display.drawString(0, 0, (String)"Test Ende!");
    factory_display.display();
#endif
    while (1) { delay(1000); }
  }

  if(lora_idle == true)
  {
    delay(100);
    txNumber += 0.01;
    sprintf(txpacket,"30dBm %d MHz Nr. %0.2f",RF_FREQUENCY/1000000,txNumber);
#if defined(WIRELESS_TRACKER_V2)
    st7735.st7735_write_str(0, 0, (String)txpacket);
#endif
#if defined(WIFI_LORA_32_V4) || defined(WIFI_LORA_32_V2)
    factory_display.clear();
    factory_display.drawString(0, 0, (String)txpacket);
    factory_display.display();
#endif
    Serial.printf("\r\nsending packet \"%s\" , length %d\r\n",txpacket, strlen(txpacket));

    Radio.Send( (uint8_t *)txpacket, strlen(txpacket) );
    lora_idle = false;
  }
  Radio.IrqProcess();
}

void OnTxDone( void )
{
  // Sicherstellen, dass die Steuerpins nach TX weiterhin HIGH sind
  ensureHighPowerPins();

  Serial.println("TX done......");
  lora_idle = true;
  num++;
}

void OnTxTimeout( void )
{
  // Wenn Radio in Sleep geht, die Pins trotzdem HIGH lassen (PA aktiviert)
  ensureHighPowerPins();

  Radio.Sleep();
  Serial.println("TX Timeout......");
  lora_idle = true;
}

Der geänderte PingPongtest mit eingeschalteten Booster folgt demnächst.

[ruessel]

Weil alles verwirrend ist, hier nochmal in Kurzform der aktuelle Stand mit den Heltec V4 Modulen.

Wie ich sehe, werden wohl von Amazon noch die alten Versionen V4.2 verschickt. Ich habe direkt beim Chinesen bestellt und die letzte Version war dort V4.31 - sie sind beschriftet auf der Platine mit V4.3. Wie unterscheiden sich nun die Versionen? Skripte von der alten V3 Version laufen oft gut auf der V4.2, es haben sich aber in einigen Befehlen kleine Änderungen ergeben und müssen angepasst werden. Bei meinen Versuchen war oft das OLED betroffen, es blieb dunkel.

Dann der leise Knall, die Änderungen von V4.2 auf V4.31. Hier wurde ein Chip geändert und ein Pin gewechselt. Läuft eine LoRa Anwendung für V4.2 auf einen V4.31 fehlen mind. 20 dBm Ausgangsleistung und auch der Empfang soll schlechter sein. Bei mir waren Strecken über 10m nicht machbar. Es MUSS beim Senden der Verstärkerchip erst mit Strom versorgt werden (GPIO 2,5 und 7 auf HIGH setzen) aber Vorsicht: eine Pause von 5 Millisekunden davor setzen, die Umschaltung ist nicht Verzögerungsfrei. Wenn die Information schon gesendet wird, bevor die Leistungsendstufe eingeschaltet wird, fehlt der Anfang der Übertragende Information. Soll das Modul wieder auf Empfang gehen, muss wieder umgestellt werden, sonst ist die Empfängerempfindlichkeit schlechter, auch hier sollte zum Umschalten eine Millisekunde Pause eingefügt werden um den Empfang störungsfrei zu gestalten.

Alles ein Programmieraufwand den man(n) bei V4.2 nicht hatte. Es fehlen dazu auch alle genauen Informationen bei den von Heltec mitgelieferten Demos, anders ausgedrückt: sie laufen ab V4.31 schlicht nicht mehr. Deshalb ist das für mich eigentlich ein völlig anderer Baustein und sollte V5.0 sich nennen. So wie ich in einen Entwicklerforum gelesen habe, sind weitere Änderungen im V4.31 still und heimlich eingeführt worden:

1. einige V4.2 Module schafften fast 1W Sendeleistung (940mW) was verboten ist. Daher wurde ein Widerstand auf der V4.31 Platine von 70 Ohm auf 300 Ohm erhöht, damit wurde die Sendeleistung auf max. 500 mW reduziert. Genaue Messungen dazu stehen bei mir noch aus.

2. V4.31 soll nun vor dem Empfänger ein Tiefpassfilter besitzen um vermeintlich alles unter 800 MHz zu dämpfen und kann so das Grundrauschen kräftig absenken (mehr Empfang schwacher Stationen). Angeblich hilft es auch den Heltec Chip in ein geschirmtes Metallgehäuse einzubauen um nochmals das Grundrauschen zu senken, besonders in der Nähe von anderen Sendern aller Art. Aber Achtung: Beim Einbau in einem Blechgehäuse funktioniert nicht mehr die BT Verbindung, deren Antenne ist im OLED Rahmen verbaut. Es muss dann eine externe 2.4 GHz Antennen verbaut werden, die aber durch eine Widerstandsbrücke 0 Ohm erst aktiv wird und auf der Platine verlötet werden muss. Näheres dazu im Heltec Handbuch.


Da ich keine genauen Infos von Heltec für V4.31 bekommen konnte, habe ich mit der Hilfe der KI Copilot die ganze Umschaltung gestalten können. War nicht einfach, habe der KI viel Details erklären müssen und nach fast 3 Stunden kam der erste Code raus der auch funktionierte. Trotzdem war noch ein wenig Handarbeit nötig damit alles so läuft wie ich mir das vorstellte.

Hier nun der PingPong Code, der auf V4.31 einwandfrei läuft. Beide Heltev V4.31 Module lagen auf meinen Schreibtisch und sendeten sich gegenseitig die Empfangsdaten zu, jede Sekunde einmal PingPong. Die LED leuchtet kurz auf, wenn der Sendecode einwandfrei gelesen werden konnte. Läuft also genauso wie mein altes Skript wie für V3, nur jetzt mit mehr Sendeleistung und wahrscheinlich etwas besserer Empfang. Damit können nun Reichweitentests durchgeführt werden. Ein Gerät zu Hause lassen, das zweite Gerät in das Auto und losfahren bis keine Daten mehr ankommen (weiße LED blitzt nicht mehr), das wäre dann vor Ort die Sendegrenze. Ist natürlich abhängig von den verwendetet Antennen (der mitgelieferte Stummel gehört in die Tonne) und der Umgebung, 800 MHz breitet sich Lichtähnlich aus, Hindernisse wie Wohnblocks oder Wälder können die Reichweite schmälern. Am besten gehts mit hohen Standorten.

Code: Alles auswählen

/*
 * Heltec LoRa V4.31 PingPong Test mit eingeschalteten Booster für 30 dBm Sendeleistung
 * c2026.03.26 Ruesseltechnik / Teilweise KI generiert - Achtung!! Nicht ohne Antenne ausfuehren, Zerstoerungsgefahr!!!!
*/

#include "Arduino.h"
#include "LoRaWan_APP.h"
#include <Wire.h>
#include "HT_SSD1306Wire.h"

/********************************* lora *********************************************/
#define RF_FREQUENCY                                869000000 // Hz - auf angepasster Antenne achten!! Zerstörungsgefahr!!!
#define TX_OUTPUT_POWER                             27        // dBm max.30 - Antenne unbedingt anschliessen!!!
#define LORA_BANDWIDTH                              0         // [0: 125 kHz, 1: 250 kHz, 2: 500 kHz]
#define LORA_SPREADING_FACTOR                       12        // [SF7..SF12]
#define LORA_CODINGRATE                             1         // [1: 4/5, 2: 4/6, 3: 4/7, 4: 4/8]
#define LORA_PREAMBLE_LENGTH                        8
#define LORA_SYMBOL_TIMEOUT                         0
#define LORA_FIX_LENGTH_PAYLOAD_ON                  false
#define LORA_IQ_INVERSION_ON                        false

#define RX_TIMEOUT_VALUE                            1000
#define BUFFER_SIZE                                 30 // Definiere die zu übertragende Datengröße
char txpacket[BUFFER_SIZE];
char rxpacket[BUFFER_SIZE];

/* Heltec V4.3 FEM control pins (KCT8103L) */
#define FEM_VCC_PIN    7   // schaltet FEM-Versorgung (Vfem)
#define FEM_ENABLE_PIN 2   // KCT8103L enable
#define FEM_RXMODE_PIN 5   // RX LNA select: LOW = LNA enabled, HIGH = RX bypass

static RadioEvents_t RadioEvents;
void OnTxDone( void );
void OnTxTimeout( void );
void OnRxDone( uint8_t *payload, uint16_t size, int16_t rssi, int8_t snr );

typedef enum
{
    LOWPOWER,
    STATE_RX,
    STATE_TX
}States_t;

int16_t txNumber;
int16_t rxNumber;
States_t state;
bool sleepMode = false;
int16_t Rssi,rxSize;

String rssi = "RSSI --";
String packSize = "--";
String packet;
String send_num;
String show_lora = "Empfange Daten:"; 

unsigned int counter = 0;
bool receiveflag = false; // Software Flag für LoRa Empfänger, empfangene Daten machen es "wahr"
long lastSendTime = 0;        // Letzte Sendezeit
int interval = 1000;          // Interval zwischen zwei Sendungen
uint64_t chipid;
int16_t RssiDetection = 0;

void OnTxDone( void )
{
  Serial.print("TX done......");
  // Nach TX wieder LNA aktivieren für bestmöglichen Empfang
  digitalWrite(FEM_RXMODE_PIN, LOW);
  state=STATE_RX;
}

void OnTxTimeout( void )
{
  Radio.Sleep( );
  Serial.print("TX Timeout......");
  state=STATE_TX;
}

void OnRxDone( uint8_t *payload, uint16_t size, int16_t rssi, int8_t snr )
{
  rxNumber++;
  Rssi=rssi;
  rxSize=size;
  memcpy(rxpacket, payload, size );
  rxpacket[size]='\0';
  Radio.Sleep( );
  Serial.printf("\r\nreceived packet \"%s\" with Rssi %d , length %d\r\n",rxpacket,Rssi,rxSize);
  Serial.println("Warte um naestes Paket zu senden");
  receiveflag = true;
  // Sicherstellen, dass LNA aktiv ist
  digitalWrite(FEM_RXMODE_PIN, LOW);
  state=STATE_TX;
}

/* FEM initialisieren: FEM-Versorgung, FEM enable, LNA enabled by default */
void fem_init() {
  pinMode(FEM_VCC_PIN, OUTPUT);
  pinMode(FEM_ENABLE_PIN, OUTPUT);
  pinMode(FEM_RXMODE_PIN, OUTPUT);

  digitalWrite(FEM_VCC_PIN, HIGH);    // Vfem einschalten
  digitalWrite(FEM_ENABLE_PIN, HIGH); // KCT8103L aktivieren
  digitalWrite(FEM_RXMODE_PIN, LOW);  // LNA enabled by default
  delay(5);
}

void lora_init(void)
{
  Mcu.begin(HELTEC_BOARD,SLOW_CLK_TPYE);
  fem_init();            // <<< neu: FEM initialisieren bevor Radio initialisiert wird

  txNumber=0;
  Rssi=0;
  rxNumber = 0;
  RadioEvents.TxDone = OnTxDone;
  RadioEvents.TxTimeout = OnTxTimeout;
  RadioEvents.RxDone = OnRxDone;

  Radio.Init( &RadioEvents );
  Radio.SetChannel( RF_FREQUENCY );
  Radio.SetTxConfig( MODEM_LORA, TX_OUTPUT_POWER, 0, LORA_BANDWIDTH,
                                 LORA_SPREADING_FACTOR, LORA_CODINGRATE,
                                 LORA_PREAMBLE_LENGTH, LORA_FIX_LENGTH_PAYLOAD_ON,
                                 true, 0, 0, LORA_IQ_INVERSION_ON, 3000 );

  Radio.SetRxConfig( MODEM_LORA, LORA_BANDWIDTH, LORA_SPREADING_FACTOR,
                                 LORA_CODINGRATE, 0, LORA_PREAMBLE_LENGTH,
                                 LORA_SYMBOL_TIMEOUT, LORA_FIX_LENGTH_PAYLOAD_ON,
                                 0, true, 0, 0, LORA_IQ_INVERSION_ON, true );
  state=STATE_TX;
}

/********************************* lora *********************************************/

SSD1306Wire  factory_display(0x3c, 500000, SDA_OLED, SCL_OLED, GEOMETRY_128_64, RST_OLED); // addr , freq , i2c group , resolution , rst

bool resendflag=false;
bool deepsleepflag=false;
bool interrupt_flag = false;
void interrupt_GPIO0()
{
  interrupt_flag = true;
}
void interrupt_handle(void)
{
  if(interrupt_flag)
  {
    interrupt_flag = false;
    if(digitalRead(0)==0)
    {
      if(rxNumber <=2)
      {
        resendflag=true;
      }
      else
      {
        deepsleepflag=true;
      }
    }
  }
}
void VextON(void)
{
  pinMode(Vext,OUTPUT);
  digitalWrite(Vext, LOW);
}
void VextOFF(void) //Vext default OFF
{
  pinMode(Vext,OUTPUT);
  digitalWrite(Vext, HIGH);
}

void setup()
{
  Serial.begin(115200);
  VextON();
  delay(100);
  factory_display.init();
  factory_display.clear();

  chipid=ESP.getEfuseMac();//Die Chip-ID ist im Wesentlichen seine MAC-Adresse (Länge: 6 Bytes).
  Serial.printf("ESP32ChipID=%04X",(uint16_t)(chipid>>32));//print High 2 bytes
  Serial.printf("%08X\n",(uint32_t)chipid);//print Low 4bytes.

  attachInterrupt(0,interrupt_GPIO0,FALLING);
  lora_init();
  packet ="Warte auf Datenempfang!";
  factory_display.drawString(0, 10, packet);
  factory_display.display();
  delay(100);
  factory_display.clear();
  pinMode(LED ,OUTPUT);
  digitalWrite(LED, LOW);
}

void loop()
{
  interrupt_handle();
  if(deepsleepflag)
  {
    VextOFF();
    Radio.Sleep();
    SPI.end();
    pinMode(RADIO_DIO_1,ANALOG);
    pinMode(RADIO_NSS,ANALOG);
    pinMode(RADIO_RESET,ANALOG);
    pinMode(RADIO_BUSY,ANALOG);
    pinMode(LORA_CLK,ANALOG);
    pinMode(LORA_MISO,ANALOG);
    pinMode(LORA_MOSI,ANALOG);
    esp_sleep_enable_timer_wakeup(600*1000*(uint64_t)1000);
    esp_deep_sleep_start();
  }

  if(resendflag)
  {
    state = STATE_TX;
    resendflag = false;
  }

  if(receiveflag && (state==LOWPOWER) )
  {
    receiveflag = false;
    packet ="Inhalt:";
    int i = 0;
    while(i < rxSize)
    {
      packet += rxpacket[i];
      i++;
    }
    packSize = "R_Size: ";
    packSize += String(rxSize,DEC);
    packSize += " R_rssi: ";
    packSize += String(Rssi,DEC);
    send_num = "Sende Nummer: ";
    send_num += String(txNumber,DEC);
    factory_display.drawString(0, 0, show_lora);
    factory_display.drawString(0, 10, packet);
    factory_display.drawString(0, 20, packSize);
    factory_display.drawString(0, 50, send_num);
    factory_display.display();
    delay(10);
    factory_display.clear();
  }

  switch(state)
  {
    case STATE_TX:
      delay(1000);
      txNumber++;
      // Bypass LNA während TX
      digitalWrite(FEM_RXMODE_PIN, HIGH);
      sprintf(txpacket,"Ahoi %d,Rssi:%d",txNumber,Rssi); // Sendenachricht die verschickt wird
      Serial.printf("\r\nsending packet \"%s\" , length %d\r\n",txpacket, strlen(txpacket));
      Radio.Send( (uint8_t *)txpacket, strlen(txpacket) );
      state=LOWPOWER;
      break;
    case STATE_RX:
      Serial.println("into RX mode");
      // Sicherstellen, dass LNA aktiv ist bevor RX gestartet wird
      digitalWrite(FEM_RXMODE_PIN, LOW);
      Radio.Rx( 0 );
      digitalWrite(LED, HIGH);
      delay(100);
      digitalWrite(LED, LOW);
      state=LOWPOWER;
      break;
    case LOWPOWER:
      Radio.IrqProcess( );
      break;
    default:
      break;
  }
}

Habe zwei Module mit diesen Code geflasht und es geht dann sofort los, beide senden und empfangen nacheinander mit kurzer Antenne. Beide V4.31 lagen nebeneinander auf meinen Schreibtisch (2. Stock höhe). Das Bild unten zeigt den Empfang auf 869 MHz (gelbe Markierung) in ca. 1 km Entfernung, bebautes Gebiet. Bin gespannt wieviel Kilometer ich damit erreiche.......

PingPong.jpg

Als nächstes kommt der Versuch Kameras damit zu steuern.

[ruessel]

Habe nun alle drei in meinen Besitz befindlichen V4.31 vermessen lassen. Der Sketch war auf Sendeleistung 30 dBm einprogrammiert bei 868 MHz.

404mW.png

Das hier war der schwächste Sender mit 404 mW statt den versprochenen 500 mW. Die beiden anderen Modulen hatten 488 mW und 497 mW und waren damit sehr nahe an den versprochenen 27 dBm = 500 mW.

In der Zwischenzeit habe ich mal Meshcore installiert. Geht genauso einfach wie Meshtastic, wird jeweils online über den Browswer programmiert. Meshcore wird in meiner Umgebung doch sehr bevorzugt, ein Rieseneinkaufscenter unterstützt diese Software mit mehreren Repeatern und ein stattlicher Jugendtreff hat wohl ein Sendeverstärker auf dem Dach gebaut, ich hatte nachdem ersten Einschalten und senden der zaghaften Botschaft "Hallo" gleich einen Kontakt. Ich finde spannend wie diese Form der Kommunikation in Deutschland sich entwickeln wird. Wie schon geschrieben verschlüsselt und für stattlichen Stellen wahrscheinlich unsichtbar. Hier ein kleines Infovideo von einem Schweitzer der die Unterschiede gut erklärt:

[ruessel]

Habe gestern das Skript "PingPong" in der Praxis getestet, ein Gerät ins Fenster gestellt, das andere ins Auto und losgefahren. Man muss aufpassen, wenn der Kontakt zwischen zwei LoRa unterbrochen wurde, muss ein Gerät neu gestartet werden um einen neuen Kontakt aufzubauen. An meinen Mobilgerät (in Tupperdose mit Akku eingebaut) habe ich dazu einen Ein/Ausschalter eingebaut. Vielleicht kann das Skript geändert werden, das bei Sendeunterbrechungen nur eine Pause gemacht wird und bei neuen Kontakt der Zähler weiterläuft.

In der Praxis war das Bild in der Stadt mit der kurzen Antenne gemischt. Teilweise nach 500m schon kaum Kontakt, wenn ein hohes Haus in der Funkrichtung dazwischen war. 2 Km weiter gefahren war wieder ein stabiler Kontakt vorhanden, die Funkwellen scheinen um das Haus noch Wege zu finden. Also in der Stadt ein gemischtes Bild. Aus der Stadt rausgefahren, nahm die Leistung pro km um ca. 1 dB ab. Ich war einige Kilometer rausgefahren und hatte eine Empfangsleistung von -98 dB, bis -120 glaube ich, gibt es noch Kontakt. Ich konnte nicht weiterfahren, die Weser versperrte mir den Weg.
An einem Badesee hatte ich diesen Effekt: Auf dem Parkplatz (Entfernung Luftlinie um 2 km, Flach keine Gebäude weit und breit) erhielt ich den Wert -84 dB, 300 Meter weiter entfernt von der Basisstation direkt am Wasser, hatte ich 4 dB bessere Werte - als wenn die große Wasserfläche die Signale gut reflektiert. ich denke auf dem Land dürften 10 km (in Ostfriesland) Reichweite keine große Leistung sein, bei erhöhten Standorten der Antennen auch wesentlich mehr.

P1000015.JPG

[ruessel]

Ich habe das Sketch so angepasst, dass das LoRa‑Modul bei Verbindungsverlust automatisch neu initialisiert und die Ausgabe nach Wiederverbindung weiterläuft, ohne das Gerät stromlos schalten zu müssen. Die Lösung überwacht die Aktivität (Senden/Empfangen) und führt bei Inaktivität eine Reinitialisierung von Radio und FEM durch.

Wichtige Änderungen (kurz)
• Heartbeat / Activity‑Timer "lastActivityMillis" aktualisiert bei TX/RX/Timeout.
• Reconnect‑Timeout "RECONNECT_TIMEOUT_MS" prüft Inaktivität; bei Überschreitung wird aufgerufen.
• radio_reinit "radio_reinit()" initialisiert Radio, Konfiguration und FEM neu, ohne das Gerät neu zu starten.
• Entfernte/angepasste Stellen, die das SPI oder Pins unbeabsichtigt deaktivieren (nur im Deep‑Sleep bleiben diese erhalten).
• Robustere State‑Handhabung: nach Reinit wird "state = STATE_TX" gesetzt, damit der Ablauf weiterläuft.

Hinweise zur Anpassung
• Timeout anpassen: Standard ist 30 Sekunden "RECONNECT_TIMEOUT_MS = 30000". Für instabilere Verbindungen kannst du ihn erhöhen.
• Debug: Serieller Monitor zeigt Reinit‑Meldungen; so siehst du, wann eine Reinitialisierung stattfindet.
• Deep Sleep Verhalten: Unverändert — Deep Sleep schaltet SPI/Pins ab. Reinit wird nur im normalen Betrieb verwendet.

Code: Alles auswählen

/*
 * Heltec LoRa V4.31 PingPong Test mit eingeschalteten Booster für 30 dBm Sendeleistung, Version laeuft bei Unterbrechung nach neuen Kontakt weiter.
 * c2026.03.30 Ruesseltechnik / Teilweise KI generiert - Achtung!! Nicht ohne Antenne ausfuehren, Zerstoerungsgefahr!!!!
*/

#include "Arduino.h"
#include "LoRaWan_APP.h"
#include <Wire.h>
#include "HT_SSD1306Wire.h"

/********************************* lora *********************************************/
#define RF_FREQUENCY                                868000000
#define TX_OUTPUT_POWER                             30
#define LORA_BANDWIDTH                              0
#define LORA_SPREADING_FACTOR                       12
#define LORA_CODINGRATE                             1
#define LORA_PREAMBLE_LENGTH                        8
#define LORA_SYMBOL_TIMEOUT                         0
#define LORA_FIX_LENGTH_PAYLOAD_ON                  false
#define LORA_IQ_INVERSION_ON                        false

#define RX_TIMEOUT_VALUE                            1000
#define BUFFER_SIZE                                 30
char txpacket[BUFFER_SIZE];
char rxpacket[BUFFER_SIZE];

/* Heltec V4.3 FEM control pins (KCT8103L) */
#define FEM_VCC_PIN    7
#define FEM_ENABLE_PIN 2
#define FEM_RXMODE_PIN 5

static RadioEvents_t RadioEvents;
void OnTxDone( void );
void OnTxTimeout( void );
void OnRxDone( uint8_t *payload, uint16_t size, int16_t rssi, int8_t snr );

typedef enum
{
    LOWPOWER,
    STATE_RX,
    STATE_TX
}States_t;

int16_t txNumber;
int16_t rxNumber;
States_t state;
bool sleepMode = false;
int16_t Rssi,rxSize;

String rssi = "RSSI --";
String packSize = "--";
String packet;
String send_num;
String show_lora = "Empfange Daten:"; 

unsigned int counter = 0;
bool receiveflag = false;
long lastSendTime = 0;
int interval = 1000;
uint64_t chipid;
int16_t RssiDetection = 0;

/* --- Neuer Mechanismus: Activity / Reconnect --- */
unsigned long lastActivityMillis = 0;
const unsigned long RECONNECT_TIMEOUT_MS = 30000; // 30s Inaktivität -> Reinit

void updateActivity() {
  lastActivityMillis = millis();
}

void OnTxDone( void )
{
  Serial.println("TX done......");
  digitalWrite(FEM_RXMODE_PIN, LOW); // LNA wieder aktivieren
  state=STATE_RX;
  updateActivity();
}

void OnTxTimeout( void )
{
  Radio.Sleep( );
  Serial.println("TX Timeout......");
  state=STATE_TX;
  updateActivity();
}

void OnRxDone( uint8_t *payload, uint16_t size, int16_t rssi, int8_t snr )
{
  rxNumber++;
  Rssi=rssi;
  rxSize=size;
  memcpy(rxpacket, payload, size );
  rxpacket[size]='\0';
  Radio.Sleep( );
  Serial.printf("\r\nreceived packet \"%s\" with Rssi %d , length %d\r\n",rxpacket,Rssi,rxSize);
  Serial.println("Warte um naestes Paket zu senden");
  receiveflag = true;
  digitalWrite(FEM_RXMODE_PIN, LOW);
  state=STATE_TX;
  updateActivity();
}

/* FEM initialisieren */
void fem_init() {
  pinMode(FEM_VCC_PIN, OUTPUT);
  pinMode(FEM_ENABLE_PIN, OUTPUT);
  pinMode(FEM_RXMODE_PIN, OUTPUT);

  digitalWrite(FEM_VCC_PIN, HIGH);
  digitalWrite(FEM_ENABLE_PIN, HIGH);
  digitalWrite(FEM_RXMODE_PIN, LOW);
  delay(5);
}

/* Radio (Re)Initialisierung in eigene Funktion ausgelagert */
void radio_reinit() {
  Serial.println("Radio Reinit: Starte Neuinitialisierung...");
  // FEM sicherstellen
  fem_init();

  // Radio Events erneut zuweisen (falls verloren)
  RadioEvents.TxDone = OnTxDone;
  RadioEvents.TxTimeout = OnTxTimeout;
  RadioEvents.RxDone = OnRxDone;

  // Radio neu initialisieren und konfigurieren
  Radio.Init( &RadioEvents );
  Radio.SetChannel( RF_FREQUENCY );
  Radio.SetTxConfig( MODEM_LORA, TX_OUTPUT_POWER, 0, LORA_BANDWIDTH,
                                 LORA_SPREADING_FACTOR, LORA_CODINGRATE,
                                 LORA_PREAMBLE_LENGTH, LORA_FIX_LENGTH_PAYLOAD_ON,
                                 true, 0, 0, LORA_IQ_INVERSION_ON, 3000 );

  Radio.SetRxConfig( MODEM_LORA, LORA_BANDWIDTH, LORA_SPREADING_FACTOR,
                                 LORA_CODINGRATE, 0, LORA_PREAMBLE_LENGTH,
                                 LORA_SYMBOL_TIMEOUT, LORA_FIX_LENGTH_PAYLOAD_ON,
                                 0, true, 0, 0, LORA_IQ_INVERSION_ON, true );
  // Nach Reinit in TX starten, damit Ablauf weiterläuft
  state = STATE_TX;
  updateActivity();
  Serial.println("Radio Reinit: Fertig.");
}

void lora_init(void)
{
  Mcu.begin(HELTEC_BOARD,SLOW_CLK_TPYE);
  fem_init();

  txNumber=0;
  Rssi=0;
  rxNumber = 0;
  RadioEvents.TxDone = OnTxDone;
  RadioEvents.TxTimeout = OnTxTimeout;
  RadioEvents.RxDone = OnRxDone;

  Radio.Init( &RadioEvents );
  Radio.SetChannel( RF_FREQUENCY );
  Radio.SetTxConfig( MODEM_LORA, TX_OUTPUT_POWER, 0, LORA_BANDWIDTH,
                                 LORA_SPREADING_FACTOR, LORA_CODINGRATE,
                                 LORA_PREAMBLE_LENGTH, LORA_FIX_LENGTH_PAYLOAD_ON,
                                 true, 0, 0, LORA_IQ_INVERSION_ON, 3000 );

  Radio.SetRxConfig( MODEM_LORA, LORA_BANDWIDTH, LORA_SPREADING_FACTOR,
                                 LORA_CODINGRATE, 0, LORA_PREAMBLE_LENGTH,
                                 LORA_SYMBOL_TIMEOUT, LORA_FIX_LENGTH_PAYLOAD_ON,
                                 0, true, 0, 0, LORA_IQ_INVERSION_ON, true );
  state=STATE_TX;
  updateActivity();
}

/********************************* lora *********************************************/

SSD1306Wire  factory_display(0x3c, 500000, SDA_OLED, SCL_OLED, GEOMETRY_128_64, RST_OLED);

bool resendflag=false;
bool deepsleepflag=false;
bool interrupt_flag = false;
void interrupt_GPIO0()
{
  interrupt_flag = true;
}
void interrupt_handle(void)
{
  if(interrupt_flag)
  {
    interrupt_flag = false;
    if(digitalRead(0)==0)
    {
      if(rxNumber <=2)
      {
        resendflag=true;
      }
      else
      {
        deepsleepflag=true;
      }
    }
  }
}
void VextON(void)
{
  pinMode(Vext,OUTPUT);
  digitalWrite(Vext, LOW);
}
void VextOFF(void) //Vext default OFF
{
  pinMode(Vext,OUTPUT);
  digitalWrite(Vext, HIGH);
}

void setup()
{
  Serial.begin(115200);
  VextON();
  delay(100);
  factory_display.init();
  factory_display.clear();

  chipid=ESP.getEfuseMac();
  Serial.printf("ESP32ChipID=%04X",(uint16_t)(chipid>>32));
  Serial.printf("%08X\n",(uint32_t)chipid);

  attachInterrupt(0,interrupt_GPIO0,FALLING);
  lora_init();
  packet ="Warte auf Datenempfang!";
  factory_display.drawString(0, 10, packet);
  factory_display.display();
  delay(100);
  factory_display.clear();
  pinMode(LED ,OUTPUT);
  digitalWrite(LED, LOW);
}

void loop()
{
  interrupt_handle();
  if(deepsleepflag)
  {
    VextOFF();
    Radio.Sleep();
    SPI.end();
    pinMode(RADIO_DIO_1,ANALOG);
    pinMode(RADIO_NSS,ANALOG);
    pinMode(RADIO_RESET,ANALOG);
    pinMode(RADIO_BUSY,ANALOG);
    pinMode(LORA_CLK,ANALOG);
    pinMode(LORA_MISO,ANALOG);
    pinMode(LORA_MOSI,ANALOG);
    esp_sleep_enable_timer_wakeup(600*1000*(uint64_t)1000);
    esp_deep_sleep_start();
  }

  if(resendflag)
  {
    state = STATE_TX;
    resendflag = false;
  }

  // Wenn ein Paket empfangen wurde und wir im LOWPOWER sind, Anzeige aktualisieren
  if(receiveflag && (state==LOWPOWER) )
  {
    receiveflag = false;
    packet ="Inhalt:";
    int i = 0;
    while(i < rxSize)
    {
      packet += rxpacket[i];
      i++;
    }
    packSize = "R_Size: ";
    packSize += String(rxSize,DEC);
    packSize += " R_rssi: ";
    packSize += String(Rssi,DEC);
    send_num = "Sende Nummer: ";
    send_num += String(txNumber,DEC);
    factory_display.drawString(0, 0, show_lora);
    factory_display.drawString(0, 10, packet);
    factory_display.drawString(0, 20, packSize);
    factory_display.drawString(0, 50, send_num);
    factory_display.display();
    delay(10);
    factory_display.clear();
  }

  // --- Reconnect Check: wenn zu lange keine Aktivität, Radio neu initialisieren ---
  if (millis() - lastActivityMillis > RECONNECT_TIMEOUT_MS) {
    Serial.println("Keine Aktivitaet erkannt: versuche Radio neu zu initialisieren...");
    radio_reinit();
  }

  switch(state)
  {
    case STATE_TX:
      delay(1000);
      txNumber++;
      digitalWrite(FEM_RXMODE_PIN, HIGH); // Bypass LNA während TX
      sprintf(txpacket,"Ahoi %d,Rssi:%d",txNumber,Rssi);
      Serial.printf("\r\nsending packet \"%s\" , length %d\r\n",txpacket, strlen(txpacket));
      Radio.Send( (uint8_t *)txpacket, strlen(txpacket) );
      state=LOWPOWER;
      updateActivity();
      break;
    case STATE_RX:
      Serial.println("into RX mode");
      digitalWrite(FEM_RXMODE_PIN, LOW);
      Radio.Rx( 0 );
      digitalWrite(LED, HIGH);
      delay(100);
      digitalWrite(LED, LOW);
      state=LOWPOWER;
      updateActivity();
      break;
    case LOWPOWER:
      Radio.IrqProcess( );
      break;
    default:
      break;
  }
}

[ruessel]

Als Vorbesteller habe ich mal den neuen Heltec LoRa T114 V2 geordert, mit GPS unter 30,- EUR. Hier ist stromsparend im Solarbetrieb angesagt.

https://heltec.org/project/mesh-node-t114/

[ruessel]

P1000016.JPG

Noch eine kleine Änderung im PingPong, die Empfangszahl (hier -16 dB) ist nun deutlich größer im Display, besonders Unterwegs nun besser ablesbar, siehe Foto.

Code: Alles auswählen

/*
 * Version mit grosser Empfangsstärken Anzeige.
 * Heltec LoRa V4.31 PingPong Test mit eingeschalteten Booster für 30 dBm Sendeleistung, Version laeuft bei Unterbruchung nach neuen Kontakt weiter.
 * c2026.03.30 Ruesseltechnik / Teilweise KI generiert - Achtung!! Nicht ohne Antenne ausfuehren, Zerstoerungsgefahr!!!!
*/

#include "Arduino.h"
#include "LoRaWan_APP.h"
#include <Wire.h>
#include "HT_SSD1306Wire.h"

/********************************* lora *********************************************/
#define RF_FREQUENCY                                868000000
#define TX_OUTPUT_POWER                             30
#define LORA_BANDWIDTH                              0
#define LORA_SPREADING_FACTOR                       12
#define LORA_CODINGRATE                             1
#define LORA_PREAMBLE_LENGTH                        8
#define LORA_SYMBOL_TIMEOUT                         0
#define LORA_FIX_LENGTH_PAYLOAD_ON                  false
#define LORA_IQ_INVERSION_ON                        false

#define RX_TIMEOUT_VALUE                            1000
#define BUFFER_SIZE                                 30
char txpacket[BUFFER_SIZE];
char rxpacket[BUFFER_SIZE];

/* Heltec V4.3 FEM control pins (KCT8103L) */
#define FEM_VCC_PIN    7
#define FEM_ENABLE_PIN 2
#define FEM_RXMODE_PIN 5

static RadioEvents_t RadioEvents;
void OnTxDone( void );
void OnTxTimeout( void );
void OnRxDone( uint8_t *payload, uint16_t size, int16_t rssi, int8_t snr );

typedef enum
{
    LOWPOWER,
    STATE_RX,
    STATE_TX
} States_t;

int16_t txNumber;
int16_t rxNumber;
States_t state;
bool sleepMode = false;
int16_t Rssi, rxSize;

String rssi = "RSSI --";
String packSize = "--";
String packet;
String send_num;
String show_lora = "Empfange Daten:";

unsigned int counter = 0;
bool receiveflag = false;
long lastSendTime = 0;
int interval = 1000;
uint64_t chipid;
int16_t RssiDetection = 0;

/* --- Neuer Mechanismus: Activity / Reconnect --- */
unsigned long lastActivityMillis = 0;
const unsigned long RECONNECT_TIMEOUT_MS = 10000; // 10s Inaktivität -> Reinit

void updateActivity() {
  lastActivityMillis = millis();
}

void OnTxDone( void )
{
  Serial.println("TX done......");
  digitalWrite(FEM_RXMODE_PIN, LOW); // LNA wieder aktivieren
  state = STATE_RX;
  updateActivity();
}

void OnTxTimeout( void )
{
  Radio.Sleep();
  Serial.println("TX Timeout......");
  state = STATE_TX;
  updateActivity();
}

void OnRxDone( uint8_t *payload, uint16_t size, int16_t rssi, int8_t snr )
{
  rxNumber++;
  Rssi = rssi;
  rxSize = size;
  memcpy(rxpacket, payload, size);
  rxpacket[size] = '\0';
  Radio.Sleep();
  Serial.printf("\r\nreceived packet \"%s\" with Rssi %d , length %d\r\n", rxpacket, Rssi, rxSize);
  Serial.println("Warte um naestes Paket zu senden");
  receiveflag = true;
  digitalWrite(FEM_RXMODE_PIN, LOW);
  state = STATE_TX;
  updateActivity();
}

/* FEM initialisieren */
void fem_init() {
  pinMode(FEM_VCC_PIN, OUTPUT);
  pinMode(FEM_ENABLE_PIN, OUTPUT);
  pinMode(FEM_RXMODE_PIN, OUTPUT);

  digitalWrite(FEM_VCC_PIN, HIGH);
  digitalWrite(FEM_ENABLE_PIN, HIGH);
  digitalWrite(FEM_RXMODE_PIN, LOW);
  delay(5);
}

/* Radio (Re)Initialisierung in eigene Funktion ausgelagert */
void radio_reinit() {
  Serial.println("Radio Reinit: Starte Neuinitialisierung...");
  fem_init();

  RadioEvents.TxDone = OnTxDone;
  RadioEvents.TxTimeout = OnTxTimeout;
  RadioEvents.RxDone = OnRxDone;

  Radio.Init(&RadioEvents);
  Radio.SetChannel(RF_FREQUENCY);
  Radio.SetTxConfig(MODEM_LORA, TX_OUTPUT_POWER, 0, LORA_BANDWIDTH,
                    LORA_SPREADING_FACTOR, LORA_CODINGRATE,
                    LORA_PREAMBLE_LENGTH, LORA_FIX_LENGTH_PAYLOAD_ON,
                    true, 0, 0, LORA_IQ_INVERSION_ON, 3000);

  Radio.SetRxConfig(MODEM_LORA, LORA_BANDWIDTH, LORA_SPREADING_FACTOR,
                    LORA_CODINGRATE, 0, LORA_PREAMBLE_LENGTH,
                    LORA_SYMBOL_TIMEOUT, LORA_FIX_LENGTH_PAYLOAD_ON,
                    0, true, 0, 0, LORA_IQ_INVERSION_ON, true);

  state = STATE_TX;
  updateActivity();
  Serial.println("Radio Reinit: Fertig.");
}

void lora_init(void)
{
  Mcu.begin(HELTEC_BOARD, SLOW_CLK_TPYE);
  fem_init();

  txNumber = 0;
  Rssi = 0;
  rxNumber = 0;
  RadioEvents.TxDone = OnTxDone;
  RadioEvents.TxTimeout = OnTxTimeout;
  RadioEvents.RxDone = OnRxDone;

  Radio.Init(&RadioEvents);
  Radio.SetChannel(RF_FREQUENCY);
  Radio.SetTxConfig(MODEM_LORA, TX_OUTPUT_POWER, 0, LORA_BANDWIDTH,
                    LORA_SPREADING_FACTOR, LORA_CODINGRATE,
                    LORA_PREAMBLE_LENGTH, LORA_FIX_LENGTH_PAYLOAD_ON,
                    true, 0, 0, LORA_IQ_INVERSION_ON, 3000);

  Radio.SetRxConfig(MODEM_LORA, LORA_BANDWIDTH, LORA_SPREADING_FACTOR,
                    LORA_CODINGRATE, 0, LORA_PREAMBLE_LENGTH,
                    LORA_SYMBOL_TIMEOUT, LORA_FIX_LENGTH_PAYLOAD_ON,
                    0, true, 0, 0, LORA_IQ_INVERSION_ON, true);

  state = STATE_TX;
  updateActivity();
}

/********************************* lora *********************************************/

SSD1306Wire factory_display(0x3c, 500000, SDA_OLED, SCL_OLED, GEOMETRY_128_64, RST_OLED);

bool resendflag = false;
bool deepsleepflag = false;
bool interrupt_flag = false;
void interrupt_GPIO0()
{
  interrupt_flag = true;
}
void interrupt_handle(void)
{
  if (interrupt_flag)
  {
    interrupt_flag = false;
    if (digitalRead(0) == 0)
    {
      if (rxNumber <= 2)
      {
        resendflag = true;
      }
      else
      {
        deepsleepflag = true;
      }
    }
  }
}
void VextON(void)
{
  pinMode(Vext, OUTPUT);
  digitalWrite(Vext, LOW);
}
void VextOFF(void) //Vext default OFF
{
  pinMode(Vext, OUTPUT);
  digitalWrite(Vext, HIGH);
}

void setup()
{
  Serial.begin(115200);
  VextON();
  delay(100);
  factory_display.init();
  factory_display.clear();

  chipid = ESP.getEfuseMac();
  Serial.printf("ESP32ChipID=%04X", (uint16_t)(chipid >> 32));
  Serial.printf("%08X\n", (uint32_t)chipid);

  attachInterrupt(0, interrupt_GPIO0, FALLING);
  lora_init();
  packet = "Warte auf Datenempfang!";
  factory_display.setFont(ArialMT_Plain_10);
  factory_display.drawString(0, 10, packet);
  factory_display.display();
  delay(100);
  factory_display.clear();
  pinMode(LED, OUTPUT);
  digitalWrite(LED, LOW);
}

void loop()
{
  interrupt_handle();
  if (deepsleepflag)
  {
    VextOFF();
    Radio.Sleep();
    SPI.end();
    pinMode(RADIO_DIO_1, ANALOG);
    pinMode(RADIO_NSS, ANALOG);
    pinMode(RADIO_RESET, ANALOG);
    pinMode(RADIO_BUSY, ANALOG);
    pinMode(LORA_CLK, ANALOG);
    pinMode(LORA_MISO, ANALOG);
    pinMode(LORA_MOSI, ANALOG);
    esp_sleep_enable_timer_wakeup(600 * 1000 * (uint64_t)1000);
    esp_deep_sleep_start();
  }

  if (resendflag)
  {
    state = STATE_TX;
    resendflag = false;
  }

  // Wenn ein Paket empfangen wurde und wir im LOWPOWER sind, Anzeige aktualisieren
  if (receiveflag && (state == LOWPOWER))
  {
    receiveflag = false;
    packet = "Inhalt:";
    int i = 0;
    while (i < rxSize)
    {
      packet += rxpacket[i];
      i++;
    }

    // packSize wird weiterhin gebildet, aber R_rssi wird nicht in dieser Zeile angezeigt
    packSize = "R_Size: ";
    packSize += String(rxSize, DEC);

    send_num = "Sende Nummer: ";
    send_num += String(txNumber, DEC);

    // RSSI als eigene Anzeige vorbereiten
    String rssiValue = String(Rssi, DEC); // z.B. "-72"
    String rssiUnit = "dBm";
    String rxLabel = "RX";

    // Zeichne normale Texte mit kleiner Schrift (oben)
    factory_display.setFont(ArialMT_Plain_10);
    // Erste Zeile wieder wie gewünscht: "Empfange Daten:"
    factory_display.drawString(0, 0, show_lora);

    // Pakettext in Zeile 2: Y etwas tiefer setzen, damit die große Zahl nicht überlappt
    factory_display.drawString(0, 12, packet);

    // Große RSSI-Anzeige: ArialMT_Plain_24 (größer nicht verfügbar)
    // Wir fügen jetzt links vor der großen Zahl das Label "RX" in kleiner Schrift ein.
    factory_display.setFont(ArialMT_Plain_24);
    int numWidth = factory_display.getStringWidth(rssiValue);

    // Einheit in kleiner Schrift messen
    factory_display.setFont(ArialMT_Plain_10);
    int unitWidth = factory_display.getStringWidth(rssiUnit);

    // "RX" in kleiner Schrift messen
    int rxLabelWidth = factory_display.getStringWidth(rxLabel);

    int spacingLabel = 6; // Abstand zwischen "RX" und großer Zahl
    int spacingUnit = 6;  // Abstand zwischen großer Zahl und Einheit
    int totalWidth = rxLabelWidth + spacingLabel + numWidth + spacingUnit + unitWidth;
    int xStart = (128 - totalWidth) / 2;
    if (xStart < 0) xStart = 0;

    // Y-Position jetzt einige Pixel weiter nach unten verschoben, damit oben weniger Leerraum ist
    // und die große Zahl nicht in Zeile 2 hineinragt. Wert leicht erhöht gegenüber vorher (z.B. 26).
    int yNumber = 26;

    // Zeichne "RX" (kleine Schrift) links von der großen Zahl
    factory_display.setFont(ArialMT_Plain_10);
    factory_display.drawString(xStart, yNumber + 8, rxLabel);

    // Zahl zeichnen (große Schrift) rechts von "RX"
    factory_display.setFont(ArialMT_Plain_24);
    int xNumber = xStart + rxLabelWidth + spacingLabel;
    factory_display.drawString(xNumber, yNumber, rssiValue);

    // Einheit rechts neben der Zahl in kleiner Schrift, vertikal leicht versetzt
    factory_display.setFont(ArialMT_Plain_10);
    factory_display.drawString(xNumber + numWidth + spacingUnit, yNumber + 8, rssiUnit);

    // Unter der großen Zahl nur noch Sende-Nummer (keine R_Size / R_rssi)
    factory_display.setFont(ArialMT_Plain_10);
    factory_display.drawString(0, 54, send_num);

    factory_display.display();
    delay(10);
    factory_display.clear();
  }

  // --- Reconnect Check: wenn zu lange keine Aktivität, Radio neu initialisieren ---
  if (millis() - lastActivityMillis > RECONNECT_TIMEOUT_MS) {
    Serial.println("Keine Aktivitaet erkannt: versuche Radio neu zu initialisieren...");
    radio_reinit();
  }

  switch (state)
  {
    case STATE_TX:
      delay(1000);
      txNumber++;
      digitalWrite(FEM_RXMODE_PIN, HIGH); // Bypass LNA während TX
      sprintf(txpacket, "Ahoi %d,Rssi:%d", txNumber, Rssi);
      Serial.printf("\r\nsending packet \"%s\" , length %d\r\n", txpacket, strlen(txpacket));
      Radio.Send((uint8_t *)txpacket, strlen(txpacket));
      state = LOWPOWER;
      updateActivity();
      break;
    case STATE_RX:
      Serial.println("into RX mode");
      digitalWrite(FEM_RXMODE_PIN, LOW);
      Radio.Rx(0);
      digitalWrite(LED, HIGH);
      delay(100);
      digitalWrite(LED, LOW);
      state = LOWPOWER;
      updateActivity();
      break;
    case LOWPOWER:
      Radio.IrqProcess();
      break;
    default:
      break;
  }
}

[ruessel]

P1000021.JPG

Die KI sagte, es geht noch mehr.... die Empfangsdaten haben nun Einheiten bekommen und es wurde im Display aufgeräumt. Siehe Bild oben.
Den Code habe ich oben gegen den neuen ausgetauscht...... aus Spaß habe ich bei meinen LoRas die Sendeleistung ganz herunter gedreht (-9 entspricht 1.8 mW) und bin aus dem Haus mehrere 100m weit gekommen, erst ein Wohnblock unterbrach die Verbindung. Dabei waren die Original von Heltec mitgelieferten kleinen Antennen drauf, die bekannt für schlechtes Abstrahlverhalten sind.

Hier ist die Heltec Tabelle für die Ausgangsleistung zur Antenne: https://github.com/meshcore-dev/MeshCore/issues/1403
so sehen wir, 0 = 11.3 dBm oder 22 = 29 dBm; also sind Werte über 22 sinnlos da schon am maximum, schaden tun sie aber auch nicht.

[ruessel]

1GHz.png

Hier ein Heltec V4.3 auf 1 GHz programmiert, hier kommen kräftige 26 dBm heraus! Runter in der Frequenz habe ich das Teil lückenlos auf 250 MHz ziehen können, da aber mit deutlichen HF Verlusten, die Platine ist dafür nicht konstruiert.




Falls jemand mit LoRa V4 spielen möchte, seit gerade eben wieder relativ günstig (max. 25 Stück inkl. der GPS Platine) in DE zu bekommen, ab 2 Stück Versandkostenfrei aus München: https://openelab.io/de/products/heltec-wifi-lora-32-v4

[ruessel]

Habe die KI gefragt ob eine Fernbedienung der BMD Pocket 6K mit dem Heltec V4.3 möglich wäre. Darauf folgte nach fast 30 Minuten Denkzeit die folgende blumige Antwort:

Kurzantwort: Ja — technisch ist eine vollständige Bluetooth‑Fernsteuerung der Blackmagic Pocket Cinema Camera 6K mit dem Heltec V4 (ESP32‑S3, BLE-fähig) realisierbar, erfordert aber Reverse‑Engineering der BLE‑GATT‑Services oder Nutzung bestehender Open‑Source‑Implementierungen als Vorlage; mit ESP‑IDF/NimBLE oder Arduino‑BLE, einem kleinen UI/Encoder und Tests mit nRF Connect lässt sich ein stabiles Remote bauen.
Machbarkeit und wichtigste Fakten
• Heltec V4 (ESP32‑S3) hat native Bluetooth Low Energy und ist für solche Projekte geeignet.
• Blackmagic Kameras bieten ein BLE‑Protokoll, das bereits von Desktop‑Apps und kommerziellen Controllern genutzt wird — Open‑Source‑Clients (z. B. CutePocketRemote) zeigen, dass Steuerbefehle per BLE möglich sind.
• Es gibt fertige Apps/Produkte (Bluetooth+ App, HaloRC), die als Referenz für unterstützte Funktionen und Reichweite dienen.

Konkreter Umsetzungsplan (Kurzversion)
Hardware
• Heltec WiFi LoRa 32 V4 (ESP32‑S3) mit USB‑C, Akkuversorgung; optional kleines Touch/Encoder + Gehäuse.
Software / Firmware
• ESP‑IDF (NimBLE) oder Arduino‑BLE als BLE‑Client; implementiere GATT‑Discovery, Pairing und Subscribe auf relevanten Characteristics.
• Nutze CutePocketRemote als Referenz für GATT‑IDs und Befehlsabläufe; analysiere mit nRF Connect oder Wireshark (BLE‑HCI) die Kommunikation beim Smartphone/Desktop‑Client.
Funktionen, die realistisch sind
• Start/Stop Aufnahme, Foto auslösen, ISO/Shutter/Aperture ändern, Weißabgleich, Fokussteuerung (relativ/absolut je nach Objektiv) — bereits in Open‑Source‑Clients implementiert.

Schritt‑für‑Schritt Umsetzung (technisch)
1. Referenz‑Client testen (Desktop/Phone) und mit nRF Connect GATT‑Profile beobachten.
2. Heltec als BLE‑Client programmieren: Scan → Pair → Discover → Subscribe. Verwende NimBLE für stabilen Low‑power‑Betrieb.
3. Mapping der Commands: Buttons/Encoder → GATT‑Writes/Notifications. Implementiere Retry/ACK‑Handling.
4. UI & Power: kleines OLED/Encoder oder Touch; Akku‑Management beachten (deep sleep, Wake on BLE optional).

Risiken, Einschränkungen & Tipps
• Protokoll‑Änderungen durch Blackmagic können Kompatibilität brechen; halte Firmware‑Update‑Pfad offen.
• Pairing/Authentifizierung: Kamera kann Pairing‑Verhalten ändern; teste mit mehreren Firmware‑Ständen.
• Reichweite & Latenz: BLE ist kurzreichweitig (~10–30 m praktisch) und nicht für extrem niedrige Latenz kritischer Fokus‑Motoren gedacht.

Empfehlung & Aufwand
• Schnellstart: Klone CutePocketRemote zur Analyse, baue ein Minimal‑Proof‑of‑Concept auf Heltec (Record/Stop + Status).
• Geschätzter Aufwand: 1–2 Wochen für POC (erfahrener ESP32‑Entwickler), 4–8 Wochen für robustes Produkt mit UI, Gehäuse und Akku‑Management.
Wenn du willst, liefere ich ein konkretes Hardware‑Teile‑Listing, eine minimal funktionale Firmware‑Skizze (NimBLE) und ein Test‑Protokoll zum Nachmessen der GATT‑Services — ich kann das direkt ausarbeiten und Beispielcode bereitstellen.

Ich habe da eine andere Idee zur Umsetzung, 8 Wochen zur Realisierung wäre mir eigentlich zu lang.........

[ruessel]

P1000022.JPG

Um die Ausgänge kennen zu lernen habe ich mal mit dem Heltec V4.3 eine Ampel realisiert. Wie üblich muss jede LED einen Vorwiderstand von 200 Ohm - 1Kohm besitzen, damit die Ausgänge nicht vom Strom beschädigt werden. Das Skript funzte sofort, ist ja auch keine große Programmierleistung. Im Foto die roten Pfeile zeigen noch weitere Ausgänge wo ich vergessen habe, weitere Beinchen anzulöten. Viele GPIOs haben eine Doppelbelegung, bei LEDs sollte man wohl die Anschlüsse für das OLED oder LoRa meiden, bin aber nicht sicher....


Hier mein Ampelcode:

Code: Alles auswählen

// Ampel-Demo für Heltec V4 (GPIO 19,48,33)
// Rot = 19, Gelb = 48, Grün = 33
const int PIN_RED = 19;
const int PIN_YELLOW = 48;
const int PIN_GREEN = 33;

void setup() {
  pinMode(PIN_RED, OUTPUT);
  pinMode(PIN_YELLOW, OUTPUT);
  pinMode(PIN_GREEN, OUTPUT);
  // Alle LEDs aus
  digitalWrite(PIN_RED, LOW);
  digitalWrite(PIN_YELLOW, LOW);
  digitalWrite(PIN_GREEN, LOW);
}

void loop() {
  // Rot an, Grün aus
  digitalWrite(PIN_RED, HIGH);
  digitalWrite(PIN_YELLOW, LOW);
  digitalWrite(PIN_GREEN, LOW);
  delay(5000); // 5 s

  // Rot+Gelb (Übergang)
  digitalWrite(PIN_RED, HIGH);
  digitalWrite(PIN_YELLOW, HIGH);
  digitalWrite(PIN_GREEN, LOW);
  delay(2000); // 2 s

  // Grün an
  digitalWrite(PIN_RED, LOW);
  digitalWrite(PIN_YELLOW, LOW);
  digitalWrite(PIN_GREEN, HIGH);
  delay(5000); // 5 s

  // Gelb (Warnung)
  digitalWrite(PIN_RED, LOW);
  digitalWrite(PIN_YELLOW, HIGH);
  digitalWrite(PIN_GREEN, LOW);
  delay(2000); // 2 s
}

Das ist eine Übung für den nächsten schritt, eine (gesicherte) Funkverbindung zu einem zweiten Modul (über Kilometer hinweg) um dort die Ausgänge aktiv zu schalten um bei Kameras irgendwelche Reaktionen (Verschluss, Start/Stopp etc) auszulösen. Dabei sollte es einen Rückkanal geben, der auf dem OLED die erfolgreiche Auslösung meldet und auch den Status ON/Off aller Schaltkanäle.

Heute habe ich noch eine Versandbestätigung für ein Stromsparendes LoRa Modul von Heltec bekommen: https://openelab.io/de/products/heltec- ... 2588757190 den möchte ich für einen Solarbetriebenen Repeater austesten, um die Reichweite nochmal zu erweitern.

[ruessel]

P1000024.JPG

Heute wollte ich die zwei neuen Module Heltec V4.3 freischalten. Das Skript dazu lässt sich aufspielen und zeigt auch die Seriennummer an, beim Eingeben des Freischaltcodes kommt aber keine Antwort mehr. Beim zweiten Modul das gleiche neue Verhalten. Insgesamt habe ich nun 7 Module freigeschaltet (für volle Sendeleistung), 5 davon gaben kurze Meldung mit dem Erfolg heraus.

Die beiden Module sind Brandfrisch aus der Produktion, gestern erst aus China angekommen. Um zu testen ob die Freischaltung einwandfrei geklappt hat, habe ich mein Sendeskript aufgespielt und mit kurzer Antenne in 1 Km Entfernung das Signal auf 868 MHz empfangen (siehe Bild unten) - ist also freigeschaltet - auch ohne Antwort aus dem Modul. Scheint nun normal zu sein, ich hoffe Heltec hat nicht noch mehr geändert.

P1000022a.JPG

Das dicke Signal auf genau 868 MHz ist das das neue Modul, rechts daneben die kurzen Striche sind Autos. Ihre Reifenventile senden kurze Druckluftstände in die Luft. Mit einem guten Empfänger/Antenne kann man diese Daten bis 50m empfangen. Es gibt sogar Softwaremodule die diese Striche zu Daten einblenden können, was interessiert mich aber der Luftdruck in Nachbars Reifen?