Wednesday 29 April 2026 4 versions

Gemini 1 ¶

Um den Heltec WiFi LoRa 32 V3 mit CircuitPython und LoRa zu nutzen, musst du zuerst die passende CircuitPython-Firmware flashen und anschließend eine Treiber-Bibliothek für den verbauten SX1262-Chip verwenden. [1, 2]

1. CircuitPython installieren ¶

Das Heltec V3 Board basiert auf dem ESP32-S3. [1]

Lade die passende Firmware von der offiziellen CircuitPython-Seite für das heltec_esp32s3_wifi_lora_v3 herunter.
Bringe das Board in den Bootloader-Modus (PRG-Taste gedrückt halten beim Anschließen oder Reset drücken) und flashe die .bin-Datei. [1, 3, 4, 5]

2. LoRa-Bibliothek hinzufügen ¶

Da der Heltec V3 den SX1262 LoRa-Chip nutzt, benötigst du einen Treiber, der diesen unterstützt. Die Standard adafruit_circuitpython_rfm9x Bibliothek ist primär für ältere Chips (SX127x) gedacht. [5, 6]

Nutze stattdessen eine Bibliothek wie micropySX126X, die für CircuitPython portiert wurde.
Kopiere die Bibliotheksdateien in den lib-Ordner auf deinem CIRCUITPY-Laufwerk. [2, 7]

3. Pin-Konfiguration (Wichtig) ¶

Die interne Verschaltung des LoRa-Chips beim V3 ist fest vorgegeben. Du musst diese Pins in deinem Python-Skript definieren: [8, 9]

Funktion [9]	GPIO Pin (V3)
SCK (SPI Clock)	9
MOSI	10
MISO	11
CS (NSS)	8
Reset	12
Busy	13
DIO1 (Interrupt)	14

4. Code-Beispiel (Prinzip) ¶

Hier ist ein grober Aufbau, wie die Initialisierung in CircuitPython aussieht:

 1import board
 2import busio
 3import digitalio
 4# Beispiel mit der micropySX126X oder ähnlichen Treibernfrom sx1262 
 5import SX1262
 6
 7# SPI Bus initialisieren
 8spi = busio.SPI(board.IO9, MOSI=board.IO10, MISO=board.IO11)
 9
10# LoRa Modul initialisieren
11lora = SX1262(
12    spi,
13    cs=board.IO8,
14    irq=board.IO14,
15    rst=board.IO12,
16    gpio=board.IO13 # Busy Pin
17)
18
19lora.begin()
20lora.setFrequency(868.0) # Frequenz für Europa

Zusätzliche Tipps:

Antenne: Schließe immer die mitgelieferte LoRa-Antenne an den U.FL-Anschluss (neben dem V3-Logo) an, bevor du sendest, um den Chip nicht zu beschädigen. [10, 11]
Vext: Beim Heltec V3 muss oft der Pin GPIO18 (Vext) auf Low gezogen werden, um Peripheriegeräte wie das Display oder externe Sensoren mit Strom zu versorgen. [8]

Möchtest du ein konkretes Sende- oder Empfangsskript für deine erste Verbindung sehen?

[1] https://circuitpython.org
[2] https://github.com
[3] https://icssw.org
[4] https://openelab.io
[5] https://heltec.org
[6] https://heltec.org
[7] https://polluxlabs.net
[8] https://community.heltec.cn
[9] https://eddyds-smarthome.de
[10] https://www.youtube.com
[11] https://gist.github.com

 1import board
 2import busio
 3import digitalio
 4# Beispiel mit der micropySX126X oder ähnlichen Treibern
 5from sx1262 import SX1262 
 6
 7# SPI Bus initialisieren
 8spi = busio.SPI(board.IO9, MOSI=board.IO10, MISO=board.IO11)
 9
10# LoRa Modul initialisieren
11lora = SX1262(
12    spi,
13    cs=board.IO8,
14    irq=board.IO14,
15    rst=board.IO12,
16    gpio=board.IO13 # Busy Pin
17)
18
19lora.begin()
20lora.setFrequency(868.0) # Frequenz für Europa

Gemini 2 ¶

Hier ist ein vollständiges Beispiel für ein einfaches Sende- und Empfangsskript. Wir nutzen dafür die Bibliothek micropySX126X, da sie speziell für den SX1262-Chip des Heltec V3 in CircuitPython und MicroPython entwickelt wurde. [1, 2]

Vorbereitung ¶

