I can't find the problem in my LoRa Code, can you?

[MrTinkerman]

Edit 1:

I Solved my problem,
This topic can be deleted.

Edit 2:

Reason for deleting was my post getting to elaborate and at
some point I lost track of what to even explain.
I just posted a summary in the 3rd reply though.

[davefes]

Not ulora by any chance?

[andypiper]

It can be really helpful to other people if you leave the original code on a forum, but add the solution you discovered. It means that other people can learn what they might also have missed in their code!

[MrTinkerman]

Yes, I thought about that too and you right.
But it was A huge post and explaining it all was taking too much time.
But let's see if can make a summary ok?

It's about this library: https://github.com/martynwheeler/u-lora/blob/main/ulora.py

Hardware: Xiao ESP32-C3 and RFM95

You can set a function to run when a message is received, a callback. I wrote code to reply to messages:
** Node A sends a message to node B
** Node B acks the message and sends a reply message back to node A
** Node A was receiving that reply message and sending an ack back to node B

This were it went wrong, the ack from node A never triggered an interrupt at node B
So node B kept retrying to send the reply. You still with me?

Both the non-working code and my 'solution' for the (replying) node B are posted below.

I'm am not exactly sure why this 'solution' works but I have a hunch.
What might be a problem is that the callback function gets the data from a function inside an interrupt routine inside the library (line 368).

My 'solution' is:
** Store a reply message in a global variable in the receive callback
** Run a check in the loop to see if a message is queued
** If so, call a separate function to send out the queued message

So yeah, that's the summary.
If you'd like any more details let me know ok?

Thanks.

Non working code:

import time
from ulora import LoRa, ModemConfig, SPIConfig
import json

# Lora Parameters
RST, CS, INT, FRQ, POW = 3, 4, 5, 868.0, 14
SPI = SPIConfig.esp32_C3
BASE_ADR = 1

# initialise radio
lora = LoRa(SPI, INT, BASE_ADR, CS, reset_pin=RST,
            freq=FRQ, tx_power=POW, acks=True)


def send(msg, to):								# msg: dictionary, to: address (int 0-255)
    
    print(f'sending mesage {msg}    @ {time.ticks_ms()}')
        
    if lora.send_to_wait(msg, to):
        print(f'ack received @ {time.ticks_ms()}')
    else: print('no ack received')
    
    
def recv(pl):									# Function runs on received message
    
    print(pl)
    time.sleep_ms(1000)
    reply(pl)


def reply(pl):
    
    rep={}
    rep['mnr'] = pl.message['mnr']
    print(rep, pl.header_from)
    send(rep, pl.header_from)
    
    
# set callback
lora.on_recv = recv

# set to listen continuously
lora.set_mode_rx()

# loop and wait for data
while True:
    time.sleep(0.1)

Working code:

import time, json, random
from ulora import LoRa, ModemConfig, SPIConfig


RST, CS, INT, FRQ, POW = 3, 4, 5, 868.0, 14					# Lora Parameters
SPI = SPIConfig.esp32_C3
net_id 	 = 35846
node_adr = 2									# Swap on other device
base_adr = 1

reply_queued = None


lora = LoRa(SPI, INT, node_adr, net_id, CS, reset_pin=RST,			# initialise LoRa
            freq=FRQ, tx_power=POW, acks=True)

        
def send(msg, to):								# msg: dictionary, to: address (int 0-255)
    
    lora.send_to_wait(msg, to)


def recv(payload):
    
    global reply_queued
    msg = {}									# Message to store
    msg['rep_to']= payload.message['mnr']
    reply_queued = [msg, payload.header_from]					# Store msg in reply_queued    
    

def send_queued():
    
    global reply_queued
    send(reply_queued[0], reply_queued[1])
    reply_queued = None
    
    
lora.on_recv = recv								# Callback on received message
lora.set_mode_rx()								# Put in receive mode at startup


while True:
    
    time.sleep_ms(10)
    if reply_queued: send_queued()

[davefes]

Which hardware platform? I see you moved from send_to_wait() to send(). Likewise, after reading some of the possible timing issues ... especially with a PICO.

[MrTinkerman]

Added the info: Xiao ESP32-C3 and RFM95

[rkompass]

@MrTinkerman Did you notice this discussion?

[jimmo]

@MrTinkerman FYI we recently published a LoRa driver (for sx126x and sx127x parts). It can be installed with mip from micropython-lib. See https://github.com/micropython/micropython-lib/tree/master/micropython/lora

[rkompass]

@jimmo Thank you for the link. I will check (after reading and learning) if rfm95 may be integrated into those libs.

[MrTinkerman]

Thank indeed for this link @jimmo, hadn't seen it before.

@rkompass , the RFM95 is a 1276 device should work with the library as I think?
(let me know if this is this is incorrect though)

On the subject of the chips on those RFM95 modules, I'm a bit confused.
For example, on this product page
The module is shown with a "H RF96" chip
On this page: https://webshop.ideetron.nl/RFM95W
The marking on the chip is blurred/photoshopped

The marking on the modules I have is "H RF96" but it's very faint, can only see it at the right angle with a magnifier.

I've had my share of headaches with Arduino clones in the past. Are there clones around for these kinds of lora boards and how do you know you get a genuine board if there even is such a thing?

Thanks

[rkompass]

@MrTinkerman I checked the datasheets: The Protocol is the same, but registers of Hope (RFM95) and Semtex (1276X) chips are different. They only in the beginning look similar. Adapting the 1276 driver will at least require a translation of the corresponding register settings.

My chip also has the H RF96.

[davefes]

I have been using modules marked 'H RF96' with Wei's Lora code https://github.com/Wei1234c/SX127x_driver_for_MicroPython_on_ESP8266/tree/master for the last year. Basic functionality must be similar.

[davefes]

@jimmo Whose SX127x chips were used in this comprehensive implementation?