Heltec LoRa 32 – Kompakt, leistungsfähig und bereit für echte Funkprojekte

In diesem Beitrag stelle ich den Heltec LoRa 32 vor – einen kompakten Mikrocontroller, der ESP32-S3, Wi-Fi, Bluetooth und LoRa auf einem einzigen Board vereint. Der Fokus liegt dabei ganz bewusst auf der Hardware und den technischen Eigenschaften. Es geht also darum, was dieses Board ausmacht, welche Funktionen es bietet und für welche Einsatzbereiche es gedacht ist.

Dieses Video auf YouTube ansehen.

Highlights auf den ersten Blick

ESP32-S3FN8 Dual-Core (Wi-Fi & Bluetooth 5 LE)
SX1262 LoRa-Chip für 470–510 MHz & 863–928 MHz
Hohe Reichweite dank bis zu 21 dBm Sendeleistung
USB-C mit CP2102 für stabiles Flashen
8 MB Flash + großzügige SRAM-Ausstattung
LiPo-Anschluss inkl. Ladefunktion
Kompaktes Format: 50,2 × 25,5 mm

Mikrocontroller Heltec LoRa 32 V3 von vorne

Mikrocontroller Heltec LoRa 32 V3 von hinten - IPEX Anschluss

👉 In diesem Beitrag erhältst du eine klare, kompakte Übersicht über den Heltec LoRa 32 – ideal, um schnell einzuschätzen, ob der Controller für dein nächstes LoRa- oder IoT-Projekt geeignet ist.

Technische Daten des Heltec LoRa 32

Der Heltec LoRa 32 kombiniert einen leistungsfähigen ESP32-S3 mit einem dedizierten LoRa-Transceiver und eignet sich damit ideal für moderne Funk- und IoT-Anwendungen. Die wichtigsten technischen Daten habe ich dir hier übersichtlich in Tabellenform zusammengestellt.

ESP32-S3 Chip auf dem Heltec LoRa 32 Mikrocontroller

Allgemein

Merkmal	Spezifikation
Mikrocontroller	ESP32-S3FN8 (Xtensa® 32-bit LX7 Dual Core)
Hersteller	Heltec
Abmessungen	50,2 × 25,5 × 10,2 mm
Betriebstemperatur	−20 °C bis +70 °C

Funk & Kommunikation

Merkmal	Spezifikation
LoRa-Chip	SX1262
Frequenzbereiche	470–510 MHz, 863–928 MHz
Maximale Sendeleistung	21 ± 1 dBm
Empfangsempfindlichkeit	−134 dBm @ SF12 / 125 kHz
Wi-Fi	802.11 b/g/n (bis 150 Mbit/s)
Bluetooth	Bluetooth 5 (LE)
Antennenanschluss	IPEX 1.0 (LoRa)

Speicher

Merkmal	Spezifikation
ROM	384 KB
SRAM	512 KB
RTC SRAM	16 KB
Flash	8 MB (SiP)

Schnittstellen & Peripherie

Merkmal	Spezifikation
ADC	7× ADC1, 2× ADC2
Touch-Pins	7
UART	3
I²C	2
SPI	2
USB	USB-C (CP2102 USB-to-Serial)
GPIO-Header	2× 18 Pins, 2,54 mm

Stromversorgung

Merkmal	Spezifikation
Versorgung	USB-C oder 3,7 V LiPo
Akkuanschluss	2× 1,25 mm
Ladefunktion	integriert

Preis & Bezug des Heltec LoRa 32

Der Heltec LoRa 32 liegt preislich über klassischen ESP32-Boards – was vor allem am integrierten LoRa-Transceiver (SX1262) liegt. Während einfache ESP32-Mikrocontroller oft schon für wenige Euro erhältlich sind, bewegen sich LoRa-fähige Boards grundsätzlich in einer höheren Preisklasse.

