You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
934 lines
29 KiB
934 lines
29 KiB
#include <stdio.h>
|
|
#include <string.h>
|
|
#include <time.h>
|
|
#include <stdarg.h>
|
|
#include "pico/stdlib.h"
|
|
#include "pico/binary_info.h"
|
|
#include "hardware/flash.h"
|
|
#include "LoRa-RP2040.h"
|
|
#include "Config.h"
|
|
#include "kiss.h"
|
|
#include "hardware/claim.h"
|
|
|
|
KissClass Kiss;
|
|
|
|
bool startRadio();
|
|
void getPacketData(int packetLength);
|
|
int compare_strings(uint8_t a[], uint8_t b[]);
|
|
bool is_message_for_me (uint8_t data[], uint8_t mycall[]);
|
|
|
|
/* declaration for receive functions */
|
|
uint16_t decode_packet ();
|
|
|
|
/* declaration for transmit functions */
|
|
void ComposeAprsFrame(uint8_t payload[]);
|
|
bool TransmitRequest = false;
|
|
void transmit();
|
|
|
|
const uint PowerSupply24VControl = 6;
|
|
const uint PowerSupply12VControl = 5;
|
|
const uint PowerSupply5VControl = 4;
|
|
const uint RelayOffControl = 2;
|
|
const uint RelayOnControl = 3;
|
|
|
|
// We're going to use a region 512k from the start of flash as non volatile storage for our settings.
|
|
// We can access this at XIP_BASE + 512k.
|
|
#define FLASH_TARGET_OFFSET (512 * 1024)
|
|
|
|
const uint8_t *flash_target_contents = (const uint8_t *) (XIP_BASE + FLASH_TARGET_OFFSET);
|
|
|
|
void log_out(const char *fmt, ...)
|
|
{
|
|
char buf[256];
|
|
va_list args;
|
|
|
|
if (Status.KissMode == OFF) {
|
|
va_start(args, fmt);
|
|
|
|
vsnprintf(buf, sizeof buf, fmt, args);
|
|
|
|
va_end( args);
|
|
|
|
printf("%s", buf);
|
|
}
|
|
|
|
}
|
|
|
|
/*
|
|
* Saves settings in struct AprsSettings to FLASH memory
|
|
* Struct AprsSettings should be exactly a multiple of FLASH_PAGE_SIZE in size.
|
|
*
|
|
* Returns: 0 when successfull
|
|
* 1 when error
|
|
*/
|
|
|
|
uint8_t SaveSettingsToFlash(void)
|
|
{
|
|
uint32_t ints = save_and_disable_interrupts();
|
|
|
|
// First we erase the FLASH sector we need. After that we can store new values.
|
|
// Note that a whole number of sectors must be erased at a time.
|
|
// Sector size is 4kB, so this is way bigger than the 256 bytes PAGE_SIZE for storing the settings.
|
|
// We can therefore store up to 16 blocks of 256 bytes per sector
|
|
log_out("Erasing FLASH region...");
|
|
flash_range_erase(FLASH_TARGET_OFFSET, FLASH_SECTOR_SIZE);
|
|
log_out("done\n");
|
|
log_out("Writing settings to FLASH...");
|
|
flash_range_program(FLASH_TARGET_OFFSET, (uint8_t*)&AprsSettings, sizeof(AprsSettings) );
|
|
log_out("done\n");
|
|
restore_interrupts (ints);
|
|
|
|
return(0);
|
|
}
|
|
|
|
void ShowSettings(void)
|
|
{
|
|
log_out("LoRa APRS remote switcher with build in KISS TNC.\n");
|
|
log_out(" Firmware version : %s\n",AprsSettings.FirmwareVersion);
|
|
log_out(" Size of struct : %u.\n\n", sizeof(AprsSettings));
|
|
|
|
log_out("APRS settings\n");
|
|
log_out(" My call : %s\n", AprsSettings.MyCall);
|
|
log_out(" Server call : %s\n", AprsSettings.ServerCall);
|
|
log_out(" Destination : %s\n", AprsSettings.Destination);
|
|
log_out(" Path 1 : %s\n", AprsSettings.Path1);
|
|
log_out(" Path 2 : %s\n\n", AprsSettings.Path2);
|
|
|
|
log_out("LoRa settings\n");
|
|
log_out(" Frequency : %u\n", AprsSettings.loraFrequency);
|
|
log_out(" SpreadingFactor : %i\n", AprsSettings.loraSpreadingFactor);
|
|
log_out(" Preamble : %i\n", AprsSettings.loraPreamble);
|
|
log_out(" CodingRate : %i\n", AprsSettings.loraCodingRate);
|
|
log_out(" TxPower : %i\n", AprsSettings.loraTxPower);
|
|
log_out(" PaSelect : %i\n", AprsSettings.loraPaSelect);
|
|
log_out(" Bandwidth : %u\n", AprsSettings.loraBandwidth);
|
|
}
|
|
|
|
uint8_t ReadSettingsFromFlash(void)
|
|
{
|
|
// If byte zero of flash contains 0x5A we assume the data to be valid, otherwise we fill the flash with default values.
|
|
if (flash_target_contents[0] != 0x5A)
|
|
{
|
|
log_out( "No valid data found in FLASH memory. Using default values.\n" );
|
|
memset(AprsSettings.FillerData, 0, sizeof(AprsSettings.FillerData));
|
|
SaveSettingsToFlash();
|
|
|
|
} else {
|
|
// Read settings stored in flash memory
|
|
log_out("Found valid settings in FLASH memory.\n");
|
|
}
|
|
memcpy((uint8_t*)&AprsSettings, flash_target_contents, sizeof(AprsSettings));
|
|
ShowSettings();
|
|
}
|
|
|
|
void setup(void)
|
|
{
|
|
/* Among others, this initializes the USB-serial port at 115200bps 8N1 */
|
|
stdio_init_all();
|
|
|
|
// Buffers
|
|
memset(rxBuffer, 0, sizeof(rxBuffer));
|
|
memset(txBuffer, 0, sizeof(txBuffer));
|
|
|
|
gpio_init(PowerSupply24VControl);
|
|
gpio_init(PowerSupply12VControl);
|
|
gpio_init(PowerSupply5VControl);
|
|
gpio_init(RelayOffControl);
|
|
gpio_init(RelayOnControl);
|
|
|
|
gpio_set_dir(PowerSupply24VControl, GPIO_OUT);
|
|
gpio_set_dir(PowerSupply12VControl, GPIO_OUT);
|
|
gpio_set_dir(PowerSupply5VControl, GPIO_OUT);
|
|
gpio_set_dir(RelayOffControl, GPIO_OUT);
|
|
gpio_set_dir(RelayOnControl, GPIO_OUT);
|
|
|
|
gpio_put(PowerSupply24VControl, 0);
|
|
Status.PowerSupply24V = OFF;
|
|
gpio_put(PowerSupply12VControl, 0);
|
|
Status.PowerSupply12V = OFF;
|
|
gpio_put(PowerSupply5VControl, 1);
|
|
Status.PowerSupply5V = OFF;
|
|
|
|
gpio_put(RelayOffControl, 1);
|
|
sleep_ms(250);
|
|
gpio_put(RelayOffControl, 0);
|
|
gpio_put(RelayOnControl, 0);
|
|
Status.ControlRelay = OFF;
|
|
|
|
sleep_ms(5000);
|
|
|
|
ReadSettingsFromFlash();
|
|
|
|
startRadio();
|
|
|
|
}
|
|
|
|
void print_help(void)
|
|
{
|
|
log_out("Unknown command.\n\n");
|
|
log_out("kiss\n");
|
|
log_out(" Enter KISS mode.\n");
|
|
log_out("save\n");
|
|
log_out(" Save settings to flash.\n");
|
|
log_out("read <flash/ram>\n");
|
|
log_out(" Read settings from FLASH or RAM.\n");
|
|
log_out("mycall/servercall/destination/path1/path2\n");
|
|
log_out(" APRS settings.\n");
|
|
log_out("freq/spread/pre/rate/power/pa/band.\n");
|
|
log_out(" LoRa settings.\n");
|
|
|
|
}
|
|
|
|
/*
|
|
* Reads a string and converts it to its 32 bit value if it contains a number,
|
|
* else it returns 0xFFFFFFFF
|
|
*/
|
|
uint32_t ConvertStringToValue(char string[])
|
|
{
|
|
uint16_t position = 0;
|
|
uint32_t value = 0;
|
|
|
|
// Extract value from string (if present)
|
|
while( string[position] != 0 )
|
|
{
|
|
// Is character a number?
|
|
if (string[position] >= 48 && string[position] <= 57) {
|
|
value = 10*value + string[position]-48;
|
|
} else {
|
|
return 0xFFFFFFFF;
|
|
}
|
|
position++;
|
|
|
|
}
|
|
return value;
|
|
}
|
|
|
|
void ProcessSerialInput(char string[])
|
|
{
|
|
uint8_t cnt;
|
|
uint8_t position=0;
|
|
uint32_t tmp = 0;
|
|
|
|
char command[100];
|
|
char parameter[100];
|
|
|
|
//log_out("You wrote - %s (%u).\n", string, strlen(string));
|
|
|
|
// Command cannot be any shorter than 3 characters
|
|
if (strlen(string) > 2) {
|
|
|
|
// Extract command (part before space)
|
|
cnt = 0;
|
|
while( string[position] != 0 )
|
|
{
|
|
command[cnt++] = string[position];
|
|
if ( string[position] == ' ' ) {
|
|
command[cnt-1] = 0; // terminate command string
|
|
position++;
|
|
break;
|
|
}
|
|
position++;
|
|
}
|
|
|
|
// Extract parameter (part after space)
|
|
cnt = 0;
|
|
while( string[position] != 0 )
|
|
{
|
|
parameter[cnt++] = string[position++];
|
|
}
|
|
parameter[cnt] = 0; //terminate string
|
|
|
|
//log_out("Command - %s.\n", command);
|
|
//log_out("Parameter - %s.\n", parameter);
|
|
|
|
// Read settings
|
|
if (strcmp(command, "read") == 0) {
|
|
if (strcmp(parameter, "flash") == 0) {
|
|
ReadSettingsFromFlash();
|
|
}
|
|
else if (strcmp(parameter, "ram") == 0) {
|
|
ShowSettings();
|
|
}
|
|
}
|
|
// Save settings to FLASH
|
|
else if (strcmp(command, "save") == 0)
|
|
SaveSettingsToFlash();
|
|
|
|
// Enter KISS mode
|
|
else if (strcmp(command, "kiss") == 0) {
|
|
log_out("Entering KISS mode.\n");
|
|
log_out("You can exit KISS mode via KISS command <0xC0 0xFF 0xC0>\n");
|
|
// disable CRLF convertion, so we can write raw data to the USB port in KISS mode
|
|
stdio_set_translate_crlf(&stdio_usb, false);
|
|
//fwrite(buf, 1, sizeof(buf), stdout); // seems not to work
|
|
//putchar(49);
|
|
|
|
Status.KissMode = ON;
|
|
}
|
|
|
|
// Set mycall (cannot be longer than 9 characters)
|
|
else if (strcmp(command, "mycall") == 0) {
|
|
if (sizeof(AprsSettings.MyCall) > strlen(parameter)) {
|
|
position = 0;
|
|
while( parameter[position] != 0 )
|
|
{
|
|
AprsSettings.MyCall[position] = parameter[position];
|
|
position++;
|
|
}
|
|
AprsSettings.MyCall[position] = 0;
|
|
log_out("MyCall set to %s.\n", AprsSettings.MyCall);
|
|
}
|
|
}
|
|
// Set servercall (cannot be longer than 9 characters)
|
|
else if (strcmp(command, "servercall") == 0) {
|
|
if (sizeof(AprsSettings.ServerCall) > strlen(parameter)) {
|
|
position = 0;
|
|
while( parameter[position] != 0 )
|
|
{
|
|
AprsSettings.ServerCall[position] = parameter[position];
|
|
position++;
|
|
}
|
|
AprsSettings.ServerCall[position] = 0;
|
|
log_out("ServerCall set to %s.\n", AprsSettings.ServerCall);
|
|
}
|
|
}
|
|
// Set path 1 (cannot be longer than 9 characters)
|
|
else if (strcmp(command, "path1") == 0) {
|
|
// Set path to nothing
|
|
if (parameter[0] == '0') {
|
|
AprsSettings.Path1[0] = 0;
|
|
log_out("Path1 cleared.\n");
|
|
}
|
|
else if (sizeof(AprsSettings.Path1) > strlen(parameter)) {
|
|
position = 0;
|
|
while( parameter[position] != 0 )
|
|
{
|
|
AprsSettings.Path1[position] = parameter[position];
|
|
position++;
|
|
}
|
|
AprsSettings.Path1[position] = 0;
|
|
log_out("Path1 set to %s.\n", AprsSettings.Path1);
|
|
}
|
|
}
|
|
// Set path 2 (cannot be longer than 9 characters)
|
|
else if (strcmp(command, "path2") == 0) {
|
|
// Set path to nothing
|
|
if (parameter[0] == '0') {
|
|
AprsSettings.Path2[0] = 0;
|
|
log_out("Path2 cleared.\n");
|
|
}
|
|
else if (sizeof(AprsSettings.Path2) > strlen(parameter)) {
|
|
position = 0;
|
|
while( parameter[position] != 0 )
|
|
{
|
|
AprsSettings.Path2[position] = parameter[position];
|
|
position++;
|
|
}
|
|
AprsSettings.Path2[position] = 0;
|
|
log_out("Path2 set to %s.\n", AprsSettings.Path2);
|
|
}
|
|
}
|
|
// Set destination (cannot be longer than 9 characters)
|
|
else if (strcmp(command, "dest") == 0) {
|
|
if (sizeof(AprsSettings.Destination) > strlen(parameter)) {
|
|
position = 0;
|
|
while( parameter[position] != 0 )
|
|
{
|
|
AprsSettings.Destination[position] = parameter[position];
|
|
position++;
|
|
}
|
|
AprsSettings.Destination[position] = 0;
|
|
log_out("Destination set to %s.\n", AprsSettings.Destination);
|
|
}
|
|
}
|
|
// Set lora frequency (limited between 420MHz and 450MHz)
|
|
else if (strcmp(command, "freq") == 0) {
|
|
tmp = ConvertStringToValue(parameter);
|
|
if (tmp == 0xFFFFFFFF || tmp < 420000000 || tmp > 450000000)
|
|
log_out("ERROR: that is not a valid value.\n");
|
|
else {
|
|
AprsSettings.loraFrequency = tmp;
|
|
log_out("LoRa frequency set to %u.\n", AprsSettings.loraFrequency);
|
|
}
|
|
}
|
|
// Set lora spreading factor (can be between 6 and 12)
|
|
else if (strcmp(command, "spread") == 0) {
|
|
tmp = ConvertStringToValue(parameter);
|
|
if (tmp == 0xFFFFFFFF || tmp < 6 || tmp > 12)
|
|
log_out("ERROR: that is not a valid value.\n");
|
|
else {
|
|
AprsSettings.loraSpreadingFactor = (uint16_t)tmp;
|
|
log_out("LoRa spreading factor set to %u.\n", AprsSettings.loraSpreadingFactor);
|
|
}
|
|
}
|
|
// Set lora preamble (can be between 6 and 0xFFFF)
|
|
else if (strcmp(command, "pre") == 0) {
|
|
tmp = ConvertStringToValue(parameter);
|
|
if (tmp == 0xFFFFFFFF || tmp < 6 || tmp > 0xFFFF)
|
|
log_out("ERROR: that is not a valid value.\n");
|
|
else {
|
|
AprsSettings.loraPreamble = (uint16_t)tmp;
|
|
log_out("LoRa preamble set to %u.\n", AprsSettings.loraPreamble);
|
|
}
|
|
}
|
|
// Set lora coding rate (can be between 5 and 8)
|
|
else if (strcmp(command, "rate") == 0) {
|
|
tmp = ConvertStringToValue(parameter);
|
|
if (tmp == 0xFFFFFFFF || tmp < 5 || tmp > 8)
|
|
log_out("ERROR: that is not a valid value.\n");
|
|
else {
|
|
AprsSettings.loraCodingRate = (uint16_t)tmp;
|
|
log_out("LoRa coding rate set to %u.\n", AprsSettings.loraCodingRate);
|
|
}
|
|
}
|
|
// Set lora tx power (can be between 2 and 17)
|
|
else if (strcmp(command, "power") == 0) {
|
|
tmp = ConvertStringToValue(parameter);
|
|
if (tmp == 0xFFFFFFFF || tmp < 2 || tmp > 17)
|
|
log_out("ERROR: that is not a valid value.\n");
|
|
else {
|
|
AprsSettings.loraTxPower = (uint16_t)tmp;
|
|
log_out("LoRa tx power set to %u.\n", AprsSettings.loraTxPower);
|
|
}
|
|
}
|
|
// Set lora bandwidth (can be between 7800 and 500000)
|
|
else if (strcmp(command, "band") == 0) {
|
|
tmp = ConvertStringToValue(parameter);
|
|
if (tmp == 0xFFFFFFFF || tmp < 7800 || tmp > 5000000)
|
|
log_out("ERROR: that is not a valid value.\n");
|
|
else {
|
|
AprsSettings.loraBandwidth = tmp;
|
|
log_out("LoRa bandwidth set to %u.\n", AprsSettings.loraBandwidth);
|
|
}
|
|
}
|
|
// Set lora pa to +20dBm (can be either 0 or 1)
|
|
else if (strcmp(command, "pa") == 0) {
|
|
tmp = ConvertStringToValue(parameter);
|
|
if (tmp != 0 && tmp != 1)
|
|
log_out("ERROR: that is not a valid value.\n");
|
|
else {
|
|
AprsSettings.loraPaSelect = (uint16_t)tmp;
|
|
log_out("LoRa PA set to %u.\n", AprsSettings.loraPaSelect);
|
|
}
|
|
}
|
|
// Restart radio
|
|
else if (strcmp(command, "restart") == 0)
|
|
if (strcmp(parameter, "lora") == 0) {
|
|
log_out("Re-");
|
|
startRadio();
|
|
}
|
|
|
|
else {
|
|
print_help();
|
|
}
|
|
}
|
|
else
|
|
{
|
|
print_help();
|
|
}
|
|
}
|
|
void ReadUSBSerial(void)
|
|
{
|
|
static char strg[100];
|
|
int chr;
|
|
static int lp = 0;
|
|
|
|
// Read serial port (USB) - non-blocking!
|
|
chr = getchar_timeout_us(0);
|
|
while(chr != PICO_ERROR_TIMEOUT)
|
|
{
|
|
log_out("%c", chr);
|
|
|
|
strg[lp++] = chr;
|
|
if(chr == CR || lp == (sizeof(strg) - 1))
|
|
{
|
|
strg[lp-1] = 0; //terminate string by overwriting <CR> with NULL
|
|
//log_out("You wrote - %s\n", strg);
|
|
lp = 0; //reset string buffer pointer
|
|
log_out("\n");
|
|
|
|
ProcessSerialInput(strg);
|
|
|
|
break;
|
|
}
|
|
|
|
chr = getchar_timeout_us(0);
|
|
}
|
|
}
|
|
|
|
int main() {
|
|
|
|
uint16_t ServerCommand = 0;
|
|
uint16_t TxDelay = 0;
|
|
|
|
setup();
|
|
|
|
while (1) {
|
|
int packetSize = LoRa.parsePacket();
|
|
if (packetSize) {
|
|
// received a packet
|
|
log_out("Received packet (RSSI = %idBm)\n",LoRa.packetRssi());
|
|
|
|
getPacketData(packetSize);
|
|
|
|
// Check APRS header: must be 0x3C 0xFF 0x01
|
|
if (rxBuffer[0] == 0x3C && rxBuffer[1] == 0xFF && rxBuffer[2] == 0x01 ) {
|
|
// Shift array three places to left (= remove APRS header)
|
|
for (int cnt = 3; cnt < packetSize; cnt++) {
|
|
rxBuffer[cnt-3] = rxBuffer[cnt];
|
|
}
|
|
rxBuffer[packetSize-3] = 0;
|
|
log_out("%s\n", rxBuffer);
|
|
ServerCommand = decode_packet();
|
|
} else {
|
|
log_out("ERROR: No or corrupted APRS frame.\n");
|
|
}
|
|
}
|
|
|
|
if (ServerCommand) {
|
|
|
|
switch(ServerCommand) {
|
|
|
|
case 1 :
|
|
ComposeAprsFrame(AprsSettings.FirmwareVersion);
|
|
break;
|
|
// Send status of output pins
|
|
case 6 :
|
|
if (Status.PowerSupply24V == ON)
|
|
Status.StatusString[4] = '1';
|
|
else
|
|
Status.StatusString[4] = '0';
|
|
|
|
if (Status.PowerSupply12V == ON)
|
|
Status.StatusString[3] = '1';
|
|
else
|
|
Status.StatusString[3] = '0';
|
|
|
|
if (Status.PowerSupply5V == ON)
|
|
Status.StatusString[2] = '1';
|
|
else
|
|
Status.StatusString[2] = '0';
|
|
|
|
if (Status.ControlRelay == ON)
|
|
Status.StatusString[1] = '1';
|
|
else
|
|
Status.StatusString[1] = '0';
|
|
|
|
ComposeAprsFrame(Status.StatusString);
|
|
|
|
break;
|
|
|
|
// Send description digital outputs
|
|
case 7 :
|
|
ComposeAprsFrame(Status.DescriptionString);
|
|
|
|
// Switch off 24V power supply
|
|
case 30 :
|
|
gpio_put(PowerSupply24VControl, 0);
|
|
Status.PowerSupply24V = OFF;
|
|
break;
|
|
// Switch on 24V power supply
|
|
case 31 :
|
|
gpio_put(PowerSupply24VControl, 1);
|
|
Status.PowerSupply24V = ON;
|
|
break;
|
|
// Switch off 12V power supply
|
|
case 32 :
|
|
gpio_put(PowerSupply12VControl, 0);
|
|
Status.PowerSupply12V = OFF;
|
|
break;
|
|
// Switch on 12V power supply
|
|
case 33 :
|
|
gpio_put(PowerSupply12VControl, 1);
|
|
Status.PowerSupply12V = ON;
|
|
break;
|
|
// Switch off 5V power supply
|
|
case 34 :
|
|
gpio_put(PowerSupply5VControl, 1);
|
|
Status.PowerSupply5V = OFF;
|
|
break;
|
|
// Switch on 5V power supply
|
|
case 35 :
|
|
gpio_put(PowerSupply5VControl, 0);
|
|
Status.PowerSupply5V = ON;
|
|
break;
|
|
// Switch off relay
|
|
case 36 :
|
|
gpio_put(RelayOffControl, 1);
|
|
sleep_ms(250);
|
|
gpio_put(RelayOffControl, 0);
|
|
Status.ControlRelay = OFF;
|
|
break;
|
|
// Switch on 24V relay
|
|
case 37 :
|
|
gpio_put(RelayOnControl, 1);
|
|
sleep_ms(250);
|
|
gpio_put(RelayOnControl, 0);
|
|
Status.ControlRelay = ON;
|
|
break;
|
|
|
|
default :
|
|
break;
|
|
}
|
|
|
|
ServerCommand = 0;
|
|
}
|
|
|
|
/* A message is ready to be send */
|
|
if (TransmitRequest) {
|
|
|
|
if ( TxDelay == 0 ) {
|
|
// Generate pseudo random value between 0-1024
|
|
TxDelay = time_us_32()&0x3FF;
|
|
}
|
|
|
|
/* If TxDelay times out: send message */
|
|
if ( TxDelay-- == 1 ) {
|
|
transmit();
|
|
TransmitRequest = false;
|
|
}
|
|
}
|
|
|
|
// Read serial input and process it
|
|
ReadUSBSerial();
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
* Initializes the LoRa module with the parameters set in config.h
|
|
*/
|
|
bool startRadio()
|
|
{
|
|
// override the default CS, reset, and IRQ pins (optional)
|
|
// LoRa.setPins(7, 6, 1); // set CS, reset, IRQ pin
|
|
log_out("Starting LoRa radio");
|
|
if (!LoRa.begin(AprsSettings.loraFrequency)) {
|
|
log_out(" [ FAILED ]\n");
|
|
while(1);
|
|
}
|
|
else {
|
|
LoRa.setPreambleLength(AprsSettings.loraPreamble);
|
|
LoRa.setSignalBandwidth(AprsSettings.loraBandwidth);
|
|
LoRa.setTxPower(AprsSettings.loraTxPower,AprsSettings.loraPaSelect);
|
|
LoRa.setSpreadingFactor(AprsSettings.loraSpreadingFactor);
|
|
LoRa.setCodingRate4(AprsSettings.loraCodingRate);
|
|
LoRa.enableCrc();
|
|
log_out(" [ DONE ]\n");
|
|
}
|
|
}
|
|
|
|
void getPacketData(int packetLength)
|
|
{
|
|
int position = 0;
|
|
|
|
while (packetLength--) {
|
|
rxBuffer[position++] = LoRa.read();
|
|
}
|
|
rxBuffer[position] = 0;
|
|
}
|
|
|
|
/* Decode LoRa APRS frame: extract source call, digipeater path and data field. At the same time, check for data corruption
|
|
*
|
|
* If frame is a message from the server it returns the command from this server
|
|
*
|
|
* The resulting fields are stored in struct AprsFrame and given to the kiss-routines for further processing (when in kiss-mode)
|
|
*/
|
|
uint16_t decode_packet ()
|
|
{
|
|
int position = 0;
|
|
int cnt = 0;
|
|
|
|
struct aprs_frame AprsFrame; //defined in kiss.h
|
|
struct ax25_frame AX25Frame; //defined in kiss.h
|
|
|
|
memset(AprsFrame.source_address, 0, sizeof(AprsFrame.source_address));
|
|
memset(AprsFrame.digi_path, 0, sizeof(AprsFrame.digi_path));
|
|
memset(AprsFrame.data_field, 0, sizeof(AprsFrame.data_field));
|
|
memset(AprsFrame.message, 0, sizeof(AprsFrame.message));
|
|
memset(AprsFrame.digis, 0, sizeof(AprsFrame.digis));
|
|
memset(AprsFrame.acknowledge_number, 0, sizeof(AprsFrame.acknowledge_number));
|
|
AprsFrame.acknowledge_request = false;
|
|
AprsFrame.server_command = 0;
|
|
AprsFrame.number_of_digipeaters = 0;
|
|
AprsFrame.valid_apsr_data = false;
|
|
|
|
// Extract from address
|
|
cnt = 0;
|
|
while( rxBuffer[position] != 0 )
|
|
{
|
|
AprsFrame.source_address[cnt++] = rxBuffer[position];
|
|
if ( rxBuffer[position] == '>' && position < 10 ) {
|
|
AprsFrame.source_address[cnt-1] = 0;
|
|
AprsFrame.valid_apsr_data = true;
|
|
position++;
|
|
break;
|
|
}
|
|
position++;
|
|
}
|
|
|
|
if (AprsFrame.valid_apsr_data == true)
|
|
{
|
|
// Extract digi path
|
|
AprsFrame.valid_apsr_data = false;
|
|
cnt = 0;
|
|
while( rxBuffer[position] != 0 )
|
|
{
|
|
AprsFrame.digi_path[cnt++] = rxBuffer[position];
|
|
if ( rxBuffer[position] == ':' ) {
|
|
AprsFrame.digi_path[cnt-1] = 0;
|
|
AprsFrame.valid_apsr_data = true;
|
|
position++;
|
|
break;
|
|
}
|
|
position++;
|
|
}
|
|
|
|
}
|
|
|
|
if (AprsFrame.valid_apsr_data == true)
|
|
{
|
|
// Extract data field
|
|
cnt = 0;
|
|
while( rxBuffer[position] != 0 )
|
|
{
|
|
AprsFrame.data_field[cnt++] = rxBuffer[position];
|
|
position++;
|
|
}
|
|
AprsFrame.data_field[cnt] = 0;
|
|
}
|
|
|
|
if (AprsFrame.valid_apsr_data == true)
|
|
{
|
|
// Extract digis from digi-path
|
|
cnt = 0;
|
|
position = 0;
|
|
AprsFrame.number_of_digipeaters = 0;
|
|
while( AprsFrame.digi_path[position] != 0 )
|
|
{
|
|
AprsFrame.digis[AprsFrame.number_of_digipeaters][cnt++] = AprsFrame.digi_path[position];
|
|
if ( AprsFrame.digi_path[position] == ',' && cnt < 10 ) {
|
|
AprsFrame.digis[AprsFrame.number_of_digipeaters][cnt-1] = 0;
|
|
if (++AprsFrame.number_of_digipeaters > 9) {
|
|
AprsFrame.valid_apsr_data = false;
|
|
break;
|
|
}
|
|
cnt = 0;
|
|
}
|
|
position++;
|
|
}
|
|
AprsFrame.digis[AprsFrame.number_of_digipeaters][cnt] = 0;
|
|
}
|
|
|
|
if (AprsFrame.valid_apsr_data) {
|
|
|
|
// Check if packet comes from our server and if so, check if it is a message for us.
|
|
if ( !compare_strings(AprsFrame.source_address, AprsSettings.ServerCall) ) {
|
|
|
|
if ( is_message_for_me(AprsFrame.data_field, AprsSettings.MyCall) )
|
|
{
|
|
|
|
// Extract aprs message from data field
|
|
position=11;
|
|
while( AprsFrame.data_field[position] != 0 )
|
|
{
|
|
AprsFrame.message[position-11] = AprsFrame.data_field[position];
|
|
position++;
|
|
}
|
|
AprsFrame.message[position-11] = 0; // Terminate string
|
|
|
|
// Extract command and acknowledge number (if present)
|
|
cnt = 0;
|
|
position = 0;
|
|
while( AprsFrame.message[position] != 0 )
|
|
{
|
|
if ( AprsFrame.message[position] == '{' ) {
|
|
|
|
AprsFrame.acknowledge_number[cnt++] = 'a';
|
|
AprsFrame.acknowledge_number[cnt++] = 'c';
|
|
AprsFrame.acknowledge_number[cnt++] = 'k';
|
|
AprsFrame.acknowledge_request = true;
|
|
}
|
|
// Calculate server command
|
|
if (!AprsFrame.acknowledge_request) {
|
|
AprsFrame.server_command = 10*AprsFrame.server_command + AprsFrame.message[position]-48;
|
|
}
|
|
|
|
position++;
|
|
if (AprsFrame.acknowledge_request) {
|
|
AprsFrame.acknowledge_number[cnt++] = AprsFrame.message[position];
|
|
}
|
|
}
|
|
AprsFrame.acknowledge_number[cnt] = 0;
|
|
}
|
|
|
|
}
|
|
|
|
log_out("Source address: %s\nDigipeaters (%u): %s %s %s %s\nData: %s\n", AprsFrame.source_address, AprsFrame.number_of_digipeaters+1, AprsFrame.digis[0], AprsFrame.digis[1], AprsFrame.digis[2], AprsFrame.digis[3], AprsFrame.data_field);
|
|
|
|
// If in KISS mode the struct AprsFrame is handed over to the KISS encoder
|
|
if (Status.KissMode == 0)
|
|
Kiss.EncodeFrame(&AprsFrame, &AX25Frame);
|
|
|
|
if (AprsFrame.message[0])
|
|
{
|
|
log_out("Message from server: %s (command %u)\n", AprsFrame.message, AprsFrame.server_command);
|
|
if (AprsFrame.acknowledge_request) {
|
|
ComposeAprsFrame(AprsFrame.acknowledge_number);
|
|
log_out("Acknowledge request: %s\n", AprsFrame.acknowledge_number);
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
else
|
|
log_out("Error decoding APRS frame.");
|
|
|
|
return (AprsFrame.server_command);
|
|
}
|
|
|
|
/*
|
|
* Checks if aprs datafield contains message and if message is for us
|
|
*
|
|
* Returns: 0 if datafield contains no message for us
|
|
* 1 if datafield contains a message for us
|
|
*/
|
|
bool is_message_for_me (uint8_t data[], uint8_t mycall[])
|
|
{
|
|
// A variable to iterate through the strings
|
|
int i=0;
|
|
|
|
if (data[0] == ':' && data[10] == ':')
|
|
{
|
|
while( i<9 && mycall[i] != 0 ) {
|
|
if (data[i+1] != mycall[i]) {
|
|
return (0);
|
|
}
|
|
i++;
|
|
}
|
|
return (1);
|
|
}
|
|
return (0);
|
|
}
|
|
|
|
int compare_strings(uint8_t a[], uint8_t b[])
|
|
{
|
|
// A variable to iterate through the strings
|
|
int i = 0;
|
|
|
|
while (a[i] == b[i])
|
|
{
|
|
// If either of the strings reaches the end
|
|
// we stop the loop
|
|
if (a[i] == '\0' || b[i] == '\0')
|
|
break;
|
|
i++;
|
|
}
|
|
|
|
// We check if both the strings have been compared
|
|
// till the end or not
|
|
// If the strings are compared till the end they are equal
|
|
if (a[i] == '\0' && b[i] == '\0')
|
|
return 0;
|
|
else
|
|
{
|
|
if(a[i] == '\0')
|
|
return -1*(b[i]);
|
|
else if(b[i] == '\0')
|
|
return a[i];
|
|
else
|
|
return (a[i]-b[i]);
|
|
}
|
|
}
|
|
|
|
void ComposeAprsFrame(uint8_t payload[])
|
|
{
|
|
uint16_t BufferPosition = 0;
|
|
uint16_t cnt = 0;
|
|
|
|
memset(txBuffer, 0, sizeof(txBuffer));
|
|
|
|
// APRS header
|
|
txBuffer[BufferPosition++] = '<';
|
|
txBuffer[BufferPosition++] = 0xff;
|
|
txBuffer[BufferPosition++] = 0x01;
|
|
|
|
while ( AprsSettings.MyCall[cnt] != 0 && BufferPosition<MTU )
|
|
{
|
|
txBuffer[BufferPosition++] = AprsSettings.MyCall[cnt];
|
|
cnt++;
|
|
}
|
|
txBuffer[BufferPosition++] = '>';
|
|
|
|
cnt=0;
|
|
while ( AprsSettings.Destination[cnt] != 0 && BufferPosition<MTU )
|
|
{
|
|
txBuffer[BufferPosition++] = AprsSettings.Destination[cnt];
|
|
cnt++;
|
|
}
|
|
|
|
if ( AprsSettings.Path1[0] != 0)
|
|
txBuffer[BufferPosition++] = ',';
|
|
|
|
cnt=0;
|
|
while ( AprsSettings.Path1[cnt] != 0 && BufferPosition<MTU )
|
|
{
|
|
txBuffer[BufferPosition++] = AprsSettings.Path1[cnt];
|
|
cnt++;
|
|
}
|
|
|
|
if ( AprsSettings.Path2[0] != 0)
|
|
txBuffer[BufferPosition++] = ',';
|
|
|
|
cnt=0;
|
|
while ( AprsSettings.Path2[cnt] != 0 && BufferPosition<MTU )
|
|
{
|
|
txBuffer[BufferPosition++] = AprsSettings.Path2[cnt];
|
|
cnt++;
|
|
}
|
|
|
|
txBuffer[BufferPosition++] = ':';
|
|
txBuffer[BufferPosition++] = ':';
|
|
|
|
cnt=0;
|
|
while ( AprsSettings.ServerCall[cnt] != 0 )
|
|
{
|
|
txBuffer[BufferPosition++] = AprsSettings.ServerCall[cnt];
|
|
cnt++;
|
|
}
|
|
|
|
//Fill with spaces
|
|
while ( cnt<9 )
|
|
{
|
|
txBuffer[BufferPosition++] = ' ';
|
|
cnt++;
|
|
|
|
}
|
|
txBuffer[BufferPosition++] = ':';
|
|
|
|
cnt=0;
|
|
while ( payload[cnt] != 0 && BufferPosition<MTU )
|
|
{
|
|
txBuffer[BufferPosition++] = payload[cnt];
|
|
cnt++;
|
|
}
|
|
|
|
// Set variable to indicate a send request
|
|
TransmitRequest = true;
|
|
log_out("%s\n", txBuffer);
|
|
}
|
|
|
|
void transmit() {
|
|
uint16_t position = 0;
|
|
|
|
LoRa.beginPacket();
|
|
while( txBuffer[position] != 0 )
|
|
{
|
|
LoRa.write(txBuffer[position]);
|
|
position++;
|
|
}
|
|
LoRa.endPacket();
|
|
|
|
LoRa.receive();
|
|
}
|
|
|