Exemple code LiLYGO T3_V1.6.1

[rudsomlima]

I would like some help. I tried several sample codes but I couldn't get an interrupt to work with the LILYGO T3_V1.6.1 module. Can anyone provide code that works? Usage is for FSK wmbus mode T. I will try to decode an IZAR 433 water meter.

[jgromes]

I'm not familiar with that board, so here's a couple generic ideas:

1. Check you pinout
2. Enable debug output: /~https://github.com/jgromes/RadioLib/wiki/Debug-mode
3. Post the code

[rudsomlima]

Terminal

[SX1278] Initializing ... success!
[SX1278] Starting to listen ... success!

Universal Rádio Hacker output by RTL_433 RTL SDR - IZAR 433 water meter

2aaaaaaaaaa83e9b2bc705ace68386b42e1ccb2d658596b0d6594c3933564d658696d59a0ea65b261b885a7d059a69b1a6d267692c3b2 [Pause: 4671719 samples]
aaaaaaaaaaa83e9b95e3c2d679d079668bc3ce596b2c596784da6a63993564d65c6969e934f354f0a72e329eb07932ee4b8c34d9e2b652a [Pause: 5893109 samples]
2aaaaaaaaaa83e9b2bc782d679a0f1ad178732cb596172d61acb298f2c3564d658d2dab264cb65369ca789d4d837a0d985ca9d361e2d4a [Pause: 3827691 samples]
aaaaaaaaaaa83e9b2bc782d679a0f2cd178f32cb597172cf1369a98f346ac9acb1d2d3d27a33792ee2d2d4aea5a365e4f295933d66278b4 [Pause: 7430870 samples]
2aaaaaaaaaa83e9b2b8782d679a0f1ad0b8732cb596165ac3596530f1a6ac9acb0d2dab21ac366174e4e5259e87d0ce834f2c9f0b94b92a [Pause: 2983956 samples]
aaaaaaaaaaa83e9b95e3c16b3cd079668bc3ce596b2c5cb3c4da7531e4cd5935971a5a7497d059af1e691f134f33d16174f295359e34d328 [Pause: 7168381 samples]
2aaaaaaaaaa83e9b2bc382d679a0f0d685c39965acb165ac359729870e1ab26b2c34b6acb256a1f264d965359a66a66d0b434e6347582d [Pause: 3246445 samples]
5555555555507d36578e0b59e683cb345e1e6596b2c596789b4d4c3cb8d59359634b4f4b32d3863d92cc5b83bcb4c25f299a4f8ad1f13d0 [Pause: 385361 samples]

main.ino

/*
   RadioLib SX127x FSK Modem Example

   This example shows how to use FSK modem in SX127x chips.

   NOTE: The sketch below is just a guide on how to use
         FSK modem, so this code should not be run directly!
         Instead, modify the other examples to use FSK
         modem and use the appropriate configuration
         methods.

   For default module settings, see the wiki page
   /~https://github.com/jgromes/RadioLib/wiki/Default-configuration#sx127xrfm9x---fsk-modem

   For full API reference, see the GitHub Pages
   https://jgromes.github.io/RadioLib/
*/

// include the library
#include <RadioLib.h>
#include <Arduino.h>
#define RADIOLIB_MODULE SX1278
#define RADIOLIB_DEBUG
#define RADIOLIB_VERBOSE


SX1278 radio = new Module(18, 26, 23, 33);

// or using RadioShield
// /~https://github.com/jgromes/RadioShield
// SX1278 radio = RadioShield.ModuleA;

  // if needed, you can switch between LoRa and FSK modes
  //
  // radio.begin()       start LoRa mode (and disable FSK)
  // radio.beginFSK()    start FSK mode (and disable LoRa)

  // the following settings can also
  // be modified at run-time

// flag to indicate that a packet was received
volatile bool receivedFlag = false;

// this function is called when a complete packet
// is received by the module
// IMPORTANT: this function MUST be 'void' type
//            and MUST NOT have any arguments!