Ich habe mein Board über AliExpress für knapp 12 € bezogen. Je nach Händler, Lieferzeit und Antennen-Set kann der Preis leicht schwanken. Im Vergleich zu separaten LoRa-Modulen ist das dennoch attraktiv, da hier ESP32-S3, LoRa, USB-C und Ladeelektronik bereits auf einem Board vereint sind.

Shop	Preis
https://www.amazon.de*	ab 22 €
https://ebay.de*	ab 21 €
https://de.aliexpress.com/	ab 12 €

Hinweis von mir: Die mit einem Sternchen (*) markierten Links sind Affiliate-Links. Wenn du über diese Links einkaufst, erhalte ich eine kleine Provision, die dazu beiträgt, diesen Blog zu unterstützen. Der Preis für dich bleibt dabei unverändert. Vielen Dank für deine Unterstützung!

Lieferumfang des Heltec LoRa 32

Der Lieferumfang des Heltec LoRa 32 ist – typisch für viele Entwicklerboards – funktional, aber nicht einheitlich, da er stark vom jeweiligen Händler abhängt. In der Regel bekommst du jedoch alles, was für den grundlegenden Betrieb notwendig ist.

Typischer Lieferumfang

Heltec LoRa 32 Mikrocontroller
Stiftleisten (2,54 mm) zur optionalen Bestückung
Externe LoRa-Antenne (IPEX-Anschluss)
Anschlusskabel für eine 3,7 V LiPo-Batterie

👉 Nicht enthalten ist eine LiPo-Batterie selbst. Diese muss separat beschafft werden.

Lieferumfang - Heltec LoRa 32 — Lieferumfang – Heltec LoRa 32

Je nach Angebot sind auch Sets mit passendem Gehäuse erhältlich, was insbesondere für mobile oder semi-feste Installationen interessant ist.

Aliexpress - LoRa32 v3 Mikrocontroller Sets — Aliexpress – LoRa32 v3 Mikrocontroller Sets

In meinem Fall liegt der Fokus klar auf dem Einsatz als Entwicklerboard – die Stiftleisten müssen also noch selbst angelötet werden, was bei Prototypen und Tests ohnehin die flexibelste Lösung ist.

Stiftleisten sauber anlöten – kleiner Stolperstein beim Heltec LoRa 32

Beim Anlöten der Stiftleisten ist es wichtig, dass diese exakt im 90°-Winkel sitzen – nur so lässt sich der Mikrocontroller später sauber in ein Breadboard oder auf eine Lochrasterplatine stecken.

Dafür nutze ich üblicherweise ein 400-Pin-Breadboard, in das die Stiftleisten gesteckt werden. So bleiben sie beim Löten automatisch gerade ausgerichtet.

Problem: LiPo-Anschluss auf der Rückseite

Beim Heltec LoRa 32 ist mir dabei ein kleiner, aber wichtiger Punkt aufgefallen:
Der LiPo-Anschluss auf der Rückseite steht relativ weit ab. Dadurch liegt das Board nicht plan auf dem Breadboard, und die vorderen Stiftleisten sitzen nicht korrekt an. Das Ergebnis wären leicht schräge oder verspannte Pins.

Heltec LoRa 32 - Stiftleisten anlöten - Problem — Heltec LoRa 32 – Stiftleisten anlöten – Problem

Meine Lösung

Um dieses Problem zu umgehen, habe ich:

zwei 400-Pin-Breadboards verwendet
bei einem Breadboard die seitlichen Buchsenleisten für die Stromversorgung entfernt
das Board so positioniert, dass der LiPo-Anschluss frei „in der Luft“ hängt

Heltec LoRa 32 - Stiftleisten anlöten - Lösung — Heltec LoRa 32 – Stiftleisten anlöten – Lösung

Damit liegt der Heltec LoRa 32 sauber und spannungsfrei auf den Stiftleisten, und diese lassen sich problemlos gerade anlöten.

👉 Kleiner Handgriff, große Wirkung:
Mit dieser Methode sitzen die Pins exakt im 90°-Winkel – und spätere Kontaktprobleme oder schief sitzende Boards werden von Anfang an vermieden.