Lade die Datei sx1262.py von GitHub (micropySX126X) herunter.
Kopiere die Datei in den Ordner lib auf deinem CIRCUITPY-Laufwerk. [3]

1. LoRa Sender (Transmitter) ¶

Dieses Skript sendet alle zwei Sekunden eine Nachricht (“Hallo LoRa!”). [4]

 1import board
 2import busio
 3import time
 4import digitalio
 5from sx1262 import SX1262
 6
 7# Vext aktivieren (Stromversorgung für Peripherie beim Heltec V3)
 8vext = digitalio.DigitalInOut(board.IO18) # Vext Control Pin
 9vext.direction = digitalio.Direction.OUTPUT
10vext.value = False # LOW aktiviert Vext beim V3
11
12# SPI-Bus mit V3-spezifischen Pins initialisieren
13spi = busio.SPI(board.IO9, MOSI=board.IO10, MISO=board.IO11)
14
15# SX1262 Konfiguration für Heltec V3
16lora = SX1262(
17    spi,
18    cs=board.IO8,
19    irq=board.IO14,
20    rst=board.IO12,
21    gpio=board.IO13 # Busy Pin
22)
23
24lora.begin()
25lora.setFrequency(868.0) # Frequenz für Europa
26
27while True:
28    print("Sende Nachricht...")
29    lora.send(b"Hallo LoRa!")
30    time.sleep(2)

2. LoRa Empfänger (Receiver) ¶

Dieses Skript wartet kontinuierlich auf eingehende Daten und gibt diese im seriellen Monitor aus. [4]

 1import board
 2import busio
 3import digitalio
 4from sx1262 import SX1262
 5
 6# Vext aktivieren (wie oben)
 7vext = digitalio.DigitalInOut(board.IO18)
 8vext.direction = digitalio.Direction.OUTPUT
 9vext.value = False
10
11# SPI initialisieren
12spi = busio.SPI(board.IO9, MOSI=board.IO10, MISO=board.IO11)
13
14# SX1262 initialisieren
15lora = SX1262(spi, cs=board.IO8, irq=board.IO14, rst=board.IO12, gpio=board.IO13)
16lora.begin()
17lora.setFrequency(868.0)
18
19print("Warte auf Daten...")
20
21while True:
22    payload, status = lora.recv() # Blockiert bis Daten kommen
23    if payload:
24        print("Empfangen:", payload.decode())
25        print("Status:", status)

Wichtige Hinweise für den Heltec V3: ¶

Vext Control: Pin IO18 muss auf False (Low) gesetzt werden, damit der LoRa-Chip und andere Komponenten stabil mit Strom versorgt werden.
Antenne: Betreibe das Board niemals ohne die U.FL-Antenne, da der SX1262 beim Senden ohne Last durchbrennen kann.
Interne Pins: Die Pins für SPI (9, 10, 11) und LoRa-Control (8, 12, 13, 14) sind auf dem Board fest verdrahtet und können nicht frei gewählt werden. [5, 6, 7, 8]

Soll ich dir zeigen, wie du die empfangenen Nachrichten zusätzlich auf dem integrierten OLED-Display anzeigst?

[1] https://github.com
[2] https://github.com
[3] https://learn.adafruit.com
[4] https://www.slashcam.de
[5] https://community.heltec.cn
[6] https://github.com
[7] https://www.youtube.com
[8] https://community.heltec.cn

LoRa Sender:

 1import board
 2import busio
 3import time
 4import digitalio
 5from sx1262 import SX1262
 6
 7# Vext aktivieren (Stromversorgung für Peripherie beim Heltec V3)
 8vext = digitalio.DigitalInOut(board.IO18) # Vext Control Pin
 9vext.direction = digitalio.Direction.OUTPUT
10vext.value = False # LOW aktiviert Vext beim V3
11
12# SPI-Bus mit V3-spezifischen Pins initialisieren
13spi = busio.SPI(board.IO9, MOSI=board.IO10, MISO=board.IO11)
14
15# SX1262 Konfiguration für Heltec V3
16lora = SX1262(
17    spi,
18    cs=board.IO8,
19    irq=board.IO14,
20    rst=board.IO12,
21    gpio=board.IO13 # Busy Pin
22)
23
24lora.begin()
25lora.setFrequency(868.0) # Frequenz für Europa
26
27while True:
28    print("Sende Nachricht...")
29    lora.send(b"Hallo LoRa!")
30    time.sleep(2)