ICACHE_RAM_ATTR void setFlag(void)
{
  // we got a packet, set the flag
  receivedFlag = true;
}

  void setup()
  {
    Serial.begin(9600);

    // initialize SX1278 with default settings
    Serial.print(F("[SX1278] Initializing ... "));
    int state = radio.beginFSK(434.47,100,80,200);
    // state = radio.setFrequency(434.47);
    // state = radio.setBitRate(100.0);
    // state = radio.setFrequencyDeviation(800.0);
    // state = radio.setRxBandwidth(200.0);
    // state = radio.setOutputPower(10.0);
    // state = radio.setCurrentLimit(100);
    // state = radio.setDataShaping(RADIOLIB_SHAPING_0_5);
    uint8_t syncWord[] = {0x55};
    state = radio.setSyncWord(syncWord, 1);

    if (state == RADIOLIB_ERR_NONE)
    {
      Serial.println(F("success!"));
    }
    else
    {
      Serial.print(F("failed, code "));
      Serial.println(state);
      while (true)
        ;
    }

    // set the function that will be called
    // when new packet is received
    radio.setPacketReceivedAction(setFlag);

    // start listening for LoRa packets
    Serial.print(F("[SX1278] Starting to listen ... "));
    state = radio.startReceive();
    if (state == RADIOLIB_ERR_NONE)
    {
      Serial.println(F("success!"));
    }
    else
    {
      Serial.print(F("failed, code "));
      Serial.println(state);
      while (true)
        ;
    }

    // if needed, 'listen' mode can be disabled by calling
    // any of the following methods:
    //
    // radio.standby()
    // radio.sleep()
    // radio.transmit();
    // radio.receive();
    // radio.scanChannel();
  }

  void loop()
  {
    // check if the flag is set
    if (receivedFlag)
    {
      // reset flag
      receivedFlag = false;

      // you can read received data as an Arduino String
      String str;
      int state = radio.readData(str);

      // you can also read received data as byte array
      /*
        byte byteArr[8];
        int state = radio.readData(byteArr, 8);
      */

      if (state == RADIOLIB_ERR_NONE)
      {
        // packet was successfully received
        Serial.println(F("[SX1278] Received packet!"));

        // print data of the packet
        Serial.print(F("[SX1278] Data:\t\t"));
        Serial.println(str);

        // print RSSI (Received Signal Strength Indicator)
        Serial.print(F("[SX1278] RSSI:\t\t"));
        Serial.print(radio.getRSSI());
        Serial.println(F(" dBm"));

        // print SNR (Signal-to-Noise Ratio)
        Serial.print(F("[SX1278] SNR:\t\t"));
        Serial.print(radio.getSNR());
        Serial.println(F(" dB"));

        // print frequency error
        Serial.print(F("[SX1278] Frequency error:\t"));
        Serial.print(radio.getFrequencyError());
        Serial.println(F(" Hz"));
      }
      else if (state == RADIOLIB_ERR_CRC_MISMATCH)
      {
        // packet was received, but is malformed
        Serial.println(F("[SX1278] CRC error!"));
      }
      else
      {
        // some other error occurred
        Serial.print(F("[SX1278] Failed, code "));
        Serial.println(state);
      }
    }
  }

platformio.ini

[env:ttgo-lora32-v21]
platform = espressif32
board = ttgo-lora32-v21
framework = arduino
lib_deps = jgromes/RadioLib@^6.1.0

[jgromes]

It seems like you're trying to use the packet mode for device that doesn't have the expected packet structure. So you will have to find out more about the signal:

1. How long is the preamble and what is the polrity (0x55 vs 0xAA)
2. Does it have a sync word? If so, what is it?
3. Does the packet header contain the length of the packet? Or is the packet length fixed?
4. Does it have some forward error coding or whitening?
5. Does it have a CRC?

RadioLib contains provisions to receive almost any signal, but the more you know about it, the more processing the library can do for you. You can always receie in direct mode (see the examples) and do the processing yourself.

[rudsomlima]

1. How long is the preamble and what is the polrity (0x55 vs 0xAA): 38 bits = 010101....
2. Does it have a sync word? If so, what is it? Yes: 0000111101
   The rest are coded as 3of6.
   I've tried several changes to the code but I still can't receive consistent data.

Inspiration: ​https://www.zewaren.net/wmbus-izar-meter.html

Thanks

[jgromes]

In that case, this doesn't conform to the packet format expected by SX127x, so you cannot use the packet mode. You will have to use direct reception: /~https://github.com/jgromes/RadioLib/blob/master/examples/SX127x/SX127x_Receive_Direct/SX127x_Receive_Direct.ino

Alternatively as @NorthernMan54 suggested, you can use the rtl_433_ESP project, which internally still uses RadioLib direct mode. And if your meter isn't suppported, you can add the support and it could be a nice contribution to that project.

[NorthernMan54]

A couple of code suggestions ( I’m not sure if your meter is supported though )

This library decodes a lot of 433 MHz device signals with that board

/~https://github.com/NorthernMan54/rtl_433_ESP

And this package wraps it into a slick framework

/~https://github.com/1technophile/OpenMQTTGateway

[rudsomlima]

Thanks for the replies, I'm still trying with this.

[patrick-kiwi]

Hi All

I'm also tinkering with this lilygo T3_V1.6.1 module, and I made some progress which I thought I'd share. The pinout for the sx1276 LORA module is shown below. If you hold the LILYGO board with the antenna pointed down, then vcc pin is on the right side.

One problem that I found is that it seems like something wrong with the SPI pin definitions. Debugging with a Serial.printf hightlights the problem:

