sx127x.py lib

[kjm1102]

Just wondering if anyone has experience of the sx127x.py lora lib behaviour after an esp32 deepsleep? I'm getting a lot of

entry 0x40080680
Traceback (most recent call last):
  File "boot.py", line 8, in <module>
  File "/lib/sx127x.py", line 98, in __init__
Exception: Invalid version=80

after the esp32 wakes up, often the invalid version is 252 instead of 80. I took a look around the offending line in the lib

# check hardware version
        init_try = True
        re_try = 0
        while init_try and re_try < 5:
            version = self.read_register(REG_VERSION)
            re_try = re_try + 1
            if version != 0: init_try = False
        if version != 0x12: raise Exception('Invalid version='+str(version)) 

it appears that a version register is supposed to change from 0x42 to 0x12 but isn't? I'm trying to get the sx1276 module to listen for lora packets while the esp32 is in deepsleep but I need to fix this problem first because I can't see what's been going on with the lora during deepsleep if there is a persistent crash after deepsleep.

[davefes]

For a LoRa TX module that I put into deepsleep I had to do a power-on reset. I use a circuit that that pulls the EN line for a short period.
https://github.com/orgs/micropython/discussions/9345
Also, somewhere in here https://github.com/Wei1234c/SX127x_driver_for_MicroPython_on_ESP8266/issues there was some discussion about using:
controller.reset_pin(controller.pin_reset)
after coming out of deepsleep. I do both.
Found it:
Wei1234c/SX127x_driver_for_MicroPython_on_ESP8266#14

I have contacted the author of the LoRa code that I am using to see if he can make any suggests re CAD or similar.

[davefes]

Have you got a oscilloscope and able to look on DIO0? On closer inspection my chip is marked RF96 made by HopeRF looks like I will need to dig-in and see what the differences might be.

[kjm1102]

I checked pin 26, it powers up hi, goes lo when boot.py runs & goes hi again when the packets come in. I also tried your pin14 reset as per below

import ssd1306,random,struct,esp32; from time import sleep, ticks_ms as ms; from machine import Pin,SoftSPI,I2C,SoftI2C,Pin,deepsleep; from sx127x import SX127x; t=ms()
i2c=SoftI2C(scl=Pin(22), sda=Pin(21)); oled=ssd1306.SSD1306_I2C(128, 64, i2c); cnfg={'miso':19, 'mosi':27, 'ss':18, 'sck':5, 'dio_0':26, 'reset':14, 'led':25}
loracnfg={'frequency':9205E5, 'tx_power_level':14, 'signal_bandwidth':125E3, 'spreading_factor': 12, 'coding_rate':5, 'preamble_length':8, 'implicit_header':0, 'sync_word':0x12, 'enable_CRC':0, 'invert_IQ':0}    # sync_word: 0x34=public, 0x12=private
spi=SoftSPI(baudrate=10000000, polarity=0, phase=0, bits=8, firstbit=SoftSPI.MSB, sck=Pin(cnfg['sck'],Pin.OUT,Pin.PULL_DOWN), mosi=Pin(cnfg['mosi'],Pin.OUT,Pin.PULL_UP), miso=Pin(cnfg['miso'],Pin.IN,Pin.PULL_UP))
reset_pin=Pin(cnfg['reset'], Pin.OUT); reset_pin(0); print('reset lo'); sleep(.1); reset_pin(1); print('reset hi'); sleep(.1)
lora=SX127x(spi, pins=cnfg, parameters=loracnfg)
wake=Pin(26, Pin.IN); esp32.wake_on_ext0(pin=wake, level=esp32.WAKEUP_ANY_HIGH)

def _t(): T=ms()-t; return '%04d'%T

lora.blink_led()
lora.receive()
print(_t(), 'ctrl C opportunity'); sleep(9)                                                                                                           # for repl development
Rx=lora.read_payload(); msg=0
if Rx: msg,rssi,snr=Rx,lora.packet_rssi(),lora.packet_snr(); print(_t(), 'msg', msg, 'rssi', rssi, 'snr', snr )

deepsleep(60*1000)                                                                                                                                    # wakep after a minute with no packets found

but no joy, sx127x still crashes at the same place after a deepsleep

