Heltec LoRa32 Evaluationboard

#7827803
Lesenswert?

Hallo,

für erste Tests mit LoRa habe ich mir 2 Evaluationboards von Heltec besorgt. Lleider ist es mir bisher nicht gelungen ein erstes Programm mit diesen Modulen aufzubauen. Ich nutze VisualCode und PlatformIO. Gibt es hier eventuell erfahrene Entwickler die solch ein Modul in VisualCode mit PlatformIO in Betrieb genommen haben?

Bezeichnung Evaluationboard: Heltec Automation LoRa32

#7827814
Lesenswert?

Zo R. schrieb:

Lleider ist es mir bisher nicht gelungen ein erstes Programm mit diesen Modulen aufzubauen.

Was hast du denn seither genau gemacht? Zeig Mal.

Controller ist ja scheinbar ein ESP32. Ich würde ein einfaches ESP32 Projekt mit PlatformIO aufsetzen und dann eine Library für den Funk Chip suchen. Vielleicht sowas: https://github.com/sandeepmistry/arduino-LoRa

Und dann in der Example Abteilung nachschauen.

#7828088
Lesenswert?

Guten Morgen,

ich habe schon bisher alles versucht in VScode und PlatformIO. Leider gingt mir kein kompilirfähiges Projekt nur mit dem esp32-s3.

Variante 1:

1
[env:esp32s3]
2
platform = espressif32
3
board = esp32-s3-devkitc-1
4
framework = arduino

Variante 2:

1
[env:esp32-s3]
2
platform = espressif32
3
board = esp32-s3-devkitc-1
4
framework = arduino
5
monitor_speed = 115200
6
upload_speed = 460800
7

8
; Optional: Define build flags if needed
9
build_flags =
10
  -DCORE_DEBUG_LEVEL=5
11

12
; Optional: Define additional libraries or configuration for external hardware
13
lib_deps =
14
  adafruit/Adafruit Unified Sensor @ ^1.1.0

Muss ich in platformIO noch eine weitere Biblithek einbinden?

#7828098
Lesenswert?

Musste espressif deinstallieren und nochmal neu installieren. Jetzt kann ich zumindest mal ein esp32-s3 Projekt erfolgreich bauen.

platformIO.ini:

1
[env:esp32-s3]
2
platform = espressif32
3
board = esp32-s3-devkitc-1
4
framework = arduino
5
monitor_speed = 115200
6
upload_speed = 460800
7

8
lib_deps =
9
    jgromes/RadioLib @ ^6.3.0
10
    Wire
11
    SPI
12

13
build_flags =
14
    -DCORE_DEBUG_LEVEL=5
#7828160
Lesenswert?

1
#include <Arduino.h>
2
#include <SPI.h>
3

4
#define CS 5  // Dein Chip Select Pin
5

6
uint8_t readRegister(uint8_t addr);
7

8
#define RST 14
9

10
void setup() {
11
    Serial.begin(115200);
12
    while (!Serial);
13
    
14
    pinMode(RST, OUTPUT);
15
    digitalWrite(RST, LOW);
16
    delay(10);
17
    digitalWrite(RST, HIGH);
18
    delay(10);
19

20
    SPI.begin(5, 19, 23, 18); // (SCK, MISO, MOSI, SS)
21

22
    Serial.println("Teste SPI-Register des LoRa-Chips...");
23
    
24
    uint8_t version = readRegister(0x01);
25
    Serial.print("SX1276 Version: 0x");
26
    Serial.println(version, HEX);
27
}
28

29
void loop() {
30
    delay(1000);
31
}
32

33
uint8_t readRegister(uint8_t addr) {
34
    digitalWrite(CS, LOW);
35
    SPI.transfer(addr & 0x7F); // Read-Befehl: MSB muss 0 sein
36
    uint8_t value = SPI.transfer(0x00); // Dummy-Byte senden und Wert empfangen
37
    digitalWrite(CS, HIGH);
38
    return value;
39
}

Hier ein kleine Beispielanwendung um mal vom Lora Modul was auszulesen. Ich erhalte immer den Wert 0x00 zurück auch wenn ich das SPI Kommando 0x042 benutze.

#7828195
Lesenswert?

Ok ich kann die Bezeichnung V3 lesen.

Hab auch den Schaltplan gefunden und die verwendeten SPI Pins überprüft. Stimmt alles soweit. Trotzdem erhalte ich bei 0x01 immer 0x00 zurück.

1
#include <Arduino.h>
2
#include <SPI.h>
3