void setup() {
Serial.begin(115200);
Serial.printf("MISO: %d, MOSI: %d, SCK: %d, SS: %d\n", MISO, MOSI, SCK, SS);

Then the output looks like this:

rst:0x1 (POWERON_RESET),boot:0x13 (SPI_FAST_FLASH_BOOT)
configsip: 188777542, SPIWP:0xee
clk_drv:0x00,q_drv:0x00,d_drv:0x00,cs0_drv:0x00,hd_drv:0x00,wp_drv:0x00
mode:DIO, clock div:1
load:0x3fff0030,len:1448
load:0x40078000,len:14844
ho 0 tail 12 room 4
load:0x40080400,len:4
load:0x40080404,len:3356
entry 0x4008059c
MISO: 19, MOSI: 23, SCK: 18, SS: 5
[SX1278] Initializing ... failed, code -2

Notice how the ESP32 thinks that MOSI, clock, and chip select pins are 23, 18, and 5 respectively, but according to the pinout diagram they've been assigned as 27, 5, and 18. Check out the manual for the LILYGO T3_V1.6.1 here https://www.manualslib.com/download/2830608/Lilygo-T3-V1-6-1.html.

Good news is I managed to get the RadioLib SX127x examples working by manually connecting dio1 and io34 as shown below and changing the code a little as shown below. Had to change dots to arrows because of something to do with pointers. I hope this is helpful. More good news is this unit works just fine without any extra wires using the openMQTTgateway with LORA enabled (upload from the web and use the ttgo-lora32-v21 option). I tested it and homeassistant can receive json LORA messages.

#include <RadioLib.h>
#include <SPI.h>

//LILYGO/TTGO T3_V1.6.1 board pinout
#define ss_pin 18
#define dio0_pin 26
#define rst_pin 23
#define dio1_pin 22 //have to manually connect this!

SPIClass newSPI(HSPI);
Module* mod;
SX1276* radio1;

void setup() {
Serial.begin(115200);
SPI.begin();

//define hardware SPI pins
newSPI.begin(5, 19, 27, ss_pin); //SCLK, MISO, MOSI, SS
mod = new Module(ss_pin, dio0_pin, rst_pin, dio1_pin, newSPI);
radio1 = new SX1276(mod);

Serial.printf("MISO: %d, MOSI: %d, SCK: %d, SS: %d\n", MISO, MOSI, SCK, SS);

// initialize SX127x with default settings
Serial.print(F("[SX1276] Initializing ... "));
int state = radio1->begin();
if (state == RADIOLIB_ERR_NONE) {
Serial.println(F("success!"));
} else {
Serial.print(F("failed, code "));
Serial.println(state);
while (true);
}

// set carrier frequency to 433.5 MHz
if (radio1->setFrequency(433) == RADIOLIB_ERR_INVALID_FREQUENCY) {
Serial.println(F("Selected frequency is invalid for this module!"));
while (true);
}

// set bandwidth to 250 kHz
if (radio1->setBandwidth(125) == RADIOLIB_ERR_INVALID_BANDWIDTH) {
Serial.println(F("Selected bandwidth is invalid for this module!"));
while (true);
}

// set spreading factor to 10
if (radio1->setSpreadingFactor(7) == RADIOLIB_ERR_INVALID_SPREADING_FACTOR) {
Serial.println(F("Selected spreading factor is invalid for this module!"));
while (true);
}

// set coding rate to 6
if (radio1->setCodingRate(5) == RADIOLIB_ERR_INVALID_CODING_RATE) {
Serial.println(F("Selected coding rate is invalid for this module!"));
while (true);
}

// set LoRa sync word to 0x14
// NOTE: value 0x34 is reserved for LoRaWAN networks and should not be used
if (radio1->setSyncWord(0x12) != RADIOLIB_ERR_NONE) {
Serial.println(F("Unable to set sync word!"));
while (true);
}

// set output power to 10 dBm (accepted range is -3 - 17 dBm)
// NOTE: 20 dBm value allows high power operation, but transmission
// duty cycle MUST NOT exceed 1%
if (radio1->setOutputPower(10) == RADIOLIB_ERR_INVALID_OUTPUT_POWER) {
Serial.println(F("Selected output power is invalid for this module!"));
while (true);
}

// set over current protection limit to 80 mA (accepted range is 45 - 240 mA)
// NOTE: set value to 0 to disable overcurrent protection
if (radio1->setCurrentLimit(80) == RADIOLIB_ERR_INVALID_CURRENT_LIMIT) {
Serial.println(F("Selected current limit is invalid for this module!"));
while (true);
}

// set LoRa preamble length to 15 symbols (accepted range is 6 - 65535)
if (radio1->setPreambleLength(8) == RADIOLIB_ERR_INVALID_PREAMBLE_LENGTH) {
Serial.println(F("Selected preamble length is invalid for this module!"));
while (true);
}

// set amplifier gain to 1 (accepted range is 1 - 6, where 1 is maximum gain)
// NOTE: set value to 0 to enable automatic gain control
// leave at 0 unless you know what you're doing
if (radio1->setGain(1) == RADIOLIB_ERR_INVALID_GAIN) {
Serial.println(F("Selected gain is invalid for this module!"));
while (true);
}

Serial.println(F("All settings successfully changed!"));
}

void loop() {
// nothing here
}