Aufbau des Boards – das steckt auf dem Heltec LoRa 32

Der Heltec LoRa 32 ist trotz seiner kompakten Abmessungen erstaunlich gut ausgestattet. Viele Funktionen, die man sonst nur von größeren Entwicklungsboards kennt, sind hier bereits integriert.

Aufbau - Heltec LoRa 32 Mikrocontroller — Aufbau – Heltec LoRa 32 Mikrocontroller

Vorderseite: Funk & Anzeige

Auf der Vorderseite des Boards finden sich direkt mehrere zentrale Features:

0,96″ OLED-Display
Ideal für Debug-Ausgaben, Statusanzeigen oder einfache Menüs – gerade bei mobilen Projekten extrem praktisch.
2,4 GHz Antenne
Zuständig für Wi-Fi und Bluetooth des ESP32-S3. Die Antenne ist fest auf dem Board integriert.
IPEX-Anschluss für die LoRa-Antenne
Separater Anschluss für den SX1262 LoRa-Chip, wodurch sich eine externe Antenne mit deutlich besserer Reichweite nutzen lässt.

Rückseite: Stromversorgung

Auf der Rückseite sitzt ein wichtiger Anschluss für mobile Anwendungen:

1,25 mm LiPo-Anschluss
Zum direkten Betrieb mit einer 3,7 V LiPo-Batterie, inklusive integrierter Ladeelektronik auf dem Board.

Die „üblichen Verdächtigen“

Natürlich fehlen auch die klassischen Bedienelemente nicht:

PRG-Taster (Program-Taster für Flash- und Startmodi)
RESET-Taster
Power-LED (orange) zur Anzeige der Versorgungsspannung
Weiße Status-LED, frei nutzbar für eigene Zwecke

👉 Insgesamt bietet der Heltec LoRa 32 einen sehr durchdachten Aufbau: Display, Funkmodule und Stromversorgung sind bereits integriert – ideal für kompakte LoRa- und IoT-Projekte ohne zusätzliches Zubehör.

Programmierung des Heltec LoRa 32 – erster Start in der Arduino IDE

Bevor der Heltec LoRa 32 programmiert werden kann, lohnt sich ein kurzer Blick auf die USB-Anbindung. Das Board nutzt einen CP2102 USB-zu-Serial-Konverter, der je nach Betriebssystem nicht immer automatisch erkannt wird.

Schritt 1: CP2102-Treiber installieren

Falls der Mikrocontroller nach dem Anstecken nicht als serielles Gerät erscheint, muss zunächst der passende Treiber installiert werden.
Die offiziellen Treiber für Windows, Linux und macOS stellt Silicon Labs bereit:

CP2102 USB2Serial Converter nicht erkannt

👉 https://www.silabs.com/software-and-tools/usb-to-uart-bridge-vcp-drivers?tab=downloads

Nach der Installation (und ggf. einem Neustart) sollte der Heltec LoRa 32 beim Anstecken per USB-C korrekt erkannt werden.

Silicon Labs CP210x USB to UART Bridge

Schritt 2: Arduino IDE verwenden

Sobald der Treiber installiert ist, kann der Mikrocontroller direkt in der Arduino IDE programmiert werden:

USB-Kabel anschließen
Passenden seriellen Port auswählen
Heltec WiFi LoRa 32(V3) als Zielplattform konfigurieren

Beispiel – Systeminformationen auf dem OLED anzeigen

Dieses Beispiel zeigt, wie das integrierte OLED-Display des Heltec LoRa 32 genutzt werden kann, um Systeminformationen des ESP32-S3 darzustellen. Das eignet sich ideal als Einstieg, da sofort sichtbar ist, ob Board, Stromversorgung und Display korrekt funktionieren.

Heltec LoRa 32 - Systeminformationen auf dem OLED-Display — Heltec LoRa 32 – Systeminformationen auf dem OLED-Display