LoRa Receiver:

 1import board
 2import busio
 3import digitalio
 4from sx1262 import SX1262
 5
 6# Vext aktivieren (wie oben)
 7vext = digitalio.DigitalInOut(board.IO18)
 8vext.direction = digitalio.Direction.OUTPUT
 9vext.value = False
10
11# SPI initialisieren
12spi = busio.SPI(board.IO9, MOSI=board.IO10, MISO=board.IO11)
13
14# SX1262 initialisieren
15lora = SX1262(spi, cs=board.IO8, irq=board.IO14, rst=board.IO12, gpio=board.IO13)
16lora.begin()
17lora.setFrequency(868.0)
18
19print("Warte auf Daten...")
20
21while True:
22    payload, status = lora.recv() # Blockiert bis Daten kommen
23    if payload:
24        print("Empfangen:", payload.decode())
25        print("Status:", status)

Gemini 3 ¶

Das integrierte 0,96-Zoll-OLED-Display des Heltec V3 nutzt den SSD1306-Treiber und wird über eine interne I2C-Schnittstelle angesteuert. [1, 2]

1. Bibliotheken installieren [3] ¶

Um das Display in CircuitPython zu nutzen, benötigst du zwei Bibliotheken von Adafruit:

adafruit_ssd1306: Der Hardware-Treiber.
adafruit_framebuf: Ermöglicht das Zeichnen von Text und Grafiken. [4]

Lade das Adafruit CircuitPython Bundle herunter und kopiere die entsprechenden Dateien in den lib-Ordner deines CIRCUITPY-Laufwerks.

2. Pin-Belegung (V3-spezifisch) ¶

Das Display beim V3 ist an festen Pins angeschlossen, die von den Standard-I2C-Pins abweichen: [5, 6]

SDA: GPIO 17
SCL: GPIO 18
RST (Reset): GPIO 21 [7, 8]

3. Code-Beispiel: Text anzeigen ¶

Dieses Skript initialisiert das Display und zeigt zwei Zeilen Text an: [9]

 1import board
 2import busio
 3import digitalio
 4import adafruit_ssd1306
 5
 6# 1. Reset-Pin des Displays kurz triggern (wichtig für V3)
 7oled_reset = digitalio.DigitalInOut(board.IO21)
 8oled_reset.direction = digitalio.Direction.OUTPUT
 9oled_reset.value = Falseimport time
10time.sleep(0.01)
11oled_reset.value = True
12
13# 2. I2C-Bus für das Display initialisieren
14# SDA = IO17, SCL = IO18
15i2c = busio.I2C(board.IO18, board.IO17)
16
17# 3. Display-Objekt erstellen (128x64 Pixel)
18display = adafruit_ssd1306.SSD1306_I2C(128, 64, i2c)
19
20# 4. Inhalt zeichnen
21display.fill(0) # Bildschirm leeren (schwarz)
22display.text("Heltec V3", 0, 0, 1) # Text an Position (x=0, y=0)
23display.text("LoRa aktiv!", 0, 20, 1) # Text an Position (x=0, y=20)
24
25# 5. Änderungen auf das Display übertragen
26display.show()

Wichtige Tipps ¶

Vext (IO18): Beim Heltec V3 teilen sich der I2C-SCL-Pin und die Vext-Steuerung oft denselben Pin oder sind voneinander abhängig. Wenn das Display dunkel bleibt, stelle sicher, dass keine anderen Funktionen den Pin blockieren.
Aktualisierung: Da der SSD1306 gepuffert arbeitet, erscheint Text erst auf dem Bildschirm, wenn du den Befehl display.show() ausführst.
I2C-Adresse: Die Standardadresse für das integrierte Display ist in der Regel 0x3C. [3, 5, 7, 10, 11]

Möchtest du wissen, wie du Grafiken oder Sensordaten in Echtzeit auf dem Display visualisierst?

[1] https://wiki.heltec.org
[2] https://www.amazon.com
[3] https://www.sabulo.com
[4] https://docs.circuitpython.org
[5] https://www.youtube.com
[6] https://www.hackerspace-ffm.de
[7] https://community.heltec.cn
[8] https://community.heltec.cn
[9] https://www.youtube.com
[10] https://docs.micropython.org
[11] https://heltec.org

 1import board
 2import busio
 3import digitalio
 4import adafruit_ssd1306
 5
 6# 1. Reset-Pin des Displays kurz triggern (wichtig für V3)
 7oled_reset = digitalio.DigitalInOut(board.IO21)
 8oled_reset.direction = digitalio.Direction.OUTPUT
 9oled_reset.value = False