>>> 
>>> 
reset lo
reset hi
SX version: 18
0458 ctrl C opportunity
[Memory - free: 92320   allocated: 18848]
ets Jun  8 2016 00:22:57

rst:0x5 (DEEPSLEEP_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:2
load:0x3fff0030,len:4540
ho 0 tail 12 room 4
load:0x40078000,len:12344
ho 0 tail 12 room 4
load:0x40080400,len:4124
entry 0x40080680
reset lo
reset hi
Traceback (most recent call last):
  File "boot.py", line 14, in <module>
  File "/lib/sx127x.py", line 98, in __init__
Exception: Invalid version=80

[davefes]

A new day ... just realised that doing a reset on a RX coming out of deepsleep is probably not what you want to do. I do the reset on the TX and a RX that runs continuously to stop that crash.

I would expect that you should be able to get rid of the crash but also that you will lose your data.

[davefes]

An idea ... if that reset gets rid of the crash in a continuously-running RX, see previously posted code below, then put the deepsleep back in and in main add:

if umachine.reset_cause() == umachine.HARD_RESET or umachine.reset_cause() == umachine.SOFT_RESET or umachine.PWRON_RESET() or umachine.WDT_RESET:
    do the reset

this way coming out of deepsleep should not reset the SX127x

[davefes]

Backing-up a bit ... have you been able to run lemarvia's examples without it crashing? Before adding deepsleep?

[davefes]

Here are my test scripts to stop the crash:

LoRaReceiver.py

from machine import Pin
import utime


red_led = Pin(19, Pin.OUT) #  red LED


def receive(lora):
    print("LoRa Receiver")

    while True:
        if lora.received_packet():

            print('something here')
            utime.sleep_ms(10)

            payload = lora.read_payload()

            red_led.on()

            print(payload)
            utime.sleep_ms(10)

            utime.sleep(1)
            red_led.off()

main.py

import LoRaReceiver
from config import *
from machine import Pin, SPI
from sx127x import SX127x
import utime


red_led = Pin(19, Pin.OUT) #  red LED

device_spi = SPI(baudrate = 10000000,
        polarity = 0, phase = 0, bits = 8, firstbit = SPI.MSB,
        sck = Pin(device_config['sck'], Pin.OUT, Pin.PULL_DOWN),
        mosi = Pin(device_config['mosi'], Pin.OUT, Pin.PULL_UP),
        miso = Pin(device_config['miso'], Pin.IN, Pin.PULL_UP))

reset_pin = Pin(device_config['reset'], Pin.OUT)

#  reset the RFM96W after a re-boot or when coming out of deepsleep()
reset_pin.off()
utime.sleep_ms(50)
reset_pin.on()
utime.sleep_ms(50)

lora = SX127x(device_spi, pins=device_config, parameters=lora_parameters)


if __name__ == '__main__':
    LoRaReceiver.receive(lora)

and your config.py

[kjm1102]

I fixed the Lemariva sx127x so it doesn't crash after deepsleep but it was wasted effort because the post deepsleep lora initialisation clobbers the packets received by the lora chip during deepsleep. I'll take a look at wake stubs or lightsleep as an alternative. Shame there's not an lora equipped rpi pico where deepsleep resumes from where the program left off rather than restarting, although pico deepsleep has it own unique problems too.

You making any progress with CAD?

[davefes]

No progress on CAD until I understand why my setup doesn't work.

When you come out of deepsleep could you skip the chip initialisation?

[davefes]

ibrary is already checking if the CRC flag calculated by the chip on reception is ok (if it is enabled on the sender node with enableCrc() method). It should not pass a packet whose CRC is not ok if it is enabled.

But that is for Arduino and I would much prefer a Micropython LoRa solution. One would think there would be an explanation for using end-to-end CRCs

[kjm1102]

I managed to verify that enable_CRC in sx127x.py works. I had to push the received signal down to -129 dBm to -130 dBm at which point it stopped receiving which I presume was the CRC checker junking the packets. When I disabled CRCs the successful receives shot up again & about half of those packets had errors (ie didn't match what was sent).
Interestingly, there seemed to be no variation in 'on 'air' time for all 4 combinations of implicit_header & enable_CRC which surprised me. Maybe that's because all my packets are short, 3 to 5 bytes.

[davefes]

With enable_CRC and implicit_header: 1, correct?

[kjm1102]

With enable_crc:1 at both ends you get RF chip CRC checking & it doesn't seem to matter what implicit_header is set to as long as both ends match

[davefes]

Thank you. Page 28 suggests that by using implicit_header you can speed things up a bit.

[davefes]

[davefes]

That is if you have a continuous carrier. When modulated things changed, especially with modulation formats like LoRa. I would expect that you should see something around the 0dBm level. Are you connecting directly to the antenna port?

Also, I noticed that your TX power was set to 14. What level is that? Mine is at 2.

[davefes]

Spent a few fruit-less hours comparing onReceive() and handleOnReceive() in various distributions. So, I thought I'd take your wake on RxDone example and just change the wake_on_ext0 to a pin interrupt. I wanted to be able to do other processing while waiting for a received signal. Here's my example (works but may not be the best way):

import esp32
import utime
from machine import Pin, SoftSPI
from sx127x import SX127x
import machine


cnfg = {'miso':12, 'mosi':13, 'ss':15, 'sck':14, 'dio_0':5, 'reset':4}
loracnfg = {'frequency':433E6, 'tx_power_level':17, 'signal_bandwidth':125E3, 'spreading_factor': 8, 'coding_rate':5, 'preamble_length':8, 'implicit_header':0, 'sync_word':0x12, 'enable_CRC':0, 'invert_IQ':0}    # sync_word: 0x34=public, 0x12=private
spi = SoftSPI(baudrate = 10000000, polarity = 0, phase = 0, bits = 8, firstbit = SoftSPI.MSB, sck = Pin(cnfg['sck'],Pin.OUT,Pin.PULL_DOWN), mosi = Pin(cnfg['mosi'],Pin.OUT,Pin.PULL_UP), miso = Pin(cnfg['miso'],Pin.IN,Pin.PULL_UP))

red_led = Pin(21, Pin.OUT) #  red LED
reset_pin = Pin(cnfg['reset'], Pin.OUT)
rxDone_interrupt = False
red_led.off()
reset_pin.off()


#  reset the RFM96W after a re-boot
utime.sleep_ms(50)
reset_pin.on() #  needs to stay high until reset

lora = SX127x(spi, pins = cnfg, parameters = loracnfg)
lora.receive()


def handle_interrupt(xyz): #  needs something in the brackets
    global rxDone_interrupt

    rxDone_interrupt = True

#  GPIO connected to DIO0 for rxDone high.
pir = Pin(26, Pin.IN, Pin.PULL_DOWN)
pir.irq(trigger=Pin.IRQ_RISING, handler=handle_interrupt)


def process_rx_msg():
    global rxDone_interrupt
    global lora


    if (rxDone_interrupt == True):
        rxDone_interrupt = False

     #  process the received message
        msg = b'xyz'

        red_led.on()
        Rx = lora.read_payload()

        if Rx:
            try:
                msg,rssi,snr = Rx,lora.packet_rssi(),lora.packet_snr()
                print('msg', msg, ' rssi', rssi, ' snr', int(snr))
                utime.sleep_ms(10)

         #  process msg
     
        utime.sleep_ms(500)
        red_led.off()

     #  re-init every loop
        lora = SX127x(spi, pins = cnfg, parameters = loracnfg)
        lora.receive()


#  blink the Red LED
red_led.on()
utime.sleep_ms(250)
red_led.off()

print('you have 2 seconds to do a CTRL-C')
utime.sleep(2)


while True:
    process_rx_msg()

    if not process_rx_msg():

     #  blink the Red LED to show there is no rx_msg
        red_led.on()
        utime.sleep_ms(250)
        red_led.off()
        utime.sleep_ms(250)

[davefes]

Tried disabling interrupts during process_rx_msg() as per the docs but crashed.

P.S. you can not disable IRQs for "long" periods.

[kjm1102]

I haven't done much with callbacks & ISRs, I've been able to get away with polling things so far. Apart from Sara's random nerd tutorials (which are always well illustrated with examples) I find a lot of the 'how-to's on line overly cerebral & lacking in examples. On the odd occasion I have had a crack I've found them trigger happy which means I then have to use RC hardware to calm them down. Easier to just poll & debounce in software.