4
#define LED 35
5

6
#define CS 8 
7
#define RST 12
8

9
uint8_t readRegister(uint8_t addr);
10

11
void setup() 
12
{
13
    Serial.begin(115200);
14
    while (!Serial);
15
    
16
    pinMode(LED, OUTPUT);
17

18
    pinMode(RST, OUTPUT);
19
    digitalWrite(RST, LOW);
20
    delay(10);
21
    digitalWrite(RST, HIGH);
22
    delay(10);
23

24
    SPI.begin(9, 11, 10, CS); // (SCK, MISO, MOSI, SS)
25

26
    Serial.println("Teste SPI-Register des LoRa-Chips...");
27
    
28
    uint8_t version = readRegister(0x01);
29
    Serial.print("SX1276 Version: 0x");
30
    Serial.println(version, HEX);
31

32
    version = readRegister(0x42);
33
    Serial.print("SX1276 Version: 0x");
34
    Serial.println(version, HEX);
35
}
36

37
void loop() 
38
{
39
  digitalWrite(LED, !digitalRead(LED));
40
  delay(1000);
41
}
42

43
uint8_t readRegister(uint8_t addr) 
44
{
45
  SPI.beginTransaction(SPISettings(1000000, MSBFIRST, SPI_MODE0)); // 1 MHz
46
  digitalWrite(CS, LOW);
47
  uint8_t value = SPI.transfer(addr & 0x7F); // Read-Befehl: MSB muss 0 sein
48
  digitalWrite(CS, HIGH);
49
  SPI.endTransaction();
50
  return value;
51
}

Ich habe aktuell kein Oszi zur Hand.

Es ist doch ein fertiges Board. Warum muss alles so kompliziert sein. Ich möchte nur mal das Board mit Lora testen.

#7828211
Lesenswert?

Zo R. schrieb:

Es ist doch ein fertiges Board. Warum muss alles so kompliziert sein. Ich möchte nur mal das Board mit Lora testen.

das Gefuehl kenne ich. Ich wollte die Boards mit MicroPython zum laufen bringen. Hat bisher nicht geklappt. Bin danach zu Arduino zurueckgegangen und habe mich an die Instruktionen von Heltec gehalten. Selbst dann ware die Installation mit Fehlern behaftet. Ich musste eine Adafruit OLED Library manuell installieren, sonst kompilierten die Heltec Examples nicht. Dann hatte ich im Rahmen meiner MicroPython Experimente den ESP32S3 Flash geloescht. Damit war eine von Heltec in den Flash geschriebener Lizenz Key weg. Den musste ich dann ueber Heltec Webseite neu generieren und ueber Serial Monitor in das Board reinschreiben (liblorawan.a verweigert sonst Radi Chip init). Es war ein steiniger Weg ...

#7828213
Lesenswert?

Zo R. schrieb:

Wie binde ich die Lib in VSCode + PlatformIO ein, so dass ich die Lora.h nutzen kann?

Du hast (mindestens ...) zwei Probleme:

  • die Heltec Boards irgendwie zum laufen zu bekommen
  • Einbindung in Deine bevorzugte Entwicklungs-Umgebung

Fuer Punkt 1 hast Du eine realistische Chance, wenn Du mit Arduino anfaengst. Wenn das klappt, wuerde ich versuchen, eines der Boards mit PlattformIO zum laufen zu bringen (ein Board bleibt auf Arduino und laeuft als LoRaSender).

Viel Glueck ;o)

#7828332
Lesenswert?

Es kann doch nicht sein. Die SPI Kommunikation will einfach nicht. Das kann ich nicht verstehen. Ich habe auch den Schaltplan angeschaut. Die Pins sind soweit korrekt eingestellt.

Ich möchte nicht noch eine weitere IDE installieren. Hat hier jemand das ganze in VSCode und platformio zum Laufen gebracht? Zumindest die SPI Kommunikation zum Lora Chip?

Angehängte Dateien:
Persönliche Seite #7828334
Lesenswert?

Zo R. schrieb:

Es kann doch nicht sein. Die SPI Kommunikation will einfach nicht.

Schließ doch bitte mal ein Oszilloskop/Logic Analyzer an, so ist das doch reiner Blindflug. Wenn du keins hast schließ wenigstens mal LEDs an und setz die SPI-Frequenz auf Minimum. An den LEDs sollte man ein Flackern erkennen können, insbesondere beim MISO wäre das wichtig.

Persönliche Seite #7828349
Lesenswert?

Zo R. schrieb:

VSCode und platformio