/*****************************************************************************************
 * Heltec LoRa 32 (ESP32-S3) – OLED System-Dashboard (Uptime / Heap / CPU / Flash)
 *
 * Titel:
 *   OLED-Dashboard: Systeminformationen auf dem Heltec LoRa 32 anzeigen
 *
 * Beschreibung:
 *   Dieses Beispiel zeigt, wie du das integrierte 0,96" OLED-Display des Heltec LoRa 32
 *   (ESP32-S3) nutzt, um wichtige Systemwerte live darzustellen:
 *   - Uptime (Laufzeit seit Start)
 *   - freier Heap (RAM)
 *   - CPU-Frequenz
 *   - Flash-Größe
 *
 * Blogbeitrag (Hintergrund/Hardware-Details):
 *   https://draeger-it.blog/heltec-lora-32-kompakt-leistungsfaehig-und-bereit-fuer-echte-funkprojekte/
 *
 * Benötigte Bibliothek:
 *   Heltec ESP32 Library (enthält HT_SSD1306Wire & Board-Defines wie SDA_OLED/SCL_OLED/RST_OLED/Vext)
 *   https://github.com/HelTecAutomation/Heltec_ESP32
 *
 * Hinweis:
 *   - Viele Heltec-Boards schalten die Versorgung für externe Peripherie (u.a. OLED) über "Vext".
 *     Deshalb muss VextON() vor display.init() aufgerufen werden, sonst bleibt das Display dunkel.
 *   - Je nach Board/Revision kann es sein, dass das OLED ohne "flipScreenVertically()" gespiegelt ist.
 *
 * Autor:
 *   Stefan Draeger (draeger-it.blog)
 *****************************************************************************************/

#include <Arduino.h>          // Grundlegende Arduino/ESP32 Funktionen (millis, String, etc.)
#include <Wire.h>             // I2C-Bus (OLED hängt per I2C am ESP32)
#include "HT_SSD1306Wire.h"   // Heltec OLED-Treiber (SSD1306Wire-Klasse) aus Heltec_ESP32 Library

// --------------------------------------------------------------------------------------
// Display-Instanz
// --------------------------------------------------------------------------------------
// 0x3C           -> I2C-Adresse des OLED (bei SSD1306 sehr häufig 0x3C, seltener 0x3D)
// 500000         -> I2C-Taktfrequenz (500 kHz). Schneller als Standard (100 kHz), sorgt für flüssige Updates.
// SDA_OLED/SCL_OLED/RST_OLED -> Board-spezifische Pin-Defines aus der Heltec Board-Definition (pins_arduino.h)
// GEOMETRY_128_64 -> Display-Auflösung 128x64 Pixel
//
// "static" sorgt hier dafür, dass das Objekt nur in dieser Datei sichtbar ist (sauberer Namensraum).
static SSD1306Wire display(
  0x3C,          // I2C-Adresse
  500000,        // I2C-Frequenz (Hz)
  SDA_OLED,      // SDA-Pin (OLED)
  SCL_OLED,      // SCL-Pin (OLED)
  GEOMETRY_128_64,// Geometrie/Auflösung
  RST_OLED       // Reset-Pin des OLED (wird vom Board bereitgestellt)
);

// --------------------------------------------------------------------------------------
// Versorgung für Peripherie aktivieren (Heltec-typisch)
// --------------------------------------------------------------------------------------
// Vext ist bei vielen Heltec Boards ein GPIO, der die externe Versorgung schaltet.
// LOW  -> Vext an (Stromversorgung aktiv)
// HIGH -> Vext aus (Stromversorgung aus)
static void VextON() {
  pinMode(Vext, OUTPUT);
  digitalWrite(Vext, LOW);
}

// Optional: Wenn du später Strom sparen willst (DeepSleep etc.)
// static void VextOFF() {
//   pinMode(Vext, OUTPUT);
//   digitalWrite(Vext, HIGH);
// }

