Trying to send an APRS message using LoRa

[strobesactual]

Hello. I am building a tracking & telemetry system for a stratospheric balloon. I want the balloon to transmit an APRS message using a 433MHz LoRa transmitter (SX-1278 chip). To test the components and architecture, I wrote some code to send an APRS message from a Raspberry Pi via LoRa to an APRS LoRa I-Gate at my house. I hear the device transmitting, but I do not see the message appear on APRS.fi

I THINK this might be because there is no flag at the beginning of the message, as indicated on line 499 in ax25 / init.py

Does anyone see something I am doing wrong? Is there a better way to encode an APRS message for transmission?

I am pasting my code below:

import ax25
from LoRaRF import SX127x

# Create a regular station address
src_call = ax25.Address("AB1CDE") #AB1CDE
dst_call = ax25.Address("GPS")

frame_type = ax25.FrameType.UI
control_field = ax25.Control(frame_type,False)
protocol_id = 0xF0

obj_report = ";Balon01*050859z3023.38N/09743.09W>999/888_Sts_AG10600AB21100_F1C1T1A1_16.7_END"
obj_report_bytes = obj_report.encode('utf-8')  # Encode message as bytes

message = ax25.Frame(src_call,src_call,None,control_field,protocol_id,obj_report_bytes)

LoRa = SX127x()
LoRa.begin()
LoRa.setFrequency(433000000)
LoRa.setLoRaModulation(8, 125000, 5, False)  # Spreading factor 8, bandwidth 125 kHz, coding rate 4/5, and low data rate optimization off

# Convert AX.25 frame to bytes
frame_bytes = bytes(message)  # Use __bytes__() method
data_to_send = list(frame_bytes)  # File "/usr/local/lib/python3.11/dist-packages/LoRaRF/SX127x.py", line 513, in write raise TypeError("input data must be list, tuple, integer or float")

LoRa.beginPacket()
LoRa.write(data_to_send)
LoRa.endPacket()
LoRa.wait()

This is the output when I print the message variable: <ax25.Frame object at 0x7fa8b4cc50>

Thank you for your help!

[mfncooper]

I'm afraid I know almost nothing about LoRA. However, after taking a quick look at the LoRaRF package, I think you need to be converting and sending the data in a slightly different manner. I'd suggest trying this:

# Convert AX.25 frame to bytes
data_to_send = message.pack()

LoRa.beginPacket()
LoRa.put(data_to_send)
LoRa.endPacket()

Note the use of pack() to create a bytes object from your ax25.Frame instance, and then the use of LoRa.put() (instead of LoRa.write()) to send that bytes object.

[strobesactual]

Thank you. Packing helped but I am still unable to get the messages to upload to the APRS.is server. I am not sure if its the lack of flags or the FCS. I cannot seem to find an FCS method either. here is what I have been able to write so far:

import ax25

(RED, ORANGE, YELLOW, GREEN, CYAN, BLUE, MAGENTA, RESET) = ('\033[91m', '\033[38;5;208m', '\033[93m', '\033[92m', '\033[96m', '\033[94m', '\033[95m', '\033[0m')

addr_src = ax25.Address('K-----', 11)
addr_dst = ax25.Address('K-----', 10)
via_path = [ax25.Address('WIDE2', 2, True)]

info_field = ';TEST__11A*051234z3024.00N/9747.40WO888/999_Alt:10600M_10.2min_Intact_None'
info_field_bytes = list(info_field.encode('utf-8'))

frame_type = ax25.FrameType.UI # Unproto messages are sent as Unnumbered Information (UI) packets
control_field = 0x03
protocol_id = 0xF0 # A PID value of 0xF0 is used to specify text content

def compose_unproto_frame(src_call, dst_call, msg, via):
control = ax25.Control(frame_type)
frame = ax25.Frame(
dst_call,
src_call,
control=control,
pid=protocol_id,
data=msg.encode('utf-8'),
via = via
)
return frame

aprs_frame = compose_unproto_frame(addr_src, addr_dst, info_field, via_path) # Compose the frame
aprs_byteframe = aprs_frame.pack() # Pack the frame into bytes

print('\n')
print(f"{BLUE}{'APRS frame (bytes):':<25}{RESET}{aprs_byteframe}\n")

The output is a byte string but lacks the flags at the beginning or end as well as an FCS. Does this happen in the background?

[mfncooper]

Wrapping the frame with the FCS and flag bytes is a very low-level activity, and nothing I've seen in terms of AX.25 services and so forth requires the client to do that; it's part of the protocol implementation that takes the packet (without those), wraps it, and sends it out. Even using the native Linux AX.25 API doesn't require the caller to do that.

If you look at the LoRa_simple_node.py example that's part of the LoRaRF-Python package, that example takes a structure, packs it into a byte string, and ships it out using beginPacket() / put() / endPacket(), with no additional wrapping required.

https://github.com/chandrawi/LoRaRF-Python/blob/main/examples/network/LoRa_simple_node.py#L71