Uwe L. schrieb:

Zo R. schrieb:

Es ist doch ein fertiges Board. Warum muss alles so kompliziert sein. Ich möchte nur mal das Board mit Lora testen.

das Gefuehl kenne ich. Ich wollte die Boards mit MicroPython zum laufen bringen. Hat bisher nicht geklappt.

Wenn man irgendwelche 3rd-Party Tools nutzt muss man immer basteln. Bei sehr billigen chinesischen Herstellern ist Bastelei auch meist garantiert. Die besten Chancen hat man normalerweise mit den Tools des Herstellers.

Beim ESP32 wäre das die eclipse-basierte Espressif-IDE, oder die ESP-IDF Extension for VS Code, wobei letzteres vermutlich noch nicht so ausgereift ist, und natürlich was anderes ist als PlatformIO, nämlich "nur" direkt ESP-IDF.

Zo R. schrieb:

Auf folgender Seite https://heltec.org/project/wifi-kit32-v3/ kann ich den Schaltplan sehen, allerdings ist der Lora Chip nicht zu sehen.

Das ist ja auch ein ganz anderes Produkt das gar kein LoRa hat... Auf der korrekten Produktseite sind die Schaltpläne für Version v3.1 und v3.2 verlinkt. Allerdings zeigen beide Links auf Version v.3.1. Mit etwas suchen findet man den für v3.2.

Produktseite: https://heltec.org/project/wifi-lora-32-v3/

Version v3.1: https://resource.heltec .cn/download/WiFi_LoRa_32_V3/HTIT-WB32LA(F)_V3.1_Schematic_Diagram.pdf

Version v3.2: https://resource.heltec .cn/download/WiFi_LoRa_32_V3/WiFi_LoRa_32_V3.2_Schematic_Diagram.pdf

(Leerzeichen vor .cn entfernen wegen Spamverdacht)

Der LoRa-IC ist unten links. Es gibt da doch einige Unterschiede zwischen den Versionen. Insbesondere U3 sind zwei ganz verschiedene Produkte.

#7828372
Lesenswert?

Was die SPI Pins betreffen sehe ich keinen Unterschied. Ich habe auch diese Pins benutzt. Kein Chance eine einfache SPI Kommunikation zu realisieren.

1
#include <Arduino.h>
2
#include <SPI.h>
3

4
#define REG_VERSION 0x42
5

6
// LoRa Pins für Heltec V3
7
#define LORA_MOSI  10   
8
#define LORA_MISO  11   
9
#define LORA_SCK    9   
10
#define LORA_CS     8   
11

12
uint8_t readRegister(uint8_t reg) {
13
    digitalWrite(LORA_CS, LOW);
14
    delayMicroseconds(10);
15
    
16
    SPI.transfer(reg & 0x7F);  // Read command (MSB = 0 für lesen)
17
    uint8_t response = SPI.transfer(0x00);
18
    
19
    digitalWrite(LORA_CS, HIGH);
20
    delayMicroseconds(10);
21
    
22
    return response;
23
}
24

25
void setup() {
26
    Serial.begin(9600);
27
    delay(1000);
28
    
29
    // SPI Konfiguration
30
    SPI.begin(LORA_SCK, LORA_MISO, LORA_MOSI, LORA_CS);
31
    SPI.beginTransaction(SPISettings(1000000, MSBFIRST, SPI_MODE0));  // Langsamere Clock
32
    
33
    pinMode(LORA_CS, OUTPUT);
34
    digitalWrite(LORA_CS, HIGH);
35
    
36
    // Versuche verschiedene Register zu lesen
37
    Serial.printf("Version Register (0x42): 0x%02X\n", readRegister(0x42));
38
    Serial.printf("OpMode Register (0x01): 0x%02X\n", readRegister(0x01));
39
    Serial.printf("FreqMSB Register (0x06): 0x%02X\n", readRegister(0x06));
40
}
41

42
void loop() {
43
    delay(1000);
44
}

Ausgabe: Version Register (0x42): 0xAA OpMode Register (0x01): 0xAA FreqMSB Register (0x06): 0xAA

Board bestellt über amazon: APKLVSR LoRa ESP32 Development Board, LoRa V3 Board with OLED Display and Antenna USB C Dual-Core IOT Board 240MHz Bluetooth WiFi Module 863 928MHz for Arduino (Pack of 2)

ESP32 V3 LoRa V3 SX1262 0.96 Inch OLED Display for Arduino Smart Home WiFi LoRa 32

#7828383
Lesenswert?