// --------------------------------------------------------------------------------------
// Dashboard zeichnen (Inhalt fürs OLED)
// --------------------------------------------------------------------------------------
// Diese Funktion baut den kompletten Screen neu auf.
// Vorteil: sehr robust und einfach.
// Nachteil: kompletter Redraw pro Sekunde (für dieses Beispiel völlig ok).
static void drawDashboard() {
  // Display-Puffer löschen (noch nicht sichtbar, erst nach display.display())
  display.clear();

  // Text linksbündig
  display.setTextAlignment(TEXT_ALIGN_LEFT);

  // Kleine Schrift für 4 Zeilen + Header
  display.setFont(ArialMT_Plain_10);

  // ----- Kopfzeile -----
  display.drawString(0, 0, "Heltec LoRa 32 (ESP32-S3)");
  display.drawLine(0, 12, 127, 12); // horizontale Trennlinie (x0,y12) bis (x127,y12)

  // ----- Systemwerte ermitteln -----
  // Uptime: Zeit seit Start in Sekunden
  uint32_t up = millis() / 1000;

  // Freier Heap (RAM) in KB
  uint32_t heapKB = ESP.getFreeHeap() / 1024;

  // Flash-Größe in MB
  uint32_t flashMB = ESP.getFlashChipSize() / (1024 * 1024);

  // CPU-Frequenz in MHz
  uint32_t cpuMHz = getCpuFrequencyMhz();

  // ----- Werte ausgeben -----
  // y-Positionen in 12px-Schritten -> passt gut zur 10px Schrift
  display.drawString(0, 16, "Uptime: " + String(up) + " s");
  display.drawString(0, 28, "Heap:   " + String(heapKB) + " KB");
  display.drawString(0, 40, "CPU:    " + String(cpuMHz) + " MHz");
  display.drawString(0, 52, "Flash:  " + String(flashMB) + " MB");

  // Puffer auf das Display übertragen
  display.display();
}

void setup() {
  // Serielle Ausgabe nur für Debug (optional)
  Serial.begin(115200);
  Serial.println();

  // 1) OLED-Stromversorgung aktivieren
  //    Wichtig: Ohne VextON() bleibt das Display je nach Board dunkel.
  VextON();
  delay(100); // kurze Stabilisierung der Versorgung

  // 2) OLED initialisieren
  //    Setzt I2C auf, initialisiert Controller, legt internen Buffer an.
  display.init();

  // 3) Display-Ausrichtung
  //    Manche Heltec-Boards sind "auf dem Kopf" montiert -> daher optional drehen.
  //    Wenn dein Text korrekt herum ist: diese Zeile auskommentieren.
  display.flipScreenVertically();

  // 4) Erstes Rendering direkt im Setup, damit sofort etwas zu sehen ist
  drawDashboard();
}

void loop() {
  // Dashboard zyklisch aktualisieren
  // -> Uptime/Heap ändern sich, CPU/Flash bleiben konstant
  drawDashboard();
  delay(1000); // 1 Hz Update, schont I2C und flackert nicht
}

Fazit

Unterm Strich ist der Heltec LoRa 32 (V3) ein überraschend gut ausgestatteter Mikrocontroller: ESP32-S3, SX1262 LoRa, OLED-Display, USB-C und LiPo-Anschluss mit Ladefunktion – das ist in dieser kompakten Form definitiv nicht selbstverständlich. Gerade für Funk- und IoT-Projekte ist das Board damit eine spannende Basis, weil viele typische „Extras“ schon integriert sind.

Ein kleiner Stolperstein ist allerdings die OLED-Versorgung: Dass das OLED-Display vor der Nutzung über Vext aktiviert werden muss, ist erstmal ungewohnt – und sollte aus meiner Sicht vom Hersteller deutlich sichtbarer dokumentiert werden. Wer das nicht weiß, sucht sonst unnötig lange nach der Ursache, warum das Display „nicht funktioniert“.

👉 Im nächsten Beitrag wird es dann praktisch: Ich verbinde den Heltec LoRa 32 per LoRa mit dem Arduino Nesso N1 und teste die Verbindung inklusive Reichweite unter realen Bedingungen.