10import time
11time.sleep(0.01)
12oled_reset.value = True
13
14# 2. I2C-Bus für das Display initialisieren
15# SDA = IO17, SCL = IO18
16i2c = busio.I2C(board.IO18, board.IO17)
17
18# 3. Display-Objekt erstellen (128x64 Pixel)
19display = adafruit_ssd1306.SSD1306_I2C(128, 64, i2c)
20
21# 4. Inhalt zeichnen
22display.fill(0) # Bildschirm leeren (schwarz)
23display.text("Heltec V3", 0, 0, 1) # Text an Position (x=0, y=0)
24display.text("LoRa aktiv!", 0, 20, 1) # Text an Position (x=0, y=20)
25
26# 5. Änderungen auf das Display übertragen
27display.show()

Gemini 4 ¶

Für CircuitPython gibt es mehrere etablierte LoRa-Bibliotheken, die je nach verwendetem Funkmodul und Protokoll (einfaches Paket-Radio oder LoRaWAN) ausgewählt werden sollten.

Offizielle Adafruit Bibliotheken ¶

Diese Bibliotheken sind am besten dokumentiert und direkt im Adafruit CircuitPython Library Bundle enthalten. [1]

Adafruit RFM9x Library:
Unterstützte Hardware: RFM95, RFM96, RFM97 und RFM98 (SX1276/SX127x Chipsatz).
- Anwendung: Ideal für die direkte Punkt-zu-Punkt-Kommunikation (P2P) zwischen zwei Modulen.
- Besonderheiten: Unterstützt Frequenzen von 433 MHz bis 915 MHz und ermöglicht die Anpassung von Sendeleistung, Bandbreite und Spreading-Faktor. [2, 3, 4, 5]
Adafruit TinyLoRa Library:
Unterstützte Hardware: RFM95/96 LoRa Module.
- Anwendung: Eine schlanke Implementierung für LoRaWAN-Verbindungen, speziell für das Senden kleiner Datenpakete an Netzwerke wie “The Things Network” (TTN).
- Wichtiger Hinweis: Diese Bibliothek ist nicht kompatibel mit dem TTN V3 Stack. [6, 7, 8, 9, 10]

Community-Bibliotheken für spezifische Hardware ¶

Für Module, die nicht direkt von Adafruit stammen, gibt es spezialisierte Treiber in der Community: [11]

micropySX126X Library: Ein Port der RadioLib für den neueren SX1261/SX1262/SX1268 Chipsatz. Er wurde erfolgreich auf Boards wie dem Raspberry Pi Pico mit Waveshare LoRa HAT oder dem HelTec LoRa 32 V3 getestet. [12]
EByte LoRa Bibliotheken: Für die weit verbreiteten EByte-Module (oft über UART gesteuert) gibt es spezifische CircuitPython-Ports:
E22 Series (SX1262/SX1268).
- E32 Series (SX1276/SX1278).
- E220 Series (LLCC68). [13, 14, 15, 16]

Hardware mit integrierter Unterstützung ¶

Einige Entwicklungsboards sind so vorkonfiguriert, dass die Bibliotheken bereits im CircuitPython-Image enthalten sind oder direkt unterstützt werden:

Challenger RP2040 LoRa: Das offizielle Image für dieses Board enthält die RFM9x-Bibliothek bereits im “Frozen”-Format, was Speicherplatz spart.
Adafruit Feather RP2040 RFM95: Vollständig integriert in das Adafruit-Ökosystem mit fertigen Beispielskripten für den Einstieg. [17, 18, 19]

Welches LoRa-Modul oder Entwicklungsboard planst du für dein Projekt zu verwenden?

[1] https://www.phippselectronics.com
[2] https://docs.circuitpython.org
[3] https://github.com
[4] https://www.youtube.com
[5] https://docs.circuitpython.org
[6] https://docs.circuitpython.org
[7] https://docs.circuitpython.org
[8] https://pypi.org
[9] https://github.com
[10] https://lowpowerlab.com
[11] https://www.phippselectronics.com
[12] https://github.com
[13] https://github.com
[14] https://github.com
[15] https://github.com
[16] https://github.com
[17] https://ilabs.se
[18] https://learn.adafruit.com
[19] https://circuitpython.org