0xAA ueber alle Register hatte ich auch schon und trotzdem laufen die Boards. Eines direkt bei Heltec gekauft, ein anderes ueber Amazon. Ich habe fast den Verdacht, dass Du irgendwo zwischen SPI.begin() und SPI.beginTransaction() bereits CS nach oben oder unten setzen musst

#7828400
Lesenswert?

Ich nutzte nun die RadioLib:

1
#include <Arduino.h>
2
#include <SPI.h>
3
#include <RadioLib.h>
4

5
#define LED 35
6

7
#define LORA_MOSI  10   
8
#define LORA_MISO  11   
9
#define LORA_SCK    9   
10
#define LORA_CS     8   
11
#define LORA_RST   12
12
#define LORA_IRQ   14   
13
#define LORA_RST   12
14
#define LORA_BUSY  13
15

16
SPIClass spiSX(SPI);
17
SPISettings spiSettings(2000000, MSBFIRST, SPI_MODE0);
18
SX1278 radio = new Module(LORA_CS, LORA_IRQ, LORA_RST, LORA_BUSY);
19

20
int transmissionState = RADIOLIB_ERR_NONE;
21
volatile bool transmittedFlag = false;
22
int count = 0;
23

24
#if defined(ESP8266) || defined(ESP32)
25
  ICACHE_RAM_ATTR
26
#endif
27
void setFlag(void) 
28
{
29
  // we sent a packet, set the flag
30
  transmittedFlag = true;
31
}
32

33
void setup() 
34
{
35
  Serial.begin(115200);
36
  delay(1000);
37
  Serial.println("LoRa SPI Test startet...");
38

39
  // SPI starten (SCK, MISO, MOSI, NSS)
40
  SPI.begin(9, 11, 10, 8);
41

42
  // Reset-Pin initialisieren und zurücksetzen
43
  pinMode(12, OUTPUT);
44
  digitalWrite(12, LOW);
45
  delay(10);
46
  digitalWrite(12, HIGH);
47
  delay(10);
48

49
  // LoRa-Chip initialisieren
50
  int state = radio.begin(868.0); // Frequenz für EU
51
  if (state == RADIOLIB_ERR_NONE) 
52
  {
53
      Serial.println("SX1262 erfolgreich initialisiert!");
54
  } 
55
  else 
56
  {
57
      Serial.print("Fehler beim Initialisieren: ");
58
      Serial.println(state);
59
  }
60

61
  pinMode(LED, OUTPUT);
62
}
63

64
void loop() 
65
{
66
  digitalWrite(LED, !digitalRead(LED));
67

68
  delay(1000);
69
}

Ausgabe: LoRa SPI Test startet... Fehler beim Initialisieren: -2

platformio.ini:

1
[env:esp32-s3]
2
platform = espressif32
3
board = esp32-s3-devkitc-1
4
framework = arduino
5
monitor_speed = 115200
6
upload_speed = 460800
7
debug_tool = esp-prog
8
debug_init_break = tbreak setup
9
lib_deps = 
10
  Wire
11
  SPI
12
  jgromes/RadioLib@^7.1.2
13
build_flags = 
14
  -DCORE_DEBUG_LEVEL=5
Persönliche Seite #7828445
Lesenswert?

Zo R. schrieb:

Irgendein verdammter Scheiß wo man vergessen hat zu berücksichtigen. Das kotzt mich an diese ganzen Bastellplatinen.

An den Billigst-China-Platinen mit begrenztem Software-Support, wo du aber eine ganz andere Software für benutzt...?

Zo R. schrieb:

Version Register (0x42): 0xAA OpMode Register (0x01): 0xAA FreqMSB Register (0x06): 0xAA

Höchst verdächtig. Offenbar tut sich doch was auf der MISO-Leitung. Irgendwas ist da vermutlich mit der Clock-Leitung überkreuz. Vielleicht ist auch der SPI-Mode falsch (CPHA, CPOL).

Uwe L. schrieb:

Ich habe fast den Verdacht, dass Du irgendwo zwischen SPI.begin() und SPI.beginTransaction() bereits CS nach oben oder unten setzen musst

Es muss nach oben gesetzt werden! Das passiert im Code gar nicht...

Zo R. schrieb:

Ich habe echt alles kontrolliert.

Du hast nichtmal LEDs an die Pins angeschlossen. Das wäre das Mindeste.

#7828516
Lesenswert?

Zo R. schrieb:

wie sieht deine Applikation mit der vollständigen Lora Spi Initialisierung aus? Das wäre sehr hilfreich für mich.

