sergiotarxz/nuttx-apps
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
ee4d8b738f
nuttx-apps/examples/tcp_ipc_server/uart_lorawan_layer.c
pedrobertoleti 1d9e1deb77 Improve tcp_ipc_server LoraWAN module communication
2022-11-05 12:55:40 +08:00

533 lines
16 KiB
C
Raw Blame History

/****************************************************************************
* apps/examples/tcp_ipc_server/uart_lorawan_layer.c
*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership. The
* ASF licenses this file to you under the Apache License, Version 2.0 (the
* "License"); you may not use this file except in compliance with the
* License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
* WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
* License for the specific language governing permissions and limitations
* under the License.
*
****************************************************************************/
/****************************************************************************
* Included Files
****************************************************************************/
#include <nuttx/config.h>
#include <inttypes.h>
#include <stdio.h>
#include <fcntl.h>
#include <unistd.h>
#include <sys/time.h>
#include "lorawan/uart_lorawan_layer.h"
/* Useful links:
*
* LoRaWAN module used here: Radioenge LoRaWAN module
* Radioenge LoRaWAN module page:
* https://www.radioenge.com.br/produto/modulo-lorawan/
* Radioenge LoRaWAN module datasheet:
* https://www.radioenge.com.br/storage/2021/08/Manual_LoRaWAN_Jun2022.pdf
*/
/****************************************************************************
* Pre-processor Definitions
****************************************************************************/
#ifndef CONFIG_ESP32_UART1
# error "CONFIG_ESP32_UART1 needs to be defined in order to compile this program."
#endif
/****************************************************************************
* Private Types
****************************************************************************/
/****************************************************************************
* Private Function Prototypes
****************************************************************************/
/****************************************************************************
* Private Data
****************************************************************************/
/****************************************************************************
* Public Data
****************************************************************************/
/****************************************************************************
* Private Functions
****************************************************************************/
static void clear_uart_rx_buffer(void);
static int send_uart_lorawan_at_commands(unsigned char * ptr_at_cmd,
int size_at_cmd);
static int read_uart_lorawan_resp(unsigned char * ptr_response_buffer,
int size_response_buffer,
int time_to_wait_ms);
/****************************************************************************
* Public Functions
****************************************************************************/
/****************************************************************************
* Definitions
****************************************************************************/
#define PATH_TO_UART1 "/dev/ttyS1"
#define FULL_AT_CMD_MAX_SIZE 200
#define TIME_BETWEEN_AT_CMDS 1 //s
#define MAX_ATTEMPTS_TO_SEND 3
/****************************************************************************
* Public variables
****************************************************************************/
static int fd_uart = 0;
static bool is_lorawan_busy = false;
/****************************************************************************
* Name: clear_uart_rx_buffer
* Description: clean UART RX buffer
* Parameters: nothing
* Return: nothing
****************************************************************************/
static void clear_uart_rx_buffer(void)
{
char rcv_byte_uart = 0x00;
if (fd_uart <= -1)
{
/* invalid UART file descriptor */
return;
}
else
{
while (read(fd_uart, &rcv_byte_uart, 1) > 0);
}
}
/****************************************************************************
* Name: send_uart_lorawan_at_commands
* Description: send AT commands to LoRaWAN module via UART
* Parameters: - pointer to array containing AT command to send
* - AT command size
* Return: number of bytes written to UART
****************************************************************************/
static int send_uart_lorawan_at_commands(unsigned char * ptr_at_cmd,
int size_at_cmd)
{
int bytes_written_uart = 0;
if (fd_uart <= -1)
{
/* invalid UART file descriptor */
goto END_UART_SEND_AT_CMD;
}
/* Send AT command to LoRaWAN module */
bytes_written_uart = write(fd_uart, ptr_at_cmd, size_at_cmd);
END_UART_SEND_AT_CMD:
return bytes_written_uart;
}
/****************************************************************************
* Name: read_uart_LoRaWAN_AT_command_response
* Description: read AT command response via UART
* Parameters: - pointer to array containing response buffer
* - response buffer size
* - time to wait for UART response
* Return: number of bytes read from UART
****************************************************************************/
static int read_uart_lorawan_resp(unsigned char * ptr_response_buffer,
int size_response_buffer,
int time_to_wait_ms)
{
int total_bytes_read_uart = 0;
int bytes_read_uart = 0;
bool keep_reading = true;
useconds_t time_to_wait_us = 0;
char full_response[50];
char *pos_msg_downlink;
char *pos_msg_at_busy_error;
int status_read_uart_lorawan_resp = 0;
memset(full_response, 0x00, sizeof(full_response));
if (fd_uart <= -1)
{
/* invalid UART file descriptor */
goto END_UART_READ_AT_CMD;
}
/* Wait for UART response */
time_to_wait_us = time_to_wait_ms * 1000;
usleep(time_to_wait_us);
do
{
bytes_read_uart = read(fd_uart,
full_response + total_bytes_read_uart,
1);
if (bytes_read_uart > 0)
{
ptr_response_buffer++;
total_bytes_read_uart++;
}
else
{
/* No more bytes to read */
keep_reading = false;
}
if (total_bytes_read_uart >= 50)
{
keep_reading = false;
}
}
while (keep_reading == true);
/* Check if response message is AT_BUSY_ERROR */
pos_msg_at_busy_error = strstr(full_response, "AT_BUSY_ERROR");
if (pos_msg_at_busy_error != NULL)
{
status_read_uart_lorawan_resp = ERR_AT_BUSY_ERROR;
goto END_UART_READ_AT_CMD;
}
/* Check if response is a downlink message */
pos_msg_downlink = strstr(full_response, "RX:");
if (pos_msg_downlink == NULL)
{
status_read_uart_lorawan_resp = 0;
}
else
{
snprintf((char *)ptr_response_buffer, size_response_buffer, "%s",
pos_msg_downlink + 3);
status_read_uart_lorawan_resp = strlen((char *)ptr_response_buffer);
}
END_UART_READ_AT_CMD:
return status_read_uart_lorawan_resp;
}
/****************************************************************************
* Name: LoRaWAN_Radioenge_init
* Description: init LoRaWAN module
* Parameters: LoRaWAN module config structure
* Return: nothing
****************************************************************************/
void lorawan_radioenge_init(config_lorawan_radioenge_t config_lorawan)
{
int bytes_written_at_cmd = 0;
unsigned char full_at_cmd[FULL_AT_CMD_MAX_SIZE];
memset(full_at_cmd, 0x00, sizeof(full_at_cmd));
/* Open UART communication with LoRaWAN module */
fd_uart = open(PATH_TO_UART1, O_RDWR | O_NONBLOCK);
if (fd_uart <= -1)
{
perror("Cannot open UART communication with LoRaWAN module");
goto END_UART_LORAWAN_MODULE_INIT;
}
/* Configuration: LoRaWAN channel mask */
memset(full_at_cmd, 0x00, FULL_AT_CMD_MAX_SIZE);
snprintf((char *)full_at_cmd, FULL_AT_CMD_MAX_SIZE, "AT+CHMASK=%s\n\r",
config_lorawan.channel_mask);
bytes_written_at_cmd = send_uart_lorawan_at_commands(full_at_cmd,
strlen((char *)full_at_cmd));
if (bytes_written_at_cmd <= 0)
{
perror("Error when writting Channel Mask to LoRaWAN module");
goto END_UART_LORAWAN_MODULE_INIT;
}
sleep(TIME_BETWEEN_AT_CMDS);
printf("\n\r[LORAWAN] Channel mask configured\r\n");
clear_uart_rx_buffer();
/* Configuration: join mode (ABP) */
memset(full_at_cmd, 0x00, FULL_AT_CMD_MAX_SIZE);
snprintf((char *)full_at_cmd, FULL_AT_CMD_MAX_SIZE, "AT+NJM=0\n\r");
bytes_written_at_cmd = send_uart_lorawan_at_commands(full_at_cmd,
strlen((char *)full_at_cmd));
if (bytes_written_at_cmd <= 0)
{
perror("Error when writting Join Mode to LoRaWAN module");
goto END_UART_LORAWAN_MODULE_INIT;
}
sleep(TIME_BETWEEN_AT_CMDS);
printf("\n\r[LORAWAN] NJM configured\r\n");
clear_uart_rx_buffer();
/* Configuration: device address */
memset(full_at_cmd, 0x00, FULL_AT_CMD_MAX_SIZE);
snprintf((char *)full_at_cmd, FULL_AT_CMD_MAX_SIZE, "AT+DADDR=%s\n\r",
config_lorawan.device_address);
bytes_written_at_cmd = send_uart_lorawan_at_commands(full_at_cmd,
strlen((char *)full_at_cmd));
if (bytes_written_at_cmd <= 0)
{
perror("Error when writting device address to LoRaWAN module");
goto END_UART_LORAWAN_MODULE_INIT;
}
sleep(TIME_BETWEEN_AT_CMDS);
printf("\n\r[LORAWAN] Device address configured\r\n");
clear_uart_rx_buffer();
/* Configuration: Application EUI */
memset(full_at_cmd, 0x00, FULL_AT_CMD_MAX_SIZE);
snprintf((char *)full_at_cmd, FULL_AT_CMD_MAX_SIZE, "AT+APPEUI=%s\n\r",
config_lorawan.application_eui);
bytes_written_at_cmd = send_uart_lorawan_at_commands(full_at_cmd,
strlen((char *)full_at_cmd));
if (bytes_written_at_cmd <= 0)
{
perror("Error when writting application EUI to LoRaWAN module");
goto END_UART_LORAWAN_MODULE_INIT;
}
sleep(TIME_BETWEEN_AT_CMDS);
printf("\n\r[LORAWAN] APP EUI configured\r\n");
clear_uart_rx_buffer();
/* Configuration: Application Session Key */
memset(full_at_cmd, 0x00, sizeof(full_at_cmd));
snprintf((char *)full_at_cmd, sizeof(full_at_cmd), "AT+APPSKEY=%s\n\r",
config_lorawan.application_session_key);
bytes_written_at_cmd = send_uart_lorawan_at_commands(full_at_cmd,
strlen((char *)full_at_cmd));
if (bytes_written_at_cmd <= 0)
{
perror("Error when writting application session key"
"to LoRaWAN module");
goto END_UART_LORAWAN_MODULE_INIT;
}
sleep(TIME_BETWEEN_AT_CMDS);
printf("\n\r[LORAWAN] APPSKEY configured\r\n");
clear_uart_rx_buffer();
/* Configuration: Network Session Key */
memset(full_at_cmd, 0x00, sizeof(full_at_cmd));
snprintf((char *)full_at_cmd, sizeof(full_at_cmd), "AT+NWKSKEY=%s\n\r",
config_lorawan.network_session_key);
bytes_written_at_cmd = send_uart_lorawan_at_commands(full_at_cmd,
strlen((char *)full_at_cmd));
if (bytes_written_at_cmd <= 0)
{
perror("Error when writting network session key"
"to LoRaWAN module");
goto END_UART_LORAWAN_MODULE_INIT;
}
sleep(TIME_BETWEEN_AT_CMDS);
printf("\n\r[LORAWAN] NWSKEY configured\r\n");
clear_uart_rx_buffer();
/* Configuration: ADR */
memset(full_at_cmd, 0x00, sizeof(full_at_cmd));
snprintf((char *)full_at_cmd, sizeof(full_at_cmd), "AT+ADR=0\n\r");
bytes_written_at_cmd = send_uart_lorawan_at_commands(full_at_cmd,
strlen((char *)full_at_cmd));
if (bytes_written_at_cmd <= 0)
{
perror("Error when writting ADR configuration to LoRaWAN module");
goto END_UART_LORAWAN_MODULE_INIT;
}
sleep(TIME_BETWEEN_AT_CMDS);
printf("\n\r[LORAWAN] ADR configured\r\n");
clear_uart_rx_buffer();
/* Configuration: DR */
memset(full_at_cmd, 0x00, sizeof(full_at_cmd));
snprintf((char *)full_at_cmd, sizeof(full_at_cmd), "AT+DR=0\n\r");
bytes_written_at_cmd = send_uart_lorawan_at_commands(full_at_cmd,
strlen((char *)full_at_cmd));
if (bytes_written_at_cmd <= 0)
{
perror("Error when writting DR configuration to LoRaWAN module");
goto END_UART_LORAWAN_MODULE_INIT;
}
sleep(TIME_BETWEEN_AT_CMDS);
printf("\n\r[LORAWAN] DR configured\r\n");
clear_uart_rx_buffer();
/* Configuration: LoRaWAN class */
memset(full_at_cmd, 0x00, sizeof(full_at_cmd));
snprintf((char *)full_at_cmd, sizeof(full_at_cmd), "AT+CLASS=A\n\r");
bytes_written_at_cmd = send_uart_lorawan_at_commands(full_at_cmd,
strlen((char *)full_at_cmd));
if (bytes_written_at_cmd <= 0)
{
perror("Error when writting LoRaWAN class to LoRaWAN module");
goto END_UART_LORAWAN_MODULE_INIT;
}
sleep(TIME_BETWEEN_AT_CMDS);
printf("\n\r[LORAWAN] LoRaWAN class A configured\r\n");
clear_uart_rx_buffer();
/* Configuration: send confirmation */
memset(full_at_cmd, 0x00, sizeof(full_at_cmd));
snprintf((char *)full_at_cmd, sizeof(full_at_cmd), "AT+CFM=1\n\r");
bytes_written_at_cmd = send_uart_lorawan_at_commands(full_at_cmd,
strlen((char *)full_at_cmd));
if (bytes_written_at_cmd <= 0)
{
perror("Error when writting send confirmation to LoRaWAN module");
}
sleep(TIME_BETWEEN_AT_CMDS);
printf("\n\r[LORAWAN] CFM configured\r\n");
clear_uart_rx_buffer();
END_UART_LORAWAN_MODULE_INIT:
return;
}
/****************************************************************************
* Name: lorawan_radioenge_send_msg
* Description: send LoRaWAN message with waiting for a downlink message
* Parameters: - pointer to array containing uplink message (in Hex-String
* format)
* - uplink message size
* - pointer to array containing downlink message
* - downlink message array size
* - Time to wait for the downlink message (ms)
* Return: nothing
****************************************************************************/
int lorawan_radioenge_send_msg(unsigned char * pt_uplink_hexstring,
int size_uplink,
unsigned char * pt_downlink_hexstring,
int max_size_downlink,
int time_to_wait_ms)
{
int bytes_rcv_downlink_msg = 0;
int number_of_attempts = 0;
unsigned char at_cmd_send_message[FULL_AT_CMD_MAX_SIZE];
memset(at_cmd_send_message, 0x00, sizeof(at_cmd_send_message));
while (is_lorawan_busy == true);
is_lorawan_busy = true;
/* Clear RX UART buffer before sending a new command
* (to clean all messages received from previous AT commands
*/
clear_uart_rx_buffer();
/* Compose AT command */
snprintf((char *)at_cmd_send_message,
FULL_AT_CMD_MAX_SIZE,
"AT+SENDB=5:%s\n\r",
pt_uplink_hexstring);
printf("\n\r[LORAWAN] AT CMD: %s\n\r", at_cmd_send_message);
/* Send uplink message (until success or number of attempts exceeds
* what is defined in MAX_ATTEMPTS_TO_SEND)
*/
while (number_of_attempts < MAX_ATTEMPTS_TO_SEND)
{
if (send_uart_lorawan_at_commands(at_cmd_send_message,
strlen((char *)at_cmd_send_message)) <= 0)
{
printf("\n\rError when sending uplink message.\n\r");
number_of_attempts++;
continue;
}
/* Get downlink message */
bytes_rcv_downlink_msg = read_uart_lorawan_resp(pt_downlink_hexstring,
max_size_downlink,
time_to_wait_ms);
/* If a AT_BUSY is received as command responde, command must
* be sent again
*/
if (bytes_rcv_downlink_msg == ERR_AT_BUSY_ERROR)
{
number_of_attempts++;
continue;
}
/* If there isn't AT_BUSY_ERROR response, check for downlink
* message
*/
if (bytes_rcv_downlink_msg == 0)
{
printf("\n\rNo downlink message has been received.\n\r");
break;
}
}
if (number_of_attempts == MAX_ATTEMPTS_TO_SEND)
{
printf("\n\rError: failed to send command in all %d attempts\n\r",
MAX_ATTEMPTS_TO_SEND);
}
is_lorawan_busy = false;
return bytes_rcv_downlink_msg;
}
Reference in New Issue View Git Blame Copy Permalink