All that said, as I noted before, I don't know anything about LoRA. I don't see any AX.25 related examples in the LoRaRF-Python package, so I'm unclear as to how it's supposed to work. In particular, it's not clear to me how the recipient of one of these packets would know what's in it and therefore how to decode it. (The structure in the example is clearly not an AX.25 packet, so the question is, if you adapted that example so that the payload is an AX.25 packet, how would the recipient know to decode it as an AX.25 packet and not the structure given in the example? There's no 'type' field to indicate the difference.)

Sorry I can't be more help. I noticed that you opened an issue against LoRaRF-Python, so hopefully you'll get some more helpful feedback there.

[mfncooper]

I had a quick dig around on the web, and this site led me to some code that indicates there's more to it than sending a raw AX.25 packet. Here:

https://github.com/lora-aprs/LoRa_APRS_Tracker/blob/master/src/LoRa_APRS_Tracker.cpp#L312

you can see that several bytes are sent before what's referred to as "APRS Data". The data appears to be coming from an APRSMessage instance, but I didn't try to track that down (except insofar as I found that it's apparently defined in a different project). It's not actually clear where, or even if, an AX.25 packet is involved.

Perhaps the website and / or code at the above links can lead you closer to a solution.

[mfncooper]

A little more digging (I got curious 😄 ) found me this post on StackExchange that, in part, states that the data is text, and not an AX.25 encoded packet. Note in particular this paragraph in the answer:

It is different, because of the aforementioned header, and because the stuff that would have been in the AX.25 packet headers ends up encoded as text (in the same format as APRS-IS or a TNC2 would use) in the LoRa payload, but nothing is changed in the APRS payload.

So I believe what you need is the 3-byte header I mentioned before (and also noted in the above post), followed by the APRS message in text format. For examples of the text format, see the test messages in this example file.

[strobesactual]

Martin, Thank you for your replies, and I apologize for taking some time to get back to you. Ill try to connect APRS, AX25, and LoRa together in this reply—please forgive if I cover any information you already know:

Automatic position reporting system (APRS) is a packet communications protocol for disseminating live data to everyone on a network in real time. At the link level, APRS uses the AX.25 protocol utilizing Unnumbered Information (UI) frames exclusively.

The Field specifications are:

This information was sourced from the APRS protocol guide, page 12, accessible at: http://www.aprs.org/doc/APRS101.PDF

The APRS network broadcasts on 144.39 MHz in the US. However, there is a growing community of operators using the LoRa frequency of 433.775 MHz (consistent across the globe) to send and receive APRS signals. The APRS network relies on a series of ground stations (digipeaters and I-Gates) that will receive and transmit these messages. The I-Gates will receive an APRS message and upload it to the APRS-IS service (https://aprs-is.net/). A map of these stations can be found on aprs.fi and a list of raw messages uploaded are shown at: https://aprs.fi/?c=raw&call=

To ensure I had the required physical layer to receive the APRS messages, I setup a LoRa I-Gate using a LILYGO TTGO (https://meshtastic.org/docs/hardware/devices/lilygo/lora/?t-lora=v2.1) operating at 433.775 MHz following the instructions listed here https://www.lora-aprs.info/docs/LoRa_APRS_iGate/quick-start-guide/ with my tracker visible here https://lora.ham-radio-op.net/views/search.php?imperialUnits=1&q=KW5AUS-1&seconds=0&center=30.3939,-86.5929&zoom=12

Since the physical layer seems to be setup correctly, the core challenge is structing the data appropriately and then transmitting it in the proper format to be recognized and decoded by the iGate.

This takes us back to the start of our discussion: what is the proper format. As you pointed out in your reply, the APRS data contained in the information field is text data, but the message itself is an AX.25 frame that holds the data. For the information field, the formatting is listed on page 17 of the APRS link protocol document (http://www.aprs.org/doc/APRS101.PDF). For the pruposes of my project, for now I will just assume this information field will be “Hello World”.

I'm not sure if this helped to clear up the background. If not, I apologize. If it does clear it up, my questions would thus be: how can I use your library to format the AX.25 frame to be passed to the Transceiver? Do I just pass plain text as shown in the example above?

I suppose if I ever solve this I should just write a library to perform this function so more people can send APRS transmissions, but I will need to 10x my coding skills and learn C++ I think.

Again, I sincerely appreciate all your help.

[mfncooper]

I see you took this to StackExchange, where someone confirmed what I noted before, that what you need is the 3-byte header, followed by the APRS message in text format. Hopefully you have everything sorted out now.

For later readers, here's the StackExchange confirmation.

[strobesactual]

Unfortunately I wasnt able to get it going. I am not sure if the issue is with the SX1278, but anytime I tried transmitting a message I would not see it appear on the LoRa APRS network. I had a LoRa APRS gateway maybe 3 feet away but it never saw a packet. I am not sure what I am doing wrong. Here is the most updated code I was using: https://github.com/strobesactual/SABER_/blob/main/LoRa_APRS_5.py
Lines 160 start the byte flags you had mentioned.