liegt mir aktuell nicht vor, aber ich hatte vorhin bereits auf Heltec Github hingewiesen. Z. B.: https://github.com/HelTecAutomation/Heltec_ESP32/blob/adea0f5622413d4a403c3270eb01a513d18f02c7/src/lora/LoRa.cpp#L85

da sieht man gut wie der RESET Pin geschaltet wird, mit welchen Timings. Dort ist auch erkenntlich, dass vor SPI.begin() der CS Pin gesetzt werden muss.

#7828523
Lesenswert?

Als Beispiel für ein Projekt, das mit PlatformIO funktioniert und viele Lora-Boards unterstützt (und die RadioLib benutzt), kannst du ja mal hier in die Sourcen schauen. Das ist die Anleitung für PlatformIO dazu: https://github.com/G4lile0/tinyGS/wiki/Platformio. Das Projekt findest du unter https://github.com/G4lile0/tinyGS. In den Sourcen unter ConfigManager sind auch die Pinbelegungen zu finden.

#7828859
Lesenswert?

Es lag an der SPI Initialisierung und Verwendung.

Ich poste hier mal die Applikation für den LoRa Sender:

1
#include <Arduino.h>
2
#include <SPI.h>
3
#include <RadioLib.h>
4

5
#define LORA_MOSI 10  
6
#define LORA_MISO 11  
7
#define LORA_SCK   9  
8
#define LORA_CS    8  
9
#define LORA_RST  12
10
#define LORA_DIO  14
11
#define LORA_BUSY 13
12

13
SX1262 radio = new Module(LORA_CS, LORA_DIO, LORA_RST, LORA_BUSY, SPI, SPISettings(2000000, MSBFIRST, SPI_MODE0));
14

15
void setup() {
16
    Serial.begin(115200);
17
    delay(2000);
18

19
    Serial.println("LoRa Test startet...");
20

21
    SPI.begin(LORA_SCK, LORA_MISO, LORA_MOSI, LORA_CS);
22
    
23
    Serial.println("Initialisiere LoRa...");
24
    int state = radio.begin(868.0, 125.0, 7, 5);  // Freq, BW, SF, CR
25
    
26
    if (state == RADIOLIB_ERR_NONE) 
27
    {
28
        Serial.println("SX1262 erfolgreich initialisiert!");
29
        
30
        // LoRa Parameter setzen
31
        radio.setOutputPower(22);
32
        radio.setCodingRate(5);
33
    } 
34
    else 
35
    {
36
        Serial.print("Fehler beim Initialisieren: ");
37
        Serial.println(state);
38
    }
39

40
  //  // Version Register lesen
41
  //  digitalWrite(LORA_CS, LOW);
42
  //  SPI.transfer(0x42);  // Command byte
43
  //  uint8_t version = SPI.transfer(0x00);  // Dummy byte zum Lesen
44
  //  digitalWrite(LORA_CS, HIGH);
45

46
  //  Serial.printf("SX1262 Version Register (0x42): 0x%02X\n", version);
47
}
48

49
void loop() 
50
{
51
  static uint32_t packetCount = 0;
52
  char message[64];
53
  snprintf(message, sizeof(message), "LoRa Paket #%lu", packetCount++);
54
  
55
  Serial.print("Sende: ");
56
  Serial.println(message);
57
  
58
  int state = radio.transmit(message);
59
  if (state == RADIOLIB_ERR_NONE) {
60
      Serial.println("Paket erfolgreich gesendet!");
61
  } else {
62
      Serial.print("Fehler beim Senden: ");
63
      Serial.println(state);
64
  }
65

66
  delay(1000);
67
}
Persönliche Seite #7828871
Lesenswert?

Zo R. schrieb:

Es lag an der SPI Initialisierung

Deine SPI-Settings sind aber unverändert. Die Settings, die du jetzt explizit angibst, sind identisch zum Default:

https://github.com/jgromes/RadioLib/blob/977b2c28c8989167719e9f0df8ee69b67b3feddb/src/BuildOpt.h#L166

Zo R. schrieb:

Nachdem ich das Radio Modul so konfiguriert habe hat es funktioniert.

Du hast SX1278 durch SX1262 ersetzt. Joah, macht natürlich Sinn den richtigen Chip einzustellen.

Antwort schreiben

Bitte melde dich an, um einen Beitrag zu schreiben.

oder

Mit Google-Account einloggen

Die Registrierung ist kostenlos und dauert nur eine Minute.

Jetzt registrieren