From 8475689d130c259fab8d0840931945f5478387e9 Mon Sep 17 00:00:00 2001 From: Scott Wohler Date: Tue, 4 Jun 2019 12:43:18 -0400 Subject: [PATCH 01/33] Test FOTA intergration --- inc/ll_ifc_ftp.h | 10 ++++++---- src/ll_ifc_ftp.c | 34 +++++++++++++++++++++++----------- 2 files changed, 29 insertions(+), 15 deletions(-) diff --git a/inc/ll_ifc_ftp.h b/inc/ll_ifc_ftp.h index 1899016..0463ee7 100644 --- a/inc/ll_ifc_ftp.h +++ b/inc/ll_ifc_ftp.h @@ -61,12 +61,14 @@ extern "C" { * @{ */ -#define MAX_NUM_SEGMENTS (2400) +#define MAX_NUM_SEGMENTS (9800) // Can support a 1MB image #define MAX_FILE_SEGMENT_BYTES (107) -#define NUM_RX_SEGS_BITMASK (MAX_NUM_SEGMENTS / 32) +//#define NUM_RX_SEGS_BITMASK (MAX_NUM_SEGMENTS / 32) +#define NUM_RX_SEGS_BITMASK (((MAX_NUM_SEGMENTS % 32) == 0) ? (MAX_NUM_SEGMENTS >> 5) : ((MAX_NUM_SEGMENTS >> 5) + 1)) #define BASE_UL_MSG_LEN (14) -#define MAX_NUM_RETRY_SEGS (16) -#define LL_FTP_TX_BUF_SIZE (BASE_UL_MSG_LEN + MAX_NUM_RETRY_SEGS * 2) +#define MAX_NUM_RETRY_SEGS (1024) +//#define LL_FTP_TX_BUF_SIZE (BASE_UL_MSG_LEN + MAX_NUM_RETRY_SEGS * 2) +#define LL_FTP_TX_BUF_SIZE (256) // Can fit 121 segment requests per payload // The file header contains the crc, file size, file id, and file version diff --git a/src/ll_ifc_ftp.c b/src/ll_ifc_ftp.c index 6491aae..665a29f 100644 --- a/src/ll_ifc_ftp.c +++ b/src/ll_ifc_ftp.c @@ -30,7 +30,7 @@ dst[3] = (src >> 24) & 0xFF; const uint8_t LL_FTP_MAX_NUM_RETRIES = 5; -const uint8_t LL_FTP_RETRY_INTERVAL = 16; +const uint8_t LL_FTP_RETRY_INTERVAL = 15; const uint8_t LL_FTP_PORT = 128; extern uint8_t ll_ul_max_port; @@ -194,6 +194,7 @@ static uint16_t ll_ftp_get_missing_segs(ll_ftp_t* f, bool fill_buf) uint16_t seg_num; uint8_t num_segs_base; uint8_t idx; + uint16_t total_payload = fill_buf ? BASE_UL_MSG_LEN : 0; uint16_t base_max = f->num_segs >> 5; // divide by 32 for(i = 0; i <= base_max; i++) @@ -209,15 +210,21 @@ static uint16_t ll_ftp_get_missing_segs(ll_ftp_t* f, bool fill_buf) // request complete retransmission return 0xFFFF; } + seg_num = (i << 5) + j; // i * 32 + j - + idx = num_missing_segs * 2; - if(fill_buf) + + // Only fill the buffer up to the maximum number of segments we can request in + // a single payload + if ((fill_buf) && ((total_payload + sizeof(seg_num)) <= LL_FTP_TX_BUF_SIZE)) { f->tx_buf[LL_FTP_NAK_FILE_SEGS_INDEX + idx] = seg_num & 0x00FF; f->tx_buf[LL_FTP_NAK_FILE_SEGS_INDEX + idx + 1] = (seg_num >> 8) & 0x00FF; + + total_payload += sizeof(seg_num); + num_missing_segs++; } - num_missing_segs++; } } } @@ -284,10 +291,10 @@ static uint8_t ll_ftp_ack_segs_request_generate(ll_ftp_t* f) return return_len; } -static uint8_t ll_ftp_ack_apply_generate(ll_ftp_t* f) +static uint8_t ll_ftp_ack_apply_generate(ll_ftp_t* f, bool success) { f->tx_buf[LL_FTP_MSG_PACKET_TYPE_INDEX] = ACK_APPLY; - f->tx_buf[LL_FTP_ACK_ACK_TYPE_INDEX] = ACK_ACK; + f->tx_buf[LL_FTP_ACK_ACK_TYPE_INDEX] = (success ? ACK_ACK : ACK_NAK); UINT32_TO_BYTESTREAM((&f->tx_buf[LL_FTP_ACK_FILE_ID_INDEX]), f->file_id); UINT32_TO_BYTESTREAM((&f->tx_buf[LL_FTP_ACK_FILE_VERSION_INDEX]), f->file_version); @@ -542,6 +549,7 @@ static int32_t ll_ftp_transition_out_of_segment(ll_ftp_t* f, ll_ftp_msg_t* msg, } break; default: + ret = LL_FTP_ERROR; break; } @@ -718,19 +726,22 @@ static int32_t ll_ftp_apply_process_msg(ll_ftp_t* f, uint8_t* buf, uint8_t len) } else if ((TX_APPLY == ftp_msg.msg_type) && (IS_MY_FILE)) { + uint8_t len; int32_t cb_ret = f->cb.apply(f->file_id, f->file_version, f->file_size); if(LL_FTP_OK == cb_ret) { - uint8_t len = ll_ftp_ack_apply_generate(f); - ll_ftp_send_uplink(f, len); - next_state = IDLE; + len = ll_ftp_ack_apply_generate(f, true); } else { - // Apply rejected. Forget File. + // Apply rejected. Send NAK and forget file. + len = ll_ftp_ack_apply_generate(f, false); ret = LL_FTP_ERROR; - next_state = IDLE; } + + next_state = IDLE; + ll_ftp_send_uplink(f, len); + } else if(TICK == ftp_msg.msg_type) { @@ -751,6 +762,7 @@ static int32_t ll_ftp_apply_process_msg(ll_ftp_t* f, uint8_t* buf, uint8_t len) next_state = IDLE; } } + ret = LL_FTP_OK; } From 5593612d7b104682c4aab5dc7ed328d018d6f376 Mon Sep 17 00:00:00 2001 From: Scott Wohler Date: Tue, 4 Jun 2019 15:01:52 -0400 Subject: [PATCH 02/33] Fix return length variable --- src/ll_ifc_ftp.c | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/ll_ifc_ftp.c b/src/ll_ifc_ftp.c index 665a29f..5fdaf94 100644 --- a/src/ll_ifc_ftp.c +++ b/src/ll_ifc_ftp.c @@ -275,7 +275,7 @@ static uint8_t ll_ftp_ack_segs_request_generate(ll_ftp_t* f) // check max length number of retry segments uint16_t num_missing_segs = ll_ftp_get_missing_segs(f, true); - uint8_t return_len = BASE_UL_MSG_LEN; + uint16_t return_len = BASE_UL_MSG_LEN; if(MAX_NUM_RETRY_SEGS <= num_missing_segs) { f->tx_buf[LL_FTP_ACK_ACK_TYPE_INDEX] = ACK_NAK; @@ -285,7 +285,7 @@ static uint8_t ll_ftp_ack_segs_request_generate(ll_ftp_t* f) return_len += num_missing_segs * sizeof(uint16_t); } - uint32_t crc = crc32(0, &f->tx_buf[LL_FTP_ACK_ACK_TYPE_INDEX], return_len - LL_FTP_ACK_ACK_TYPE_INDEX); + uint32_t crc = crc32(0, &f->tx_buf[LL_FTP_ACK_ACK_TYPE_INDEX], (size_t) return_len - LL_FTP_ACK_ACK_TYPE_INDEX); UINT32_TO_BYTESTREAM((&f->tx_buf[LL_FTP_MSG_CRC_INDEX]), crc); return return_len; From 524dcd4fdbe98e0221d467bd85614cda4f6de9da Mon Sep 17 00:00:00 2001 From: Scott Wohler Date: Thu, 6 Jun 2019 11:27:13 -0400 Subject: [PATCH 03/33] Fix length variable size for uplink calls --- inc/ll_ifc_ftp.h | 2 +- src/ll_ifc_ftp.c | 16 ++++++++-------- 2 files changed, 9 insertions(+), 9 deletions(-) diff --git a/inc/ll_ifc_ftp.h b/inc/ll_ifc_ftp.h index 0463ee7..b0460e6 100644 --- a/inc/ll_ifc_ftp.h +++ b/inc/ll_ifc_ftp.h @@ -223,7 +223,7 @@ typedef ll_ftp_return_code_t (*ll_ftp_apply_t)(uint32_t file_id, uint32_t file_v * @return * LL_FTP_OK - success, see ::ll_ftp_return_code. */ -typedef ll_ftp_return_code_t (*ll_ftp_send_uplink_t)(const uint8_t* buf, uint8_t len, bool acked, uint8_t port); +typedef ll_ftp_return_code_t (*ll_ftp_send_uplink_t)(const uint8_t* buf, uint16_t len, bool acked, uint8_t port); /** * @brief diff --git a/src/ll_ifc_ftp.c b/src/ll_ifc_ftp.c index 5fdaf94..60475b4 100644 --- a/src/ll_ifc_ftp.c +++ b/src/ll_ifc_ftp.c @@ -73,7 +73,7 @@ static ll_ftp_return_code_t ll_ftp_send_uplink(ll_ftp_t* f, size_t len) { uint8_t old_max_port = ll_ul_max_port; ll_ul_max_port = LL_FTP_PORT; - ll_ftp_return_code_t ret = f->cb.uplink(f->tx_buf, len, true, LL_FTP_PORT); + ll_ftp_return_code_t ret = f->cb.uplink(f->tx_buf, (uint16_t) len, true, LL_FTP_PORT); ll_ul_max_port = old_max_port; gettime(&f->time_last_msg); return ret; @@ -314,7 +314,7 @@ static void ll_ftp_new_file_initialize(ll_ftp_t* f, ll_ftp_msg_t* msg) memset(f->rx_segs, 0, sizeof(f->rx_segs[0]) * NUM_RX_SEGS_BITMASK); // send ACK_INIT - uint8_t len = ll_ftp_ack_init_generate(f, true); + uint16_t len = ll_ftp_ack_init_generate(f, true); ll_ftp_send_uplink(f, len); } @@ -351,7 +351,7 @@ static int32_t ll_ftp_segment_start(ll_ftp_t* f, ll_ftp_msg_t* msg) else if (TX_INIT == msg->msg_type || TX_SEGMENT == msg->msg_type) { // send ACK_INIT - uint8_t len = ll_ftp_ack_init_generate(f, false); + uint16_t len = ll_ftp_ack_init_generate(f, false); ll_ftp_send_uplink(f, len); } @@ -365,7 +365,7 @@ static int32_t ll_ftp_apply_start(ll_ftp_t* f) int32_t cb_ret = f->cb.close(f->file_id, f->file_version); if(LL_FTP_OK == cb_ret) { - uint8_t len = ll_ftp_ack_segs_complete_generate(f); + uint16_t len = ll_ftp_ack_segs_complete_generate(f); ll_ftp_send_uplink(f, len); ret = LL_FTP_OK; } @@ -613,7 +613,7 @@ static int32_t ll_ftp_segment_process_msg(ll_ftp_t* f, uint8_t* buf, uint8_t len { // Only able to apply in APPLY state // send NAK with retry segs - uint8_t len = ll_ftp_ack_segs_request_generate(f); + uint16_t len = ll_ftp_ack_segs_request_generate(f); ll_ftp_send_uplink(f, len); ret = LL_FTP_OK; } @@ -627,7 +627,7 @@ static int32_t ll_ftp_segment_process_msg(ll_ftp_t* f, uint8_t* buf, uint8_t len { if(f->retry_count < LL_FTP_MAX_NUM_RETRIES) { - uint8_t len = ll_ftp_ack_segs_request_generate(f); + uint16_t len = ll_ftp_ack_segs_request_generate(f); ll_ftp_send_uplink(f, len); f->retry_count++; } @@ -726,7 +726,7 @@ static int32_t ll_ftp_apply_process_msg(ll_ftp_t* f, uint8_t* buf, uint8_t len) } else if ((TX_APPLY == ftp_msg.msg_type) && (IS_MY_FILE)) { - uint8_t len; + uint16_t len; int32_t cb_ret = f->cb.apply(f->file_id, f->file_version, f->file_size); if(LL_FTP_OK == cb_ret) { @@ -753,7 +753,7 @@ static int32_t ll_ftp_apply_process_msg(ll_ftp_t* f, uint8_t* buf, uint8_t len) { if(f->retry_count < LL_FTP_MAX_NUM_RETRIES) { - uint8_t len = ll_ftp_ack_segs_complete_generate(f); + uint16_t len = ll_ftp_ack_segs_complete_generate(f); ll_ftp_send_uplink(f, len); f->retry_count++; } From ef632e3cfe622917176c5dc11c9144b57746f3f0 Mon Sep 17 00:00:00 2001 From: Scott Wohler Date: Thu, 6 Jun 2019 12:54:19 -0400 Subject: [PATCH 04/33] Fix return values for length on FTP messages --- src/ll_ifc_ftp.c | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/src/ll_ifc_ftp.c b/src/ll_ifc_ftp.c index 60475b4..093c04e 100644 --- a/src/ll_ifc_ftp.c +++ b/src/ll_ifc_ftp.c @@ -232,7 +232,7 @@ static uint16_t ll_ftp_get_missing_segs(ll_ftp_t* f, bool fill_buf) return num_missing_segs; } -static uint8_t ll_ftp_ack_init_generate(ll_ftp_t* f, bool ack) +static uint16_t ll_ftp_ack_init_generate(ll_ftp_t* f, bool ack) { f->tx_buf[LL_FTP_MSG_PACKET_TYPE_INDEX] = ACK_INIT; if (ack) @@ -253,7 +253,7 @@ static uint8_t ll_ftp_ack_init_generate(ll_ftp_t* f, bool ack) return BASE_UL_MSG_LEN; } -static uint8_t ll_ftp_ack_segs_complete_generate(ll_ftp_t* f) +static uint16_t ll_ftp_ack_segs_complete_generate(ll_ftp_t* f) { f->tx_buf[LL_FTP_MSG_PACKET_TYPE_INDEX] = ACK_SEGMENT; f->tx_buf[LL_FTP_ACK_ACK_TYPE_INDEX] = ACK_ACK; @@ -266,7 +266,7 @@ static uint8_t ll_ftp_ack_segs_complete_generate(ll_ftp_t* f) return BASE_UL_MSG_LEN; } -static uint8_t ll_ftp_ack_segs_request_generate(ll_ftp_t* f) +static uint16_t ll_ftp_ack_segs_request_generate(ll_ftp_t* f) { f->tx_buf[LL_FTP_MSG_PACKET_TYPE_INDEX] = ACK_SEGMENT; f->tx_buf[LL_FTP_ACK_ACK_TYPE_INDEX] = ACK_NAK_SEGMENT; @@ -291,7 +291,7 @@ static uint8_t ll_ftp_ack_segs_request_generate(ll_ftp_t* f) return return_len; } -static uint8_t ll_ftp_ack_apply_generate(ll_ftp_t* f, bool success) +static uint16_t ll_ftp_ack_apply_generate(ll_ftp_t* f, bool success) { f->tx_buf[LL_FTP_MSG_PACKET_TYPE_INDEX] = ACK_APPLY; f->tx_buf[LL_FTP_ACK_ACK_TYPE_INDEX] = (success ? ACK_ACK : ACK_NAK); From 75f3f3b305c849d9e109fe84a666e73e628c8007 Mon Sep 17 00:00:00 2001 From: Scott Wohler Date: Thu, 6 Jun 2019 15:01:44 -0400 Subject: [PATCH 05/33] Check error codes from message return values --- src/ll_ifc_ftp.c | 51 ++++++++++++++++++++++++++++++++++++++---------- 1 file changed, 41 insertions(+), 10 deletions(-) diff --git a/src/ll_ifc_ftp.c b/src/ll_ifc_ftp.c index 093c04e..2deb792 100644 --- a/src/ll_ifc_ftp.c +++ b/src/ll_ifc_ftp.c @@ -339,6 +339,7 @@ static int32_t ll_ftp_idle_start(ll_ftp_t* f) static int32_t ll_ftp_segment_start(ll_ftp_t* f, ll_ftp_msg_t* msg) { + ll_ftp_return_code_t msg_ret; int32_t ret = LL_FTP_NO_ACTION; int32_t cb_ret = f->cb.open(msg->file_id, msg->file_version, msg->file_size); @@ -352,7 +353,11 @@ static int32_t ll_ftp_segment_start(ll_ftp_t* f, ll_ftp_msg_t* msg) { // send ACK_INIT uint16_t len = ll_ftp_ack_init_generate(f, false); - ll_ftp_send_uplink(f, len); + msg_ret = ll_ftp_send_uplink(f, len); + if (msg_ret != LL_FTP_OK) + { + ret = LL_FTP_ERROR; + } } return ret; @@ -360,14 +365,20 @@ static int32_t ll_ftp_segment_start(ll_ftp_t* f, ll_ftp_msg_t* msg) static int32_t ll_ftp_apply_start(ll_ftp_t* f) { + ll_ftp_return_code_t msg_ret; int32_t ret = LL_FTP_ERROR; int32_t cb_ret = f->cb.close(f->file_id, f->file_version); if(LL_FTP_OK == cb_ret) { uint16_t len = ll_ftp_ack_segs_complete_generate(f); - ll_ftp_send_uplink(f, len); + ret = LL_FTP_OK; + msg_ret = ll_ftp_send_uplink(f, len); + if (msg_ret != LL_FTP_OK) + { + ret = LL_FTP_ERROR; + } } return ret; @@ -558,6 +569,7 @@ static int32_t ll_ftp_transition_out_of_segment(ll_ftp_t* f, ll_ftp_msg_t* msg, static int32_t ll_ftp_segment_process_msg(ll_ftp_t* f, uint8_t* buf, uint8_t len) { + ll_ftp_return_code_t msg_ret; ll_ftp_msg_t ftp_msg; int32_t ret = ll_ftp_parse_rx_msg(buf, len, &ftp_msg); if(LL_FTP_OK != ret) @@ -614,12 +626,18 @@ static int32_t ll_ftp_segment_process_msg(ll_ftp_t* f, uint8_t* buf, uint8_t len // Only able to apply in APPLY state // send NAK with retry segs uint16_t len = ll_ftp_ack_segs_request_generate(f); - ll_ftp_send_uplink(f, len); + ret = LL_FTP_OK; + msg_ret = ll_ftp_send_uplink(f, len); + if (msg_ret != LL_FTP_OK) + { + ret = LL_FTP_ERROR; + } } else if(TICK == ftp_msg.msg_type) { struct time time_now; + ret = LL_FTP_OK; // Rely on a periodic 1 Hz tick to request segments if necessary gettime(&time_now); @@ -628,7 +646,12 @@ static int32_t ll_ftp_segment_process_msg(ll_ftp_t* f, uint8_t* buf, uint8_t len if(f->retry_count < LL_FTP_MAX_NUM_RETRIES) { uint16_t len = ll_ftp_ack_segs_request_generate(f); - ll_ftp_send_uplink(f, len); + msg_ret = ll_ftp_send_uplink(f, len); + if (msg_ret != LL_FTP_OK) + { + ret = LL_FTP_ERROR; + } + f->retry_count++; } else @@ -636,7 +659,6 @@ static int32_t ll_ftp_segment_process_msg(ll_ftp_t* f, uint8_t* buf, uint8_t len next_state = IDLE; } } - ret = LL_FTP_OK; } // Do state transitions out of SEGMENT @@ -694,6 +716,7 @@ static int32_t ll_ftp_transition_out_of_apply(ll_ftp_t* f, ll_ftp_msg_t* msg, ll static int32_t ll_ftp_apply_process_msg(ll_ftp_t* f, uint8_t* buf, uint8_t len) { ll_ftp_msg_t ftp_msg; + ll_ftp_return_code_t msg_ret; int32_t ret = ll_ftp_parse_rx_msg(buf, len, &ftp_msg); if(LL_FTP_OK != ret) @@ -740,12 +763,17 @@ static int32_t ll_ftp_apply_process_msg(ll_ftp_t* f, uint8_t* buf, uint8_t len) } next_state = IDLE; - ll_ftp_send_uplink(f, len); - + msg_ret = ll_ftp_send_uplink(f, len); + if (msg_ret != LL_FTP_OK) + { + ret = LL_FTP_ERROR; + } } else if(TICK == ftp_msg.msg_type) { struct time time_now; + + ret = LL_FTP_OK; // Rely on a periodic 1 Hz tick to request segments if necessary gettime(&time_now); @@ -754,7 +782,12 @@ static int32_t ll_ftp_apply_process_msg(ll_ftp_t* f, uint8_t* buf, uint8_t len) if(f->retry_count < LL_FTP_MAX_NUM_RETRIES) { uint16_t len = ll_ftp_ack_segs_complete_generate(f); - ll_ftp_send_uplink(f, len); + msg_ret = ll_ftp_send_uplink(f, len); + if (msg_ret != LL_FTP_OK) + { + ret = LL_FTP_ERROR; + } + f->retry_count++; } else @@ -762,8 +795,6 @@ static int32_t ll_ftp_apply_process_msg(ll_ftp_t* f, uint8_t* buf, uint8_t len) next_state = IDLE; } } - - ret = LL_FTP_OK; } // Do state transitions out of APPLY From ffcb4a3e2bc542bc0567c56303a3980d7714edf5 Mon Sep 17 00:00:00 2001 From: Scott Wohler Date: Wed, 12 Jun 2019 15:09:42 -0400 Subject: [PATCH 06/33] Experiment with header bytes --- src/ll_ifc.c | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/ll_ifc.c b/src/ll_ifc.c index 0a9bc76..5eb1bef 100644 --- a/src/ll_ifc.c +++ b/src/ll_ifc.c @@ -446,7 +446,7 @@ int32_t ll_reset_state( void ) */ static void send_packet(opcode_t op, uint8_t message_num, uint8_t *buf, uint16_t len) { - #define SP_NUM_ZEROS (4) + #define SP_NUM_ZEROS (6) #define SP_HEADER_SIZE (CMD_HEADER_LEN + SP_NUM_ZEROS) uint8_t header_buf[SP_HEADER_SIZE]; uint8_t checksum_buff[2]; @@ -457,7 +457,7 @@ static void send_packet(opcode_t op, uint8_t message_num, uint8_t *buf, uint16_t // Send a couple wakeup bytes, just-in-case for (i = 0; i < SP_NUM_ZEROS; i++) { - header_buf[header_idx ++] = 0xff; + header_buf[header_idx ++] = 0x5F; } header_buf[header_idx++] = FRAME_START; From 30aa82b7324a8135edd1dff7e980d57f766bac8f Mon Sep 17 00:00:00 2001 From: Scott Wohler Date: Thu, 27 Jun 2019 16:45:15 -0400 Subject: [PATCH 07/33] WIP: Build mono repo --- Doxyfile | 3 +- inc/ifc_struct_defs.h | 114 +++-- inc/ll_ifc_consts.h | 38 +- inc/ll_ifc_ftp.h | 2 - inc/ll_ifc_symphony.h | 423 ++++++++++++++++++ inc/ll_ifc_utils.h | 1 + src/ifc_struct_defs.c | 79 +++- src/ll_ifc.c | 193 ++++++--- src/ll_ifc_ftp.c | 103 ++--- src/ll_ifc_no_mac.c | 40 +- src/ll_ifc_symphony.c | 438 ++++++++++++++++--- test_ftp/utils_ftp.c | 2 +- test_ifc_lib/Makefile | 8 +- test_ifc_lib/main.c | 6 +- test_ifc_lib/test_ifc_lib_gen.c | 408 ++++++++++++++++++ test_ifc_lib/test_ifc_lib_gen.h | 83 ++++ test_ifc_lib/test_ifc_lib_nomac.c | 323 ++++++++++++++ test_ifc_lib/test_ifc_lib_nomac.h | 64 +++ test_ifc_lib/test_ifc_lib_symphony.c | 622 +++++++++++++++++++++++++++ test_ifc_lib/test_ifc_lib_symphony.h | 105 +++++ test_ifc_lib/utils_ifc_lib.c | 22 +- test_utils/Makefile | 163 +++++++ test_utils/main.c | 20 + test_utils/test_ifc_lib_utils.c | 236 ++++++++++ test_utils/test_ifc_lib_utils.h | 21 + test_utils/utils.c | 196 +++++++++ test_utils/utils.h | 10 + 27 files changed, 3422 insertions(+), 301 deletions(-) create mode 100644 test_ifc_lib/test_ifc_lib_gen.c create mode 100644 test_ifc_lib/test_ifc_lib_gen.h create mode 100644 test_ifc_lib/test_ifc_lib_nomac.c create mode 100644 test_ifc_lib/test_ifc_lib_nomac.h create mode 100644 test_ifc_lib/test_ifc_lib_symphony.c create mode 100644 test_ifc_lib/test_ifc_lib_symphony.h create mode 100644 test_utils/Makefile create mode 100644 test_utils/main.c create mode 100644 test_utils/test_ifc_lib_utils.c create mode 100644 test_utils/test_ifc_lib_utils.h create mode 100644 test_utils/utils.c create mode 100644 test_utils/utils.h diff --git a/Doxyfile b/Doxyfile index 2cbdbb8..1ab0e4e 100644 --- a/Doxyfile +++ b/Doxyfile @@ -38,7 +38,7 @@ PROJECT_NAME = "Link Labs Interface Library" # could be handy for archiving the generated documentation or if some version # control system is used. -PROJECT_NUMBER = 0.3.1 +PROJECT_NUMBER = 0.7.0 # Using the PROJECT_BRIEF tag one can provide an optional one line description # for a project that appears at the top of each page and should give viewer a @@ -59,6 +59,7 @@ PROJECT_LOGO = logo.png # left blank the current directory will be used. OUTPUT_DIRECTORY = docs/build + # If the CREATE_SUBDIRS tag is set to YES then doxygen will create 4096 sub- # directories (in 2 levels) under the output directory of each output format and # will distribute the generated files over these directories. Enabling this diff --git a/inc/ifc_struct_defs.h b/inc/ifc_struct_defs.h index 7861faf..282073f 100644 --- a/inc/ifc_struct_defs.h +++ b/inc/ifc_struct_defs.h @@ -3,20 +3,24 @@ #include -#define NET_INFO_BUFF_SIZE (30) +#define NET_INFO_BUFF_SIZE (31) #define DL_BAND_CFG_SIZE (3 * 4 + 2) #define STATS_SIZE (10 * 4) #define TIME_INFO_SIZE (6 * 2 + 1) +#define GW_SCAN_INFO_SIZE (13) +#define MAX_GW_SCAN_RESULTS (16) +#define NUM_GW_SCANS_TO_KEEP (8) // sort through the list and find the best +#define MAX_GW_KEY_LIST (16) // number of gateways to keep keys in gw_list + +#define GW_SCAN_INFO_BUFF_SIZE (MAX_GW_SCAN_RESULTS * GW_SCAN_INFO_SIZE + 1) #ifndef PACKED -#if defined ( __CC_ARM ) - #define PACKED(TYPE) __packed TYPE -#elif defined(__GNUC__) || defined(__GNU_C__) - #define PACKED __attribute__ ((packed)) -#elif defined (__ICCARM__) - #define PACKED_STRUCT __packed struct +#ifdef __GNU_C__ +#define PACKED __attribute((__packed__)) #else - #error "PACKED must be defined for the platform!" +#ifndef PACKED +#define PACKED +#endif #endif #endif @@ -35,13 +39,11 @@ extern "C" { * @{ */ - -typedef enum -{ - LLABS_CONNECT_INITIAL = 0, ///< 0x00 - LLABS_CONNECT_DISCONNECTED, ///< 0x01 - LLABS_CONNECT_CONNECTED, ///< 0x02 - LLABS_NUM_CONNECT_STATUSES ///< 0x03 +typedef enum { + LLABS_CONNECT_INITIAL = 0, ///< 0x00 + LLABS_CONNECT_DISCONNECTED, ///< 0x01 + LLABS_CONNECT_CONNECTED, ///< 0x02 + LLABS_NUM_CONNECT_STATUSES ///< 0x03 } llabs_connect_status_t; typedef struct PACKED llabs_network_info_t @@ -56,6 +58,7 @@ typedef struct PACKED llabs_network_info_t llabs_connect_status_t connection_status; uint8_t is_scanning_gateways; uint64_t gateway_id; + uint8_t is_repeater; } llabs_network_info_t; // Defines the band-specific frequency parameters (FCC 902-928, etc...) @@ -70,41 +73,58 @@ typedef struct PACKED llabs_dl_band_cfg typedef struct llabs_stats { - uint32_t num_send_calls; ///< Number of times SendMessage has been called successfully - uint32_t num_pkts_transmitted; ///< Number of packet transmissions (includes retries) - uint32_t num_gateway_scans; ///< Number of gateway scans - uint32_t num_collisions; ///< Number of CSMA collisions detected - uint32_t num_ack_successes; ///< Number of successful acknowledgments - uint32_t num_ack_failures; ///< Number of failed acknowledgments - uint32_t num_sync_failures; ///< Number of Sync failures - uint32_t num_canceled_pkts_ack; ///< Number of times packet was canceled due to LLABS_ACK_FAIL_RETRIES - uint32_t num_canceled_pkts_csma; ///< Number of times packet was canceled due to LLABS_MAX_CSMA_COLLISIONS - uint32_t num_rx_errors; ///< Number of times we received a Rx error from the back end + uint32_t num_send_calls; ///< Number of times SendMessage has been called successfully + uint32_t num_pkts_transmitted; ///< Number of packet transmissions (includes retries) + uint32_t num_gateway_scans; ///< Number of gateway scans + uint32_t num_collisions; ///< Number of CSMA collisions detected + uint32_t num_ack_successes; ///< Number of successful acknowledgments + uint32_t num_ack_failures; ///< Number of failed acknowledgments + uint32_t num_sync_failures; ///< Number of Sync failures + uint32_t num_canceled_pkts_ack; ///< Number of times packet was canceled due to + /// LLABS_ACK_FAIL_RETRIES + uint32_t num_canceled_pkts_csma; ///< Number of times packet was canceled due to + /// LLABS_MAX_CSMA_COLLISIONS + uint32_t num_rx_errors; ///< Number of times we received a Rx error from the back end } llabs_stats_t; +typedef struct PACKED llabs_gateway_scan_results +{ + uint64_t id; + int16_t rssi; + int8_t snr; + int8_t channel; + uint8_t is_repeater; +} llabs_gateway_scan_results_t; + typedef struct PACKED llabs_time { - uint32_t seconds; ///< Seconds since UNIX epoch 00:00:00 UTC on 1 January 1970 - uint16_t millis; ///< number of milliseconds since time seconds since the epoch + uint32_t seconds; ///< Seconds since UNIX epoch 00:00:00 UTC on 1 January 1970 + uint16_t millis; ///< number of milliseconds since time seconds since the epoch } llabs_time_t; typedef struct PACKED llabs_time_info { - uint8_t sync_mode; ///< 0: Time sync only when requested, 1: Time sync opportunistically + uint8_t sync_mode; ///< 0: Time sync only when requested, 1: Time sync opportunistically llabs_time_t curr; llabs_time_t last_sync; } llabs_time_info_t; -void ll_net_info_deserialize(const uint8_t buff[NET_INFO_BUFF_SIZE], llabs_network_info_t * net_info); -uint16_t ll_net_info_serialize(const llabs_network_info_t * net_info, uint8_t buff[NET_INFO_BUFF_SIZE]); -void ll_dl_band_cfg_deserialize(const uint8_t buff[DL_BAND_CFG_SIZE], llabs_dl_band_cfg_t * dl_cfg); -uint16_t ll_dl_band_cfg_serialize(const llabs_dl_band_cfg_t * dl_cfg, uint8_t buff[DL_BAND_CFG_SIZE]); -void ll_stats_deserialize(const uint8_t buff[STATS_SIZE], llabs_stats_t * stats); -uint16_t ll_stats_serialize(const llabs_stats_t * stats, uint8_t buff[STATS_SIZE]); +void ll_net_info_deserialize(const uint8_t buff[NET_INFO_BUFF_SIZE], + llabs_network_info_t *net_info); +uint16_t ll_net_info_serialize(const llabs_network_info_t *net_info, + uint8_t buff[NET_INFO_BUFF_SIZE]); +void ll_gw_scan_result_deserialize(const uint8_t buff[GW_SCAN_INFO_BUFF_SIZE], + llabs_gateway_scan_results_t *scan_result, uint8_t *num_gw); +uint16_t ll_gw_scan_result_serialize(llabs_gateway_scan_results_t scan_result, + uint8_t num_gw, uint8_t buff[GW_SCAN_INFO_BUFF_SIZE]); +void ll_dl_band_cfg_deserialize(const uint8_t buff[DL_BAND_CFG_SIZE], llabs_dl_band_cfg_t *dl_cfg); +uint16_t ll_dl_band_cfg_serialize(const llabs_dl_band_cfg_t *dl_cfg, + uint8_t buff[DL_BAND_CFG_SIZE]); +void ll_stats_deserialize(const uint8_t buff[STATS_SIZE], llabs_stats_t *stats); +uint16_t ll_stats_serialize(const llabs_stats_t *stats, uint8_t buff[STATS_SIZE]); void ll_time_deserialize(const uint8_t buff[TIME_INFO_SIZE], llabs_time_info_t *time_info); uint16_t ll_time_serialize(const llabs_time_info_t *time_info, uint8_t buff[TIME_INFO_SIZE]); - /** @} (end addtogroup Module_Interface) */ /* @@ -118,14 +138,14 @@ uint16_t ll_time_serialize(const llabs_time_info_t *time_info, uint8_t buff[TIME * messages over the host interface. The write_* functions serialize an * integer into a byte stream , and the read_* functions deserialize an * integer from a byte stream. - * + * * See * serialization on Wikipedia for more details about why these functions * exist. */ - /** - * @{ - */ +/** +* @{ +*/ /** * @brief @@ -139,7 +159,7 @@ uint16_t ll_time_serialize(const llabs_time_info_t *time_info, uint8_t buff[TIME * @return * The u8 read from the buffer. */ -uint8_t read_uint8(const uint8_t ** buffer); +uint8_t read_uint8(const uint8_t **buffer); /** * @brief @@ -153,7 +173,7 @@ uint8_t read_uint8(const uint8_t ** buffer); * @return * The u16 read from the buffer. */ -uint16_t read_uint16(const uint8_t ** buffer); +uint16_t read_uint16(const uint8_t **buffer); /** * @brief @@ -167,7 +187,7 @@ uint16_t read_uint16(const uint8_t ** buffer); * @return * The u32 read from the buffer. */ -uint32_t read_uint32(const uint8_t ** buffer); +uint32_t read_uint32(const uint8_t **buffer); /** * @brief @@ -181,7 +201,7 @@ uint32_t read_uint32(const uint8_t ** buffer); * @return * The u64 read from the buffer. */ -uint64_t read_uint64(const uint8_t ** buffer); +uint64_t read_uint64(const uint8_t **buffer); /** * @brief @@ -195,7 +215,7 @@ uint64_t read_uint64(const uint8_t ** buffer); * The pointer to the big-endian buffer. The pointer is * incremented to the next location past the value written. */ -void write_uint8(uint8_t x, uint8_t ** buffer); +void write_uint8(uint8_t x, uint8_t **buffer); /** * @brief @@ -209,7 +229,7 @@ void write_uint8(uint8_t x, uint8_t ** buffer); * The pointer to the big-endian buffer. The pointer is * incremented to the next location past the value written. */ -void write_uint16(uint16_t x, uint8_t ** buffer); +void write_uint16(uint16_t x, uint8_t **buffer); /** * @brief @@ -223,7 +243,7 @@ void write_uint16(uint16_t x, uint8_t ** buffer); * The pointer to the big-endian buffer. The pointer is * incremented to the next location past the value written. */ -void write_uint32(uint32_t x, uint8_t ** buffer); +void write_uint32(uint32_t x, uint8_t **buffer); /** * @brief @@ -237,7 +257,7 @@ void write_uint32(uint32_t x, uint8_t ** buffer); * The pointer to the big-endian buffer. The pointer is * incremented to the next location past the value written. */ -void write_uint64(uint64_t x, uint8_t ** buffer); +void write_uint64(uint64_t x, uint8_t **buffer); /** @} (end defgroup ifc_serialize) */ diff --git a/inc/ll_ifc_consts.h b/inc/ll_ifc_consts.h index 637c95a..39b7d60 100644 --- a/inc/ll_ifc_consts.h +++ b/inc/ll_ifc_consts.h @@ -15,10 +15,11 @@ */ #define IFC_VERSION_MAJOR (0) -#define IFC_VERSION_MINOR (6) +#define IFC_VERSION_MINOR (8) #define IFC_VERSION_TAG (0) -#define APP_TOKEN_LEN (10) +#define APP_TOKEN_LEN (10) +#define UNIQUE_ID_LEN (8) #define MAX_RX_MSG_LEN (128) extern const uint32_t OPEN_NET_TOKEN; ///< Open network token (0x4f50454e) @@ -65,9 +66,9 @@ typedef enum OP_CONN_FILT_GET = 94, ///< 0x5E //STRIPTHIS!START OP_RESERVED0 = 96, ///< 0x60 - OP_RESERVED1 = 97, ///< 0x60 + OP_RESERVED1 = 97, ///< 0x61 //STRIPTHIS!STOP - OP_TX_CW = 98, ///< 0x61 + OP_TX_CW = 98, ///< 0x62 OP_SYSTEM_TIME_GET = 108, ///< 0x6C OP_SYSTEM_TIME_SYNC = 109, ///< 0x6D OP_RX_MODE_SET = 110, ///< 0x6E @@ -94,7 +95,25 @@ typedef enum OP_TIMESTAMP = 131, ///< 0x83 reserved, not fully implemented OP_SEND_TIMESTAMP = 132, ///< 0x84 reserved, not fully implemented //STRIPTHIS!STOP - + OP_GET_SCAN_INFO = 133, ///< 0x85 + OP_CONN_TO_GW_CH = 134, ///< 0x86 + OP_DISCONNECT = 135, ///< 0x87 + OP_SCAN_MODE_GET = 136, ///< 0x88 + OP_SCAN_MODE_SET = 137, ///< 0x89 + OP_SCAN_THRESHOLD_GET = 138, ///< 0x8A + OP_SCAN_THRESHOLD_SET = 139, ///< 0x8B + OP_SCAN_ATTEMPTS_GET = 140, ///< 0x8C + OP_SCAN_ATTEMPTS_SET = 141, ///< 0x8D + OP_SCAN_ATTEMPTS_LEFT = 142, ///< 0x8E + OP_RSSI_OFFSET_GET = 143, ///< 0x8F + OP_RSSI_OFFSET_SET = 144, ///< 0x90 + OP_CTRL_MSG_ENABLED_SET = 145, ///< 0x91 + OP_CTRL_MSG_ENABLED_GET = 146, ///< 0x92 + OP_GPIO_ENABLE_PIN = 147, ///< 0x93 + OP_GPIO_DISABLE_PIN = 148, ///< 0x94 + OP_GPIO_PIN_STATUS = 149, ///< 0x95 + OP_GPIO_SET_HIGH = 150, ///< 0x96 + OP_GPIO_SET_LOW = 151, ///< 0x97 //STRIPTHIS!START OP_FCC_TEST = 245, ///< 0xF5 OP_PER_TEST_TX = 246, ///< 0xF6 @@ -255,7 +274,6 @@ typedef enum ll_ifc_error_codes_e { LL_IFC_ERROR_TIMEOUT = -110, ///< The operation timed out. LL_IFC_ERROR_INCORRECT_MESSAGE_SIZE = -111, ///< The message size from the device was incorrect. LL_IFC_ERROR_NO_NETWORK = -112, ///< No network was available. - LL_IFC_ERROR_HAL_CALL_FAILED = -113, ///< A User defined function failed. /* When adding a new value, update ll_return_code_name() and ll_return_code_description() */ } ll_ifc_error_codes_t; @@ -289,11 +307,9 @@ typedef enum ll_ifc_error_codes_e { #define IRQ_FLAGS_INITIALIZATION_COMPLETE (0x00080000UL) ///< Set every time the MAC has completed initialization #define IRQ_FLAGS_CRYPTO_ERROR (0x00100000UL) ///< Set when a crypto exchange attempt fails #define IRQ_FLAGS_APP_TOKEN_ERROR (0x00200000UL) ///< Set when an application token registration fails -//STRIPTHIS!START -// LifeRaft IRQ flags -#define IRQ_FLAGS_STATUS_REQ (0x00400000UL) ///< Set when we want to request the status of the host controller -#define IRQ_FLAGS_FIRMWARE_REQ (0x00800000UL) ///< Set when we want to request the firmware data of the host controller -//STRIPTHIS!STOP +#define IRQ_FLAGS_DOWNLINK_ERROR (0x00400000UL) ///< Set when a downlink registration fails +#define IRQ_CLOUD_GPIO_2_INTERRUPT (0x01000000UL) ///< Set when the cloud GPIO input is triggered +#define IRQ_CLOUD_GPIO_3_INTERRUPT (0x02000000UL) ///< Set when the cloud GPIO input is triggered #define IRQ_FLAGS_ASSERT (0x80000000UL) ///< Set every time we transition from the connected->disconnected state /** diff --git a/inc/ll_ifc_ftp.h b/inc/ll_ifc_ftp.h index b0460e6..fd5a10f 100644 --- a/inc/ll_ifc_ftp.h +++ b/inc/ll_ifc_ftp.h @@ -63,11 +63,9 @@ extern "C" { #define MAX_NUM_SEGMENTS (9800) // Can support a 1MB image #define MAX_FILE_SEGMENT_BYTES (107) -//#define NUM_RX_SEGS_BITMASK (MAX_NUM_SEGMENTS / 32) #define NUM_RX_SEGS_BITMASK (((MAX_NUM_SEGMENTS % 32) == 0) ? (MAX_NUM_SEGMENTS >> 5) : ((MAX_NUM_SEGMENTS >> 5) + 1)) #define BASE_UL_MSG_LEN (14) #define MAX_NUM_RETRY_SEGS (1024) -//#define LL_FTP_TX_BUF_SIZE (BASE_UL_MSG_LEN + MAX_NUM_RETRY_SEGS * 2) #define LL_FTP_TX_BUF_SIZE (256) // Can fit 121 segment requests per payload diff --git a/inc/ll_ifc_symphony.h b/inc/ll_ifc_symphony.h index 73ba78d..e2d57d2 100644 --- a/inc/ll_ifc_symphony.h +++ b/inc/ll_ifc_symphony.h @@ -26,6 +26,40 @@ extern "C" { * @{ */ +/** + * @brief These are the different scanning modes for Link Labs Symphony + * Modules. + * + * A Quick Scan will attempt to connect to the first gateway or repeater it sees. The + * intent behind this scan is to keep the scanning process as quick and + * simple as possible resulting in less power consumption of the scanning + * features. + * + * A Normal Scan is the default scan that Link Labs Symphony Modules have + * always used. This scan looks for a balance between power consumption, + * results and performance. The normal scan will look at every gateway within + * it's range and assess which gateway has the best connection credentials. + * Once all of the channels have been scanned, it will connect to the gateway or + * repeater with the best RSSI and SNR. + * + * An Info Scan can be use to gather a list of scan results. This scan mode + * gathers much more data about each gateway and repeater on the air; then + * saves all of that information into an array of scan_results that the user + * can use. The intent behind this scan was to provide the users with a "WiFi-like" + * connection system with symphony. So once you have your scan results and you + * find the gateway you want to connect to, you can specify that to the module + * and it will directly connect you to it. You can also re-purpose this scan in + * many ways to see what gateways your module can see for RSSI analysis and much more. + * This scan will not attempt to connect to any gateway, but will wait for the user + * to either manually connect to a gateway, or set the scan_config in order to scan + * regularly. + */ +enum ll_scan_mode { + LLABS_QUICK_SCAN_AND_CONNECT, ///< Quick Scan resulting in a connection attempt. + LLABS_NORMAL_SCAN_AND_CONNECT, ///< Normal Scan resulting in a connection attempt. + LLABS_INFO_SCAN ///< Full Scan resulting in a list of local gateways. +}; + enum ll_downlink_mode { LL_DL_OFF = 0, ///< 0x00 LL_DL_ALWAYS_ON = 1, ///< 0x01 @@ -129,6 +163,368 @@ int32_t ll_config_set(uint32_t net_token, const uint8_t app_token[APP_TOKEN_LEN] int32_t ll_config_get(uint32_t *net_token, uint8_t app_token[APP_TOKEN_LEN], enum ll_downlink_mode * dl_mode, uint8_t *qos); +/** + * @brief + * Set the current scan configuration of the module. + * + * @details + * Sets the scan configuration values for the module. + * Calling this function will put the module in scanning mode + * automatically. + * + * @param[in] scan_mode + * The type of scan that should be done. + * + * @param[in] threshold + * The minimum RSSI threshold for the module to accept a gateway or repeater connection. + * 0 = No RSSI threshold; + * + * @param[in] scan_attempts + * The number of times the scan will restart upon a failed scan. + * 0 = Infinite Scan Attempts; Range (1, 65535) + * + * @return + * 0, on success, negative otherwise + */ +int32_t ll_scan_config_set(enum ll_scan_mode scan_mode, int16_t threshold, uint16_t scan_attempts); + +/** + * @brief + * Get the current scan configuration of the module. + * + * @details + * Returns the configuration of the module set by the user + * (or the defualts if the user didn't get the scan config + * yet). + * + * @param[out] scan_type + * Pointer to the scan type of the module. + * + * @param[out] threshold + * Pointer to the minimum RSSI threshold to connect to a gateway. + * 0 = No RSSI threshold; + * + * @param[out] scan_attempts + * Pointer to the number of times the scan will restart upon a failed scan. + * 0 = Infinite Scan Attempts; Range (1, 65535) + * + * @param[out] scans_left + * Pointer to how many scan attempts the module still has to do before becoming idle. + * + * @return + * 0, on success, negative otherwise + */ +int32_t ll_scan_config_get(enum ll_scan_mode *scan_mode, int16_t *threshold, uint16_t *scan_attempts, uint16_t *scans_left); + +/** + * @brief + * Provides the user with a list of available access points and allows the user to decide + * which one to connect to. + * + * @details + * You can only retrieve a scan list when the gateway is in a "INFO SCAN" mode, this can be + * set in the scan_config, and setting the new values will trigger a new scan. + * This method should be constantly polled at any interval during and after the scan, while + * the scan is executing, you will receive a nack - "busy try again" until the results are given. + * + * @param[out] scan_results + * This is an array of network information that contains the results of the scan. + * + * @param[out] num_gw + * The number of gateways scanned. + * + * @return + * 0, on success; NACK_BUSY_TRY_AGAIN, While scan is still going, negative otherwise + */ +int32_t ll_get_gateway_scan_results(llabs_gateway_scan_results_t (*scan_results)[MAX_GW_SCAN_RESULTS], uint8_t* num_gw); + +/** + * @brief + * Provides an extensible way to get gateway scan results, when you call this function + * (given the module has scan results stored), you will receive a scan result and the + * number of scan results left for you to poll. + * + * @details + * You can only retrieve a scan list when the gateway is in a "INFO SCAN" mode, this can be + * set in the scan_config, and setting the new values will trigger a new scan. + * This method should be constantly polled at any interval during and after the scan, while + * the scan is executing, you will receive a nack - "busy try again" until the results are given. + * + * @param[out] scan_results + * The scan results of the given gateway. + * + * @param[out] num_gw + * The current gateway number as well as how many gateways are left to poll. + * + * @return + * 0, on success; NACK_BUSY_TRY_AGAIN, While scan is still going, negative otherwise + */ +int32_t ll_poll_scan_result(llabs_gateway_scan_results_t *scan_result, uint8_t *num_gw); + +/** + * @brief + * Connect to a gateway based on the Channel it is on. + * + * @details + * This function will set the modules downlink channel to that of the + * requested channel and attempt to sync with any gateway on that channel. + * This function call does not require any scan results to be effective. + * Will only take effect when in IDLE_NO_GW mode. + * + * @param[in] channel + * The channel of the gateway that should be connected to. Must be between + * 0 and 45. + * + * @return + * 0, on success, negative otherwise + */ +int32_t ll_connect_to_gw_channel(uint8_t channel); + +/** + * @brief + * Disconnects the module from any current gateway. + * + * @details + * The state that the module is left in depends on the scan_config, + * since this call could either put the gateway in IDLE_NO_GW or can + * just start a new scan. Will only take effect when in IDLE_GW mode. + * + * @return + * 0, on success, negative otherwise + */ +int32_t ll_disconnect(void); + +/** + * @brief + * Enable or Disable the Control Message Feature. + * + * @details + * The control message feature allows the module to receive the following + * messages from conductor and bypass the host application completely. + * * Module Reset + * * Module Info Scan & Report + * * Connect to Gateway Channel + * * Get Module Stats + * * Cloud GPIO Functions + * + * These functions are good for recovering modules that have a locked up host + * and are also good for deployment operations with site analysis. Using the + * info scan and report function with the connect to gateway channel commands + * can give a server operator a lot of control over their deployment and fix + * any possible connectivity issues. The module stats command can also give + * a server administrator an idea of how the module is doing on a system level. + * Cloud GPIO functions have an infinite number of possibilities that can be used + * and configured how ever the host application sees fit. + * + * When the control message feature is enabled the module will automatically send + * out a message very similar to the mailbox request message. This message will be + * sent at a constant 15 minute interval to request any control messages that might + * be pending. In Downlink Always On mode the module will still send out this message + * in order to give the server a "heartbeat" or a constant ping to keep updating both + * the server's and the module's idea of connectivity between them. When the module is + * set for Downlink Always On mode the gateway will not hold the control message for the + * control message request, but instead will send it down ASAP because the module should + * be listening for it at that point. + * + * @param[in] enable + * If you want to enable the control message feature or not. + * + * @return + * 0, on success, negative otherwise + */ +int32_t ll_control_messages_enabled_set(bool enable); + +/** + * @brief + * Get if the Control Message Feature is Enabled or Disabled. + * + * @param[out] enabled + * If the control message feature is enabled or not. + * + * @return + * 0, on success, negative otherwise + */ +int32_t ll_control_messages_enabled_get(bool *enabled); + +/** + * @brief + * This function will activate the specified GPIO pin, by default all pins are disabled but + * as soon as a pin is enabled, that setting is persisted through module resets / reboots. + * + * Activating disabled pins will increase battery usage considerably. + * + * @details + * These GPIO pins are accessible from the cloud via control messages that enable the following + * commands to interface with the GPIO... + * * Activate Pin ( This Function ) + * * Deactivate Pin + * * Get Status + * * Write to Pin + * + * The module will also send a notification to the cloud when the GPIO input pin is triggered + * to enable external callbacks from the cloud. If you want to use the GPIO feature by itself + * and not send out the triggered read control message notification, then you can completely + * disable the control message feature with `ll_control_messages_enabled_set(false);`. + * + * @param[in] pin + * Corresponds to the Virtual GPIO pin layout... + * + * -------------------------------------------------------------------------------------------- + * | Virtual Pin # | Module Pin # | Function | + * |---------------|--------------|-----------------------------------------------------------| + * | Pin 0 | Pin 12 | Output Pin | + * | Pin 1 | Pin 23 | Output Pin | + * | Pin 2 | Pin 29 | Input Pin [ Triggers Callback on Falling Edge ] | + * | Pin 3 | Pin 31 | Input Pin [ Triggers Callback on Rising Edge ] | + * -------------------------------------------------------------------------------------------- + * + * @return + * 0, on success, negative otherwise + */ +int32_t ll_cloud_gpio_activate_pin(uint8_t pin); + +/** + * @brief + * This function will deactivate the specified GPIO pin, by default all pins are disabled but + * as soon as a pin is enabled, that setting is persisted through module resets / reboots. + * + * Disabling active pins will decrease battery usage considerably. + * + * @details + * These GPIO pins are accessible from the cloud via control messages that enable the following + * commands to interface with the GPIO... + * * Activate Pin + * * Deactivate Pin ( This Function ) + * * Get Status + * * Write to Pin + * + * The module will also send a notification to the cloud when the GPIO input pin is triggered + * to enable external callbacks from the cloud. If you want to use the GPIO feature by itself + * and not send out the triggered read control message notification, then you can completely + * disable the control message feature with `ll_control_messages_enabled_set(false);`. + * + * @param[in] pin + * Corresponds to the Virtual GPIO pin layout... + * + * -------------------------------------------------------------------------------------------- + * | Virtual Pin # | Module Pin # | Function | + * |---------------|--------------|-----------------------------------------------------------| + * | Pin 0 | Pin 12 | Output Pin | + * | Pin 1 | Pin 23 | Output Pin | + * | Pin 2 | Pin 29 | Input Pin [ Triggers Callback on Falling Edge ] | + * | Pin 3 | Pin 31 | Input Pin [ Triggers Callback on Rising Edge ] | + * -------------------------------------------------------------------------------------------- + * + * @return + * 0, on success, negative otherwise + */ +int32_t ll_cloud_gpio_deactivate_pin(uint8_t pin); + +/** + * @brief + * Get the status of the requested GPIO pin to see if it is activated or not. + * + * @details + * These GPIO pins are accessible from the cloud via control messages that enable the following + * commands to interface with the GPIO... + * * Activate Pin + * * Deactivate Pin + * * Get Status ( This Function ) + * * Write to Pin + * + * The module will also send a notification to the cloud when the GPIO input pin is triggered + * to enable external callbacks from the cloud. If you want to use the GPIO feature by itself + * and not send out the triggered read control message notification, then you can completely + * disable the control message feature with `ll_control_messages_enabled_set(false);`. + * + * @param[in] pin + * Corresponds to the Virtual GPIO pin layout... + * + * -------------------------------------------------------------------------------------------- + * | Virtual Pin # | Module Pin # | Function | + * |---------------|--------------|-----------------------------------------------------------| + * | Pin 0 | Pin 12 | Output Pin | + * | Pin 1 | Pin 23 | Output Pin | + * | Pin 2 | Pin 29 | Input Pin [ Triggers Callback on Falling Edge ] | + * | Pin 3 | Pin 31 | Input Pin [ Triggers Callback on Rising Edge ] | + * -------------------------------------------------------------------------------------------- + * + * @param[out] active + * Whether or not the pin is active or not. + * + * @return + * 0, on success, negative otherwise + */ +int32_t ll_cloud_gpio_get_pin_status(uint8_t pin, bool *active); + +/** + * @brief + * Sets the requested GPIO pin to output HIGH. This function only works for output pins. + * + * @details + * These GPIO pins are accessible from the cloud via control messages that enable the following + * commands to interface with the GPIO... + * * Activate Pin + * * Deactivate Pin + * * Get Status + * * Write to Pin ( This Function ) + * + * The module will also send a notification to the cloud when the GPIO input pin is triggered + * to enable external callbacks from the cloud. If you want to use the GPIO feature by itself + * and not send out the triggered read control message notification, then you can completely + * disable the control message feature with `ll_control_messages_enabled_set(false);`. + * + * @param[in] pin + * Corresponds to the Virtual GPIO pin layout... + * + * -------------------------------------------------------------------------------------------- + * | Virtual Pin # | Module Pin # | Function | + * |---------------|--------------|-----------------------------------------------------------| + * | Pin 0 | Pin 12 | Output Pin | + * | Pin 1 | Pin 23 | Output Pin | + * | Pin 2 | Pin 29 | Input Pin [ Triggers Callback on Falling Edge ] | + * | Pin 3 | Pin 31 | Input Pin [ Triggers Callback on Rising Edge ] | + * -------------------------------------------------------------------------------------------- + * + * @return + * 0, on success, negative otherwise + */ +int32_t ll_cloud_gpio_set_pin_high(uint8_t pin); + +/** + * @brief + * Sets the requested GPIO pin to output LOW. This function only works for output pins. + * + * @details + * These GPIO pins are accessible from the cloud via control messages that enable the following + * commands to interface with the GPIO... + * * Activate Pin + * * Deactivate Pin + * * Get Status + * * Write to Pin ( This Function ) + * + * The module will also send a notification to the cloud when the GPIO input pin is triggered + * to enable external callbacks from the cloud. If you want to use the GPIO feature by itself + * and not send out the triggered read control message notification, then you can completely + * disable the control message feature with `ll_control_messages_enabled_set(false);`. + * + * @param[in] pin + * Corresponds to the Virtual GPIO pin layout... + * + * -------------------------------------------------------------------------------------------- + * | Virtual Pin # | Module Pin # | Function | + * |---------------|--------------|-----------------------------------------------------------| + * | Pin 0 | Pin 12 | Output Pin | + * | Pin 1 | Pin 23 | Output Pin | + * | Pin 2 | Pin 29 | Input Pin [ Triggers Callback on Falling Edge ] | + * | Pin 3 | Pin 31 | Input Pin [ Triggers Callback on Rising Edge ] | + * -------------------------------------------------------------------------------------------- + * + * @return + * 0, on success, negative otherwise + */ +int32_t ll_cloud_gpio_set_pin_low(uint8_t pin); + /** * @brief * Gets the state of the module. @@ -245,6 +641,33 @@ int32_t ll_dl_band_cfg_get(llabs_dl_band_cfg_t *p_dl_band_cfg); */ int32_t ll_dl_band_cfg_set(const llabs_dl_band_cfg_t *p_dl_band_cfg); +/** + * @brief + * Get what the RSSI offset calibration is. + * + * @param[out] rssi_offset + * the rssi offset value. + * + * @ return + * 0 - success, negative otherwise. + */ +int32_t ll_rssi_offset_get(int8_t *rssi_offset); + +/** + * @brief + * Calibrate the module's rssi value with an offset. + * + * @note + * The range for an RSSI offset is (-15, 15). + * + * @param[out] rssi_offset + * the rssi offset value. + * + * @ return + * 0 - success, negative otherwise. + */ +int32_t ll_rssi_offset_set(int8_t rssi_offset); + /** * @brief * Get the Connection Filter value. diff --git a/inc/ll_ifc_utils.h b/inc/ll_ifc_utils.h index 2fc6742..36f975b 100644 --- a/inc/ll_ifc_utils.h +++ b/inc/ll_ifc_utils.h @@ -108,3 +108,4 @@ int32_t ll_difftime_from_now(struct time *a); #endif #endif //__LL_IFC_UTIL_H + diff --git a/src/ifc_struct_defs.c b/src/ifc_struct_defs.c index 22cb5c1..bc9c3bf 100644 --- a/src/ifc_struct_defs.c +++ b/src/ifc_struct_defs.c @@ -1,40 +1,45 @@ #include #include "ifc_struct_defs.h" -uint8_t read_uint8(const uint8_t ** buffer) { +uint8_t read_uint8(const uint8_t **buffer) +{ return *((*buffer)++); } -uint16_t read_uint16(const uint8_t ** buffer) { - return (((uint16_t) read_uint8(buffer)) << 8) | - ((uint16_t) read_uint8(buffer)); +uint16_t read_uint16(const uint8_t **buffer) +{ + return (((uint16_t) read_uint8(buffer)) << 8) | ((uint16_t) read_uint8(buffer)); } -uint32_t read_uint32(const uint8_t ** buffer) { - return (((uint32_t) read_uint16(buffer)) << 16) | - ((uint32_t) read_uint16(buffer)); +uint32_t read_uint32(const uint8_t **buffer) +{ + return (((uint32_t) read_uint16(buffer)) << 16) | ((uint32_t) read_uint16(buffer)); } -uint64_t read_uint64(const uint8_t ** buffer) { - return (((uint64_t) read_uint32(buffer)) << 32) | - ((uint64_t) read_uint32(buffer)); +uint64_t read_uint64(const uint8_t **buffer) +{ + return (((uint64_t) read_uint32(buffer)) << 32) | ((uint64_t) read_uint32(buffer)); } -void write_uint8(uint8_t x, uint8_t ** buffer) { +void write_uint8(uint8_t x, uint8_t **buffer) +{ *((*buffer)++) = x; } -void write_uint16(uint16_t x, uint8_t ** buffer) { +void write_uint16(uint16_t x, uint8_t **buffer) +{ write_uint8(x >> 8, buffer); write_uint8(x, buffer); } -void write_uint32(uint32_t x, uint8_t ** buffer) { +void write_uint32(uint32_t x, uint8_t **buffer) +{ write_uint16(x >> 16, buffer); write_uint16(x, buffer); } -void write_uint64(uint64_t x, uint8_t ** buffer) { +void write_uint64(uint64_t x, uint8_t **buffer) +{ write_uint32(x >> 32, buffer); write_uint32(x, buffer); } @@ -42,7 +47,7 @@ void write_uint64(uint64_t x, uint8_t ** buffer) { // Parse a serialized llabs_network_info_t struct. void ll_net_info_deserialize(const uint8_t buff[NET_INFO_BUFF_SIZE], llabs_network_info_t *net_info) { - uint8_t const * b = buff; + uint8_t const *b = buff; net_info->network_id_node = read_uint32(&b); net_info->network_id_gw = read_uint32(&b); net_info->gateway_channel = read_uint8(&b); @@ -53,13 +58,15 @@ void ll_net_info_deserialize(const uint8_t buff[NET_INFO_BUFF_SIZE], llabs_netwo net_info->connection_status = (llabs_connect_status_t) read_uint8(&b); net_info->is_scanning_gateways = read_uint8(&b); net_info->gateway_id = read_uint64(&b); + net_info->is_repeater = read_uint8(&b); } // Serializes an llabs_network_info_t struct into a buffer to be sent over the host interface. // Returns the size of the serialized struct in the buffer. -uint16_t ll_net_info_serialize(const llabs_network_info_t *net_info, uint8_t buff[NET_INFO_BUFF_SIZE]) +uint16_t ll_net_info_serialize(const llabs_network_info_t *net_info, + uint8_t buff[NET_INFO_BUFF_SIZE]) { - uint8_t * buff_cpy = buff; + uint8_t *buff_cpy = buff; write_uint32(net_info->network_id_node, &buff_cpy); write_uint32(net_info->network_id_gw, &buff_cpy); write_uint8(net_info->gateway_channel, &buff_cpy); @@ -70,12 +77,38 @@ uint16_t ll_net_info_serialize(const llabs_network_info_t *net_info, uint8_t buf write_uint8(net_info->connection_status, &buff_cpy); write_uint8(net_info->is_scanning_gateways, &buff_cpy); write_uint64(net_info->gateway_id, &buff_cpy); + write_uint8(net_info->is_repeater, &buff_cpy); + return buff_cpy - buff; +} + +void ll_gw_scan_result_deserialize(const uint8_t buff[GW_SCAN_INFO_BUFF_SIZE], + llabs_gateway_scan_results_t *scan_result, uint8_t *num_gw) +{ + uint8_t const *b = buff; + *num_gw = read_uint8(&b); + (*scan_result).id = read_uint64(&b); + (*scan_result).rssi = read_uint16(&b); + (*scan_result).snr = read_uint8(&b); + (*scan_result).channel = read_uint8(&b); + (*scan_result).is_repeater = read_uint8(&b); +} + +uint16_t ll_gw_scan_result_serialize(llabs_gateway_scan_results_t scan_result, const uint8_t num_gw, + uint8_t buff[GW_SCAN_INFO_BUFF_SIZE]) +{ + uint8_t *buff_cpy = buff; + write_uint8(num_gw, &buff_cpy); + write_uint64(scan_result.id, &buff_cpy); + write_uint16(scan_result.rssi, &buff_cpy); + write_uint8(scan_result.snr, &buff_cpy); + write_uint8(scan_result.channel, &buff_cpy); + write_uint8(scan_result.is_repeater, &buff_cpy); return buff_cpy - buff; } void ll_dl_band_cfg_deserialize(const uint8_t buff[DL_BAND_CFG_SIZE], llabs_dl_band_cfg_t *dl_cfg) { - uint8_t const * b = buff; + uint8_t const *b = buff; dl_cfg->band_edge_lower = read_uint32(&b); dl_cfg->band_edge_upper = read_uint32(&b); dl_cfg->band_edge_guard = read_uint32(&b); @@ -85,7 +118,7 @@ void ll_dl_band_cfg_deserialize(const uint8_t buff[DL_BAND_CFG_SIZE], llabs_dl_b uint16_t ll_dl_band_cfg_serialize(const llabs_dl_band_cfg_t *dl_cfg, uint8_t buff[DL_BAND_CFG_SIZE]) { - uint8_t * b = buff; + uint8_t *b = buff; write_uint32(dl_cfg->band_edge_lower, &b); write_uint32(dl_cfg->band_edge_upper, &b); write_uint32(dl_cfg->band_edge_guard, &b); @@ -96,7 +129,7 @@ uint16_t ll_dl_band_cfg_serialize(const llabs_dl_band_cfg_t *dl_cfg, uint8_t buf void ll_stats_deserialize(const uint8_t buff[STATS_SIZE], llabs_stats_t *stats) { - uint8_t const * b = buff; + uint8_t const *b = buff; stats->num_send_calls = read_uint32(&b); stats->num_pkts_transmitted = read_uint32(&b); stats->num_gateway_scans = read_uint32(&b); @@ -111,7 +144,7 @@ void ll_stats_deserialize(const uint8_t buff[STATS_SIZE], llabs_stats_t *stats) uint16_t ll_stats_serialize(const llabs_stats_t *stats, uint8_t buff[STATS_SIZE]) { - uint8_t * b = buff; + uint8_t *b = buff; write_uint32(stats->num_send_calls, &b); write_uint32(stats->num_pkts_transmitted, &b); write_uint32(stats->num_gateway_scans, &b); @@ -127,7 +160,7 @@ uint16_t ll_stats_serialize(const llabs_stats_t *stats, uint8_t buff[STATS_SIZE] void ll_time_deserialize(const uint8_t buff[TIME_INFO_SIZE], llabs_time_info_t *time_info) { - uint8_t const * b = buff; + uint8_t const *b = buff; time_info->sync_mode = read_uint8(&b); time_info->curr.seconds = read_uint32(&b); time_info->curr.millis = read_uint16(&b); @@ -137,7 +170,7 @@ void ll_time_deserialize(const uint8_t buff[TIME_INFO_SIZE], llabs_time_info_t * uint16_t ll_time_serialize(const llabs_time_info_t *time_info, uint8_t buff[TIME_INFO_SIZE]) { - uint8_t * b = buff; + uint8_t *b = buff; write_uint8(time_info->sync_mode, &b); write_uint32(time_info->curr.seconds, &b); write_uint16(time_info->curr.millis, &b); diff --git a/src/ll_ifc.c b/src/ll_ifc.c index 5eb1bef..9a66099 100644 --- a/src/ll_ifc.c +++ b/src/ll_ifc.c @@ -22,10 +22,6 @@ static int32_t message_num = 0; int32_t hal_read_write(opcode_t op, uint8_t buf_in[], uint16_t in_len, uint8_t buf_out[], uint16_t out_len) { - // int i; - // int curr_byte; - // int num_bytes; - int32_t ret; // Error checking: @@ -105,7 +101,7 @@ char const * ll_return_code_description(int32_t return_code) { switch (return_code) { - case -LL_IFC_ACK: return "success"; + case -LL_IFC_ACK: return "Success"; case -LL_IFC_NACK_CMD_NOT_SUPPORTED: return "Command not supported"; case -LL_IFC_NACK_INCORRECT_CHKSUM: return "Incorrect Checksum"; case -LL_IFC_NACK_PAYLOAD_LEN_OOR: return "Length of payload sent in command was out of range"; @@ -141,33 +137,51 @@ int32_t ll_firmware_type_get(ll_firmware_type_t *t) { uint8_t buf[FIRMWARE_TYPE_LEN]; int32_t ret; - if(t == NULL) + if(NULL == t) { return LL_IFC_ERROR_INCORRECT_PARAMETER; } + ret = hal_read_write(OP_FIRMWARE_TYPE, NULL, 0, buf, FIRMWARE_TYPE_LEN); - if (ret == FIRMWARE_TYPE_LEN) + if(ret < 0) { - t->cpu_code = buf[0] << 8 | buf[1]; - t->functionality_code = buf[2] << 8 | buf[3]; + return ret; } - return ret; + + if(FIRMWARE_TYPE_LEN != ret) + { + return LL_IFC_ERROR_INCORRECT_RESPONSE_LENGTH; + } + + t->cpu_code = buf[0] << 8 | buf[1]; + t->functionality_code = buf[2] << 8 | buf[3]; + + return (ret >= 0) ? LL_IFC_ACK : ret; } int32_t ll_hardware_type_get(ll_hardware_type_t *t) { uint8_t type; int32_t ret; - if(t == NULL) + if(NULL == t) { return LL_IFC_ERROR_INCORRECT_PARAMETER; } + ret = hal_read_write(OP_HARDWARE_TYPE, NULL, 0, &type, sizeof(type)); - if (ret == sizeof(type)) + if(ret < 0) { - *t = (ll_hardware_type_t) type; + return ret; } - return ret; + + if(sizeof(type) != ret) + { + return LL_IFC_ERROR_INCORRECT_RESPONSE_LENGTH; + } + + *t = (ll_hardware_type_t) type; + + return (ret >= 0) ? LL_IFC_ACK : ret; } const char * ll_hardware_type_string(ll_hardware_type_t t) @@ -187,46 +201,66 @@ int32_t ll_interface_version_get(ll_version_t *version) { uint8_t buf[VERSION_LEN]; int32_t ret; - if(version == NULL) + if(NULL == version) { return LL_IFC_ERROR_INCORRECT_PARAMETER; } + ret = hal_read_write(OP_IFC_VERSION, NULL, 0, buf, VERSION_LEN); - if (ret == VERSION_LEN) + if(ret < 0) { - version->major = buf[0]; - version->minor = buf[1]; - version->tag = buf[2] << 8 | buf[3]; + return ret; } - return ret; + + if (VERSION_LEN != ret) + { + return LL_IFC_ERROR_INCORRECT_RESPONSE_LENGTH; + } + + version->major = buf[0]; + version->minor = buf[1]; + version->tag = buf[2] << 8 | buf[3]; + + return (ret >= 0) ? LL_IFC_ACK : ret; } int32_t ll_version_get(ll_version_t *version) { uint8_t buf[VERSION_LEN]; int32_t ret; - if(version == NULL) + if(NULL == version) { return LL_IFC_ERROR_INCORRECT_PARAMETER; } + ret = hal_read_write(OP_VERSION, NULL, 0, buf, VERSION_LEN); - if (ret == VERSION_LEN) + if(ret < 0) { - version->major = buf[0]; - version->minor = buf[1]; - version->tag = buf[2] << 8 | buf[3]; + return ret; } - return ret; + + if (VERSION_LEN != ret) + { + return LL_IFC_ERROR_INCORRECT_RESPONSE_LENGTH; + } + + version->major = buf[0]; + version->minor = buf[1]; + version->tag = buf[2] << 8 | buf[3]; + + return (ret >= 0) ? LL_IFC_ACK : ret; } int32_t ll_sleep_block(void) { - return hal_read_write(OP_SLEEP_BLOCK, (uint8_t*) "1", 1, NULL, 0); + int32_t ret = hal_read_write(OP_SLEEP_BLOCK, (uint8_t*) "1", 1, NULL, 0); + return (ret >= 0) ? LL_IFC_ACK : ret; } int32_t ll_sleep_unblock(void) { - return hal_read_write(OP_SLEEP_BLOCK, (uint8_t*) "0", 1, NULL, 0); + int32_t ret = hal_read_write(OP_SLEEP_BLOCK, (uint8_t*) "0", 1, NULL, 0); + return (ret >= 0) ? LL_IFC_ACK : ret; } int32_t ll_mac_mode_set(ll_mac_type_t mac_mode) @@ -236,7 +270,8 @@ int32_t ll_mac_mode_set(ll_mac_type_t mac_mode) return LL_IFC_ERROR_INCORRECT_PARAMETER; } uint8_t u8_mac_mode = (uint8_t)mac_mode; - return hal_read_write(OP_MAC_MODE_SET, &u8_mac_mode, 1, NULL, 0); + int32_t ret = hal_read_write(OP_MAC_MODE_SET, &u8_mac_mode, 1, NULL, 0); + return (ret >= 0) ? LL_IFC_ACK : ret; } int32_t ll_mac_mode_get(ll_mac_type_t *mac_mode) @@ -246,17 +281,19 @@ int32_t ll_mac_mode_get(ll_mac_type_t *mac_mode) { return LL_IFC_ERROR_INCORRECT_PARAMETER; } + uint8_t u8_mac_mode; ret = hal_read_write(OP_MAC_MODE_GET, NULL, 0, &u8_mac_mode, sizeof(uint8_t)); *mac_mode = (ll_mac_type_t)u8_mac_mode; - return ret; + return (ret >= 0) ? LL_IFC_ACK : ret; } int32_t ll_antenna_set(uint8_t ant) { if((ant == 1) || (ant == 2)) { - return hal_read_write(OP_ANTENNA_SET, &ant, 1, NULL, 0); + int32_t ret = hal_read_write(OP_ANTENNA_SET, &ant, 1, NULL, 0); + return (ret >= 0) ? LL_IFC_ACK : ret; } else { @@ -270,57 +307,75 @@ int32_t ll_antenna_get(uint8_t *ant) { return LL_IFC_ERROR_INCORRECT_PARAMETER; } - return hal_read_write(OP_ANTENNA_GET, NULL, 0, ant, 1); + int32_t ret = hal_read_write(OP_ANTENNA_GET, NULL, 0, ant, 1); + return (ret >= 0) ? LL_IFC_ACK : ret; } int32_t ll_unique_id_get(uint64_t *unique_id) { - uint8_t buff[8]; + uint8_t buff[UNIQUE_ID_LEN]; int32_t ret; - int i; + uint8_t i; + if (unique_id == NULL) { return LL_IFC_ERROR_INCORRECT_PARAMETER; } - ret = hal_read_write(OP_MODULE_ID, NULL, 0, buff, 8); + + ret = hal_read_write(OP_MODULE_ID, NULL, 0, buff, UNIQUE_ID_LEN); + if(ret < 0) + { + return ret; + } + + if (UNIQUE_ID_LEN != ret) + { + return LL_IFC_ERROR_INCORRECT_RESPONSE_LENGTH; + } + *unique_id = 0; - for (i = 0; i < 8; i++) + for (i = 0; i < UNIQUE_ID_LEN; i++) { *unique_id |= ((uint64_t) buff[i]) << (8 * (7 - i)); } - return ret; + return (ret >= 0) ? LL_IFC_ACK : ret; } int32_t ll_settings_store(void) { - return hal_read_write(OP_STORE_SETTINGS, NULL, 0, NULL, 0); + int32_t ret = hal_read_write(OP_STORE_SETTINGS, NULL, 0, NULL, 0); + return (ret >= 0) ? LL_IFC_ACK : ret; } int32_t ll_settings_delete(void) { - return hal_read_write(OP_DELETE_SETTINGS, NULL, 0, NULL, 0); + int32_t ret = hal_read_write(OP_DELETE_SETTINGS, NULL, 0, NULL, 0); + return (ret >= 0) ? LL_IFC_ACK : ret; } int32_t ll_restore_defaults(void) { - return hal_read_write(OP_RESET_SETTINGS, NULL, 0, NULL, 0); + int32_t ret = hal_read_write(OP_RESET_SETTINGS, NULL, 0, NULL, 0); + return (ret >= 0) ? LL_IFC_ACK : ret; } int32_t ll_sleep(void) { - return hal_read_write(OP_SLEEP, NULL, 0, NULL, 0); + int32_t ret = hal_read_write(OP_SLEEP, NULL, 0, NULL, 0); + return (ret >= 0) ? LL_IFC_ACK : ret; } int32_t ll_reset_mcu(void) { - return hal_read_write(OP_RESET_MCU, NULL, 0, NULL, 0); + int32_t ret = hal_read_write(OP_RESET_MCU, NULL, 0, NULL, 0); + return (ret >= 0) ? LL_IFC_ACK : ret; } int32_t ll_bootloader_mode(void) { send_packet(OP_TRIGGER_BOOTLOADER, message_num, NULL, 0); - return 0; + return LL_IFC_ACK; } /** @@ -330,8 +385,12 @@ int32_t ll_bootloader_mode(void) */ int32_t ll_irq_flags(uint32_t flags_to_clear, uint32_t *flags) { - // Assuming big endian convention over the interface + if(NULL == flags) + { + return LL_IFC_ERROR_INCORRECT_PARAMETER; + } + // Assuming big endian convention over the interface uint8_t in_buf[4]; uint8_t out_buf[4] = {0,0,0,0}; @@ -340,19 +399,26 @@ int32_t ll_irq_flags(uint32_t flags_to_clear, uint32_t *flags) in_buf[2] = (uint8_t)((flags_to_clear >> 8) & 0xFF); in_buf[3] = (uint8_t)((flags_to_clear ) & 0xFF); - int32_t rw_response = hal_read_write(OP_IRQ_FLAGS, in_buf, 4, out_buf, 4); + int32_t ret = hal_read_write(OP_IRQ_FLAGS, in_buf, 4, out_buf, 4); - if(rw_response > 0) + if(ret < 0) { - uint32_t flags_temp = 0; - flags_temp |= (((uint32_t)out_buf[0]) << 24); - flags_temp |= (((uint32_t)out_buf[1]) << 16); - flags_temp |= (((uint32_t)out_buf[2]) << 8); - flags_temp |= (((uint32_t)out_buf[3])); - *flags = flags_temp; + return ret; } - return(rw_response); + if(4 != ret) + { + return LL_IFC_ERROR_INCORRECT_RESPONSE_LENGTH; + } + + uint32_t flags_temp = 0; + flags_temp |= (((uint32_t)out_buf[0]) << 24); + flags_temp |= (((uint32_t)out_buf[1]) << 16); + flags_temp |= (((uint32_t)out_buf[2]) << 8); + flags_temp |= (((uint32_t)out_buf[3])); + *flags = flags_temp; + + return (ret >= 0) ? LL_IFC_ACK : ret; } //STRIPTHIS!START @@ -446,7 +512,7 @@ int32_t ll_reset_state( void ) */ static void send_packet(opcode_t op, uint8_t message_num, uint8_t *buf, uint16_t len) { - #define SP_NUM_ZEROS (6) + #define SP_NUM_ZEROS (4) #define SP_HEADER_SIZE (CMD_HEADER_LEN + SP_NUM_ZEROS) uint8_t header_buf[SP_HEADER_SIZE]; uint8_t checksum_buff[2]; @@ -457,7 +523,7 @@ static void send_packet(opcode_t op, uint8_t message_num, uint8_t *buf, uint16_t // Send a couple wakeup bytes, just-in-case for (i = 0; i < SP_NUM_ZEROS; i++) { - header_buf[header_idx ++] = 0x5F; + header_buf[header_idx ++] = 0xff; } header_buf[header_idx++] = FRAME_START; @@ -530,24 +596,15 @@ static int32_t recv_packet(opcode_t op, uint8_t message_num, uint8_t *buf, uint1 int32_t ret; memset(header_buf, 0, sizeof(header_buf)); - - struct time time_start, time_now; - if (gettime(&time_start) < 0) - { - return LL_IFC_ERROR_HAL_CALL_FAILED; - } + //TODO: have conditionally compiled cases for various platforms to ensure accurate timeout + clock_t max_clock = (clock_t) (1.5 * (float)CLOCKS_PER_SEC); + clock_t t = clock(); do { /* Timeout of infinite Rx loop if responses never show up*/ ret = transport_read(&curr_byte, 1); - - if (gettime(&time_now) < 0) - { - return LL_IFC_ERROR_HAL_CALL_FAILED; - } - - if(time_now.tv_sec - time_start.tv_sec > 2) + if((clock()- t) > max_clock) { len = 0; return LL_IFC_ERROR_HOST_INTERFACE_TIMEOUT; diff --git a/src/ll_ifc_ftp.c b/src/ll_ifc_ftp.c index 2deb792..6491aae 100644 --- a/src/ll_ifc_ftp.c +++ b/src/ll_ifc_ftp.c @@ -30,7 +30,7 @@ dst[3] = (src >> 24) & 0xFF; const uint8_t LL_FTP_MAX_NUM_RETRIES = 5; -const uint8_t LL_FTP_RETRY_INTERVAL = 15; +const uint8_t LL_FTP_RETRY_INTERVAL = 16; const uint8_t LL_FTP_PORT = 128; extern uint8_t ll_ul_max_port; @@ -73,7 +73,7 @@ static ll_ftp_return_code_t ll_ftp_send_uplink(ll_ftp_t* f, size_t len) { uint8_t old_max_port = ll_ul_max_port; ll_ul_max_port = LL_FTP_PORT; - ll_ftp_return_code_t ret = f->cb.uplink(f->tx_buf, (uint16_t) len, true, LL_FTP_PORT); + ll_ftp_return_code_t ret = f->cb.uplink(f->tx_buf, len, true, LL_FTP_PORT); ll_ul_max_port = old_max_port; gettime(&f->time_last_msg); return ret; @@ -194,7 +194,6 @@ static uint16_t ll_ftp_get_missing_segs(ll_ftp_t* f, bool fill_buf) uint16_t seg_num; uint8_t num_segs_base; uint8_t idx; - uint16_t total_payload = fill_buf ? BASE_UL_MSG_LEN : 0; uint16_t base_max = f->num_segs >> 5; // divide by 32 for(i = 0; i <= base_max; i++) @@ -210,21 +209,15 @@ static uint16_t ll_ftp_get_missing_segs(ll_ftp_t* f, bool fill_buf) // request complete retransmission return 0xFFFF; } - seg_num = (i << 5) + j; // i * 32 + j - + idx = num_missing_segs * 2; - - // Only fill the buffer up to the maximum number of segments we can request in - // a single payload - if ((fill_buf) && ((total_payload + sizeof(seg_num)) <= LL_FTP_TX_BUF_SIZE)) + if(fill_buf) { f->tx_buf[LL_FTP_NAK_FILE_SEGS_INDEX + idx] = seg_num & 0x00FF; f->tx_buf[LL_FTP_NAK_FILE_SEGS_INDEX + idx + 1] = (seg_num >> 8) & 0x00FF; - - total_payload += sizeof(seg_num); - num_missing_segs++; } + num_missing_segs++; } } } @@ -232,7 +225,7 @@ static uint16_t ll_ftp_get_missing_segs(ll_ftp_t* f, bool fill_buf) return num_missing_segs; } -static uint16_t ll_ftp_ack_init_generate(ll_ftp_t* f, bool ack) +static uint8_t ll_ftp_ack_init_generate(ll_ftp_t* f, bool ack) { f->tx_buf[LL_FTP_MSG_PACKET_TYPE_INDEX] = ACK_INIT; if (ack) @@ -253,7 +246,7 @@ static uint16_t ll_ftp_ack_init_generate(ll_ftp_t* f, bool ack) return BASE_UL_MSG_LEN; } -static uint16_t ll_ftp_ack_segs_complete_generate(ll_ftp_t* f) +static uint8_t ll_ftp_ack_segs_complete_generate(ll_ftp_t* f) { f->tx_buf[LL_FTP_MSG_PACKET_TYPE_INDEX] = ACK_SEGMENT; f->tx_buf[LL_FTP_ACK_ACK_TYPE_INDEX] = ACK_ACK; @@ -266,7 +259,7 @@ static uint16_t ll_ftp_ack_segs_complete_generate(ll_ftp_t* f) return BASE_UL_MSG_LEN; } -static uint16_t ll_ftp_ack_segs_request_generate(ll_ftp_t* f) +static uint8_t ll_ftp_ack_segs_request_generate(ll_ftp_t* f) { f->tx_buf[LL_FTP_MSG_PACKET_TYPE_INDEX] = ACK_SEGMENT; f->tx_buf[LL_FTP_ACK_ACK_TYPE_INDEX] = ACK_NAK_SEGMENT; @@ -275,7 +268,7 @@ static uint16_t ll_ftp_ack_segs_request_generate(ll_ftp_t* f) // check max length number of retry segments uint16_t num_missing_segs = ll_ftp_get_missing_segs(f, true); - uint16_t return_len = BASE_UL_MSG_LEN; + uint8_t return_len = BASE_UL_MSG_LEN; if(MAX_NUM_RETRY_SEGS <= num_missing_segs) { f->tx_buf[LL_FTP_ACK_ACK_TYPE_INDEX] = ACK_NAK; @@ -285,16 +278,16 @@ static uint16_t ll_ftp_ack_segs_request_generate(ll_ftp_t* f) return_len += num_missing_segs * sizeof(uint16_t); } - uint32_t crc = crc32(0, &f->tx_buf[LL_FTP_ACK_ACK_TYPE_INDEX], (size_t) return_len - LL_FTP_ACK_ACK_TYPE_INDEX); + uint32_t crc = crc32(0, &f->tx_buf[LL_FTP_ACK_ACK_TYPE_INDEX], return_len - LL_FTP_ACK_ACK_TYPE_INDEX); UINT32_TO_BYTESTREAM((&f->tx_buf[LL_FTP_MSG_CRC_INDEX]), crc); return return_len; } -static uint16_t ll_ftp_ack_apply_generate(ll_ftp_t* f, bool success) +static uint8_t ll_ftp_ack_apply_generate(ll_ftp_t* f) { f->tx_buf[LL_FTP_MSG_PACKET_TYPE_INDEX] = ACK_APPLY; - f->tx_buf[LL_FTP_ACK_ACK_TYPE_INDEX] = (success ? ACK_ACK : ACK_NAK); + f->tx_buf[LL_FTP_ACK_ACK_TYPE_INDEX] = ACK_ACK; UINT32_TO_BYTESTREAM((&f->tx_buf[LL_FTP_ACK_FILE_ID_INDEX]), f->file_id); UINT32_TO_BYTESTREAM((&f->tx_buf[LL_FTP_ACK_FILE_VERSION_INDEX]), f->file_version); @@ -314,7 +307,7 @@ static void ll_ftp_new_file_initialize(ll_ftp_t* f, ll_ftp_msg_t* msg) memset(f->rx_segs, 0, sizeof(f->rx_segs[0]) * NUM_RX_SEGS_BITMASK); // send ACK_INIT - uint16_t len = ll_ftp_ack_init_generate(f, true); + uint8_t len = ll_ftp_ack_init_generate(f, true); ll_ftp_send_uplink(f, len); } @@ -339,7 +332,6 @@ static int32_t ll_ftp_idle_start(ll_ftp_t* f) static int32_t ll_ftp_segment_start(ll_ftp_t* f, ll_ftp_msg_t* msg) { - ll_ftp_return_code_t msg_ret; int32_t ret = LL_FTP_NO_ACTION; int32_t cb_ret = f->cb.open(msg->file_id, msg->file_version, msg->file_size); @@ -352,12 +344,8 @@ static int32_t ll_ftp_segment_start(ll_ftp_t* f, ll_ftp_msg_t* msg) else if (TX_INIT == msg->msg_type || TX_SEGMENT == msg->msg_type) { // send ACK_INIT - uint16_t len = ll_ftp_ack_init_generate(f, false); - msg_ret = ll_ftp_send_uplink(f, len); - if (msg_ret != LL_FTP_OK) - { - ret = LL_FTP_ERROR; - } + uint8_t len = ll_ftp_ack_init_generate(f, false); + ll_ftp_send_uplink(f, len); } return ret; @@ -365,20 +353,14 @@ static int32_t ll_ftp_segment_start(ll_ftp_t* f, ll_ftp_msg_t* msg) static int32_t ll_ftp_apply_start(ll_ftp_t* f) { - ll_ftp_return_code_t msg_ret; int32_t ret = LL_FTP_ERROR; int32_t cb_ret = f->cb.close(f->file_id, f->file_version); if(LL_FTP_OK == cb_ret) { - uint16_t len = ll_ftp_ack_segs_complete_generate(f); - + uint8_t len = ll_ftp_ack_segs_complete_generate(f); + ll_ftp_send_uplink(f, len); ret = LL_FTP_OK; - msg_ret = ll_ftp_send_uplink(f, len); - if (msg_ret != LL_FTP_OK) - { - ret = LL_FTP_ERROR; - } } return ret; @@ -560,7 +542,6 @@ static int32_t ll_ftp_transition_out_of_segment(ll_ftp_t* f, ll_ftp_msg_t* msg, } break; default: - ret = LL_FTP_ERROR; break; } @@ -569,7 +550,6 @@ static int32_t ll_ftp_transition_out_of_segment(ll_ftp_t* f, ll_ftp_msg_t* msg, static int32_t ll_ftp_segment_process_msg(ll_ftp_t* f, uint8_t* buf, uint8_t len) { - ll_ftp_return_code_t msg_ret; ll_ftp_msg_t ftp_msg; int32_t ret = ll_ftp_parse_rx_msg(buf, len, &ftp_msg); if(LL_FTP_OK != ret) @@ -625,19 +605,13 @@ static int32_t ll_ftp_segment_process_msg(ll_ftp_t* f, uint8_t* buf, uint8_t len { // Only able to apply in APPLY state // send NAK with retry segs - uint16_t len = ll_ftp_ack_segs_request_generate(f); - + uint8_t len = ll_ftp_ack_segs_request_generate(f); + ll_ftp_send_uplink(f, len); ret = LL_FTP_OK; - msg_ret = ll_ftp_send_uplink(f, len); - if (msg_ret != LL_FTP_OK) - { - ret = LL_FTP_ERROR; - } } else if(TICK == ftp_msg.msg_type) { struct time time_now; - ret = LL_FTP_OK; // Rely on a periodic 1 Hz tick to request segments if necessary gettime(&time_now); @@ -645,13 +619,8 @@ static int32_t ll_ftp_segment_process_msg(ll_ftp_t* f, uint8_t* buf, uint8_t len { if(f->retry_count < LL_FTP_MAX_NUM_RETRIES) { - uint16_t len = ll_ftp_ack_segs_request_generate(f); - msg_ret = ll_ftp_send_uplink(f, len); - if (msg_ret != LL_FTP_OK) - { - ret = LL_FTP_ERROR; - } - + uint8_t len = ll_ftp_ack_segs_request_generate(f); + ll_ftp_send_uplink(f, len); f->retry_count++; } else @@ -659,6 +628,7 @@ static int32_t ll_ftp_segment_process_msg(ll_ftp_t* f, uint8_t* buf, uint8_t len next_state = IDLE; } } + ret = LL_FTP_OK; } // Do state transitions out of SEGMENT @@ -716,7 +686,6 @@ static int32_t ll_ftp_transition_out_of_apply(ll_ftp_t* f, ll_ftp_msg_t* msg, ll static int32_t ll_ftp_apply_process_msg(ll_ftp_t* f, uint8_t* buf, uint8_t len) { ll_ftp_msg_t ftp_msg; - ll_ftp_return_code_t msg_ret; int32_t ret = ll_ftp_parse_rx_msg(buf, len, &ftp_msg); if(LL_FTP_OK != ret) @@ -749,31 +718,23 @@ static int32_t ll_ftp_apply_process_msg(ll_ftp_t* f, uint8_t* buf, uint8_t len) } else if ((TX_APPLY == ftp_msg.msg_type) && (IS_MY_FILE)) { - uint16_t len; int32_t cb_ret = f->cb.apply(f->file_id, f->file_version, f->file_size); if(LL_FTP_OK == cb_ret) { - len = ll_ftp_ack_apply_generate(f, true); + uint8_t len = ll_ftp_ack_apply_generate(f); + ll_ftp_send_uplink(f, len); + next_state = IDLE; } else { - // Apply rejected. Send NAK and forget file. - len = ll_ftp_ack_apply_generate(f, false); - ret = LL_FTP_ERROR; - } - - next_state = IDLE; - msg_ret = ll_ftp_send_uplink(f, len); - if (msg_ret != LL_FTP_OK) - { + // Apply rejected. Forget File. ret = LL_FTP_ERROR; + next_state = IDLE; } } else if(TICK == ftp_msg.msg_type) { struct time time_now; - - ret = LL_FTP_OK; // Rely on a periodic 1 Hz tick to request segments if necessary gettime(&time_now); @@ -781,13 +742,8 @@ static int32_t ll_ftp_apply_process_msg(ll_ftp_t* f, uint8_t* buf, uint8_t len) { if(f->retry_count < LL_FTP_MAX_NUM_RETRIES) { - uint16_t len = ll_ftp_ack_segs_complete_generate(f); - msg_ret = ll_ftp_send_uplink(f, len); - if (msg_ret != LL_FTP_OK) - { - ret = LL_FTP_ERROR; - } - + uint8_t len = ll_ftp_ack_segs_complete_generate(f); + ll_ftp_send_uplink(f, len); f->retry_count++; } else @@ -795,6 +751,7 @@ static int32_t ll_ftp_apply_process_msg(ll_ftp_t* f, uint8_t* buf, uint8_t len) next_state = IDLE; } } + ret = LL_FTP_OK; } // Do state transitions out of APPLY diff --git a/src/ll_ifc_no_mac.c b/src/ll_ifc_no_mac.c index d3ce57a..c90e098 100644 --- a/src/ll_ifc_no_mac.c +++ b/src/ll_ifc_no_mac.c @@ -30,7 +30,8 @@ int32_t ll_rssi_scan_set(uint32_t u1, uint32_t u2, uint32_t u3, uint32_t u4) buf[14] = (u4 >> 8) & 0xFF; buf[15] = (u4 ) & 0xFF; - return hal_read_write(OP_RSSI_SET, buf, 16, NULL, 0); + int32_t ret = hal_read_write(OP_RSSI_SET, buf, 16, NULL, 0); + return (ret >= 0) ? LL_IFC_ACK : ret; } int32_t ll_rssi_scan_get(uint8_t buf[], uint16_t len, uint8_t *bytes_received) @@ -47,22 +48,35 @@ int32_t ll_rssi_scan_get(uint8_t buf[], uint16_t len, uint8_t *bytes_received) if (rw_response < 0) { *bytes_received = 0; - return(-1); - } - else - { - *bytes_received = (uint8_t) (rw_response & 0xFF); - return(0); + return rw_response; } + + *bytes_received = (uint8_t) (rw_response & 0xFF); + return (rw_response >= 0) ? LL_IFC_ACK : rw_response; } int32_t ll_radio_params_get(uint8_t *sf, uint8_t *cr, uint8_t *bw, uint32_t *freq, uint16_t *preamble_syms, uint8_t *header_enabled, uint8_t *crc_enabled, uint8_t *iq_inverted) { + if((NULL == sf) || (NULL == cr) || (NULL == bw) || (NULL == freq) || + (NULL == preamble_syms) || (NULL == header_enabled) || (NULL == crc_enabled) || (NULL == iq_inverted)) + { + return LL_IFC_ERROR_INCORRECT_PARAMETER; + } + int32_t ret; uint8_t buff[8]; ret = hal_read_write(OP_GET_RADIO_PARAMS, NULL, 0, buff, 8); + if (ret < 0) + { + return ret; + } + if (ret != 8) + { + return LL_IFC_ERROR_INCORRECT_RESPONSE_LENGTH; + } + *sf = (buff[0] >> 4) + 6; *cr = ((buff[0] >> 2) & 0x03) + 1; @@ -79,7 +93,7 @@ int32_t ll_radio_params_get(uint8_t *sf, uint8_t *cr, uint8_t *bw, uint32_t *fre *freq |= (uint32_t)(buff[6] << 8); *freq |= (uint32_t)(buff[7] ); - return ret; + return LL_IFC_ACK; } int32_t ll_radio_params_set(uint8_t flags, uint8_t sf, uint8_t cr, uint8_t bw, uint32_t freq, @@ -179,7 +193,8 @@ int32_t ll_tx_power_get(int8_t *pwr) { return LL_IFC_ERROR_INCORRECT_PARAMETER; } - return hal_read_write(OP_TX_POWER_GET, NULL, 0, (uint8_t *)pwr, 1); + int32_t ret = hal_read_write(OP_TX_POWER_GET, NULL, 0, (uint8_t *)pwr, 1); + return (ret >= 0) ? LL_IFC_ACK : ret; } int32_t ll_frequency_set(uint32_t freq) @@ -218,7 +233,8 @@ int32_t ll_sync_word_get(uint8_t *sync_word) { return LL_IFC_ERROR_INCORRECT_PARAMETER; } - return hal_read_write(OP_SYNC_WORD_GET, NULL, 0, sync_word, 1); + int32_t ret = hal_read_write(OP_SYNC_WORD_GET, NULL, 0, sync_word, 1); + return (ret >= 0) ? LL_IFC_ACK : ret; } int32_t ll_echo_mode(void) @@ -322,7 +338,7 @@ int32_t ll_packet_recv(uint16_t num_timeout_symbols, uint8_t buf[], uint16_t len if (rw_response < 0) { *bytes_received = 0; - return(-1); + return rw_response; } else { @@ -358,7 +374,7 @@ int32_t ll_packet_recv_with_rssi(uint16_t num_timeout_symbols, uint8_t buf[], ui if (rw_response < 0) { *bytes_received = 0; - return(-1); + return rw_response; } else { diff --git a/src/ll_ifc_symphony.c b/src/ll_ifc_symphony.c index f6a58fc..b897e57 100644 --- a/src/ll_ifc_symphony.c +++ b/src/ll_ifc_symphony.c @@ -1,6 +1,7 @@ #include "ll_ifc_symphony.h" #include "ll_ifc_private.h" -#include // memmove +#include "ifc_struct_defs.h" +#include // memmove uint8_t _uplink_message_buff[256 + 2]; uint8_t *uplink_message_buff = _uplink_message_buff + 2; @@ -12,7 +13,7 @@ const llabs_dl_band_cfg_t DL_BAN_AUS = {918000000, 926000000, 386703, 3, 0}; // const llabs_dl_band_cfg_t DL_BAN_NZL = {921000000, 928000000, 386703, 3, 0}; // New Zealand const llabs_dl_band_cfg_t DL_BAN_ETSI = {869100000, 871000000, 386703, 1, 0}; // Europe -int32_t ll_net_token_get(uint32_t *p_net_token) +static int32_t ll_net_token_get(uint32_t *p_net_token) { uint8_t buff[4]; if (p_net_token == NULL) @@ -20,24 +21,35 @@ int32_t ll_net_token_get(uint32_t *p_net_token) return LL_IFC_ERROR_INCORRECT_PARAMETER; } int32_t ret = hal_read_write(OP_NET_TOKEN_GET, NULL, 0, buff, 4); + if (ret < 0) + { + return ret; + } + + if (4 != ret) + { + return LL_IFC_ERROR_INCORRECT_RESPONSE_LENGTH; + } + *p_net_token = 0; - *p_net_token |= (uint32_t)buff[0] << 24; - *p_net_token |= (uint32_t)buff[1] << 16; - *p_net_token |= (uint32_t)buff[2] << 8; - *p_net_token |= (uint32_t)buff[3]; - return ret; + *p_net_token |= (uint32_t) buff[0] << 24; + *p_net_token |= (uint32_t) buff[1] << 16; + *p_net_token |= (uint32_t) buff[2] << 8; + *p_net_token |= (uint32_t) buff[3]; + return LL_IFC_ACK; } -int32_t ll_net_token_set(uint32_t net_token) +static int32_t ll_net_token_set(uint32_t net_token) { - if(net_token != 0xFFFFFFFF) + if (net_token != 0xFFFFFFFF) { uint8_t buff[4]; buff[0] = (net_token >> 24) & 0xFF; buff[1] = (net_token >> 16) & 0xFF; buff[2] = (net_token >> 8) & 0xFF; - buff[3] = (net_token) & 0xFF; - return hal_read_write(OP_NET_TOKEN_SET, buff, 4, NULL, 0); + buff[3] = (net_token) &0xFF; + int32_t ret = hal_read_write(OP_NET_TOKEN_SET, buff, 4, NULL, 0); + return (ret >= 0) ? LL_IFC_ACK : ret; } else { @@ -51,11 +63,12 @@ static int32_t ll_app_token_set(const uint8_t *app_token, uint8_t len) { return LL_IFC_ERROR_INCORRECT_PARAMETER; } - if(10 != len) + if (10 != len) { return LL_IFC_ERROR_INCORRECT_PARAMETER; } - return hal_read_write(OP_APP_TOKEN_SET, (uint8_t*) app_token, 10, NULL, 0); + int32_t ret = hal_read_write(OP_APP_TOKEN_SET, (uint8_t *) app_token, 10, NULL, 0); + return (ret >= 0) ? LL_IFC_ACK : ret; } static int32_t ll_app_token_get(uint8_t *app_token) @@ -64,7 +77,18 @@ static int32_t ll_app_token_get(uint8_t *app_token) { return LL_IFC_ERROR_INCORRECT_PARAMETER; } - return hal_read_write(OP_APP_TOKEN_GET, NULL, 0, app_token, 10); + + int32_t ret = hal_read_write(OP_APP_TOKEN_GET, NULL, 0, app_token, 10); + if (ret < 0) + { + return ret; + } + if (10 != ret) + { + return LL_IFC_ERROR_INCORRECT_RESPONSE_LENGTH; + } + + return LL_IFC_ACK; } static int32_t ll_receive_mode_set(uint8_t rx_mode) @@ -73,7 +97,8 @@ static int32_t ll_receive_mode_set(uint8_t rx_mode) { return LL_IFC_ERROR_INCORRECT_PARAMETER; } - return hal_read_write(OP_RX_MODE_SET, &rx_mode, 1, NULL, 0); + int32_t ret = hal_read_write(OP_RX_MODE_SET, &rx_mode, 1, NULL, 0); + return (ret >= 0) ? LL_IFC_ACK : ret; } static int32_t ll_receive_mode_get(uint8_t *rx_mode) @@ -82,7 +107,8 @@ static int32_t ll_receive_mode_get(uint8_t *rx_mode) { return LL_IFC_ERROR_INCORRECT_PARAMETER; } - return hal_read_write(OP_RX_MODE_GET, NULL, 0, rx_mode, sizeof(*rx_mode)); + int32_t ret = hal_read_write(OP_RX_MODE_GET, NULL, 0, rx_mode, sizeof(*rx_mode)); + return (ret >= 0) ? LL_IFC_ACK : ret; } static int32_t ll_qos_request(uint8_t qos) @@ -91,7 +117,8 @@ static int32_t ll_qos_request(uint8_t qos) { return LL_IFC_ERROR_INCORRECT_PARAMETER; } - return hal_read_write(OP_QOS_REQUEST, &qos, 1, NULL, 0); + int32_t ret = hal_read_write(OP_QOS_REQUEST, &qos, 1, NULL, 0); + return (ret >= 0) ? LL_IFC_ACK : ret; } static int32_t ll_qos_get(uint8_t *qos) @@ -100,9 +127,67 @@ static int32_t ll_qos_get(uint8_t *qos) { return LL_IFC_ERROR_INCORRECT_PARAMETER; } - return hal_read_write(OP_QOS_GET, NULL, 0, qos, sizeof(*qos)); + int32_t ret = hal_read_write(OP_QOS_GET, NULL, 0, qos, sizeof(*qos)); + return (ret >= 0) ? LL_IFC_ACK : ret; +} + +static int32_t ll_scan_mode_set(enum ll_scan_mode scan_mode) +{ + uint8_t u8_scan_mode = (uint8_t) scan_mode; + int32_t ret = hal_read_write(OP_SCAN_MODE_SET, &u8_scan_mode, 1, NULL, 0); + return (ret >= 0) ? LL_IFC_ACK : ret; +} + +static int32_t ll_scan_mode_get(enum ll_scan_mode *scan_mode) +{ + uint8_t u8_scan_mode; + int32_t ret = hal_read_write(OP_SCAN_MODE_GET, NULL, 0, &u8_scan_mode, 1); + *scan_mode = u8_scan_mode; + return (ret >= 0) ? LL_IFC_ACK : ret; +} + +static int32_t ll_threshold_set(int16_t threshold) +{ + uint8_t buf[2]; + buf[0] = threshold & 0xff; + buf[1] = threshold >> 8; + + int32_t ret = hal_read_write(OP_SCAN_THRESHOLD_SET, buf, 2, NULL, 0); + return (ret >= 0) ? LL_IFC_ACK : ret; } +static int32_t ll_threshold_get(int16_t *threshold) +{ + uint8_t buf[2]; + int32_t ret = hal_read_write(OP_SCAN_THRESHOLD_GET, NULL, 0, buf, 2); + *threshold = ((uint16_t) buf[1] << 8) | buf[0]; + return (ret >= 0) ? LL_IFC_ACK : ret; +} + +static int32_t ll_scan_attempts_set(uint16_t scan_attempts) +{ + uint8_t buf[2]; + buf[0] = scan_attempts & 0xff; + buf[1] = scan_attempts >> 8; + int32_t ret = hal_read_write(OP_SCAN_ATTEMPTS_SET, buf, 2, NULL, 0); + return (ret >= 0) ? LL_IFC_ACK : ret; +} + +static int32_t ll_scan_attempts_get(uint16_t *scan_attempts) +{ + uint8_t buf[2]; + int32_t ret = hal_read_write(OP_SCAN_ATTEMPTS_GET, NULL, 0, buf, 2); + *scan_attempts = ((uint16_t) buf[1] << 8) | buf[0]; + return (ret >= 0) ? LL_IFC_ACK : ret; +} + +static int32_t ll_scan_attempts_left_get(uint16_t *scan_attempts) +{ + uint8_t buf[2]; + int32_t ret = hal_read_write(OP_SCAN_ATTEMPTS_LEFT, NULL, 0, buf, 2); + *scan_attempts = ((uint16_t) buf[1] << 8) | buf[0]; + return (ret >= 0) ? LL_IFC_ACK : ret; +} int32_t ll_config_set(uint32_t net_token, const uint8_t app_token[APP_TOKEN_LEN], enum ll_downlink_mode dl_mode, uint8_t qos) @@ -110,30 +195,30 @@ int32_t ll_config_set(uint32_t net_token, const uint8_t app_token[APP_TOKEN_LEN] int32_t ret; ret = ll_net_token_set(net_token); - if (LL_IFC_ACK > ret) + if (LL_IFC_ACK != ret) { return ret; } ret = ll_app_token_set(app_token, APP_TOKEN_LEN); - if (LL_IFC_ACK > ret) + if (LL_IFC_ACK != ret) { return ret; } ret = ll_receive_mode_set(dl_mode); - if (LL_IFC_ACK > ret) + if (LL_IFC_ACK != ret) { return ret; } ret = ll_qos_request(qos); - if (LL_IFC_ACK > ret) + if (LL_IFC_ACK != ret) { return ret; } - return ret; + return (ret >= 0) ? LL_IFC_ACK : ret; } int32_t ll_config_get(uint32_t *net_token, uint8_t app_token[APP_TOKEN_LEN], @@ -142,30 +227,193 @@ int32_t ll_config_get(uint32_t *net_token, uint8_t app_token[APP_TOKEN_LEN], int32_t ret; ret = ll_net_token_get(net_token); - if (LL_IFC_ACK > ret) + if (LL_IFC_ACK != ret) { return ret; } ret = ll_app_token_get(app_token); - if (LL_IFC_ACK > ret) + if (LL_IFC_ACK != ret) { return ret; } - ret = ll_receive_mode_get((uint8_t *)dl_mode); - if (LL_IFC_ACK > ret) + ret = ll_receive_mode_get((uint8_t *) dl_mode); + if (LL_IFC_ACK != ret) { return ret; } ret = ll_qos_get(qos); - if (LL_IFC_ACK > ret) + if (LL_IFC_ACK != ret) { return ret; } - return ret; + return (ret >= 0) ? LL_IFC_ACK : ret; +} + +int32_t ll_scan_config_set(enum ll_scan_mode scan_mode, int16_t threshold, uint16_t scan_attempts) +{ + if (scan_mode > LLABS_INFO_SCAN) + { + return LL_IFC_ERROR_INCORRECT_PARAMETER; + } + + int32_t ret = ll_scan_mode_set(scan_mode); + if (ret < LL_IFC_ACK) + { + return ret; + } + + ret = ll_threshold_set(threshold); + if (ret < LL_IFC_ACK) + { + return ret; + } + + ret = ll_scan_attempts_set(scan_attempts); + if (ret < LL_IFC_ACK) + { + return ret; + } + + return (ret >= 0) ? LL_IFC_ACK : ret; +} + +int32_t ll_scan_config_get(enum ll_scan_mode *scan_mode, int16_t *threshold, + uint16_t *scan_attempts, uint16_t *scans_left) +{ + int32_t ret = ll_scan_mode_get(scan_mode); + if (ret < LL_IFC_ACK) + { + return ret; + } + + ret = ll_threshold_get(threshold); + if (ret < LL_IFC_ACK) + { + return ret; + } + + ret = ll_scan_attempts_get(scan_attempts); + if (ret < LL_IFC_ACK) + { + return ret; + } + + ret = ll_scan_attempts_left_get(scans_left); + if (ret < LL_IFC_ACK) + { + return ret; + } + + return (ret >= 0) ? LL_IFC_ACK : ret; +} + +int32_t ll_connect_to_gw_channel(uint8_t channel) +{ + int32_t ret = hal_read_write(OP_CONN_TO_GW_CH, &channel, 1, NULL, 0); + return (ret >= 0) ? LL_IFC_ACK : ret; +} + +int32_t ll_control_messages_enabled_set(bool enable) +{ + int32_t ret = hal_read_write(OP_CTRL_MSG_ENABLED_SET, (uint8_t*)&enable, 1, NULL, 0); + return (ret >= 0) ? LL_IFC_ACK : ret; +} + +int32_t ll_control_messages_enabled_get(bool *enabled) +{ + int32_t ret = hal_read_write(OP_CTRL_MSG_ENABLED_GET, NULL, 0, (uint8_t*)enabled, 1); + return (ret >= 0) ? LL_IFC_ACK : ret; +} + +int32_t ll_cloud_gpio_activate_pin(uint8_t pin) +{ + int32_t ret = hal_read_write(OP_GPIO_ENABLE_PIN, (uint8_t*)&pin, 1, NULL, 0); + return (ret >= 0) ? LL_IFC_ACK : ret; +} + +int32_t ll_cloud_gpio_deactivate_pin(uint8_t pin) +{ + int32_t ret = hal_read_write(OP_GPIO_DISABLE_PIN, (uint8_t*)&pin, 1, NULL, 0); + return (ret >= 0) ? LL_IFC_ACK : ret; +} + +int32_t ll_cloud_gpio_get_pin_status(uint8_t pin, bool *active) +{ + int32_t ret = hal_read_write(OP_GPIO_PIN_STATUS, (uint8_t*)&pin, 1, NULL, 0); + return (ret >= 0) ? LL_IFC_ACK : ret; +} + +int32_t ll_cloud_gpio_set_pin_high(uint8_t pin) +{ + int32_t ret = hal_read_write(OP_GPIO_SET_HIGH, (uint8_t*)&pin, 1, NULL, 0); + return (ret >= 0) ? LL_IFC_ACK : ret; +} + +int32_t ll_cloud_gpio_set_pin_low(uint8_t pin) +{ + int32_t ret = hal_read_write(OP_GPIO_SET_LOW, (uint8_t*)&pin, 1, NULL, 0); + return (ret >= 0) ? LL_IFC_ACK : ret; +} + +int32_t ll_disconnect() +{ + int32_t ret = hal_read_write(OP_DISCONNECT, NULL, 0, NULL, 0); + return (ret >= 0) ? LL_IFC_ACK : ret; +} + +int32_t ll_poll_scan_result(llabs_gateway_scan_results_t *scan_result, uint8_t *num_gw) +{ + if (scan_result == NULL || num_gw == NULL) + { + return LL_IFC_ERROR_INCORRECT_PARAMETER; + } + + uint8_t buff[GW_SCAN_INFO_BUFF_SIZE]; + + int32_t ret = hal_read_write(OP_GET_SCAN_INFO, NULL, 0, buff, GW_SCAN_INFO_BUFF_SIZE); + if (ret < LL_IFC_ACK) + { + return ret; + } + + ll_gw_scan_result_deserialize(buff, scan_result, num_gw); + + return (ret >= 0) ? LL_IFC_ACK : ret; +} + +int32_t +ll_get_gateway_scan_results(llabs_gateway_scan_results_t (*scan_results)[MAX_GW_SCAN_RESULTS], + uint8_t *num_gw) +{ + uint8_t gw; + *num_gw = 0; + + do + { + llabs_gateway_scan_results_t scan_result; + + int32_t ret = ll_poll_scan_result(&scan_result, &gw); + if (ret != LL_IFC_ACK) + { + return ret; + } + + // When num_gw is uninitialized, we need to set it with the total + // amount of gateways + if (*num_gw == 0) + { + *num_gw = gw + 1; + } + + memcpy(&(*scan_results)[gw], &scan_result, sizeof(scan_result)); + + } while (gw > 0); + + return LL_IFC_ACK; } int32_t ll_get_state(enum ll_state *state, enum ll_tx_state *tx_state, enum ll_rx_state *rx_state) @@ -180,7 +428,7 @@ int32_t ll_get_state(enum ll_state *state, enum ll_tx_state *tx_state, enum ll_r { return ret; } - *state = (enum ll_state)(int8_t)u8_state; + *state = (enum ll_state)(int8_t) u8_state; } if (NULL != tx_state) @@ -191,7 +439,7 @@ int32_t ll_get_state(enum ll_state *state, enum ll_tx_state *tx_state, enum ll_r { return ret; } - *tx_state = (enum ll_tx_state)(int8_t)u8_tx_state; + *tx_state = (enum ll_tx_state)(int8_t) u8_tx_state; } if (NULL != rx_state) @@ -202,15 +450,16 @@ int32_t ll_get_state(enum ll_state *state, enum ll_tx_state *tx_state, enum ll_r { return ret; } - *rx_state = (enum ll_rx_state)(int8_t)u8_rx_state; + *rx_state = (enum ll_rx_state)(int8_t) u8_rx_state; } - return ret; + return (ret >= 0) ? LL_IFC_ACK : ret; } int32_t ll_mailbox_request(void) { - return hal_read_write(OP_MAILBOX_REQUEST, NULL, 0, NULL, 0); + int32_t ret = hal_read_write(OP_MAILBOX_REQUEST, NULL, 0, NULL, 0); + return (ret >= 0) ? LL_IFC_ACK : ret; } int32_t ll_app_reg_get(uint8_t *is_registered) @@ -219,12 +468,14 @@ int32_t ll_app_reg_get(uint8_t *is_registered) { return LL_IFC_ERROR_INCORRECT_PARAMETER; } - return hal_read_write(OP_APP_TOKEN_REG_GET, NULL, 0, is_registered, 1); + int32_t ret = hal_read_write(OP_APP_TOKEN_REG_GET, NULL, 0, is_registered, 1); + return (ret >= 0) ? LL_IFC_ACK : ret; } int32_t ll_encryption_key_exchange_request(void) { - return hal_read_write(OP_CRYPTO_KEY_XCHG_REQ, NULL, 0, NULL, 0); + int32_t ret = hal_read_write(OP_CRYPTO_KEY_XCHG_REQ, NULL, 0, NULL, 0); + return (ret >= 0) ? LL_IFC_ACK : ret; } int32_t ll_net_info_get(llabs_network_info_t *p_net_info) @@ -234,9 +485,19 @@ int32_t ll_net_info_get(llabs_network_info_t *p_net_info) { return LL_IFC_ERROR_INCORRECT_PARAMETER; } + int32_t ret = hal_read_write(OP_NET_INFO_GET, NULL, 0, buff, NET_INFO_BUFF_SIZE); + if (LL_IFC_ACK > ret) + { + return ret; + } + if (NET_INFO_BUFF_SIZE != ret) + { + return LL_IFC_ERROR_INCORRECT_RESPONSE_LENGTH; + } + ll_net_info_deserialize(buff, p_net_info); - return ret; + return LL_IFC_ACK; } int32_t ll_stats_get(llabs_stats_t *s) @@ -246,12 +507,23 @@ int32_t ll_stats_get(llabs_stats_t *s) { return LL_IFC_ERROR_INCORRECT_PARAMETER; } + int32_t ret = hal_read_write(OP_STATS_GET, NULL, 0, buff, STATS_SIZE); + if (LL_IFC_ACK > ret) + { + return ret; + } + if (STATS_SIZE != ret) + { + return LL_IFC_ERROR_INCORRECT_RESPONSE_LENGTH; + } + ll_stats_deserialize(buff, s); - return ret; + return LL_IFC_ACK; } -int32_t ll_retrieve_message(uint8_t *buf, uint16_t *size, uint8_t *port, int16_t *rssi, uint8_t *snr) +int32_t ll_retrieve_message(uint8_t *buf, uint16_t *size, uint8_t *port, int16_t *rssi, + uint8_t *snr) { int32_t rw_response; @@ -269,17 +541,22 @@ int32_t ll_retrieve_message(uint8_t *buf, uint16_t *size, uint8_t *port, int16_t } // Size is required + if ((rw_response & 0xff) <= 4) + { + *size = 0; + return LL_IFC_ERROR_INCORRECT_RESPONSE_LENGTH; + } *size = (uint8_t)(rw_response & 0xFF) - 4; // Optional RSSI - if(NULL != rssi) + if (NULL != rssi) { *rssi = 0; - *rssi = buf[0] + ((uint16_t)buf[1] << 8); + *rssi = buf[0] + ((uint16_t) buf[1] << 8); } // Optional RSSI - if(NULL != snr) + if (NULL != snr) { *snr = buf[2]; } @@ -289,10 +566,10 @@ int32_t ll_retrieve_message(uint8_t *buf, uint16_t *size, uint8_t *port, int16_t *port = buf[3]; } - //get rid of snr and rssi in buffer + // get rid of snr and rssi in buffer memmove(buf, buf + 4, *size); - return 0; + return LL_IFC_ACK; } int32_t ll_dl_band_cfg_get(llabs_dl_band_cfg_t *p) @@ -302,9 +579,19 @@ int32_t ll_dl_band_cfg_get(llabs_dl_band_cfg_t *p) { return LL_IFC_ERROR_INCORRECT_PARAMETER; } + int32_t ret = hal_read_write(OP_DL_BAND_CFG_GET, NULL, 0, buff, DL_BAND_CFG_SIZE); + if (LL_IFC_ACK > ret) + { + return ret; + } + if (DL_BAND_CFG_SIZE != ret) + { + return LL_IFC_ERROR_INCORRECT_RESPONSE_LENGTH; + } + ll_dl_band_cfg_deserialize(buff, p); - return ret; + return LL_IFC_ACK; } int32_t ll_dl_band_cfg_set(const llabs_dl_band_cfg_t *p) @@ -314,11 +601,32 @@ int32_t ll_dl_band_cfg_set(const llabs_dl_band_cfg_t *p) { return LL_IFC_ERROR_INCORRECT_PARAMETER; } + ll_dl_band_cfg_serialize(p, buff); - return hal_read_write(OP_DL_BAND_CFG_SET, buff, DL_BAND_CFG_SIZE, NULL, 0); + int32_t ret = hal_read_write(OP_DL_BAND_CFG_SET, buff, DL_BAND_CFG_SIZE, NULL, 0); + return (ret >= 0) ? LL_IFC_ACK : ret; } -int32_t ll_connection_filter_get(uint8_t* p_f) +int32_t ll_rssi_offset_get(int8_t *rssi_offset) +{ + uint8_t raw = 0; + int32_t ret = hal_read_write(OP_RSSI_OFFSET_GET, NULL, 0, &raw, 1); + *rssi_offset = (int8_t)raw; + return (ret >= 0) ? LL_IFC_ACK : ret; +} + +int32_t ll_rssi_offset_set(int8_t rssi_offset) +{ + if (rssi_offset > 15 || rssi_offset < -15) + { + return LL_IFC_ERROR_INCORRECT_PARAMETER; + } + + int32_t ret = hal_read_write(OP_RSSI_OFFSET_SET, (uint8_t*)&rssi_offset, 1, NULL, 0); + return (ret >= 0) ? LL_IFC_ACK : ret; +} + +int32_t ll_connection_filter_get(uint8_t *p_f) { if (NULL == p_f) { @@ -326,13 +634,23 @@ int32_t ll_connection_filter_get(uint8_t* p_f) } uint8_t f; int32_t ret = hal_read_write(OP_CONN_FILT_GET, NULL, 0, &f, 1); + if (LL_IFC_ACK > ret) + { + return ret; + } + if (sizeof(f) != ret) + { + return LL_IFC_ERROR_INCORRECT_RESPONSE_LENGTH; + } + *p_f = f; - return ret; + return (ret >= 0) ? LL_IFC_ACK : ret; } int32_t ll_connection_filter_set(uint8_t f) { - return hal_read_write(OP_CONN_FILT_SET, &f, 1, NULL, 0); + int32_t ret = hal_read_write(OP_CONN_FILT_SET, &f, 1, NULL, 0); + return (ret >= 0) ? LL_IFC_ACK : ret; } int32_t ll_system_time_get(llabs_time_info_t *time_info) @@ -342,9 +660,18 @@ int32_t ll_system_time_get(llabs_time_info_t *time_info) { return LL_IFC_ERROR_INCORRECT_PARAMETER; } - int32_t ret = hal_read_write(OP_SYSTEM_TIME_GET, NULL, 0, buff, TIME_INFO_SIZE); + int32_t ret = hal_read_write(OP_SYSTEM_TIME_GET, NULL, 0, buff, STATS_SIZE); + if (LL_IFC_ACK > ret) + { + return ret; + } + if (TIME_INFO_SIZE != ret) + { + return LL_IFC_ERROR_INCORRECT_RESPONSE_LENGTH; + } + ll_time_deserialize(buff, time_info); - return ret; + return LL_IFC_ACK; } int32_t ll_system_time_sync(uint8_t sync_mode) @@ -353,7 +680,8 @@ int32_t ll_system_time_sync(uint8_t sync_mode) { return LL_IFC_ERROR_INCORRECT_PARAMETER; } - return hal_read_write(OP_SYSTEM_TIME_SYNC, &sync_mode, sizeof(sync_mode), NULL, 0); + int32_t ret = hal_read_write(OP_SYSTEM_TIME_SYNC, &sync_mode, sizeof(sync_mode), NULL, 0); + return (ret >= 0) ? LL_IFC_ACK : ret; } int32_t ll_message_send(uint8_t buf[], uint16_t len, bool ack, uint8_t port) @@ -369,8 +697,8 @@ int32_t ll_message_send(uint8_t buf[], uint16_t len, bool ack, uint8_t port) } memmove(uplink_message_buff, buf, len); - _uplink_message_buff[0] = (uint8_t)ack; + _uplink_message_buff[0] = (uint8_t) ack; _uplink_message_buff[1] = port; - return hal_read_write(OP_MSG_SEND, _uplink_message_buff, len + 2, NULL, 0); + int32_t ret = hal_read_write(OP_MSG_SEND, _uplink_message_buff, len + 2, NULL, 0); + return (ret >= 0) ? LL_IFC_ACK : ret; } - diff --git a/test_ftp/utils_ftp.c b/test_ftp/utils_ftp.c index 925f273..3536c13 100644 --- a/test_ftp/utils_ftp.c +++ b/test_ftp/utils_ftp.c @@ -5,7 +5,7 @@ #include #include // memset, memcpy #include "ll_ifc_symphony.h" - +#include #include #include diff --git a/test_ifc_lib/Makefile b/test_ifc_lib/Makefile index f25c2cf..f3dae25 100644 --- a/test_ifc_lib/Makefile +++ b/test_ifc_lib/Makefile @@ -91,9 +91,11 @@ $(MODULE_DIR)/embc/src/fifo.c \ ../src/ll_ifc_no_mac.c \ ../src/ll_ifc_symphony.c \ ../src/ll_ifc.c \ -../test/test_ifc_lib.c \ -../test/utils_ifc_lib.c \ -../test/main.c +test_ifc_lib_gen.c \ +test_ifc_lib_symphony.c \ +test_ifc_lib_nomac.c \ +utils_ifc_lib.c \ +main.c s_SRC += diff --git a/test_ifc_lib/main.c b/test_ifc_lib/main.c index 35748f9..f2a1779 100644 --- a/test_ifc_lib/main.c +++ b/test_ifc_lib/main.c @@ -1,4 +1,6 @@ -#include "test_ifc_lib.h" +#include "test_ifc_lib_gen.h" +#include "test_ifc_lib_symphony.h" +#include "test_ifc_lib_nomac.h" #include #include @@ -12,6 +14,8 @@ int main(int argc, char* argv[]) { UnitTest tests[] = { GEN_IFC_LIB_TESTS + SYMPHONY_IFC_LIB_TESTS + NOMAC_IFC_LIB_TESTS }; return run_tests(tests); diff --git a/test_ifc_lib/test_ifc_lib_gen.c b/test_ifc_lib/test_ifc_lib_gen.c new file mode 100644 index 0000000..a2fde21 --- /dev/null +++ b/test_ifc_lib/test_ifc_lib_gen.c @@ -0,0 +1,408 @@ +#include "ll_ifc.h" +#include "utils_ifc_lib.h" + +#include +#include +#include +#include "cmockery.h" + +void setUp(void **state) +{ + (void) state; + ifc_utils_setup(); + ll_reset_state(); +} + +void tearDown(void **state) +{ + (void) state; + ifc_utils_teardown(); +} + +void test_myself_transport_write(void **state) +{ + (void) state; + uint8_t cmd_payload[] = {1, 2, 3, 4}; + uint8_t cmd[] = {0xff, 0xff, 0xff, 0xff, 0xc4, 1, 0, 0, 4, 1, 2, 3, 4, 0, 0}; + uint8_t rsp_payload[] = {5, 6, 7, 8}; + uint8_t rsp[TRANSPORT_LEN_MAX]; + + uint16_t crc = compute_checksum(cmd + 4, sizeof(cmd) - 6); + cmd[sizeof(cmd) - 2] = (crc >> 8) & 0xff; + cmd[sizeof(cmd) - 1] = (crc >> 0) & 0xff; + + transport_expect(1, cmd_payload, sizeof(cmd_payload), 0, rsp_payload, sizeof(rsp_payload)); + assert_int_equal(0, transport_write(cmd, sizeof(cmd))); + assert_int_equal(0, transport_read(rsp, sizeof(rsp_payload) + 8)); + assert_memory_equal(rsp_payload, rsp + 6, sizeof(rsp_payload)); +} + +void test_timestamp_get(void **state) +{ + (void) state; + uint8_t cmd[] = {0x00, 0x00, 0x00, 0x00, 0x00}; + uint8_t rsp[] = {0x11, 0x22, 0x33, 0x44}; + + transport_expect(OP_TIMESTAMP, cmd, sizeof(cmd), 0, rsp, sizeof(rsp)); + + uint32_t actual_timestamp_us = 0; + assert_int_equal(0, ll_timestamp_get(&actual_timestamp_us)); + assert_int_equal(0x11223344, actual_timestamp_us); +} + +void test_timestamp_get_with_response_error(void **state) +{ + (void) state; + uint8_t cmd[] = {0x00, 0x00, 0x00, 0x00, 0x00}; + uint8_t rsp[] = {0x11, 0x22, 0x33}; // too short + + transport_expect(OP_TIMESTAMP, cmd, sizeof(cmd), 0, rsp, sizeof(rsp)); + + uint32_t actual_timestamp_us = 0; + assert_int_equal(LL_IFC_ERROR_INCORRECT_RESPONSE_LENGTH, ll_timestamp_get(&actual_timestamp_us)); +} + +void test_timestamp_get_twice_to_check_message_identifier(void **state) +{ + (void) state; + uint8_t cmd[] = {0x00, 0x00, 0x00, 0x00, 0x00}; + uint8_t rsp[] = {0x11, 0x22, 0x33, 0x44}; + + transport_expect(OP_TIMESTAMP, cmd, sizeof(cmd), 0, rsp, sizeof(rsp)); + transport_expect(OP_TIMESTAMP, cmd, sizeof(cmd), 0, rsp, sizeof(rsp)); + + uint32_t actual_timestamp_us = 0; + assert_int_equal(0, ll_timestamp_get(&actual_timestamp_us)); + assert_int_equal(0x11223344, actual_timestamp_us); + + assert_int_equal(0, ll_timestamp_get(&actual_timestamp_us)); + assert_int_equal(0x11223344, actual_timestamp_us); +} + +void test_timestamp_set(void **state) +{ + (void) state; + uint8_t cmd[] = {0x01, 0x10, 0x20, 0x30, 0x40}; + uint8_t rsp[] = {0x11, 0x22, 0x33, 0x44}; + + transport_expect(OP_TIMESTAMP, cmd, sizeof(cmd), 0, rsp, sizeof(rsp)); + + uint32_t actual_timestamp_us = 0; + assert_int_equal(0, ll_timestamp_set(1, 0x10203040, &actual_timestamp_us)); + assert_int_equal(0x11223344, actual_timestamp_us); +} + +void test_timestamp_set_with_nack(void **state) +{ + (void) state; + uint8_t cmd[] = {0x01, 0x10, 0x20, 0x30, 0x40}; + + transport_expect(OP_TIMESTAMP, cmd, sizeof(cmd), LL_IFC_NACK_BUSY_TRY_AGAIN, 0, 0); + + uint32_t actual_timestamp_us = 0; + assert_int_equal(-LL_IFC_NACK_BUSY_TRY_AGAIN, ll_timestamp_set(1, 0x10203040, &actual_timestamp_us)); +} + +void test_nack_with_payload(void **state) +{ + (void) state; + uint8_t cmd[] = {0x01, 0x10, 0x20, 0x30, 0x40}; + uint8_t rsp[] = {1}; + + transport_expect(OP_TIMESTAMP, cmd, sizeof(cmd), LL_IFC_NACK_BUSY_TRY_AGAIN, rsp, sizeof(rsp)); + + uint32_t actual_timestamp_us = 0; + // todo : indicating a CRC error does not seem correct here + assert_int_equal(-104, ll_timestamp_set(1, 0x10203040, &actual_timestamp_us)); +} + +void test_timestamp_set_with_invalid_operation(void **state) +{ + (void) state; + //TODO: not sure what this is supposed to be testing +// uint32_t actual_timestamp_us = 0; +// printf("negative\n"); +// assert_int_equal(LL_IFC_ERROR_INCORRECT_PARAMETER, +// ll_timestamp_set((ll_timestamp_operation_t) -1, +// 0x10203040, &actual_timestamp_us)); +// printf("too big\n"); +// assert_int_equal(LL_IFC_ERROR_INCORRECT_PARAMETER, +// ll_timestamp_set((ll_timestamp_operation_t) LL_TIMESTAMP_SYNC + 1, +// 0x10203040, &actual_timestamp_us)); +} + +void test_packet_send_timestamp(void **state) +{ + (void) state; + uint8_t cmd1[] = {0x10, 0x20, 0x30, 0x40}; + + uint8_t cmd2[] = {1, 2, 3, 4, 5, 6, 7, 8}; + uint8_t rsp2[] = {0}; + + transport_expect(OP_SEND_TIMESTAMP, cmd1, sizeof(cmd1), 0, 0, 0); + transport_expect(OP_PKT_SEND_QUEUE, cmd2, sizeof(cmd2), 0, rsp2, sizeof(rsp2)); + assert_int_equal(0, ll_packet_send_timestamp(0x10203040, cmd2, sizeof(cmd2))); +} + +void test_fw_type_get_null_input(void **state) +{ + (void) state; + assert_int_equal(LL_IFC_ERROR_INCORRECT_PARAMETER, ll_firmware_type_get(NULL)); +} + +void test_fw_type_get_return_oor(void **state) +{ + (void) state; + uint8_t rsp[] = {0x11, 0x22}; // too short + + transport_expect(OP_FIRMWARE_TYPE, 0, 0, 0, rsp, sizeof(rsp)); + + ll_firmware_type_t t; + assert_int_equal(LL_IFC_ERROR_INCORRECT_RESPONSE_LENGTH, ll_firmware_type_get(&t)); +} + +void test_fw_type_get_return_ok(void **state) +{ + (void) state; + uint8_t rsp[] = {0x11, 0x22, 0x33, 0x44}; + + transport_expect(OP_FIRMWARE_TYPE, 0, 0, 0, rsp, sizeof(rsp)); + + ll_firmware_type_t t; + assert_int_equal(LL_IFC_ACK, ll_firmware_type_get(&t)); + assert_int_equal(0x1122, t.cpu_code); + assert_int_equal(0x3344, t.functionality_code); +} + +void test_hw_type_get_null_input(void **state) +{ + (void) state; + assert_int_equal(LL_IFC_ERROR_INCORRECT_PARAMETER, ll_hardware_type_get(NULL)); +} + +void test_hw_type_get_return_oor(void **state) +{ + (void) state; + uint8_t rsp[] = {0x11, 0x22}; // too short + + transport_expect(OP_HARDWARE_TYPE, 0, 0, 0, rsp, sizeof(rsp)); + + ll_hardware_type_t t; + assert_int_equal(LL_IFC_ERROR_BUFFER_TOO_SMALL, ll_hardware_type_get(&t)); +} + +void test_hw_type_get_return_ok(void **state) +{ + (void) state; + uint8_t rsp[] = {0x11}; + + transport_expect(OP_HARDWARE_TYPE, 0, 0, 0, rsp, sizeof(rsp)); + + ll_hardware_type_t t; + assert_int_equal(LL_IFC_ACK, ll_hardware_type_get(&t)); + assert_int_equal(rsp[0], t); +} + +void test_ifc_version_get_null_input(void **state) +{ + (void) state; + assert_int_equal(LL_IFC_ERROR_INCORRECT_PARAMETER, ll_interface_version_get(NULL)); +} + +void test_ifc_version_get_return_oor(void **state) +{ + (void) state; + uint8_t rsp[] = {0x11, 0x22}; // too short + + transport_expect(OP_IFC_VERSION, 0, 0, 0, rsp, sizeof(rsp)); + + ll_version_t v; + assert_int_equal(LL_IFC_ERROR_INCORRECT_RESPONSE_LENGTH, ll_interface_version_get(&v)); +} + +void test_ifc_version_get_return_ok(void **state) +{ + (void) state; + uint8_t rsp[] = {0x11, 0x22, 0x33, 0x44}; + + transport_expect(OP_IFC_VERSION, 0, 0, 0, rsp, sizeof(rsp)); + + ll_version_t v; + assert_int_equal(LL_IFC_ACK, ll_interface_version_get(&v)); + assert_int_equal(0x11, v.major); + assert_int_equal(0x22, v.minor); + assert_int_equal(0x3344, v.tag); +} + +void test_version_get_null_input(void **state) +{ + (void) state; + assert_int_equal(LL_IFC_ERROR_INCORRECT_PARAMETER, ll_version_get(NULL)); +} + +void test_version_get_return_oor(void **state) +{ + (void) state; + uint8_t rsp[] = {0x11, 0x22}; // too short + + transport_expect(OP_VERSION, 0, 0, 0, rsp, sizeof(rsp)); + + ll_version_t v; + assert_int_equal(LL_IFC_ERROR_INCORRECT_RESPONSE_LENGTH, ll_version_get(&v)); +} + +void test_version_get_return_ok(void **state) +{ + (void) state; + uint8_t rsp[] = {0x11, 0x22, 0x33, 0x44}; + + transport_expect(OP_VERSION, 0, 0, 0, rsp, sizeof(rsp)); + + ll_version_t v; + assert_int_equal(LL_IFC_ACK, ll_version_get(&v)); + assert_int_equal(0x11, v.major); + assert_int_equal(0x22, v.minor); + assert_int_equal(0x3344, v.tag); +} + +void test_sleep_block_ok(void **state) +{ + (void)state; + uint8_t cmd[] = {'1'}; + + transport_expect(OP_SLEEP_BLOCK, cmd, sizeof(cmd), 0, 0, 0); + assert_int_equal(LL_IFC_ACK, ll_sleep_block()); +} + +void test_sleep_unblock_ok(void **state) +{ + (void)state; + uint8_t cmd[] = {'0'}; + + transport_expect(OP_SLEEP_BLOCK, cmd, sizeof(cmd), 0, 0, 0); + assert_int_equal(LL_IFC_ACK, ll_sleep_unblock()); +} + +void test_mac_mode_set_invalid_mode(void **state) +{ + (void) state; + assert_int_equal(LL_IFC_ERROR_INCORRECT_PARAMETER, ll_mac_mode_set(NUM_MACS)); +} + +void test_mac_mode_set_ok(void **state) +{ + (void) state; + uint8_t cmd[] = {0x03}; + + transport_expect(OP_MAC_MODE_SET, cmd, sizeof(cmd), 0, 0, 0); + assert_int_equal(LL_IFC_ACK, ll_mac_mode_set(SYMPHONY_LINK)); +} + +void test_mac_mode_get_null_input(void **state) +{ + (void) state; + assert_int_equal(LL_IFC_ERROR_INCORRECT_PARAMETER, ll_mac_mode_get(NULL)); +} + +void test_mac_mode_get_ok(void **state) +{ + (void) state; + uint8_t rsp[] = {0x03}; + ll_mac_type_t t = LORA_NO_MAC; + + transport_expect(OP_MAC_MODE_GET, 0, 0, 0, rsp, sizeof(rsp)); + assert_int_equal(LL_IFC_ACK, ll_mac_mode_get(&t)); + + assert_int_equal(SYMPHONY_LINK, t); +} + +void test_antenna_set_invalid_input(void **state) +{ + (void) state; + assert_int_equal(LL_IFC_ERROR_INCORRECT_PARAMETER, ll_antenna_set(0)); +} + +void test_antenna_set_ok(void **state) +{ + (void) state; + uint8_t cmd[] = {0x02}; + + transport_expect(OP_ANTENNA_SET, cmd, sizeof(cmd), 0, 0, 0); + assert_int_equal(LL_IFC_ACK, ll_antenna_set(2)); +} + +void test_antenna_get_invalid_input(void **state) +{ + (void) state; + assert_int_equal(LL_IFC_ERROR_INCORRECT_PARAMETER, ll_antenna_get(NULL)); +} + +void test_antenna_get_ok(void **state) +{ + (void) state; + uint8_t rsp[] = {0x02}; + uint8_t ant = 0; + + transport_expect(OP_ANTENNA_GET, 0, 0, 0, rsp, sizeof(rsp)); + assert_int_equal(LL_IFC_ACK, ll_antenna_get(&ant)); + assert_int_equal(2, ant); +} + +void test_unique_id_get_invalid_input(void **state) +{ + (void) state; + assert_int_equal(LL_IFC_ERROR_INCORRECT_PARAMETER, ll_unique_id_get(NULL)); +} + +void test_unique_id_get_oor(void **state) +{ + (void) state; + uint8_t rsp[] = {0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77}; + uint64_t uid = 0; + + transport_expect(OP_MODULE_ID, 0, 0, 0, rsp, sizeof(rsp)); + assert_int_equal(LL_IFC_ERROR_INCORRECT_RESPONSE_LENGTH, ll_unique_id_get(&uid)); +} + +void test_unique_id_get_ok(void **state) +{ + (void) state; + uint8_t rsp[] = {0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88}; + uint64_t uid = 0; + + transport_expect(OP_MODULE_ID, 0, 0, 0, rsp, sizeof(rsp)); + assert_int_equal(LL_IFC_ACK, ll_unique_id_get(&uid)); + assert_int_equal(0x1122334455667788, uid); +} + +void test_irq_flags_invalid_input(void **state) +{ + (void) state; + assert_int_equal(LL_IFC_ERROR_INCORRECT_PARAMETER, ll_irq_flags(0, NULL)); +} + +void test_irq_flags_oor(void **state) +{ + (void) state; + uint8_t cmd[] = {0xa5, 0x00, 0x00, 0x5a}; + uint8_t rsp[] = {0x11, 0x22, 0x33}; + uint32_t flags = 0; + + transport_expect(OP_IRQ_FLAGS, cmd, sizeof(cmd), 0, rsp, sizeof(rsp)); + assert_int_equal(LL_IFC_ERROR_INCORRECT_RESPONSE_LENGTH, ll_irq_flags(0xa500005a, &flags)); + assert_int_equal(0, flags); +} + +void test_irq_flags_ok(void **state) +{ + (void) state; + uint8_t cmd[] = {0xa5, 0x00, 0x00, 0x5a}; + uint8_t rsp[] = {0x11, 0x22, 0x33, 0x44}; + uint32_t flags = 0; + + transport_expect(OP_IRQ_FLAGS, cmd, sizeof(cmd), 0, rsp, sizeof(rsp)); + assert_int_equal(LL_IFC_ACK, ll_irq_flags(0xa500005a, &flags)); + assert_int_equal(0x11223344, flags); +} + + diff --git a/test_ifc_lib/test_ifc_lib_gen.h b/test_ifc_lib/test_ifc_lib_gen.h new file mode 100644 index 0000000..a358944 --- /dev/null +++ b/test_ifc_lib/test_ifc_lib_gen.h @@ -0,0 +1,83 @@ + +void setUp(void **state); +void tearDown(void **state); + +void test_myself_transport_write(void **state); +void test_timestamp_get(void **state); +void test_timestamp_get_with_response_error(void **state); +void test_timestamp_get_twice_to_check_message_identifier(void **state); +void test_timestamp_set(void **state); +void test_timestamp_set_with_nack(void **state); +void test_nack_with_payload(void **state); +void test_timestamp_set_with_invalid_operation(void **state); +void test_packet_send_timestamp(void **state); +void test_fw_type_get_null_input(void **state); +void test_fw_type_get_return_oor(void **state); +void test_fw_type_get_return_ok(void **state); +void test_hw_type_get_null_input(void **state); +void test_hw_type_get_return_oor(void **state); +void test_hw_type_get_return_ok(void **state); +void test_ifc_version_get_null_input(void **state); +void test_ifc_version_get_return_oor(void **state); +void test_ifc_version_get_return_ok(void **state); +void test_version_get_null_input(void **state); +void test_version_get_return_oor(void **state); +void test_version_get_return_ok(void **state); +void test_sleep_block_ok(void **state); +void test_sleep_unblock_ok(void **state); +void test_mac_mode_set_invalid_mode(void **state); +void test_mac_mode_set_ok(void **state); +void test_mac_mode_get_null_input(void **state); +void test_mac_mode_get_ok(void **state); +void test_antenna_set_invalid_input(void **state); +void test_antenna_set_ok(void **state); +void test_antenna_get_invalid_input(void **state); +void test_antenna_get_ok(void **state); +void test_unique_id_get_invalid_input(void **state); +void test_unique_id_get_oor(void **state); +void test_unique_id_get_ok(void **state); +void test_irq_flags_invalid_input(void **state); +void test_irq_flags_oor(void **state); +void test_irq_flags_ok(void **state); + + +#define GEN_IFC_LIB_TESTS \ + unit_test_setup_teardown(test_myself_transport_write, setUp, tearDown), \ + unit_test_setup_teardown(test_timestamp_get, setUp, tearDown), \ + unit_test_setup_teardown(test_timestamp_get_with_response_error, setUp, tearDown), \ + unit_test_setup_teardown(test_timestamp_get_twice_to_check_message_identifier, setUp, tearDown), \ + unit_test_setup_teardown(test_timestamp_set, setUp, tearDown), \ + unit_test_setup_teardown(test_timestamp_set_with_nack, setUp, tearDown), \ + unit_test_setup_teardown(test_nack_with_payload, setUp, tearDown), \ + unit_test_setup_teardown(test_timestamp_set_with_invalid_operation, setUp, tearDown), \ + unit_test_setup_teardown(test_packet_send_timestamp, setUp, tearDown), \ + unit_test_setup_teardown(test_fw_type_get_null_input, setUp, tearDown), \ + unit_test_setup_teardown(test_fw_type_get_return_oor, setUp, tearDown), \ + unit_test_setup_teardown(test_fw_type_get_return_ok, setUp, tearDown), \ + unit_test_setup_teardown(test_hw_type_get_null_input, setUp, tearDown), \ + unit_test_setup_teardown(test_hw_type_get_return_oor, setUp, tearDown), \ + unit_test_setup_teardown(test_hw_type_get_return_ok, setUp, tearDown), \ + unit_test_setup_teardown(test_ifc_version_get_null_input, setUp, tearDown), \ + unit_test_setup_teardown(test_ifc_version_get_return_oor, setUp, tearDown), \ + unit_test_setup_teardown(test_ifc_version_get_return_ok, setUp, tearDown), \ + unit_test_setup_teardown(test_version_get_null_input, setUp, tearDown), \ + unit_test_setup_teardown(test_version_get_return_oor, setUp, tearDown), \ + unit_test_setup_teardown(test_version_get_return_ok, setUp, tearDown), \ + unit_test_setup_teardown(test_sleep_block_ok, setUp, tearDown), \ + unit_test_setup_teardown(test_sleep_unblock_ok, setUp, tearDown), \ + unit_test_setup_teardown(test_mac_mode_set_invalid_mode, setUp, tearDown), \ + unit_test_setup_teardown(test_mac_mode_set_ok, setUp, tearDown), \ + unit_test_setup_teardown(test_mac_mode_get_null_input, setUp, tearDown), \ + unit_test_setup_teardown(test_mac_mode_get_ok, setUp, tearDown), \ + unit_test_setup_teardown(test_antenna_set_invalid_input, setUp, tearDown), \ + unit_test_setup_teardown(test_antenna_set_ok, setUp, tearDown), \ + unit_test_setup_teardown(test_antenna_get_invalid_input, setUp, tearDown), \ + unit_test_setup_teardown(test_antenna_get_ok, setUp, tearDown), \ + unit_test_setup_teardown(test_unique_id_get_invalid_input, setUp, tearDown), \ + unit_test_setup_teardown(test_unique_id_get_oor, setUp, tearDown), \ + unit_test_setup_teardown(test_unique_id_get_ok, setUp, tearDown), \ + unit_test_setup_teardown(test_irq_flags_invalid_input, setUp, tearDown), \ + unit_test_setup_teardown(test_irq_flags_oor, setUp, tearDown), \ + unit_test_setup_teardown(test_irq_flags_ok, setUp, tearDown), \ + + diff --git a/test_ifc_lib/test_ifc_lib_nomac.c b/test_ifc_lib/test_ifc_lib_nomac.c new file mode 100644 index 0000000..c835742 --- /dev/null +++ b/test_ifc_lib/test_ifc_lib_nomac.c @@ -0,0 +1,323 @@ +#include "ll_ifc_no_mac.h" +#include "ll_ifc.h" +#include "utils_ifc_lib.h" + +#include +#include +#include +#include "cmockery.h" + +void test_rssi_scan_set_ok(void **state) +{ + (void) state; + uint8_t cmd[16] = {0}; + transport_expect(OP_RSSI_SET, cmd, sizeof(cmd), 0, 0, 0); + assert_int_equal(LL_IFC_ACK, ll_rssi_scan_set(0, 0, 0, 0)); +} + +void test_rssi_scan_get_invalid(void **state) +{ + (void) state; + assert_int_equal(LL_IFC_ERROR_INCORRECT_PARAMETER, ll_rssi_scan_get(NULL, 1, 1)); + assert_int_equal(LL_IFC_ERROR_INCORRECT_PARAMETER, ll_rssi_scan_get(1, 0, 1)); + assert_int_equal(LL_IFC_ERROR_INCORRECT_PARAMETER, ll_rssi_scan_get(1, 1, NULL)); +} + +void test_rssi_scan_get_short_length(void **state) +{ + (void) state; + uint8_t buf[255] = {0}; + uint8_t bytes_received = 0xff; + + uint8_t rsp[16] = {0}; + transport_expect(OP_RSSI_GET, 0, 0, 0, rsp, sizeof(rsp)); + + assert_int_equal(LL_IFC_ERROR_BUFFER_TOO_SMALL, ll_rssi_scan_get(buf, 1, &bytes_received)); + assert_int_equal(0, bytes_received); +} + +void test_rssi_scan_get_ok(void **state) +{ + (void) state; + uint8_t buf[255] = {0}; + uint8_t bytes_received = 0xff; + + uint8_t rsp[16] = {0}; + transport_expect(OP_RSSI_GET, 0, 0, 0, rsp, sizeof(rsp)); + assert_int_equal(LL_IFC_ACK, ll_rssi_scan_get(buf, 255, &bytes_received)); + assert_int_equal(16, bytes_received); +} + +void test_radio_params_get_invalid(void **state) +{ + (void) state; + assert_int_equal(LL_IFC_ERROR_INCORRECT_PARAMETER, ll_radio_params_get(NULL, 1, 1, 1, 1, 1, 1, 1)); + assert_int_equal(LL_IFC_ERROR_INCORRECT_PARAMETER, ll_radio_params_get(1, NULL, 1, 1, 1, 1, 1, 1)); + assert_int_equal(LL_IFC_ERROR_INCORRECT_PARAMETER, ll_radio_params_get(1, 1, NULL, 1, 1, 1, 1, 1)); + assert_int_equal(LL_IFC_ERROR_INCORRECT_PARAMETER, ll_radio_params_get(1, 1, 1, NULL, 1, 1, 1, 1)); + assert_int_equal(LL_IFC_ERROR_INCORRECT_PARAMETER, ll_radio_params_get(1, 1, 1, 1, NULL, 1, 1, 1)); + assert_int_equal(LL_IFC_ERROR_INCORRECT_PARAMETER, ll_radio_params_get(1, 1, 1, 1, 1, NULL, 1, 1)); + assert_int_equal(LL_IFC_ERROR_INCORRECT_PARAMETER, ll_radio_params_get(1, 1, 1, 1, 1, 1, NULL, 1)); + assert_int_equal(LL_IFC_ERROR_INCORRECT_PARAMETER, ll_radio_params_get(1, 1, 1, 1, 1, 1, 1, NULL)); +} + +void test_radio_params_get_incorrect_length(void **state) +{ + (void) state; + uint8_t sf, cr, bw, header_enabled, crc_enabled, iq_inverted; + uint32_t freq; + uint16_t preamble_syms; + + uint8_t rsp[7] = {0}; + transport_expect(OP_GET_RADIO_PARAMS, 0, 0, 0, rsp, sizeof(rsp)); + + assert_int_equal(LL_IFC_ERROR_INCORRECT_RESPONSE_LENGTH, ll_radio_params_get(&sf, &cr, &bw, &freq, &preamble_syms, + &header_enabled, &crc_enabled, &iq_inverted)); +} + +void test_radio_params_get_ok(void **state) +{ + (void) state; + uint8_t sf, cr, bw, header_enabled, crc_enabled, iq_inverted; + uint32_t freq; + uint16_t preamble_syms; + + uint8_t rsp[] = {0x37, 0x03, 0x12, 0x34, 0x36, 0x89, 0xca, 0xc0}; + transport_expect(OP_GET_RADIO_PARAMS, 0, 0, 0, rsp, sizeof(rsp)); + + assert_int_equal(LL_IFC_ACK, ll_radio_params_get(&sf, &cr, &bw, &freq, &preamble_syms, + &header_enabled, &crc_enabled, &iq_inverted)); + assert_int_equal(9, sf); + assert_int_equal(2, cr); + assert_int_equal(3, bw); + assert_int_equal(1, header_enabled); + assert_int_equal(1, crc_enabled != 0); + assert_int_equal(0, iq_inverted); + assert_int_equal(915000000, freq); + assert_int_equal(0x1234, preamble_syms); +} + +void test_radio_params_set_invalid(void **state) +{ + (void) state; + assert_int_equal(LL_IFC_ERROR_INCORRECT_PARAMETER, ll_radio_params_set(RADIO_PARAM_FLAGS_SF, 3, 0, 0, 0, 0, 0, 0, 0)); + assert_int_equal(LL_IFC_ERROR_INCORRECT_PARAMETER, ll_radio_params_set(RADIO_PARAM_FLAGS_CR, 0, 5, 0, 0, 0, 0, 0, 0)); + assert_int_equal(LL_IFC_ERROR_INCORRECT_PARAMETER, ll_radio_params_set(RADIO_PARAM_FLAGS_BW, 0, 0, 4, 0, 0, 0, 0, 0)); +} + +void test_radio_params_set_ok(void **state) +{ + (void) state; + uint8_t flags = RADIO_PARAM_FLAGS_SF | RADIO_PARAM_FLAGS_CR | RADIO_PARAM_FLAGS_BW | RADIO_PARAM_FLAGS_HEADER | + RADIO_PARAM_FLAGS_CRC | RADIO_PARAM_FLAGS_IQ | RADIO_PARAM_FLAGS_PREAMBLE | RADIO_PARAM_FLAGS_FREQ; + uint8_t sf = 9; + uint8_t cr = 1; + uint8_t bw = 3; + uint32_t freq = 915000000; + uint16_t preamble_syms = 8; + uint8_t enable_header = 1; + uint8_t enable_crc = 1; + uint8_t enable_iq_inversion = 1; + + uint8_t cmd[] = {flags, ((sf-6)<<4)|((cr-1)<<2)|(bw), 7, 0, preamble_syms, 0x36, 0x89, 0xca, 0xc0}; + transport_expect(OP_SET_RADIO_PARAMS, cmd, sizeof(cmd), 0, 0, 0); + + assert_int_equal(LL_IFC_ACK, ll_radio_params_set(flags, sf, cr, bw, freq, preamble_syms, + enable_header, enable_crc, enable_iq_inversion)); +} + +void test_tx_power_set_invalid(void **state) +{ + (void)state; + assert_int_equal(LL_IFC_ERROR_INCORRECT_PARAMETER, ll_tx_power_set(27)); +} + +void test_tx_power_set_ok(void **state) +{ + (void)state; + + uint8_t cmd[] = {20}; + transport_expect(OP_TX_POWER_SET, cmd, sizeof(cmd), 0, 0, 0); + + assert_int_equal(LL_IFC_ACK, ll_tx_power_set(20)); +} + +void test_tx_power_get_invalid(void **state) +{ + (void)state; + assert_int_equal(LL_IFC_ERROR_INCORRECT_PARAMETER, ll_tx_power_get(NULL)); +} + +void test_tx_power_get_ok(void **state) +{ + (void)state; + uint8_t pwr = 0; + uint8_t rsp[] = {18}; + transport_expect(OP_TX_POWER_GET, 0, 0, 0, rsp, sizeof(rsp)); + + assert_int_equal(LL_IFC_ACK, ll_tx_power_get(&pwr)); + assert_int_equal(18, pwr); +} + +void test_sync_word_set_ok(void **state) +{ + (void)state; + uint8_t sync_word = 0xa5; + + uint8_t cmd[] = {0xa5}; + transport_expect(OP_SYNC_WORD_SET, cmd, sizeof(cmd), 0, 0, 0); + + assert_int_equal(LL_IFC_ACK, ll_sync_word_set(sync_word)); +} + +void test_sync_word_get_invalid(void **state) +{ + (void)state; + assert_int_equal(LL_IFC_ERROR_INCORRECT_PARAMETER, ll_sync_word_get(NULL)); +} + +void test_sync_word_get_ok(void **state) +{ + (void)state; + uint8_t sync_word = 0; + + uint8_t rsp[] = {0xa5}; + transport_expect(OP_SYNC_WORD_GET, 0, 0, 0, rsp, sizeof(rsp)); + + assert_int_equal(LL_IFC_ACK, ll_sync_word_get(&sync_word)); + assert_int_equal(0xa5, sync_word); +} + +void test_echo_mode_ok(void **state) +{ + (void)state; + transport_expect(OP_PKT_ECHO, 0, 0, 0, 0, 0); + assert_int_equal(LL_IFC_ACK, ll_echo_mode()); +} + +void test_packet_send_queue_invalid(void **state) +{ + (void)state; + assert_int_equal(LL_IFC_ERROR_INCORRECT_PARAMETER, ll_packet_send_queue(NULL, 1)); + assert_int_equal(LL_IFC_ERROR_INCORRECT_PARAMETER, ll_packet_send_queue(1, 0)); +} + +void test_packet_send_queue_queued(void **state) +{ + (void)state; + uint8_t buf[] = {0x11, 0x22, 0x33, 0x44, 0x55}; + uint16_t len = 5; + + uint8_t cmd[] = {0x11, 0x22, 0x33, 0x44, 0x55}; + uint8_t rsp[] = {1}; + transport_expect(OP_PKT_SEND_QUEUE, cmd, sizeof(cmd), 0, rsp, sizeof(rsp)); + + assert_int_equal(1, ll_packet_send_queue(buf, len)); +} + +void test_packet_send_queue_full(void **state) +{ + (void)state; + uint8_t buf[] = {0x11, 0x22, 0x33, 0x44, 0x55}; + uint16_t len = 5; + + uint8_t cmd[] = {0x11, 0x22, 0x33, 0x44, 0x55}; + uint8_t rsp[] = {0}; + transport_expect(OP_PKT_SEND_QUEUE, cmd, sizeof(cmd), 0, rsp, sizeof(rsp)); + + assert_int_equal(0, ll_packet_send_queue(buf, len)); +} + +void test_packet_send_queue_error(void **state) +{ + (void)state; + uint8_t buf[] = {0x11, 0x22, 0x33, 0x44, 0x55}; + uint16_t len = 5; + + uint8_t cmd[] = {0x11, 0x22, 0x33, 0x44, 0x55}; + uint8_t rsp[] = {-1}; + transport_expect(OP_PKT_SEND_QUEUE, cmd, sizeof(cmd), 0, rsp, sizeof(rsp)); + + assert_int_equal(-1, (int8_t)ll_packet_send_queue(buf, len)); +} + +void test_transmit_cw_ok(void **state) +{ + (void)state; + transport_expect(OP_TX_CW, 0, 0, 0, 0, 0); + assert_int_equal(LL_IFC_ACK, ll_transmit_cw()); +} + +void test_packet_recv_cont_invalid(void **state) +{ + (void)state; + assert_int_equal(LL_IFC_ERROR_INCORRECT_PARAMETER, ll_packet_recv_cont(NULL, 1, 1, false)); + assert_int_equal(LL_IFC_ERROR_INCORRECT_PARAMETER, ll_packet_recv_cont(1, 0, 1, false)); + assert_int_equal(LL_IFC_ERROR_INCORRECT_PARAMETER, ll_packet_recv_cont(1, 1, NULL, false)); +} + +void test_packet_recv_cont_small_length(void **state) +{ + (void)state; + uint8_t buf[] = {0x11, 0x22}; + uint16_t len = sizeof(buf); + uint8_t bytes_received = 0; + bool freq_error_requested = false; + + uint8_t rsp[] = {0x11, 0x22, 0x33, 0x44, 0x55}; + transport_expect(OP_PKT_RECV_CONT, 0, 0, 0, rsp, sizeof(rsp)); + assert_int_equal(LL_IFC_ERROR_BUFFER_TOO_SMALL, ll_packet_recv_cont(buf, len, &bytes_received, freq_error_requested)); +} + +void test_packet_recv_cont_ok(void **state) +{ + (void)state; + uint8_t buf[255] = {0}; + uint16_t len = sizeof(buf); + uint8_t bytes_received = 0; + bool freq_error_requested = false; + + uint8_t rsp[] = {0x11, 0x22, 0x33, 0x44, 0x55}; + transport_expect(OP_PKT_RECV_CONT, 0, 0, 0, rsp, sizeof(rsp)); + assert_int_equal(LL_IFC_ACK, ll_packet_recv_cont(buf, len, &bytes_received, freq_error_requested)); + assert_memory_equal(buf, rsp, bytes_received); +} + +void test_packet_recv_with_rssi_invalid(void **state) +{ + (void)state; + assert_int_equal(LL_IFC_ERROR_INCORRECT_PARAMETER, ll_packet_recv_with_rssi(0, NULL, 1, 1, false)); + assert_int_equal(LL_IFC_ERROR_INCORRECT_PARAMETER, ll_packet_recv_with_rssi(0, 1, 0, 1, false)); + assert_int_equal(LL_IFC_ERROR_INCORRECT_PARAMETER, ll_packet_recv_with_rssi(0, 1, 1, NULL, false)); +} + +void test_packet_recv_with_rssi_small_length(void **state) +{ + (void)state; + uint8_t buf[] = {0x11, 0x22}; + uint16_t len = sizeof(buf); + uint8_t bytes_received = 0; + uint16_t num_timeout_symbols = 0x4455; + bool freq_error_requested = false; + + uint8_t cmd[] = {0x44, 0x55}; + uint8_t rsp[] = {0x11, 0x22, 0x33, 0x44, 0x55}; + transport_expect(OP_MSG_RECV_RSSI, cmd, sizeof(cmd), 0, rsp, sizeof(rsp)); + assert_int_equal(LL_IFC_ERROR_BUFFER_TOO_SMALL, ll_packet_recv_with_rssi(num_timeout_symbols, buf, len, &bytes_received, freq_error_requested)); +} + +void test_packet_recv_with_rssi_ok(void **state) +{ + (void)state; + uint8_t buf[255] = {0}; + uint16_t len = sizeof(buf); + uint8_t bytes_received = 0; + uint16_t num_timeout_symbols = 0x4455; + bool freq_error_requested = false; + + uint8_t cmd[] = {0x44, 0x55}; + uint8_t rsp[] = {0x11, 0x22, 0x33, 0x44, 0x55}; + transport_expect(OP_MSG_RECV_RSSI, cmd, sizeof(cmd), 0, rsp, sizeof(rsp)); + assert_int_equal(LL_IFC_ACK, ll_packet_recv_with_rssi(num_timeout_symbols, buf, len, &bytes_received, freq_error_requested)); +} + diff --git a/test_ifc_lib/test_ifc_lib_nomac.h b/test_ifc_lib/test_ifc_lib_nomac.h new file mode 100644 index 0000000..a6435fe --- /dev/null +++ b/test_ifc_lib/test_ifc_lib_nomac.h @@ -0,0 +1,64 @@ +#include "test_ifc_lib_gen.h" + +void test_rssi_scan_set_ok(void **state); +void test_rssi_scan_get_invalid(void **state); +void test_rssi_scan_get_short_length(void **state); +void test_rssi_scan_get_ok(void **state); +void test_radio_params_get_invalid(void **state); +void test_radio_params_get_incorrect_length(void **state); +void test_radio_params_get_ok(void **state); +void test_radio_params_set_invalid(void **state); +void test_radio_params_set_ok(void **state); +void test_tx_power_set_invalid(void **state); +void test_tx_power_set_ok(void **state); +void test_tx_power_get_invalid(void **state); +void test_tx_power_get_ok(void **state); +void test_sync_word_set_ok(void **state); +void test_sync_word_get_invalid(void **state); +void test_sync_word_get_ok(void **state); +void test_echo_mode_ok(void **state); +void test_packet_send_queue_invalid(void **state); +void test_packet_send_queue_queued(void **state); +void test_packet_send_queue_full(void **state); +void test_packet_send_queue_error(void **state); +void test_transmit_cw_ok(void **state); +void test_packet_recv_cont_invalid(void **state); +void test_packet_recv_cont_small_length(void **state); +void test_packet_recv_cont_ok(void **state); +void test_packet_recv_with_rssi_invalid(void **state); +void test_packet_recv_with_rssi_small_length(void **state); +void test_packet_recv_with_rssi_ok(void **state); + +#define NOMAC_IFC_LIB_TESTS \ + unit_test_setup_teardown(test_rssi_scan_set_ok, setUp, tearDown), \ + unit_test_setup_teardown(test_rssi_scan_get_invalid, setUp, tearDown), \ + unit_test_setup_teardown(test_rssi_scan_get_short_length, setUp, tearDown), \ + unit_test_setup_teardown(test_rssi_scan_get_ok, setUp, tearDown), \ + unit_test_setup_teardown(test_radio_params_get_invalid, setUp, tearDown), \ + unit_test_setup_teardown(test_radio_params_get_incorrect_length, setUp, tearDown), \ + unit_test_setup_teardown(test_radio_params_get_ok, setUp, tearDown), \ + unit_test_setup_teardown(test_radio_params_set_invalid, setUp, tearDown), \ + unit_test_setup_teardown(test_radio_params_set_ok, setUp, tearDown), \ + unit_test_setup_teardown(test_tx_power_set_invalid, setUp, tearDown), \ + unit_test_setup_teardown(test_tx_power_set_ok, setUp, tearDown), \ + unit_test_setup_teardown(test_tx_power_get_invalid, setUp, tearDown), \ + unit_test_setup_teardown(test_tx_power_get_ok, setUp, tearDown), \ + unit_test_setup_teardown(test_sync_word_set_ok, setUp, tearDown), \ + unit_test_setup_teardown(test_sync_word_get_invalid, setUp, tearDown), \ + unit_test_setup_teardown(test_sync_word_get_ok, setUp, tearDown), \ + unit_test_setup_teardown(test_echo_mode_ok, setUp, tearDown), \ + unit_test_setup_teardown(test_packet_send_queue_invalid, setUp, tearDown), \ + unit_test_setup_teardown(test_packet_send_queue_queued, setUp, tearDown), \ + unit_test_setup_teardown(test_packet_send_queue_full, setUp, tearDown), \ + unit_test_setup_teardown(test_packet_send_queue_error, setUp, tearDown), \ + unit_test_setup_teardown(test_transmit_cw_ok, setUp, tearDown), \ + unit_test_setup_teardown(test_packet_recv_cont_invalid, setUp, tearDown), \ + unit_test_setup_teardown(test_packet_recv_cont_small_length, setUp, tearDown), \ + unit_test_setup_teardown(test_packet_recv_cont_ok, setUp, tearDown), \ + unit_test_setup_teardown(test_packet_recv_with_rssi_invalid, setUp, tearDown), \ + unit_test_setup_teardown(test_packet_recv_with_rssi_small_length, setUp, tearDown), \ + unit_test_setup_teardown(test_packet_recv_with_rssi_ok, setUp, tearDown), \ + + + + diff --git a/test_ifc_lib/test_ifc_lib_symphony.c b/test_ifc_lib/test_ifc_lib_symphony.c new file mode 100644 index 0000000..18ac20a --- /dev/null +++ b/test_ifc_lib/test_ifc_lib_symphony.c @@ -0,0 +1,622 @@ +#include "ll_ifc_symphony.h" +#include "utils_ifc_lib.h" + +#include +#include +#include +#include "cmockery.h" + +void test_config_set_net_token_invalid(void **state) +{ + (void) state; + uint32_t net_token = 0xffffffff; + uint8_t app_token[] = {0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88, 0x99, 0xaa}; + enum ll_downlink_mode dl_mode = LL_DL_MAILBOX; + uint8_t qos = 8; + + assert_int_equal(LL_IFC_ERROR_INCORRECT_PARAMETER, ll_config_set(net_token, app_token, dl_mode, qos)); +} + +void test_config_set_app_token_invalid(void **state) +{ + (void) state; + uint32_t net_token = 0x11223344; + uint8_t* app_token = NULL; + enum ll_downlink_mode dl_mode = LL_DL_MAILBOX; + uint8_t qos = 8; + + uint8_t cmd[] = {0x11, 0x22, 0x33, 0x44}; + transport_expect(OP_NET_TOKEN_SET, cmd, sizeof(cmd), 0, 0, 0); + + assert_int_equal(LL_IFC_ERROR_INCORRECT_PARAMETER, ll_config_set(net_token, app_token, dl_mode, qos)); +} + +void test_config_set_dl_mode_invalid(void **state) +{ + (void) state; + uint32_t net_token = 0x11223344; + uint8_t app_token[] = {0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88, 0x99, 0xaa}; + enum ll_downlink_mode dl_mode = NUM_DOWNLINK_MODES; + uint8_t qos = 8; + + uint8_t cmd1[] = {0x11, 0x22, 0x33, 0x44}; + transport_expect(OP_NET_TOKEN_SET, cmd1, sizeof(cmd1), 0, 0, 0); + + transport_expect(OP_APP_TOKEN_SET, app_token, sizeof(app_token), 0, 0, 0); + + assert_int_equal(LL_IFC_ERROR_INCORRECT_PARAMETER, ll_config_set(net_token, app_token, dl_mode, qos)); +} + +void test_config_set_qos_invalid(void **state) +{ + (void) state; + uint32_t net_token = 0x11223344; + uint8_t app_token[] = {0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88, 0x99, 0xaa}; + enum ll_downlink_mode dl_mode = NUM_DOWNLINK_MODES; + uint8_t qos = 16; + + uint8_t cmd1[] = {0x11, 0x22, 0x33, 0x44}; + transport_expect(OP_NET_TOKEN_SET, cmd1, sizeof(cmd1), 0, 0, 0); + transport_expect(OP_APP_TOKEN_SET, app_token, sizeof(app_token), 0, 0, 0); + transport_expect(OP_RX_MODE_SET, (uint8_t*)&dl_mode, 1, 0, 0, 0); + + assert_int_equal(LL_IFC_ERROR_INCORRECT_PARAMETER, ll_config_set(net_token, app_token, dl_mode, qos)); +} + +void test_config_set_ok(void **state) +{ + (void) state; + uint32_t net_token = 0x11223344; + uint8_t app_token[] = {0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88, 0x99, 0xaa}; + enum ll_downlink_mode dl_mode = LL_DL_MAILBOX; + uint8_t qos = 8; + + uint8_t cmd1[] = {0x11, 0x22, 0x33, 0x44}; + transport_expect(OP_NET_TOKEN_SET, cmd1, sizeof(cmd1), 0, 0, 0); + transport_expect(OP_APP_TOKEN_SET, app_token, sizeof(app_token), 0, 0, 0); + transport_expect(OP_RX_MODE_SET, (uint8_t*)&dl_mode, 1, 0, 0, 0); + transport_expect(OP_QOS_REQUEST, &qos, 1, 0, 0, 0); + + assert_int_equal(LL_IFC_ACK, ll_config_set(net_token, app_token, dl_mode, qos)); +} + +void test_config_get_net_token_invalid(void **state) +{ + (void) state; + uint8_t app_token[APP_TOKEN_LEN] = {0}; + enum ll_downlink_mode dl_mode = NUM_DOWNLINK_MODES; + uint8_t qos = 0xff; + + assert_int_equal(LL_IFC_ERROR_INCORRECT_PARAMETER, ll_config_get(NULL, app_token, &dl_mode, &qos)); +} + +void test_config_get_net_token_incorrect_length(void **state) +{ + (void) state; + uint32_t net_token = 0xffffffff; + uint8_t app_token[APP_TOKEN_LEN] = {0}; + enum ll_downlink_mode dl_mode = NUM_DOWNLINK_MODES; + uint8_t qos = 0xff; + + uint8_t rsp[] = {0x11, 0x22, 0x33}; + transport_expect(OP_NET_TOKEN_GET, 0, 0, 0, rsp, sizeof(rsp)); + + assert_int_equal(LL_IFC_ERROR_INCORRECT_RESPONSE_LENGTH, ll_config_get(&net_token, app_token, &dl_mode, &qos)); + assert_int_equal(0xffffffff, net_token); +} + + +void test_config_get_app_token_invalid(void **state) +{ + (void) state; + uint32_t net_token = 0xffffffff; + enum ll_downlink_mode dl_mode = NUM_DOWNLINK_MODES; + uint8_t qos = 0xff; + + uint8_t rsp[] = {0x11, 0x22, 0x33, 0x44}; + transport_expect(OP_NET_TOKEN_GET, 0, 0, 0, rsp, sizeof(rsp)); + + assert_int_equal(LL_IFC_ERROR_INCORRECT_PARAMETER, ll_config_get(&net_token, NULL, &dl_mode, &qos)); + assert_int_equal(0x11223344, net_token); +} + +void test_config_get_app_token_incorrect_length(void **state) +{ + (void) state; + uint32_t net_token = 0xffffffff; + uint8_t app_token[APP_TOKEN_LEN] = {0}; + enum ll_downlink_mode dl_mode = NUM_DOWNLINK_MODES; + uint8_t qos = 0xff; + + uint8_t rsp1[] = {0x11, 0x22, 0x33, 0x44}; + transport_expect(OP_NET_TOKEN_GET, 0, 0, 0, rsp1, sizeof(rsp1)); + uint8_t rsp2[] = {0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88, 0x99}; + transport_expect(OP_APP_TOKEN_GET, 0, 0, 0, rsp2, sizeof(rsp2)); + + assert_int_equal(LL_IFC_ERROR_INCORRECT_RESPONSE_LENGTH, ll_config_get(&net_token, app_token, &dl_mode, &qos)); + assert_int_equal(0x11223344, net_token); +} + +void test_config_get_dl_mode_invalid(void **state) +{ + (void) state; + uint32_t net_token = 0xffffffff; + uint8_t app_token[APP_TOKEN_LEN] = {0}; + uint8_t qos = 0xff; + + uint8_t rsp[] = {0x11, 0x22, 0x33, 0x44}; + transport_expect(OP_NET_TOKEN_GET, 0, 0, 0, rsp, sizeof(rsp)); + uint8_t rsp2[] = {0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88, 0x99, 0xaa}; + transport_expect(OP_APP_TOKEN_GET, 0, 0, 0, rsp2, sizeof(rsp2)); + + assert_int_equal(LL_IFC_ERROR_INCORRECT_PARAMETER, ll_config_get(&net_token, app_token, NULL, &qos)); + assert_int_equal(0x11223344, net_token); + assert_memory_equal(app_token, rsp2, APP_TOKEN_LEN); +} + +void test_config_get_dl_mode_incorrect_length(void **state) +{ + (void) state; + uint32_t net_token = 0xffffffff; + uint8_t app_token[APP_TOKEN_LEN] = {0}; + enum ll_downlink_mode dl_mode = NUM_DOWNLINK_MODES; + uint8_t qos = 0xff; + + uint8_t rsp1[] = {0x11, 0x22, 0x33, 0x44}; + transport_expect(OP_NET_TOKEN_GET, 0, 0, 0, rsp1, sizeof(rsp1)); + uint8_t rsp2[] = {0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88, 0x99, 0xaa}; + transport_expect(OP_APP_TOKEN_GET, 0, 0, 0, rsp2, sizeof(rsp2)); + uint8_t rsp3[] = {0x11, 0x22}; + transport_expect(OP_RX_MODE_GET, 0, 0, 0, rsp3, sizeof(rsp3)); + + assert_int_equal(LL_IFC_ERROR_BUFFER_TOO_SMALL, ll_config_get(&net_token, app_token, &dl_mode, &qos)); + assert_int_equal(0x11223344, net_token); + assert_memory_equal(app_token, rsp2, APP_TOKEN_LEN); +} + +void test_config_get_qos_invalid(void **state) +{ + (void) state; + uint32_t net_token = 0xffffffff; + uint8_t app_token[APP_TOKEN_LEN] = {0}; + enum ll_downlink_mode dl_mode = NUM_DOWNLINK_MODES; + + uint8_t rsp[] = {0x11, 0x22, 0x33, 0x44}; + transport_expect(OP_NET_TOKEN_GET, 0, 0, 0, rsp, sizeof(rsp)); + uint8_t rsp2[] = {0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88, 0x99, 0xaa}; + transport_expect(OP_APP_TOKEN_GET, 0, 0, 0, rsp2, sizeof(rsp2)); + uint8_t rsp3[] = {0x02}; + transport_expect(OP_RX_MODE_GET, 0, 0, 0, rsp3, sizeof(rsp3)); + + assert_int_equal(LL_IFC_ERROR_INCORRECT_PARAMETER, ll_config_get(&net_token, app_token, &dl_mode, NULL)); + assert_int_equal(0x11223344, net_token); + assert_memory_equal(app_token, rsp2, APP_TOKEN_LEN); + assert_int_equal(LL_DL_MAILBOX, dl_mode); +} + +void test_config_get_qos_incorrect_length(void **state) +{ + (void) state; + uint32_t net_token = 0xffffffff; + uint8_t app_token[APP_TOKEN_LEN] = {0}; + enum ll_downlink_mode dl_mode = NUM_DOWNLINK_MODES; + uint8_t qos = 0xff; + + uint8_t rsp1[] = {0x11, 0x22, 0x33, 0x44}; + transport_expect(OP_NET_TOKEN_GET, 0, 0, 0, rsp1, sizeof(rsp1)); + uint8_t rsp2[] = {0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88, 0x99, 0xaa}; + transport_expect(OP_APP_TOKEN_GET, 0, 0, 0, rsp2, sizeof(rsp2)); + uint8_t rsp3[] = {0x02}; + transport_expect(OP_RX_MODE_GET, 0, 0, 0, rsp3, sizeof(rsp3)); + uint8_t rsp4[] = {0x02, 0x23}; + transport_expect(OP_QOS_GET, 0, 0, 0, rsp4, sizeof(rsp4)); + + assert_int_equal(LL_IFC_ERROR_BUFFER_TOO_SMALL, ll_config_get(&net_token, app_token, &dl_mode, &qos)); + assert_int_equal(0x11223344, net_token); + assert_memory_equal(app_token, rsp2, APP_TOKEN_LEN); + assert_int_equal(LL_DL_MAILBOX, dl_mode); + assert_int_equal(0xff, qos); +} + +void test_config_get_ok(void **state) +{ + (void) state; + uint32_t net_token = 0xffffffff; + uint8_t app_token[APP_TOKEN_LEN] = {0}; + enum ll_downlink_mode dl_mode = NUM_DOWNLINK_MODES; + uint8_t qos = 0xff; + + uint8_t rsp1[] = {0x11, 0x22, 0x33, 0x44}; + transport_expect(OP_NET_TOKEN_GET, 0, 0, 0, rsp1, sizeof(rsp1)); + uint8_t rsp2[] = {0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88, 0x99, 0xaa}; + transport_expect(OP_APP_TOKEN_GET, 0, 0, 0, rsp2, sizeof(rsp2)); + uint8_t rsp3[] = {0x02}; + transport_expect(OP_RX_MODE_GET, 0, 0, 0, rsp3, sizeof(rsp3)); + uint8_t rsp4[] = {0x07}; + transport_expect(OP_QOS_GET, 0, 0, 0, rsp4, sizeof(rsp4)); + + assert_int_equal(LL_IFC_ACK, ll_config_get(&net_token, app_token, &dl_mode, &qos)); + assert_int_equal(0x11223344, net_token); + assert_memory_equal(app_token, rsp2, APP_TOKEN_LEN); + assert_int_equal(LL_DL_MAILBOX, dl_mode); + assert_int_equal(0x07, qos); +} + +void test_get_state_all_null(void **state) +{ + (void)state; + assert_int_equal(LL_IFC_ACK, ll_get_state(NULL, NULL, NULL)); +} + +void test_get_state_ok(void **state) +{ + (void) state; + enum ll_state s = LL_STATE_ERROR; + enum ll_tx_state stx = LL_TX_STATE_ERROR; + enum ll_rx_state srx = LL_RX_STATE_NO_MSG; + + uint8_t rsp1[] = {3}; + transport_expect(OP_STATE, 0, 0, 0, rsp1, sizeof(rsp1)); + uint8_t rsp2[] = {1}; + transport_expect(OP_TX_STATE, 0, 0, 0, rsp2, sizeof(rsp2)); + uint8_t rsp3[] = {1}; + transport_expect(OP_RX_STATE, 0, 0, 0, rsp3, sizeof(rsp3)); + + assert_int_equal(LL_IFC_ACK, ll_get_state(&s, &stx, &srx)); + assert_int_equal(LL_STATE_INITIALIZING, s); + assert_int_equal(LL_TX_STATE_TRANSMITTING, stx); + assert_int_equal(LL_RX_STATE_RECEIVED_MSG, srx); +} + +void test_mailbox_request_ok(void **state) +{ + (void)state; + transport_expect(OP_MAILBOX_REQUEST, 0, 0, 0, 0, 0); + assert_int_equal(LL_IFC_ACK, ll_mailbox_request()); +} + +void test_app_reg_get_invalid(void **state) +{ + (void)state; + assert_int_equal(LL_IFC_ERROR_INCORRECT_PARAMETER, ll_app_reg_get(NULL)); +} + +void test_app_reg_get_ok(void **state) +{ + (void)state; + uint8_t is_registered = 0; + uint8_t rsp[] = {0x01}; + transport_expect(OP_APP_TOKEN_REG_GET, 0, 0, 0, rsp, sizeof(rsp)); + assert_int_equal(LL_IFC_ACK, ll_app_reg_get(&is_registered)); + assert_int_equal(1, is_registered); +} + +void test_crypto_request_ok(void **state) +{ + (void)state; + transport_expect(OP_CRYPTO_KEY_XCHG_REQ, 0, 0, 0, 0, 0); + assert_int_equal(LL_IFC_ACK, ll_encryption_key_exchange_request()); +} + +void test_net_info_get_invalid(void **state) +{ + (void)state; + assert_int_equal(LL_IFC_ERROR_INCORRECT_PARAMETER, ll_net_info_get(NULL)); +} + +void test_net_info_get_incorrect_length(void **state) +{ + (void)state; + llabs_network_info_t info; + + uint8_t rsp[NET_INFO_BUFF_SIZE - 1] = {0}; + transport_expect(OP_NET_INFO_GET, 0, 0, 0, rsp, sizeof(rsp)); + assert_int_equal(LL_IFC_ERROR_INCORRECT_RESPONSE_LENGTH, ll_net_info_get(&info)); +} + +void test_net_info_get_ok(void **state) +{ + (void)state; + llabs_network_info_t info; + + uint8_t rsp[NET_INFO_BUFF_SIZE] = {0}; + transport_expect(OP_NET_INFO_GET, 0, 0, 0, rsp, sizeof(rsp)); + assert_int_equal(LL_IFC_ACK, ll_net_info_get(&info)); +} + +void test_stats_get_invalid(void **state) +{ + (void)state; + assert_int_equal(LL_IFC_ERROR_INCORRECT_PARAMETER, ll_stats_get(NULL)); +} + +void test_stats_get_incorrect_length(void **state) +{ + (void)state; + llabs_stats_t s; + + uint8_t rsp[STATS_SIZE - 1] = {0}; + transport_expect(OP_STATS_GET, 0, 0, 0, rsp, sizeof(rsp)); + assert_int_equal(LL_IFC_ERROR_INCORRECT_RESPONSE_LENGTH, ll_stats_get(&s)); +} + +void test_stats_get_ok(void **state) +{ + (void)state; + llabs_stats_t s; + + uint8_t rsp[STATS_SIZE] = {0}; + transport_expect(OP_STATS_GET, 0, 0, 0, rsp, sizeof(rsp)); + assert_int_equal(LL_IFC_ACK, ll_stats_get(&s)); +} + +void test_retrieve_message_invalid(void **state) +{ + (void)state; + assert_int_equal(LL_IFC_ERROR_INCORRECT_PARAMETER, ll_retrieve_message(NULL, NULL, NULL, NULL, NULL)); +} + +void test_retrieve_message_small_length(void **state) +{ + (void)state; + uint8_t buff[256] = {0}; + uint16_t size = 1; + + uint8_t rsp[] = {0, 0}; + transport_expect(OP_MSG_RECV, 0, 0, 0, rsp, sizeof(rsp)); + + assert_int_equal(LL_IFC_ERROR_BUFFER_TOO_SMALL, ll_retrieve_message(buff, &size, NULL, NULL, NULL)); +} + +void test_retrieve_message_incorrect_length(void **state) +{ + (void)state; + uint8_t buff[256] = {0}; + uint16_t size = 256; + + uint8_t rsp[] = {0x11, 0x22, 0x33, 0x44}; + transport_expect(OP_MSG_RECV, 0, 0, 0, rsp, sizeof(rsp)); + + assert_int_equal(LL_IFC_ERROR_INCORRECT_RESPONSE_LENGTH, ll_retrieve_message(buff, &size, NULL, NULL, NULL)); +} + +void test_retrieve_message_ok(void **state) +{ + (void)state; + uint8_t buff[256] = {0}; + uint16_t size = 256; + uint8_t port = 0; + int16_t rssi = 0; + uint8_t snr = 0; + + uint8_t rsp[] = {0x11, 0x22, 0x33, 0x44, 0x55, 0x66}; + transport_expect(OP_MSG_RECV, 0, 0, 0, rsp, sizeof(rsp)); + + assert_int_equal(LL_IFC_ACK, ll_retrieve_message(buff, &size, &port, &rssi, &snr)); + assert_int_equal(2, size); + assert_memory_equal(buff, &rsp[4], 2); + assert_int_equal(0x44, port); + assert_int_equal(0x2211, rssi); + assert_int_equal(0x33, snr); +} + +void test_dl_band_cfg_get_invalid(void **state) +{ + (void)state; + assert_int_equal(LL_IFC_ERROR_INCORRECT_PARAMETER, ll_dl_band_cfg_get(NULL)); +} + +void test_dl_band_cfg_get_incorrect_length(void **state) +{ + (void)state; + llabs_dl_band_cfg_t cfg; + + uint8_t rsp[] = {0, 0}; + transport_expect(OP_DL_BAND_CFG_GET, 0, 0, 0, rsp, sizeof(rsp)); + + assert_int_equal(LL_IFC_ERROR_INCORRECT_RESPONSE_LENGTH, ll_dl_band_cfg_get(&cfg)); +} + +void test_dl_band_cfg_get_ok(void **state) +{ + (void)state; + llabs_dl_band_cfg_t cfg; + + uint8_t rsp[DL_BAND_CFG_SIZE] = {0}; + transport_expect(OP_DL_BAND_CFG_GET, 0, 0, 0, rsp, sizeof(rsp)); + + assert_int_equal(LL_IFC_ACK, ll_dl_band_cfg_get(&cfg)); +} + +void test_dl_band_cfg_set_invalid(void **state) +{ + (void)state; + assert_int_equal(LL_IFC_ERROR_INCORRECT_PARAMETER, ll_dl_band_cfg_set(NULL)); +} + +void test_dl_band_cfg_set_ok(void **state) +{ + (void)state; + llabs_dl_band_cfg_t cfg = {0}; + + uint8_t cmd[DL_BAND_CFG_SIZE] = {0}; + transport_expect(OP_DL_BAND_CFG_SET, cmd, sizeof(cmd), 0, 0, 0); + + assert_int_equal(LL_IFC_ACK, ll_dl_band_cfg_set(&cfg)); +} + + +void test_connection_filter_get_invalid(void **state) +{ + (void)state; + assert_int_equal(LL_IFC_ERROR_INCORRECT_PARAMETER, ll_connection_filter_get(NULL)); +} + +void test_connection_filter_get_incorrect_length(void **state) +{ + (void)state; + uint8_t f = 0xff; + + uint8_t rsp[] = {0, 0}; + transport_expect(OP_CONN_FILT_GET, 0, 0, 0, rsp, sizeof(rsp)); + assert_int_equal(LL_IFC_ERROR_BUFFER_TOO_SMALL, ll_connection_filter_get(&f)); + assert_int_equal(0xff, f); +} + +void test_connection_filter_get_ok(void **state) +{ + (void)state; + uint8_t f = 0xff; + + uint8_t rsp[] = {0x11}; + transport_expect(OP_CONN_FILT_GET, 0, 0, 0, rsp, sizeof(rsp)); + assert_int_equal(LL_IFC_ACK, ll_connection_filter_get(&f)); + assert_int_equal(0x11, f); +} + +void test_connection_filter_set_ok(void **state) +{ + (void)state; + uint8_t f = 0x11; + + uint8_t cmd[] = {0x11}; + transport_expect(OP_CONN_FILT_SET, cmd, sizeof(cmd), 0, 0, 0); + assert_int_equal(LL_IFC_ACK, ll_connection_filter_set(f)); +} + +void test_system_time_get_invalid(void **state) +{ + (void)state; + assert_int_equal(LL_IFC_ERROR_INCORRECT_PARAMETER, ll_system_time_get(NULL)); +} + +void test_system_time_get_incorrect_length(void **state) +{ + (void)state; + llabs_time_info_t info; + + uint8_t rsp[] = {0, 0}; + transport_expect(OP_SYSTEM_TIME_GET, 0, 0, 0, rsp, sizeof(rsp)); + assert_int_equal(LL_IFC_ERROR_INCORRECT_RESPONSE_LENGTH, ll_system_time_get(&info)); + //assert_int_equal(0xff, f); +} + +void test_system_time_get_ok(void **state) +{ + (void)state; + llabs_time_info_t info; + + uint8_t rsp[TIME_INFO_SIZE] = {0}; + transport_expect(OP_SYSTEM_TIME_GET, 0, 0, 0, rsp, sizeof(rsp)); + assert_int_equal(LL_IFC_ACK, ll_system_time_get(&info)); +} + +void test_system_time_sync_invalid(void **state) +{ + (void)state; + assert_int_equal(LL_IFC_ERROR_INCORRECT_PARAMETER, ll_system_time_sync(2)); +} + +void test_system_time_sync_ok(void **state) +{ + (void)state; + + uint8_t cmd[] = {1}; + transport_expect(OP_SYSTEM_TIME_SYNC, cmd, sizeof(cmd), 0, 0, 0); + assert_int_equal(LL_IFC_ACK, ll_system_time_sync(1)); +} + +void test_message_send_invalid(void **state) +{ + (void)state; + assert_int_equal(LL_IFC_ERROR_INCORRECT_PARAMETER, ll_message_send(NULL, 1, 1, 1)); + assert_int_equal(LL_IFC_ERROR_INCORRECT_PARAMETER, ll_message_send(1, 0, 1, 1)); + assert_int_equal(LL_IFC_ERROR_INCORRECT_PARAMETER, ll_message_send(1, 257, 0, 1)); + assert_int_equal(LL_IFC_ERROR_INCORRECT_PARAMETER, ll_message_send(1, 1, 1, 128)); +} + +void test_message_send_ok(void **state) +{ + (void)state; + uint8_t buf[] = {0x11, 0x22, 0x33}; + + uint8_t cmd[] = {1, 0x55, 0x11, 0x22, 0x33}; + transport_expect(OP_MSG_SEND, cmd, sizeof(cmd), 0, 0, 0); + assert_int_equal(LL_IFC_ACK, ll_message_send(buf, sizeof(buf), 1, 0x55)); +} + +void test_scan_config_set_ok(void **state) +{ + (void)state; + + int16_t threshold = 16; + uint8_t cmd[] = { threshold & 0xff, (threshold >> 8) }; + uint16_t scan_attempts = 23; + uint8_t cmd1[] = { scan_attempts & 0xff, (scan_attempts >> 8) }; + + enum ll_scan_mode scan_mode = LLABS_NORMAL_SCAN_AND_CONNECT; + + transport_expect(OP_SCAN_MODE_SET, (uint8_t*)&scan_mode, 1, 0, 0, 0); + transport_expect(OP_SCAN_THRESHOLD_SET, cmd, sizeof(cmd), 0, 0, 0); + transport_expect(OP_SCAN_ATTEMPTS_SET, cmd1, sizeof(cmd1), 0, 0, 0); + + assert_int_equal(LL_IFC_ACK, ll_scan_config_set(scan_mode, threshold, scan_attempts)); +} + +void test_scan_config_set_invalid_scan_mode(void **state) +{ + (void)state; + + int16_t threshold = 16; + uint8_t cmd[] = { threshold & 0xff, (threshold >> 8) }; + uint16_t scan_attempts = 23; + uint8_t cmd1[] = { scan_attempts & 0xff, (scan_attempts >> 8) }; + enum ll_scan_mode scan_mode = -1; + + transport_expect(OP_SCAN_MODE_SET, (uint8_t*)&scan_mode, 1, LL_IFC_ERROR_INCORRECT_PARAMETER, 0, 0); + transport_expect(OP_SCAN_THRESHOLD_SET, cmd, sizeof(cmd), 0, 0, 0); + transport_expect(OP_SCAN_ATTEMPTS_SET, cmd1, sizeof(cmd1), 0, 0, 0); + + assert_int_equal(LL_IFC_ERROR_INCORRECT_PARAMETER, ll_scan_config_set(scan_mode, threshold, scan_attempts)); +} + +void test_scan_config_get_ok(void **state) +{ + (void)state; + + // Variables + enum ll_scan_mode scan_mode = 0; + int16_t threshold = 0; + uint16_t scan_attempts = 0; + uint16_t scans_left = 0; + + // Expected Values + enum ll_scan_mode ex_scan_mode = LLABS_INFO_SCAN; + int16_t ex_threshold = -98; + uint16_t ex_scan_attempts = 560; + uint16_t ex_scans_left = 340; + + // Serialized Data "From the module" + transport_expect(OP_SCAN_MODE_GET, 0, 0, 0, (uint8_t*)&ex_scan_mode, 1); + transport_expect(OP_SCAN_THRESHOLD_GET, 0, 0, 0, (uint8_t*)&ex_threshold, 2); + transport_expect(OP_SCAN_ATTEMPTS_GET, 0, 0, 0, (uint8_t*)&ex_scan_attempts, 2); + transport_expect(OP_SCAN_ATTEMPTS_LEFT, 0, 0, 0, (uint8_t*)&ex_scans_left, 2); + + // Checks + assert_int_equal(LL_IFC_ACK, ll_scan_config_get(&scan_mode, &threshold, &scan_attempts, &scans_left)); + assert_int_equal(scan_mode, ex_scan_mode); + assert_int_equal(threshold, ex_threshold); + assert_int_equal(scan_attempts, ex_scan_attempts); + assert_int_equal(scans_left, ex_scans_left); +} + +void test_connect_to_gw_channel_ok(void **state) +{ + (void)state; + for (int i = 0; i <= 45; i += 3) + { + transport_expect(OP_CONN_TO_GW_CH, (uint8_t*)&i, 1, 0, 0, 0); + assert_int_equal(LL_IFC_ACK, ll_connect_to_gw_channel(i)); + } +} + diff --git a/test_ifc_lib/test_ifc_lib_symphony.h b/test_ifc_lib/test_ifc_lib_symphony.h new file mode 100644 index 0000000..668dc96 --- /dev/null +++ b/test_ifc_lib/test_ifc_lib_symphony.h @@ -0,0 +1,105 @@ +#include "test_ifc_lib_gen.h" + +void test_config_set_net_token_invalid(void **state); +void test_config_set_app_token_invalid(void **state); +void test_config_set_dl_mode_invalid(void **state); +void test_config_set_qos_invalid(void **state); +void test_config_set_ok(void **state); +void test_config_get_net_token_invalid(void **state); +void test_config_get_net_token_incorrect_length(void **state); +void test_config_get_app_token_invalid(void **state); +void test_config_get_app_token_incorrect_length(void **state); +void test_config_get_dl_mode_invalid(void **state); +void test_config_get_dl_mode_incorrect_length(void **state); +void test_config_get_qos_invalid(void **state); +void test_config_get_qos_incorrect_length(void **state); +void test_config_get_ok(void **state); +void test_get_state_all_null(void **state); +void test_get_state_ok(void **state); +void test_mailbox_request_ok(void **state); +void test_app_reg_get_invalid(void **state); +void test_app_reg_get_ok(void **state); +void test_crypto_request_ok(void **state); +void test_net_info_get_invalid(void **state); +void test_net_info_get_incorrect_length(void **state); +void test_net_info_get_ok(void **state); +void test_stats_get_invalid(void **state); +void test_stats_get_incorrect_length(void **state); +void test_stats_get_ok(void **state); +void test_dl_band_cfg_get_invalid(void **state); +void test_dl_band_cfg_get_incorrect_length(void **state); +void test_dl_band_cfg_get_ok(void **state); +void test_dl_band_cfg_set_invalid(void **state); +void test_dl_band_cfg_set_ok(void **state); +void test_connection_filter_get_invalid(void **state); +void test_connection_filter_get_incorrect_length(void **state); +void test_connection_filter_get_ok(void **state); +void test_connection_filter_set_ok(void **state); +void test_system_time_get_invalid(void **state); +void test_system_time_get_incorrect_length(void **state); +void test_system_time_get_ok(void **state); +void test_system_time_sync_invalid(void **state); +void test_system_time_sync_ok(void **state); +void test_message_send_invalid(void **state); +void test_message_send_ok(void **state); +void test_retrieve_message_invalid(void **state); +void test_retrieve_message_small_length(void **state); +void test_retrieve_message_incorrect_length(void **state); +void test_retrieve_message_ok(void **state); +void test_scan_config_set_ok(void **state); +void test_scan_config_set_invalid_scan_mode(void **state); +void test_scan_config_get_ok(void **state); +void test_connect_to_gw_channel_ok(void **state); + +#define SYMPHONY_IFC_LIB_TESTS \ + unit_test_setup_teardown(test_config_set_net_token_invalid, setUp, tearDown), \ + unit_test_setup_teardown(test_config_set_app_token_invalid, setUp, tearDown), \ + unit_test_setup_teardown(test_config_set_dl_mode_invalid, setUp, tearDown), \ + unit_test_setup_teardown(test_config_set_qos_invalid, setUp, tearDown), \ + unit_test_setup_teardown(test_config_set_ok, setUp, tearDown), \ + unit_test_setup_teardown(test_config_get_net_token_invalid, setUp, tearDown), \ + unit_test_setup_teardown(test_config_get_net_token_incorrect_length, setUp, tearDown), \ + unit_test_setup_teardown(test_config_get_app_token_invalid, setUp, tearDown), \ + unit_test_setup_teardown(test_config_get_app_token_incorrect_length, setUp, tearDown), \ + unit_test_setup_teardown(test_config_get_dl_mode_invalid, setUp, tearDown), \ + unit_test_setup_teardown(test_config_get_dl_mode_incorrect_length, setUp, tearDown), \ + unit_test_setup_teardown(test_config_get_qos_invalid, setUp, tearDown), \ + unit_test_setup_teardown(test_config_get_qos_incorrect_length, setUp, tearDown), \ + unit_test_setup_teardown(test_config_get_ok, setUp, tearDown), \ + unit_test_setup_teardown(test_get_state_all_null, setUp, tearDown), \ + unit_test_setup_teardown(test_get_state_ok, setUp, tearDown), \ + unit_test_setup_teardown(test_mailbox_request_ok, setUp, tearDown), \ + unit_test_setup_teardown(test_app_reg_get_invalid, setUp, tearDown), \ + unit_test_setup_teardown(test_app_reg_get_ok, setUp, tearDown), \ + unit_test_setup_teardown(test_crypto_request_ok, setUp, tearDown), \ + unit_test_setup_teardown(test_net_info_get_invalid, setUp, tearDown), \ + unit_test_setup_teardown(test_net_info_get_incorrect_length, setUp, tearDown), \ + unit_test_setup_teardown(test_net_info_get_ok, setUp, tearDown), \ + unit_test_setup_teardown(test_stats_get_invalid, setUp, tearDown), \ + unit_test_setup_teardown(test_stats_get_incorrect_length, setUp, tearDown), \ + unit_test_setup_teardown(test_stats_get_ok, setUp, tearDown), \ + unit_test_setup_teardown(test_dl_band_cfg_get_invalid, setUp, tearDown), \ + unit_test_setup_teardown(test_dl_band_cfg_get_incorrect_length, setUp, tearDown), \ + unit_test_setup_teardown(test_dl_band_cfg_get_ok, setUp, tearDown), \ + unit_test_setup_teardown(test_dl_band_cfg_set_invalid, setUp, tearDown), \ + unit_test_setup_teardown(test_dl_band_cfg_set_ok, setUp, tearDown), \ + unit_test_setup_teardown(test_connection_filter_get_invalid, setUp, tearDown), \ + unit_test_setup_teardown(test_connection_filter_get_incorrect_length, setUp, tearDown), \ + unit_test_setup_teardown(test_connection_filter_get_ok, setUp, tearDown), \ + unit_test_setup_teardown(test_connection_filter_set_ok, setUp, tearDown), \ + unit_test_setup_teardown(test_system_time_get_invalid, setUp, tearDown), \ + unit_test_setup_teardown(test_system_time_get_incorrect_length, setUp, tearDown), \ + unit_test_setup_teardown(test_system_time_get_ok, setUp, tearDown), \ + unit_test_setup_teardown(test_system_time_sync_invalid, setUp, tearDown), \ + unit_test_setup_teardown(test_system_time_sync_ok, setUp, tearDown), \ + unit_test_setup_teardown(test_message_send_invalid, setUp, tearDown), \ + unit_test_setup_teardown(test_message_send_ok, setUp, tearDown), \ + unit_test_setup_teardown(test_retrieve_message_invalid, setUp, tearDown), \ + unit_test_setup_teardown(test_retrieve_message_small_length, setUp, tearDown), \ + unit_test_setup_teardown(test_retrieve_message_incorrect_length, setUp, tearDown), \ + unit_test_setup_teardown(test_retrieve_message_ok, setUp, tearDown), \ + unit_test_setup_teardown(test_scan_config_set_ok, setUp, tearDown), \ + unit_test_setup_teardown(test_scan_config_set_invalid_scan_mode, setUp, tearDown), \ + unit_test_setup_teardown(test_scan_config_get_ok, setUp, tearDown), \ + unit_test_setup_teardown(test_connect_to_gw_channel_ok, setUp, tearDown), \ + diff --git a/test_ifc_lib/utils_ifc_lib.c b/test_ifc_lib/utils_ifc_lib.c index 23ed987..3695b4d 100644 --- a/test_ifc_lib/utils_ifc_lib.c +++ b/test_ifc_lib/utils_ifc_lib.c @@ -4,13 +4,14 @@ #include "embc/log.h" #include #include // memset, memcpy - +#include #include #include #include #include "cmockery.h" +//#define PRINT_ALL_BYTES struct fifo8_s * rd_fifo; @@ -134,6 +135,12 @@ int32_t transport_write(uint8_t *buff, uint16_t len) struct transport_expect_s * self = &transport_expect_; struct transport_single_s * s; +#ifdef PRINT_ALL_BYTES + printf("\nWRITE\n"); + for(int i = 0; ihead, self->tail); // "write when none expected"); assert_true(len + self->msg_len <= TRANSPORT_LEN_MAX); // "receive buffer overflow"); memcpy(&self->msg_buf[self->msg_len], buff, len); @@ -168,17 +175,24 @@ int32_t transport_read(uint8_t *buff, uint16_t len) return 1; } } + +#ifdef PRINT_ALL_BYTES + printf("\nREAD\n"); + for(int i = 0; i$(NULLDEVICE) 2>&1) +$(shell mkdir $(EXE_DIR)>$(NULLDEVICE) 2>&1) +$(shell mkdir $(LST_DIR)>$(NULLDEVICE) 2>&1) +ifeq (clean,$(findstring clean, $(MAKECMDGOALS))) + ifneq ($(filter $(MAKECMDGOALS),all debug release),) + $(shell $(RMFILES) $(OBJ_DIR)$(ALLFILES)>$(NULLDEVICE) 2>&1) + $(shell $(RMFILES) $(EXE_DIR)$(ALLFILES)>$(NULLDEVICE) 2>&1) + $(shell $(RMFILES) $(LST_DIR)$(ALLFILES)>$(NULLDEVICE) 2>&1) + endif +endif + + +#################################################################### +# Flags # +#################################################################### + +# -MMD : Don't generate dependencies on system header files. +# -MP : Add phony targets, useful when a h-file is removed from a project. +# -MF : Specify a file to write the dependencies to. +DEPFLAGS = -MMD -MP -MF $(@:.o=.d) + +# +# Add -Wa,-ahld=$(LST_DIR)/$(@F:.o=.lst) to CFLAGS to produce assembly list files +# +override CFLAGS += -Wall -Wextra -std=gnu99 -pedantic \ +-ffunction-sections -fdata-sections \ +$(DEPFLAGS) + +override ASMFLAGS += -x assembler-with-cpp -Wall -Wextra + +# +# NOTE: The -Wl,--gc-sections flag may interfere with debugging using gdb. +# +#override LDFLAGS += -Wl,--gc-sections + +#LIBS = -Wl,--start-group -lgcc -lc -lnosys -Wl,--end-group +LIBS = -lm + +INCLUDEPATHS += \ +-I$(MODULE_DIR)/cmockery \ +-I$(MODULE_DIR)/embc/inc \ +-I. \ +-I../inc \ +-I../src + +CTAGS_INCLUDEPATHS = $(subst -I,,$(INCLUDEPATHS)) + +#################################################################### +# Files # +#################################################################### +C_SRC += \ +$(MODULE_DIR)/cmockery/cmockery.c \ +$(MODULE_DIR)/embc/src/log.c \ +$(MODULE_DIR)/embc/src/dbc.c \ +$(MODULE_DIR)/embc/src/fifo.c \ +../src/ifc_struct_defs.c \ +../src/ll_ifc_no_mac.c \ +../src/ll_ifc_utils.c \ +../src/ll_ifc_ftp.c \ +../src/ll_ifc.c \ +utils.c \ +test_ifc_lib_utils.c \ +main.c + +s_SRC += + +S_SRC += + +#################################################################### +# Rules # +#################################################################### + +C_FILES = $(notdir $(C_SRC) ) +S_FILES = $(notdir $(S_SRC) $(s_SRC) ) +#make list of source paths, sort also removes duplicates +C_PATHS = $(sort $(dir $(C_SRC) ) ) +S_PATHS = $(sort $(dir $(S_SRC) $(s_SRC) ) ) + +C_OBJS = $(addprefix $(OBJ_DIR)/, $(C_FILES:.c=.o)) +S_OBJS = $(if $(S_SRC), $(addprefix $(OBJ_DIR)/, $(S_FILES:.S=.o))) +s_OBJS = $(if $(s_SRC), $(addprefix $(OBJ_DIR)/, $(S_FILES:.s=.o))) +C_DEPS = $(addprefix $(OBJ_DIR)/, $(C_FILES:.c=.d)) +OBJS = $(C_OBJS) $(S_OBJS) $(s_OBJS) + +vpath %.c $(C_PATHS) +vpath %.s $(S_PATHS) +vpath %.S $(S_PATHS) + +# Default build is debug +all: test + +debug: CFLAGS += -DDEBUG -O0 -g -DUNIT_TESTING +debug: $(EXE_DIR)/$(PROJECTNAME) + +# Create objects from C SRC files +$(OBJ_DIR)/%.o: %.c + @echo "Building file: $<" + $(CC) $(CFLAGS) $(INCLUDEPATHS) -c -o $@ $< + +# Assemble .s/.S files +$(OBJ_DIR)/%.o: %.s + @echo "Assembling $<" + $(CC) $(ASMFLAGS) $(INCLUDEPATHS) -c -o $@ $< + +$(OBJ_DIR)/%.o: %.S + @echo "Assembling $<" + $(CC) $(ASMFLAGS) $(INCLUDEPATHS) -c -o $@ $< + +# Link +$(EXE_DIR)/$(PROJECTNAME): $(OBJS) + @echo "Linking target: $@" + $(CC) $(LDFLAGS) $(OBJS) $(LIBS) -o $(EXE_DIR)/$(PROJECTNAME) + +test: debug + ./exe/$(PROJECTNAME) + +clean: +ifeq ($(filter $(MAKECMDGOALS),all debug release),) + $(RMDIRS) $(OBJ_DIR) $(LST_DIR) $(EXE_DIR) +endif + +# include auto-generated dependency files (explicit rules) +ifneq (clean,$(findstring clean, $(MAKECMDGOALS))) +-include $(C_DEPS) +endif + +ctags: + ctags -R $(C_PATHS) $(S_PATHS) $(CTAGS_INCLUDEPATHS) diff --git a/test_utils/main.c b/test_utils/main.c new file mode 100644 index 0000000..874e027 --- /dev/null +++ b/test_utils/main.c @@ -0,0 +1,20 @@ +#include "test_ifc_lib_utils.h" + +#include +#include +#include +#include "cmockery.h" + + +int main(int argc, char* argv[]) { + (void) argc; + (void) argv; + + srand(time(NULL)); + + UnitTest tests[] = { + UTILS_IFC_LIB_TESTS + }; + + return run_tests(tests); +} diff --git a/test_utils/test_ifc_lib_utils.c b/test_utils/test_ifc_lib_utils.c new file mode 100644 index 0000000..27c43f8 --- /dev/null +++ b/test_utils/test_ifc_lib_utils.c @@ -0,0 +1,236 @@ +#include "ll_ifc.h" + +#include +#include // memset, memcpy +#include +#include +#include +#include +#include +#include "cmockery.h" + +struct time sudo_time = { 0 , 0 }; + +int32_t gettime(struct time *tp) +{ + tp->tv_sec = sudo_time.tv_sec; + tp->tv_nsec = sudo_time.tv_nsec; +} + +void setUpRandom(void **state) +{ +// srand(time(NULL)); +} + +void tearDown(void **state) +{ + // Nothing to do +} + +void test_utils_difftime_random_positive(void **state) +{ + for (unsigned int i = 0; i < 100; i++) + { + struct time now = { + .tv_sec = rand() % LONG_MAX, + .tv_nsec = rand() % LONG_MAX + }; + + struct time then = { + .tv_sec = rand() % LONG_MAX, + .tv_nsec = rand() % LONG_MAX + }; + + long sec; + long nsec; + + if (then.tv_sec < now.tv_sec) + { + sec = then.tv_sec - now.tv_sec; + nsec = then.tv_nsec - now.tv_nsec; + if (nsec < 0) + { + sec --; + } + nsec = (nsec + 1000) % 1000; + + assert_int_equal(ll_difftime(&now, &then), sec); + } + else + { + sec = now.tv_sec - then.tv_sec; + nsec = now.tv_nsec - then.tv_nsec; + if (nsec < 0) + { + sec --; + } + nsec = (nsec + 1000) % 1000; + + assert_int_equal(ll_difftime(&then, &now), sec); + } + + // printf("Passed iteration %i [ difftime = %i || now (%i:%i) || then (%i:%i) ]\n", i + 1, sec, now.tv_sec, now.tv_nsec, then.tv_sec, then.tv_nsec); + } +} + +void test_utils_difftime_random_negative(void **state) +{ + for (unsigned int i = 0; i < 100; i++) + { + struct time now = { + .tv_sec = LONG_MIN + (rand() % LONG_MAX), + .tv_nsec = LONG_MIN + (rand() % LONG_MAX) + }; + + struct time then = { + .tv_sec = rand() % LONG_MAX, + .tv_nsec = rand() % LONG_MAX + }; + + long sec; + long nsec; + + if (then.tv_sec < now.tv_sec) + { + sec = then.tv_sec - now.tv_sec; + nsec = then.tv_nsec - now.tv_nsec; + if (nsec < 0) + { + sec --; + } + nsec = (nsec + 1000) % 1000; + + assert_int_equal(ll_difftime(&now, &then), sec); + } + else + { + sec = now.tv_sec - then.tv_sec; + nsec = now.tv_nsec - then.tv_nsec; + if (nsec < 0) + { + sec --; + } + nsec = (nsec + 1000) % 1000; + + assert_int_equal(ll_difftime(&then, &now), sec); + } + + // printf("Passed iteration %i [ difftime = %i || now (%i:%i) || then (%i:%i) ]\n", i + 1, sec, now.tv_sec, now.tv_nsec, then.tv_sec, then.tv_nsec); + } +} + +void test_utils_difftime_limits(void **state) +{ + +} + +void test_utils_difftime_now_random_positive(void **state) +{ + for (unsigned int i = 0; i < 100; i++) + { + struct time time1 = { + .tv_sec = rand() % LONG_MAX, + .tv_nsec = rand() % LONG_MAX + }; + + struct time time2 = { + .tv_sec = rand() % LONG_MAX, + .tv_nsec = rand() % LONG_MAX + }; + + long sec; + long nsec; + + if (time1.tv_sec < time2.tv_sec) + { + sudo_time.tv_sec = time2.tv_sec; + sudo_time.tv_nsec = time2.tv_nsec; + + sec = time1.tv_sec - sudo_time.tv_sec; + nsec = time1.tv_nsec - sudo_time.tv_nsec; + } + else + { + sudo_time.tv_sec = time1.tv_nsec; + sudo_time.tv_nsec = time1.tv_nsec; + + sec = time2.tv_sec - sudo_time.tv_sec; + nsec = time2.tv_nsec - sudo_time.tv_nsec; + } + + if (nsec < 0) + { + sec --; + } + nsec = (nsec + 1000) % 1000; + + if (time1.tv_sec < time2.tv_sec) + { + assert_int_equal(ll_difftime_from_now(&time1), sec); + // printf("Passed iteration %i [ difftime = %i || now (%i:%i) || then (%i:%i) ]\n", i + 1, sec, sudo_time.tv_sec, sudo_time.tv_nsec, time1.tv_sec, time1.tv_nsec); + } + else + { + assert_int_equal(ll_difftime_from_now(&time2), sec); + // printf("Passed iteration %i [ difftime = %i || now (%i:%i) || then (%i:%i) ]\n", i + 1, sec, sudo_time.tv_sec, sudo_time.tv_nsec, time2.tv_sec, time2.tv_nsec); + } + } +} + +void test_utils_difftime_now_random_negative(void **state) +{ + for (unsigned int i = 0; i < 100; i++) + { + struct time time1 = { + .tv_sec = LONG_MIN + (rand() % LONG_MAX), + .tv_nsec = LONG_MIN + (rand() % LONG_MAX) + }; + + struct time time2 = { + .tv_sec = LONG_MIN + (rand() % LONG_MAX), + .tv_nsec = LONG_MIN + (rand() % LONG_MAX) + }; + + long sec; + long nsec; + + if (time1.tv_sec < time2.tv_sec) + { + sudo_time.tv_sec = time1.tv_sec; + sudo_time.tv_nsec = time1.tv_nsec; + + sec = time2.tv_sec - sudo_time.tv_sec; + nsec = time2.tv_nsec - sudo_time.tv_nsec; + } + else + { + sudo_time.tv_sec = time2.tv_nsec; + sudo_time.tv_nsec = time2.tv_nsec; + + sec = time1.tv_sec - sudo_time.tv_sec; + nsec = time1.tv_nsec - sudo_time.tv_nsec; + } + + if (nsec < 0) + { + sec --; + } + nsec = (nsec + 1000) % 1000; + + if (time1.tv_sec < time2.tv_sec) + { + assert_int_equal(ll_difftime_from_now(&time2), sec); + // printf("Passed iteration %i [ difftime = %i || now (%i:%i) || then (%i:%i) ]\n", i + 1, sec, sudo_time.tv_sec, sudo_time.tv_nsec, time1.tv_sec, time1.tv_nsec); + } + else + { + assert_int_equal(ll_difftime_from_now(&time1), sec); + // printf("Passed iteration %i [ difftime = %i || now (%i:%i) || then (%i:%i) ]\n", i + 1, sec, sudo_time.tv_sec, sudo_time.tv_nsec, time2.tv_sec, time2.tv_nsec); + } + } +} + +void test_utils_difftime_now_limits(void **state) +{ + +} diff --git a/test_utils/test_ifc_lib_utils.h b/test_utils/test_ifc_lib_utils.h new file mode 100644 index 0000000..901c344 --- /dev/null +++ b/test_utils/test_ifc_lib_utils.h @@ -0,0 +1,21 @@ +#include "ll_ifc_utils.h" + +void setUpRandom(void **state); +void tearDown(void **state); + +void test_utils_difftime_random_positive(void **state); +void test_utils_difftime_random_negative(void **state); +void test_utils_difftime_limits(void **state); +void test_utils_difftime_now_random_positive(void **state); +void test_utils_difftime_now_random_negative(void **state); +void test_utils_difftime_now_limits(void **state); + +#define UTILS_IFC_LIB_TESTS \ + unit_test_setup_teardown(test_utils_difftime_random_positive, setUpRandom, tearDown), \ + unit_test_setup_teardown(test_utils_difftime_random_negative, setUpRandom, tearDown), \ + unit_test(test_utils_difftime_limits), \ + unit_test(test_utils_difftime_now_limits) + + +// unit_test_setup_teardown(test_utils_difftime_now_random_positive, setUpRandom, tearDown), \ +// unit_test_setup_teardown(test_utils_difftime_now_random_negative, setUpRandom, tearDown), \ diff --git a/test_utils/utils.c b/test_utils/utils.c new file mode 100644 index 0000000..dd7236b --- /dev/null +++ b/test_utils/utils.c @@ -0,0 +1,196 @@ +#include "ll_ifc.h" +#include "embc/fifo.h" +#include "embc/log.h" +#include +#include // memset, memcpy +#include "ll_ifc_symphony.h" + +#include +#include +#include +#include "cmockery.h" + +#define TRANSPORT_LEN_MAX 256 +#define TRANSPORT_INVOKE_MAX 16 + +struct fifo8_s * rd_fifo; + +int32_t ll_ul_max_port = 127; + +int32_t ll_config_set(uint32_t net_token, const uint8_t app_token[APP_TOKEN_LEN], enum ll_downlink_mode dl_mode, uint8_t qos) +{ + (void) net_token; + (void) app_token; + (void) dl_mode; + (void) qos; + return 0; +} + +int32_t ll_config_get(uint32_t *net_token, uint8_t app_token[APP_TOKEN_LEN], enum ll_downlink_mode * dl_mode, uint8_t *qos) +{ + (void) net_token; + (void) app_token; + *dl_mode = LL_DL_OFF; + (void) qos; + return 0; +} + +uint32_t log_timestamp_us( void ) { + return 0; +} + +void log_printf(const char * format, ...) { + (void) format; +} + +void dbc_assert(char const *file, unsigned line, const char * msg) { + (void) file; + (void) line; + (void) msg; +} + +int32_t sleep_ms(int32_t millis) +{ + (void) millis; + return 0; +} + +struct transport_single_s { + uint8_t wr_buf[TRANSPORT_LEN_MAX]; + uint16_t wr_len; + uint8_t rd_buf[TRANSPORT_LEN_MAX]; + uint16_t rd_len; +}; + +struct transport_expect_s { + struct transport_single_s buffer[TRANSPORT_INVOKE_MAX]; + int head; + int tail; + + uint8_t message_num; + uint8_t msg_buf[TRANSPORT_LEN_MAX]; + uint16_t msg_len; +}; + +struct transport_expect_s transport_expect_; + +uint16_t compute_checksum(uint8_t const * buf, uint16_t len) +{ + uint16_t i; + uint16_t crc = 0; + for(i = 0; i < len; i++) + { + crc = (crc >> 8) | (crc << 8); + crc ^= buf[i]; + crc ^= (crc & 0xff) >> 4; + crc ^= crc << 12; + crc ^= (crc & 0xff) << 5; + } + return crc; +} + +void transport_expect( + uint8_t opcode, + uint8_t const * wr_buf, uint16_t wr_len, + uint8_t ack, + uint8_t const * rd_buf, uint16_t rd_len) +{ + uint16_t crc; + struct transport_expect_s * self = &transport_expect_; + struct transport_single_s * s; + int next = self->head + 1; + if (next >= TRANSPORT_INVOKE_MAX) + { + next = 0; + } + assert_true(next != self->tail); + assert_true(wr_len <= TRANSPORT_LEN_MAX - 11); + assert_true(rd_len <= TRANSPORT_LEN_MAX - 8); + s = &self->buffer[self->head]; + + // construct command + s->wr_len = 11 + wr_len; + s->wr_buf[0] = 0xff; + s->wr_buf[1] = 0xff; + s->wr_buf[2] = 0xff; + s->wr_buf[3] = 0xff; + s->wr_buf[4] = 0xc4; + s->wr_buf[5] = opcode; + s->wr_buf[6] = self->message_num; + s->wr_buf[7] = (wr_len >> 8) & 0xff; + s->wr_buf[8] = (wr_len >> 0) & 0xff; + memcpy(&s->wr_buf[9], wr_buf, wr_len); + crc = compute_checksum(s->wr_buf + 4, s->wr_len - 6); + s->wr_buf[s->wr_len - 2] = (crc >> 8) & 0xff; + s->wr_buf[s->wr_len - 1] = (crc >> 0) & 0xff; + + // construct response + s->rd_len = 8 + rd_len; + s->rd_buf[0] = 0xc4; + s->rd_buf[1] = opcode; + s->rd_buf[2] = self->message_num; + s->rd_buf[3] = ack; + s->rd_buf[4] = (rd_len >> 8) & 0xff; + s->rd_buf[5] = (rd_len >> 0) & 0xff; + memcpy(&s->rd_buf[6], rd_buf, rd_len); + crc = compute_checksum(s->rd_buf, s->rd_len - 2); + s->rd_buf[s->rd_len - 2] = (crc >> 8) & 0xff; + s->rd_buf[s->rd_len - 1] = (crc >> 0) & 0xff; + + self->head = next; + self->message_num++; +} + +int32_t transport_write(uint8_t *buff, uint16_t len) +{ + struct transport_expect_s * self = &transport_expect_; + struct transport_single_s * s; + + //assert_int_not_equal(self->head, self->tail); // "write when none expected"); + assert_true(len + self->msg_len <= TRANSPORT_LEN_MAX); // "receive buffer overflow"); + memcpy(&self->msg_buf[self->msg_len], buff, len); + self->msg_len += len; + + s = &self->buffer[self->tail]; + if (self->msg_len >= s->wr_len) + { + int next = self->tail + 1; + if (next >= TRANSPORT_INVOKE_MAX) + { + next = 0; + } + assert_memory_equal(s->wr_buf, self->msg_buf, s->wr_len); + memcpy(self->msg_buf, self->msg_buf + s->wr_len, self->msg_len - s->wr_len); + self->msg_len -= s->wr_len; + if (s->rd_len) { + fifo_size_t actual_size; + assert_int_equal(0, fifo8_write(rd_fifo, s->rd_buf, (fifo_size_t) s->rd_len, &actual_size)); + assert_int_equal(actual_size, s->rd_len); + } + self->tail = next; + } + return 0; +} + +int32_t transport_read(uint8_t *buff, uint16_t len) +{ + uint16_t i; + for (i = 0; i < len; ++i) { + if (fifo8_read_u8(rd_fifo, buff++)) { + return 1; + } + } + return 0; +} + +void ifc_utils_setup(void) +{ + memset(&transport_expect_, 0, sizeof(transport_expect_)); + assert_int_equal(0, fifo8_alloc(&rd_fifo, TRANSPORT_LEN_MAX + TRANSPORT_INVOKE_MAX)); + assert_true(0 != rd_fifo); +} + +void ifc_utils_teardown(void) +{ + fifo8_free(rd_fifo); +} diff --git a/test_utils/utils.h b/test_utils/utils.h new file mode 100644 index 0000000..e718c16 --- /dev/null +++ b/test_utils/utils.h @@ -0,0 +1,10 @@ +#ifndef UTILS_H +#define UTILS_H + +#include + +void ifc_utils_setup(void); +void ifc_utils_teardown(void); + +#endif + From ead1dad6b84243cda268e172d621e6b6cd34a5db Mon Sep 17 00:00:00 2001 From: Scott Wohler Date: Fri, 28 Jun 2019 14:33:34 -0400 Subject: [PATCH 08/33] Remove PACKED def, add new types * Require PACKED to be defined at project level --- inc/ifc_struct_defs.h | 10 +++------- inc/ll_ifc_consts.h | 13 ++++++++----- 2 files changed, 11 insertions(+), 12 deletions(-) diff --git a/inc/ifc_struct_defs.h b/inc/ifc_struct_defs.h index 282073f..deab3d0 100644 --- a/inc/ifc_struct_defs.h +++ b/inc/ifc_struct_defs.h @@ -3,6 +3,8 @@ #include +#include "ll_mac_config.h" + #define NET_INFO_BUFF_SIZE (31) #define DL_BAND_CFG_SIZE (3 * 4 + 2) #define STATS_SIZE (10 * 4) @@ -15,13 +17,7 @@ #define GW_SCAN_INFO_BUFF_SIZE (MAX_GW_SCAN_RESULTS * GW_SCAN_INFO_SIZE + 1) #ifndef PACKED -#ifdef __GNU_C__ -#define PACKED __attribute((__packed__)) -#else -#ifndef PACKED -#define PACKED -#endif -#endif + #error "PACKED must be defined for the compiler platform" #endif #ifdef __cplusplus diff --git a/inc/ll_ifc_consts.h b/inc/ll_ifc_consts.h index 39b7d60..f6dbe89 100644 --- a/inc/ll_ifc_consts.h +++ b/inc/ll_ifc_consts.h @@ -159,7 +159,8 @@ typedef enum LLRXR26_V2 = 2, ///< 0x02 LLRLP20_V3 = 3, ///< 0x03 LLRXR26_V3 = 4, ///< 0x04 - LLREPEATER = 5 ///< 0x05 AES_TODO - Replace with official part number? + LLREPEATER = 5, ///< 0x05 AES_TODO - Replace with official part number? + LLSLAP_HOST = 16 ///< 0x10 } ll_hardware_type_t; /** @@ -171,14 +172,16 @@ typedef enum CPU_EFM32G210F128 = 1, ///< 0x01 CPU_R5F51115ADNE = 2, ///< 0x02 CPU_R5F51116ADNE = 3, ///< 0x03 - CPU_EFM32GG232F1024 = 4 ///< 0x04 + CPU_EFM32GG232F1024 = 4, ///< 0x04 + CPU_NRF52840 = 16 ///< 0x10 } cpu_code_t; typedef enum { - GATEWAY_TX_ONLY = 0, ///< 0x00 - MODULE_END_NODE = 1, ///< 0x01 - REPEATER_HOST = 2 ///< 0x02 + GATEWAY_TX_ONLY = 0, ///< 0x00 + MODULE_END_NODE = 1, ///< 0x01 + REPEATER_HOST = 2, ///< 0x02 + RADIO_INTEGRATED = 16 ///< 0x10 // TBD - How to define others ? } functionality_code_t; From 127d00475604c1bcea892a67b94da998964c0fde Mon Sep 17 00:00:00 2001 From: Joe Boring Date: Fri, 9 Aug 2019 09:50:03 -0400 Subject: [PATCH 09/33] incremental change still have issue with communication after info scan --- inc/ifc_struct_defs.h.bak | 250 ++++++++++ inc/ll_ifc_consts.h.bak | 389 +++++++++++++++ inc/ll_ifc_consts.h.bak.bak | 367 ++++++++++++++ inc/ll_ifc_symphony.h.bak | 375 +++++++++++++++ src/ifc_struct_defs.c.bak | 148 ++++++ src/ll_ifc.c.bak | 692 +++++++++++++++++++++++++++ src/ll_ifc_ftp.c.bak | 866 ++++++++++++++++++++++++++++++++++ src/ll_ifc_no_mac.c.bak | 368 +++++++++++++++ src/ll_ifc_symphony.c.bak | 661 ++++++++++++++++++++++++++ src/ll_ifc_symphony.c.bak.bak | 661 ++++++++++++++++++++++++++ 10 files changed, 4777 insertions(+) create mode 100644 inc/ifc_struct_defs.h.bak create mode 100644 inc/ll_ifc_consts.h.bak create mode 100644 inc/ll_ifc_consts.h.bak.bak create mode 100644 inc/ll_ifc_symphony.h.bak create mode 100644 src/ifc_struct_defs.c.bak create mode 100644 src/ll_ifc.c.bak create mode 100644 src/ll_ifc_ftp.c.bak create mode 100644 src/ll_ifc_no_mac.c.bak create mode 100644 src/ll_ifc_symphony.c.bak create mode 100644 src/ll_ifc_symphony.c.bak.bak diff --git a/inc/ifc_struct_defs.h.bak b/inc/ifc_struct_defs.h.bak new file mode 100644 index 0000000..7861faf --- /dev/null +++ b/inc/ifc_struct_defs.h.bak @@ -0,0 +1,250 @@ +#ifndef __IFC_STRUCT_DEFS_H_ +#define __IFC_STRUCT_DEFS_H_ + +#include + +#define NET_INFO_BUFF_SIZE (30) +#define DL_BAND_CFG_SIZE (3 * 4 + 2) +#define STATS_SIZE (10 * 4) +#define TIME_INFO_SIZE (6 * 2 + 1) + +#ifndef PACKED +#if defined ( __CC_ARM ) + #define PACKED(TYPE) __packed TYPE +#elif defined(__GNUC__) || defined(__GNU_C__) + #define PACKED __attribute__ ((packed)) +#elif defined (__ICCARM__) + #define PACKED_STRUCT __packed struct +#else + #error "PACKED must be defined for the platform!" +#endif +#endif + +#ifdef __cplusplus +extern "C" { +#endif + +/** + * @addtogroup Link_Labs_Interface_Library + * @{ + */ + +/** + * @addtogroup Module_Interface + * @brief + * @{ + */ + + +typedef enum +{ + LLABS_CONNECT_INITIAL = 0, ///< 0x00 + LLABS_CONNECT_DISCONNECTED, ///< 0x01 + LLABS_CONNECT_CONNECTED, ///< 0x02 + LLABS_NUM_CONNECT_STATUSES ///< 0x03 +} llabs_connect_status_t; + +typedef struct PACKED llabs_network_info_t +{ + uint32_t network_id_node; + uint32_t network_id_gw; + int8_t gateway_channel; + uint32_t gateway_frequency; + uint32_t last_rx_tick; + int16_t rssi; + int8_t snr; + llabs_connect_status_t connection_status; + uint8_t is_scanning_gateways; + uint64_t gateway_id; +} llabs_network_info_t; + +// Defines the band-specific frequency parameters (FCC 902-928, etc...) +typedef struct PACKED llabs_dl_band_cfg +{ + uint32_t band_edge_lower; + uint32_t band_edge_upper; + uint32_t band_edge_guard; + uint8_t chan_step_size; + uint8_t chan_step_offset; +} llabs_dl_band_cfg_t; + +typedef struct llabs_stats +{ + uint32_t num_send_calls; ///< Number of times SendMessage has been called successfully + uint32_t num_pkts_transmitted; ///< Number of packet transmissions (includes retries) + uint32_t num_gateway_scans; ///< Number of gateway scans + uint32_t num_collisions; ///< Number of CSMA collisions detected + uint32_t num_ack_successes; ///< Number of successful acknowledgments + uint32_t num_ack_failures; ///< Number of failed acknowledgments + uint32_t num_sync_failures; ///< Number of Sync failures + uint32_t num_canceled_pkts_ack; ///< Number of times packet was canceled due to LLABS_ACK_FAIL_RETRIES + uint32_t num_canceled_pkts_csma; ///< Number of times packet was canceled due to LLABS_MAX_CSMA_COLLISIONS + uint32_t num_rx_errors; ///< Number of times we received a Rx error from the back end +} llabs_stats_t; + +typedef struct PACKED llabs_time +{ + uint32_t seconds; ///< Seconds since UNIX epoch 00:00:00 UTC on 1 January 1970 + uint16_t millis; ///< number of milliseconds since time seconds since the epoch +} llabs_time_t; + +typedef struct PACKED llabs_time_info +{ + uint8_t sync_mode; ///< 0: Time sync only when requested, 1: Time sync opportunistically + llabs_time_t curr; + llabs_time_t last_sync; +} llabs_time_info_t; + +void ll_net_info_deserialize(const uint8_t buff[NET_INFO_BUFF_SIZE], llabs_network_info_t * net_info); +uint16_t ll_net_info_serialize(const llabs_network_info_t * net_info, uint8_t buff[NET_INFO_BUFF_SIZE]); +void ll_dl_band_cfg_deserialize(const uint8_t buff[DL_BAND_CFG_SIZE], llabs_dl_band_cfg_t * dl_cfg); +uint16_t ll_dl_band_cfg_serialize(const llabs_dl_band_cfg_t * dl_cfg, uint8_t buff[DL_BAND_CFG_SIZE]); +void ll_stats_deserialize(const uint8_t buff[STATS_SIZE], llabs_stats_t * stats); +uint16_t ll_stats_serialize(const llabs_stats_t * stats, uint8_t buff[STATS_SIZE]); +void ll_time_deserialize(const uint8_t buff[TIME_INFO_SIZE], llabs_time_info_t *time_info); +uint16_t ll_time_serialize(const llabs_time_info_t *time_info, uint8_t buff[TIME_INFO_SIZE]); + + +/** @} (end addtogroup Module_Interface) */ + +/* + * @defgroup ifc_serialize Serialization utilities + * @private + * @brief Format common data types for the host IFC message + * protocol. + * + * The utility functions contained in this group serialize (marshal) and + * deserialize (unmarshal) the common integer datatypes exchanged within + * messages over the host interface. The write_* functions serialize an + * integer into a byte stream , and the read_* functions deserialize an + * integer from a byte stream. + * + * See + * serialization on Wikipedia for more details about why these functions + * exist. + */ + /** + * @{ + */ + +/** + * @brief + * Read a u8 from the buffer [not memory safe]. + * + * @private + * @param[inout] buffer + * The pointer to the big-endian buffer. The pointer is + * incremented to the next location past the value read. + * + * @return + * The u8 read from the buffer. + */ +uint8_t read_uint8(const uint8_t ** buffer); + +/** + * @brief + * Read a u16 from the buffer [not memory safe]. + * + * @private + * @param[inout] buffer + * The pointer to the big-endian buffer. The pointer is + * incremented to the next location past the value read. + * + * @return + * The u16 read from the buffer. + */ +uint16_t read_uint16(const uint8_t ** buffer); + +/** + * @brief + * Read a u32 from the buffer [not memory safe]. + * + * @private + * @param[inout] buffer + * The pointer to the big-endian buffer. The pointer is + * incremented to the next location past the value read. + * + * @return + * The u32 read from the buffer. + */ +uint32_t read_uint32(const uint8_t ** buffer); + +/** + * @brief + * Read a u64 from the buffer [not memory safe]. + * + * @private + * @param[inout] buffer + * The pointer to the big-endian buffer. The pointer is + * incremented to the next location past the value read. + * + * @return + * The u64 read from the buffer. + */ +uint64_t read_uint64(const uint8_t ** buffer); + +/** + * @brief + * Write a u8 to the buffer [not memory safe]. + * + * @private + * @param[in] x + * The u8 to write. + * + * @param[inout] buffer + * The pointer to the big-endian buffer. The pointer is + * incremented to the next location past the value written. + */ +void write_uint8(uint8_t x, uint8_t ** buffer); + +/** + * @brief + * Write a u16 to the buffer [not memory safe]. + * + * @private + * @param[in] x + * The u16 to write. + * + * @param[inout] buffer + * The pointer to the big-endian buffer. The pointer is + * incremented to the next location past the value written. + */ +void write_uint16(uint16_t x, uint8_t ** buffer); + +/** + * @brief + * Write a u32 to the buffer [not memory safe]. + * + * @private + * @param[in] x + * The u32 to write. + * + * @param[inout] buffer + * The pointer to the big-endian buffer. The pointer is + * incremented to the next location past the value written. + */ +void write_uint32(uint32_t x, uint8_t ** buffer); + +/** + * @brief + * Write a u64 to the buffer [not memory safe]. + * + * @private + * @param[in] x + * The u64 to write. + * + * @param[inout] buffer + * The pointer to the big-endian buffer. The pointer is + * incremented to the next location past the value written. + */ +void write_uint64(uint64_t x, uint8_t ** buffer); + +/** @} (end defgroup ifc_serialize) */ + +/** @} (end addtogroup Link_Labs_Interface_Library) */ + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/inc/ll_ifc_consts.h.bak b/inc/ll_ifc_consts.h.bak new file mode 100644 index 0000000..d99b7f0 --- /dev/null +++ b/inc/ll_ifc_consts.h.bak @@ -0,0 +1,389 @@ +#ifndef __LL_IFC_CONSTS_H +#define __LL_IFC_CONSTS_H + +#include + +/** + * @addtogroup Link_Labs_Interface_Library + * @{ + */ + +/** + * @addtogroup Module_Interface + * @brief + * @{ + */ + +#define IFC_VERSION_MAJOR (0) +#define IFC_VERSION_MINOR (8) +#define IFC_VERSION_TAG (0) + +#define APP_TOKEN_LEN (10) +#define UNIQUE_ID_LEN (8) +#define MAX_RX_MSG_LEN (128) + +extern const uint32_t OPEN_NET_TOKEN; ///< Open network token (0x4f50454e) + +typedef enum +{ + OP_VERSION = 0, ///< 0x00 + OP_IFC_VERSION = 1, ///< 0x01 + OP_STATE = 2, ///< 0x02 + OP_TX_STATE = 3, ///< 0x03 + OP_RX_STATE = 4, ///< 0x04 + OP_FREQUENCY = 6, ///< 0x06 + OP_TX_POWER_SET = 7, ///< 0x07 + OP_RESET_SETTINGS = 8, ///< 0x08 + OP_GET_RADIO_PARAMS = 9, ///< 0x09 + OP_SET_RADIO_PARAMS = 10, ///< 0x0A + OP_PKT_SEND_QUEUE = 11, ///< 0x0B + OP_TX_POWER_GET = 12, ///< 0x0C + OP_SYNC_WORD_SET = 13, ///< 0x0D + OP_SYNC_WORD_GET = 14, ///< 0x0E + OP_IRQ_FLAGS = 15, ///< 0x0F + OP_IRQ_FLAGS_MASK = 16, ///< 0x10 + OP_SLEEP = 20, ///< 0x14 + OP_SLEEP_BLOCK = 21, ///< 0x15 + OP_PKT_ECHO = 31, ///< 0x1F + OP_PKT_RECV = 40, ///< 0x28 + OP_MSG_RECV_RSSI = 41, ///< 0x29 - Deprecated for Symphony mode + OP_PKT_RECV_CONT = 42, ///< 0x2A + OP_MSG_RECV = 43, ///< 0x2B + OP_MODULE_ID = 50, ///< 0x32 + OP_STORE_SETTINGS = 51, ///< 0x33 + OP_DELETE_SETTINGS = 52, ///< 0x34 + OP_RESET_MCU = 60, ///< 0x3C + OP_TRIGGER_BOOTLOADER = 61, ///< 0x3D + OP_MAC_MODE_SET = 70, ///< 0x46 + OP_MAC_MODE_GET = 71, ///< 0x47 +//STRIPTHIS!START + OP_RESERVED_LIFERAFT0 = 72, ///< 0x48 - Liferaft Specific (Do not use!) +//STRIPTHIS!STOP + OP_MSG_SEND_ACK = 90, ///< 0x5A - Deprecated + OP_MSG_SEND_UNACK = 91, ///< 0x5B - Deprecated + OP_MSG_SEND = 92, ///< 0x5C + OP_CONN_FILT_SET = 93, ///< 0x5D + OP_CONN_FILT_GET = 94, ///< 0x5E +//STRIPTHIS!START + OP_RESERVED0 = 96, ///< 0x5F + OP_RESERVED1 = 97, ///< 0x60 +//STRIPTHIS!STOP + OP_TX_CW = 98, ///< 0x61 + OP_SYSTEM_TIME_GET = 108, ///< 0x6C + OP_SYSTEM_TIME_SYNC = 109, ///< 0x6D + OP_RX_MODE_SET = 110, ///< 0x6E + OP_RX_MODE_GET = 111, ///< 0x6F + OP_QOS_REQUEST = 112, ///< 0x70 + OP_QOS_GET = 113, ///< 0x71 + OP_ANTENNA_SET = 114, ///< 0x72 + OP_ANTENNA_GET = 115, ///< 0x73 + OP_NET_TOKEN_SET = 116, ///< 0x74 + OP_NET_TOKEN_GET = 117, ///< 0x75 + OP_NET_INFO_GET= 118, ///< 0x76 + OP_STATS_GET = 119, ///< 0x77 + OP_RSSI_SET = 120, ///< 0x78 + OP_RSSI_GET = 121, ///< 0x79 + OP_DL_BAND_CFG_GET = 122, ///< 0x7A + OP_DL_BAND_CFG_SET = 123, ///< 0x7B + OP_APP_TOKEN_SET = 124, ///< 0x7C + OP_APP_TOKEN_GET = 125, ///< 0x7D + OP_APP_TOKEN_REG_GET = 126, ///< 0x7E + OP_CRYPTO_KEY_XCHG_REQ = 128, ///< 0x80 + OP_MAILBOX_REQUEST = 129, ///< 0x81 +//STRIPTHIS!START + OP_RESERVED_LIFERAFT1 = 130, ///< 0x82 - Liferaft Specific (Do not use!) + OP_TIMESTAMP = 131, ///< 0x83 reserved, not fully implemented + OP_SEND_TIMESTAMP = 132, ///< 0x84 reserved, not fully implemented +//STRIPTHIS!STOP + OP_GET_SCAN_INFO = 133, ///< 0x85 + OP_CONN_TO_GW_CH = 134, ///< 0x86 + OP_DISCONNECT = 135, ///< 0x87 + OP_SCAN_MODE_GET = 136, ///< 0x88 + OP_SCAN_MODE_SET = 137, ///< 0x89 + OP_SCAN_THRESHOLD_GET = 138, ///< 0x8A + OP_SCAN_THRESHOLD_SET = 139, ///< 0x8B + OP_SCAN_ATTEMPTS_GET = 140, ///< 0x8C + OP_SCAN_ATTEMPTS_SET = 141, ///< 0x8D + OP_SCAN_ATTEMPTS_LEFT = 142, ///< 0x8E + OP_RSSI_OFFSET_GET = 143, ///< 0x8F + OP_RSSI_OFFSET_SET = 144, ///< 0x90 + OP_CTRL_MSG_ENABLED_SET = 145, ///< 0x91 + OP_CTRL_MSG_ENABLED_GET = 146, ///< 0x92 + OP_GPIO_ENABLE_PIN = 147, ///< 0x93 + OP_GPIO_DISABLE_PIN = 148, ///< 0x94 + OP_GPIO_PIN_STATUS = 149, ///< 0x95 + OP_GPIO_SET_HIGH = 150, ///< 0x96 + OP_GPIO_SET_LOW = 151, ///< 0x97 +//STRIPTHIS!START + OP_FCC_TEST = 245, ///< 0xF5 + OP_PER_TEST_TX = 246, ///< 0xF6 + OP_PER_TEST_RX = 247, ///< 0xF7 + OP_GET_ASSERT = 248, ///< 0xF8 + OP_SET_ASSERT = 249, ///< 0xF9 +//STRIPTHIS!STOP + OP_HARDWARE_TYPE = 254, ///< 0xFE + OP_FIRMWARE_TYPE = 255 ///< 0xFF +} opcode_t; + +typedef enum +{ + FRAME_START = 0xC4 ///< 0xC4 +} frame_t; + +typedef enum +{ + LORA_NO_MAC = 0, ///< 0x00 + DEPRECATED_MAC1, ///< 0x01 + DEPRECATED_MAC2, ///< 0x02 + SYMPHONY_LINK, ///< 0x03 + NUM_MACS, ///< Total number of MAC modes + MAC_INVALID = 255, ///< 0xFF +} ll_mac_type_t; + +/** + * version struct + */ +typedef struct { + uint8_t major; + uint8_t minor; + uint16_t tag; +} ll_version_t; + +#define VERSION_LEN (4) + +// Hardware Types +typedef enum +{ + UNAVAILABLE = 0, ///< 0x00 + LLRLP20_V2 = 1, ///< 0x01 + LLRXR26_V2 = 2, ///< 0x02 + LLRLP20_V3 = 3, ///< 0x03 + LLRXR26_V3 = 4, ///< 0x04 + LLREPEATER = 5 ///< 0x05 AES_TODO - Replace with official part number? +} ll_hardware_type_t; + +/** + * Firmware identifiers + */ +typedef enum +{ + CPU_EFM32TG210F32 = 0, ///< 0x00 + CPU_EFM32G210F128 = 1, ///< 0x01 + CPU_R5F51115ADNE = 2, ///< 0x02 + CPU_R5F51116ADNE = 3, ///< 0x03 + CPU_EFM32GG232F1024 = 4 ///< 0x04 +} cpu_code_t; + +typedef enum +{ + GATEWAY_TX_ONLY = 0, ///< 0x00 + MODULE_END_NODE = 1, ///< 0x01 + REPEATER_HOST = 2 ///< 0x02 + // TBD - How to define others ? +} functionality_code_t; + +/** + * Link Labs LORA enumeration identifiers for Bandwidth + */ +typedef enum +{ + PROPERTY_LORA_BW_MIN = 0, ///< range limit value (lower) + PROPERTY_LORA_BW_62_5 = 0, ///< 62.5KHz BW + PROPERTY_LORA_BW_125 = 1, ///< 125KHz BW + PROPERTY_LORA_BW_250 = 2, ///< 250KHz BW + PROPERTY_LORA_BW_500 = 3, ///< 500KHz BW + PROPERTY_LORA_BW_MAX, ///< range limit value (upper) +} property_bw_t; + +/** + * Link Labs LORA enumeration identifiers for Spreading Factor + */ +typedef enum +{ + PROPERTY_LORA_SF_MIN = 6, ///< range limit value (lower) + PROPERTY_LORA_SF_6 = 6, ///< SF 6 + PROPERTY_LORA_SF_7 = 7, ///< SF 7 + PROPERTY_LORA_SF_8 = 8, ///< SF 8 + PROPERTY_LORA_SF_9 = 9, ///< SF 9 + PROPERTY_LORA_SF_10 = 10, ///< SF 10 + PROPERTY_LORA_SF_11 = 11, ///< SF 11 + PROPERTY_LORA_SF_12 = 12, ///< SF 12 + PROPERTY_LORA_SF_MAX, ///< range limit value (upper) +} property_sf_t; + +/** + * Link Labs LORA enumeration identifiers for Coding rate + */ +typedef enum +{ + PROPERTY_LORA_CR_MIN = 1, ///< range limit value (lower) + PROPERTY_LORA_CR_4_5 = 1, ///< 0x01 -- 4/5 + PROPERTY_LORA_CR_4_6 = 2, ///< 0x02 -- 4/6 + PROPERTY_LORA_CR_4_7 = 3, ///< 0x03 -- 4/7 + PROPERTY_LORA_CR_4_8 = 4, ///< 0x04 -- 4/8 + PROPERTY_LORA_CR_MAX, ///< range limit value (upper) +} property_cr_t; + +typedef struct { + uint16_t cpu_code; + uint16_t functionality_code; +} ll_firmware_type_t; + +#define FIRMWARE_TYPE_LEN (4) + +/** Possible downlink modes for OP_DOWNLINK_MODE */ +typedef enum +{ + DOWNLINK_MODE_OFF = 0, ///< 0x00 + DOWNLINK_MODE_ALWAYS_ON = 1, ///< 0x01 + DOWNLINK_MODE_MAILBOX = 2, ///< 0x02 + DOWNLINK_MODE_PERIODIC = 3, ///< 0x03 + NUM_DOWNLINK_MODES, + DOWNLINK_MODE_FAILURE = 255, ///< 0xFF +} downlink_mode_t; + +/** ACK/NACK Codes */ +#define LL_IFC_ACK (0) ///< All good. +#define LL_IFC_NACK_CMD_NOT_SUPPORTED (1) ///< Command not supported. +#define LL_IFC_NACK_INCORRECT_CHKSUM (2) ///< Incorrect Checksum. +#define LL_IFC_NACK_PAYLOAD_LEN_OOR (3) ///< Length of payload sent in command was out of range. +#define LL_IFC_NACK_PAYLOAD_OOR (4) ///< Payload sent in command was out of range. +#define LL_IFC_NACK_BOOTUP_IN_PROGRESS (5) ///< Not allowed since firmware bootup still in progress. Wait. +#define LL_IFC_NACK_BUSY_TRY_AGAIN (6) ///< Operation prevented by temporary event. Re-try should work. +#define LL_IFC_NACK_APP_TOKEN_REG (7) ///< Application token is not registered for this node. +#define LL_IFC_NACK_PAYLOAD_LEN_EXCEEDED (8) ///< Payload length is greater than the max supported length +#define LL_IFC_NACK_NOT_IN_MAILBOX_MODE (9) ///< Module must be in DOWNLINK_MAILBOX mode +#define LL_IFC_NACK_PAYLOAD_BAD_PROPERTY (10) ///< Invalid property specified in command +#define LL_IFC_NACK_NODATA (11) ///< No data is available to be returned +#define LL_IFC_NACK_QUEUE_FULL (12) ///< Data could not be enqueued for transmission (queue full) +#define LL_IFC_NACK_OTHER (99) +/* When adding a new value, update ll_return_code_name() and ll_return_code_description() */ + +/** Error Codes */ +/* Note: Error codes -1 to -99 map to NACK codes received from the radio */ +typedef enum ll_ifc_error_codes_e { + LL_IFC_ERROR_INCORRECT_PARAMETER = -101, ///< The parameter value was invalid. + LL_IFC_ERROR_INCORRECT_RESPONSE_LENGTH = -102, ///< Module response was not the expected size. + LL_IFC_ERROR_MESSAGE_NUMBER_MISMATCH = -103, ///< Message number in response doesn't match expected + LL_IFC_ERROR_CHECKSUM_MISMATCH = -104, ///< Checksum mismatch + LL_IFC_ERROR_COMMAND_MISMATCH = -105, ///< Command mismatch (responding to a different command) + LL_IFC_ERROR_HOST_INTERFACE_TIMEOUT = -106, ///< Timed out waiting for Rx bytes from interface + LL_IFC_ERROR_BUFFER_TOO_SMALL = -107, ///< Response larger than provided output buffer + LL_IFC_ERROR_START_OF_FRAME = -108, ///< transport_read failed getting FRAME_START + LL_IFC_ERROR_HEADER = -109, ///< transport_read failed getting header + LL_IFC_ERROR_TIMEOUT = -110, ///< The operation timed out. + LL_IFC_ERROR_INCORRECT_MESSAGE_SIZE = -111, ///< The message size from the device was incorrect. + LL_IFC_ERROR_NO_NETWORK = -112, ///< No network was available. + LL_IFC_ERROR_HAL_CALL_FAILED = -113, ///< A User defined function failed. + /* When adding a new value, update ll_return_code_name() and ll_return_code_description() */ +} ll_ifc_error_codes_t; + + +/** Bit Definitions for OP_SET_RADIO_PARAMS */ +#define RADIO_PARAM_FLAGS_SF (1u<<0u) +#define RADIO_PARAM_FLAGS_CR (1u<<1u) +#define RADIO_PARAM_FLAGS_BW (1u<<2u) +#define RADIO_PARAM_FLAGS_FREQ (1u<<3u) +#define RADIO_PARAM_FLAGS_PREAMBLE (1u<<4u) +#define RADIO_PARAM_FLAGS_HEADER (1u<<5u) +#define RADIO_PARAM_FLAGS_CRC (1u<<6u) +#define RADIO_PARAM_FLAGS_IQ (1u<<7u) + +/** Bit Definitions for OP_IRQ_FLAGS */ +#define IRQ_FLAGS_WDOG_RESET (0x00000001UL) ///< Set every time the module reboots after a Watchdog reboot +#define IRQ_FLAGS_RESET (0x00000002UL) ///< Set every time the module reboots for any reason +#define IRQ_FLAGS_TX_DONE (0x00000010UL) ///< Set every time a Tx Queue goes from non-empty to empty +#define IRQ_FLAGS_TX_ERROR (0x00000020UL) ///< Set every time there is a Tx Error +#define IRQ_FLAGS_RX_DONE (0x00000100UL) ///< Set every time a new packet is received +#define IRQ_FLAGS_MAILBOX_EMPTY (0x00000200UL) ///< Set when a GW reports an empty mailbox +#define IRQ_FLAGS_CONNECTED (0x00001000UL) ///< Set every time we transition from the disconnected -> connected state +#define IRQ_FLAGS_DISCONNECTED (0x00002000UL) ///< Set every time we transition from the connected -> disconnected state +//STRIPTHIS!START +// LifeRaft IRQ flags +#define IRQ_FLAGS_ENROLL_GRANT (0x00004000UL) ///< Set when the module has been granted an enrollment by the gateway +//STRIPTHIS!STOP +#define IRQ_FLAGS_CRYPTO_ESTABLISHED (0x00010000UL) ///< Set every time we transition from the crypto not established -> crytpto established state +#define IRQ_FLAGS_APP_TOKEN_CONFIRMED (0x00020000UL) ///< Set every time an application token is confirmed by Conductor +#define IRQ_FLAGS_DOWNLINK_REQUEST_ACK (0x00040000UL) ///< Set every time a downlink registration request is acknowledged +#define IRQ_FLAGS_INITIALIZATION_COMPLETE (0x00080000UL) ///< Set every time the MAC has completed initialization +#define IRQ_FLAGS_CRYPTO_ERROR (0x00100000UL) ///< Set when a crypto exchange attempt fails +#define IRQ_FLAGS_APP_TOKEN_ERROR (0x00200000UL) ///< Set when an application token registration fails +#define IRQ_FLAGS_DOWNLINK_ERROR (0x00400000UL) ///< Set when a downlink registration fails +#define IRQ_CLOUD_GPIO_2_INTERRUPT (0x01000000UL) ///< Set when the cloud GPIO input is triggered +#define IRQ_CLOUD_GPIO_3_INTERRUPT (0x02000000UL) ///< Set when the cloud GPIO input is triggered +//STRIPTHIS!START +// LifeRaft IRQ flags +#define IRQ_FLAGS_STATUS_REQ (0x00400000UL) ///< Set when we want to request the status of the host controller +#define IRQ_FLAGS_FIRMWARE_REQ (0x00800000UL) ///< Set when we want to request the firmware data of the host controller +//STRIPTHIS!STOP +#define IRQ_FLAGS_ASSERT (0x80000000UL) ///< Set every time we transition from the connected->disconnected state + +/** + * @brief + * The operations for ll_timestamp_set(). + */ +typedef enum ll_timestamp_operation_e { + /** + * @brief + * No set operation. + * + * @details + * Just get the current timestamp. + */ + LL_TIMESTAMP_NO_OPERATION, + + /** + * @brief + * Directly set the timestamp from the provided value. + * + * @details + * The value is not applied until the command is processed by the + * module, and it does not account for transmission delay. + */ + LL_TIMESTAMP_SET_IMMEDIATE, + + /** + * @brief + * Synchronize the timestamp using the provided value which + * corresponds to the most recent event. + * + * @details + * Use this mechanism when the host directly controls the trigger + * event received by both the reference time source and the module. + * This mechanism guarantees the module that the reference value + * aligns to the module's timestamp value when the most recent + * trigger event occurred. + */ + LL_TIMESTAMP_SYNC_IMMEDIATE, + + /** + * @brief + * Intelligently synchronize the timestamp using the provided value + * accounting for possible mismatched trigger events. + * + * @details + * Use this mechanism when the host does not control the trigger + * event. When the trigger event is free-running such as with a + * GPS pulse-per-seconds (PPS) output, the reference value may + * be one event behind the module's value. This mechanism allows + * the module to detect and account for this variability. To + * correctly update the module's timestamp using this mechanism: + * + * 1. Read the reference timestamp. + * 2. Call ll_timestamp_set() + * 3. Read the reference timestamp. + * 4. Call ll_timestamp_set() + */ + LL_TIMESTAMP_SYNC +} ll_timestamp_operation_t; + +/** @} (end addtogroup Module_Interface) */ + + + + +/** @} (end defgroup Module_Interface) */ + +/** @} (end addtogroup Link_Labs_Interface_Library) */ + +#endif /* __LL_IFC_CONSTS_H */ diff --git a/inc/ll_ifc_consts.h.bak.bak b/inc/ll_ifc_consts.h.bak.bak new file mode 100644 index 0000000..637c95a --- /dev/null +++ b/inc/ll_ifc_consts.h.bak.bak @@ -0,0 +1,367 @@ +#ifndef __LL_IFC_CONSTS_H +#define __LL_IFC_CONSTS_H + +#include + +/** + * @addtogroup Link_Labs_Interface_Library + * @{ + */ + +/** + * @addtogroup Module_Interface + * @brief + * @{ + */ + +#define IFC_VERSION_MAJOR (0) +#define IFC_VERSION_MINOR (6) +#define IFC_VERSION_TAG (0) + +#define APP_TOKEN_LEN (10) +#define MAX_RX_MSG_LEN (128) + +extern const uint32_t OPEN_NET_TOKEN; ///< Open network token (0x4f50454e) + +typedef enum +{ + OP_VERSION = 0, ///< 0x00 + OP_IFC_VERSION = 1, ///< 0x01 + OP_STATE = 2, ///< 0x02 + OP_TX_STATE = 3, ///< 0x03 + OP_RX_STATE = 4, ///< 0x04 + OP_FREQUENCY = 6, ///< 0x06 + OP_TX_POWER_SET = 7, ///< 0x07 + OP_RESET_SETTINGS = 8, ///< 0x08 + OP_GET_RADIO_PARAMS = 9, ///< 0x09 + OP_SET_RADIO_PARAMS = 10, ///< 0x0A + OP_PKT_SEND_QUEUE = 11, ///< 0x0B + OP_TX_POWER_GET = 12, ///< 0x0C + OP_SYNC_WORD_SET = 13, ///< 0x0D + OP_SYNC_WORD_GET = 14, ///< 0x0E + OP_IRQ_FLAGS = 15, ///< 0x0F + OP_IRQ_FLAGS_MASK = 16, ///< 0x10 + OP_SLEEP = 20, ///< 0x14 + OP_SLEEP_BLOCK = 21, ///< 0x15 + OP_PKT_ECHO = 31, ///< 0x1F + OP_PKT_RECV = 40, ///< 0x28 + OP_MSG_RECV_RSSI = 41, ///< 0x29 - Deprecated for Symphony mode + OP_PKT_RECV_CONT = 42, ///< 0x2A + OP_MSG_RECV = 43, ///< 0x2B + OP_MODULE_ID = 50, ///< 0x32 + OP_STORE_SETTINGS = 51, ///< 0x33 + OP_DELETE_SETTINGS = 52, ///< 0x34 + OP_RESET_MCU = 60, ///< 0x3C + OP_TRIGGER_BOOTLOADER = 61, ///< 0x3D + OP_MAC_MODE_SET = 70, ///< 0x46 + OP_MAC_MODE_GET = 71, ///< 0x47 +//STRIPTHIS!START + OP_RESERVED_LIFERAFT0 = 72, ///< 0x48 - Liferaft Specific (Do not use!) +//STRIPTHIS!STOP + OP_MSG_SEND_ACK = 90, ///< 0x5A - Deprecated + OP_MSG_SEND_UNACK = 91, ///< 0x5B - Deprecated + OP_MSG_SEND = 92, ///< 0x5C + OP_CONN_FILT_SET = 93, ///< 0x5D + OP_CONN_FILT_GET = 94, ///< 0x5E +//STRIPTHIS!START + OP_RESERVED0 = 96, ///< 0x60 + OP_RESERVED1 = 97, ///< 0x60 +//STRIPTHIS!STOP + OP_TX_CW = 98, ///< 0x61 + OP_SYSTEM_TIME_GET = 108, ///< 0x6C + OP_SYSTEM_TIME_SYNC = 109, ///< 0x6D + OP_RX_MODE_SET = 110, ///< 0x6E + OP_RX_MODE_GET = 111, ///< 0x6F + OP_QOS_REQUEST = 112, ///< 0x70 + OP_QOS_GET = 113, ///< 0x71 + OP_ANTENNA_SET = 114, ///< 0x72 + OP_ANTENNA_GET = 115, ///< 0x73 + OP_NET_TOKEN_SET = 116, ///< 0x74 + OP_NET_TOKEN_GET = 117, ///< 0x75 + OP_NET_INFO_GET= 118, ///< 0x76 + OP_STATS_GET = 119, ///< 0x77 + OP_RSSI_SET = 120, ///< 0x78 + OP_RSSI_GET = 121, ///< 0x79 + OP_DL_BAND_CFG_GET = 122, ///< 0x7A + OP_DL_BAND_CFG_SET = 123, ///< 0x7B + OP_APP_TOKEN_SET = 124, ///< 0x7C + OP_APP_TOKEN_GET = 125, ///< 0x7D + OP_APP_TOKEN_REG_GET = 126, ///< 0x7E + OP_CRYPTO_KEY_XCHG_REQ = 128, ///< 0x80 + OP_MAILBOX_REQUEST = 129, ///< 0x81 +//STRIPTHIS!START + OP_RESERVED_LIFERAFT1 = 130, ///< 0x82 - Liferaft Specific (Do not use!) + OP_TIMESTAMP = 131, ///< 0x83 reserved, not fully implemented + OP_SEND_TIMESTAMP = 132, ///< 0x84 reserved, not fully implemented +//STRIPTHIS!STOP + +//STRIPTHIS!START + OP_FCC_TEST = 245, ///< 0xF5 + OP_PER_TEST_TX = 246, ///< 0xF6 + OP_PER_TEST_RX = 247, ///< 0xF7 + OP_GET_ASSERT = 248, ///< 0xF8 + OP_SET_ASSERT = 249, ///< 0xF9 +//STRIPTHIS!STOP + OP_HARDWARE_TYPE = 254, ///< 0xFE + OP_FIRMWARE_TYPE = 255 ///< 0xFF +} opcode_t; + +typedef enum +{ + FRAME_START = 0xC4 ///< 0xC4 +} frame_t; + +typedef enum +{ + LORA_NO_MAC = 0, ///< 0x00 + DEPRECATED_MAC1, ///< 0x01 + DEPRECATED_MAC2, ///< 0x02 + SYMPHONY_LINK, ///< 0x03 + NUM_MACS, ///< Total number of MAC modes + MAC_INVALID = 255, ///< 0xFF +} ll_mac_type_t; + +/** + * version struct + */ +typedef struct { + uint8_t major; + uint8_t minor; + uint16_t tag; +} ll_version_t; + +#define VERSION_LEN (4) + +// Hardware Types +typedef enum +{ + UNAVAILABLE = 0, ///< 0x00 + LLRLP20_V2 = 1, ///< 0x01 + LLRXR26_V2 = 2, ///< 0x02 + LLRLP20_V3 = 3, ///< 0x03 + LLRXR26_V3 = 4, ///< 0x04 + LLREPEATER = 5 ///< 0x05 AES_TODO - Replace with official part number? +} ll_hardware_type_t; + +/** + * Firmware identifiers + */ +typedef enum +{ + CPU_EFM32TG210F32 = 0, ///< 0x00 + CPU_EFM32G210F128 = 1, ///< 0x01 + CPU_R5F51115ADNE = 2, ///< 0x02 + CPU_R5F51116ADNE = 3, ///< 0x03 + CPU_EFM32GG232F1024 = 4 ///< 0x04 +} cpu_code_t; + +typedef enum +{ + GATEWAY_TX_ONLY = 0, ///< 0x00 + MODULE_END_NODE = 1, ///< 0x01 + REPEATER_HOST = 2 ///< 0x02 + // TBD - How to define others ? +} functionality_code_t; + +/** + * Link Labs LORA enumeration identifiers for Bandwidth + */ +typedef enum +{ + PROPERTY_LORA_BW_MIN = 0, ///< range limit value (lower) + PROPERTY_LORA_BW_62_5 = 0, ///< 62.5KHz BW + PROPERTY_LORA_BW_125 = 1, ///< 125KHz BW + PROPERTY_LORA_BW_250 = 2, ///< 250KHz BW + PROPERTY_LORA_BW_500 = 3, ///< 500KHz BW + PROPERTY_LORA_BW_MAX, ///< range limit value (upper) +} property_bw_t; + +/** + * Link Labs LORA enumeration identifiers for Spreading Factor + */ +typedef enum +{ + PROPERTY_LORA_SF_MIN = 6, ///< range limit value (lower) + PROPERTY_LORA_SF_6 = 6, ///< SF 6 + PROPERTY_LORA_SF_7 = 7, ///< SF 7 + PROPERTY_LORA_SF_8 = 8, ///< SF 8 + PROPERTY_LORA_SF_9 = 9, ///< SF 9 + PROPERTY_LORA_SF_10 = 10, ///< SF 10 + PROPERTY_LORA_SF_11 = 11, ///< SF 11 + PROPERTY_LORA_SF_12 = 12, ///< SF 12 + PROPERTY_LORA_SF_MAX, ///< range limit value (upper) +} property_sf_t; + +/** + * Link Labs LORA enumeration identifiers for Coding rate + */ +typedef enum +{ + PROPERTY_LORA_CR_MIN = 1, ///< range limit value (lower) + PROPERTY_LORA_CR_4_5 = 1, ///< 0x01 -- 4/5 + PROPERTY_LORA_CR_4_6 = 2, ///< 0x02 -- 4/6 + PROPERTY_LORA_CR_4_7 = 3, ///< 0x03 -- 4/7 + PROPERTY_LORA_CR_4_8 = 4, ///< 0x04 -- 4/8 + PROPERTY_LORA_CR_MAX, ///< range limit value (upper) +} property_cr_t; + +typedef struct { + uint16_t cpu_code; + uint16_t functionality_code; +} ll_firmware_type_t; + +#define FIRMWARE_TYPE_LEN (4) + +/** Possible downlink modes for OP_DOWNLINK_MODE */ +typedef enum +{ + DOWNLINK_MODE_OFF = 0, ///< 0x00 + DOWNLINK_MODE_ALWAYS_ON = 1, ///< 0x01 + DOWNLINK_MODE_MAILBOX = 2, ///< 0x02 + DOWNLINK_MODE_PERIODIC = 3, ///< 0x03 + NUM_DOWNLINK_MODES, + DOWNLINK_MODE_FAILURE = 255, ///< 0xFF +} downlink_mode_t; + +/** ACK/NACK Codes */ +#define LL_IFC_ACK (0) ///< All good. +#define LL_IFC_NACK_CMD_NOT_SUPPORTED (1) ///< Command not supported. +#define LL_IFC_NACK_INCORRECT_CHKSUM (2) ///< Incorrect Checksum. +#define LL_IFC_NACK_PAYLOAD_LEN_OOR (3) ///< Length of payload sent in command was out of range. +#define LL_IFC_NACK_PAYLOAD_OOR (4) ///< Payload sent in command was out of range. +#define LL_IFC_NACK_BOOTUP_IN_PROGRESS (5) ///< Not allowed since firmware bootup still in progress. Wait. +#define LL_IFC_NACK_BUSY_TRY_AGAIN (6) ///< Operation prevented by temporary event. Re-try should work. +#define LL_IFC_NACK_APP_TOKEN_REG (7) ///< Application token is not registered for this node. +#define LL_IFC_NACK_PAYLOAD_LEN_EXCEEDED (8) ///< Payload length is greater than the max supported length +#define LL_IFC_NACK_NOT_IN_MAILBOX_MODE (9) ///< Module must be in DOWNLINK_MAILBOX mode +#define LL_IFC_NACK_PAYLOAD_BAD_PROPERTY (10) ///< Invalid property specified in command +#define LL_IFC_NACK_NODATA (11) ///< No data is available to be returned +#define LL_IFC_NACK_QUEUE_FULL (12) ///< Data could not be enqueued for transmission (queue full) +#define LL_IFC_NACK_OTHER (99) +/* When adding a new value, update ll_return_code_name() and ll_return_code_description() */ + +/** Error Codes */ +/* Note: Error codes -1 to -99 map to NACK codes received from the radio */ +typedef enum ll_ifc_error_codes_e { + LL_IFC_ERROR_INCORRECT_PARAMETER = -101, ///< The parameter value was invalid. + LL_IFC_ERROR_INCORRECT_RESPONSE_LENGTH = -102, ///< Module response was not the expected size. + LL_IFC_ERROR_MESSAGE_NUMBER_MISMATCH = -103, ///< Message number in response doesn't match expected + LL_IFC_ERROR_CHECKSUM_MISMATCH = -104, ///< Checksum mismatch + LL_IFC_ERROR_COMMAND_MISMATCH = -105, ///< Command mismatch (responding to a different command) + LL_IFC_ERROR_HOST_INTERFACE_TIMEOUT = -106, ///< Timed out waiting for Rx bytes from interface + LL_IFC_ERROR_BUFFER_TOO_SMALL = -107, ///< Response larger than provided output buffer + LL_IFC_ERROR_START_OF_FRAME = -108, ///< transport_read failed getting FRAME_START + LL_IFC_ERROR_HEADER = -109, ///< transport_read failed getting header + LL_IFC_ERROR_TIMEOUT = -110, ///< The operation timed out. + LL_IFC_ERROR_INCORRECT_MESSAGE_SIZE = -111, ///< The message size from the device was incorrect. + LL_IFC_ERROR_NO_NETWORK = -112, ///< No network was available. + LL_IFC_ERROR_HAL_CALL_FAILED = -113, ///< A User defined function failed. + /* When adding a new value, update ll_return_code_name() and ll_return_code_description() */ +} ll_ifc_error_codes_t; + + +/** Bit Definitions for OP_SET_RADIO_PARAMS */ +#define RADIO_PARAM_FLAGS_SF (1u<<0u) +#define RADIO_PARAM_FLAGS_CR (1u<<1u) +#define RADIO_PARAM_FLAGS_BW (1u<<2u) +#define RADIO_PARAM_FLAGS_FREQ (1u<<3u) +#define RADIO_PARAM_FLAGS_PREAMBLE (1u<<4u) +#define RADIO_PARAM_FLAGS_HEADER (1u<<5u) +#define RADIO_PARAM_FLAGS_CRC (1u<<6u) +#define RADIO_PARAM_FLAGS_IQ (1u<<7u) + +/** Bit Definitions for OP_IRQ_FLAGS */ +#define IRQ_FLAGS_WDOG_RESET (0x00000001UL) ///< Set every time the module reboots after a Watchdog reboot +#define IRQ_FLAGS_RESET (0x00000002UL) ///< Set every time the module reboots for any reason +#define IRQ_FLAGS_TX_DONE (0x00000010UL) ///< Set every time a Tx Queue goes from non-empty to empty +#define IRQ_FLAGS_TX_ERROR (0x00000020UL) ///< Set every time there is a Tx Error +#define IRQ_FLAGS_RX_DONE (0x00000100UL) ///< Set every time a new packet is received +#define IRQ_FLAGS_MAILBOX_EMPTY (0x00000200UL) ///< Set when a GW reports an empty mailbox +#define IRQ_FLAGS_CONNECTED (0x00001000UL) ///< Set every time we transition from the disconnected -> connected state +#define IRQ_FLAGS_DISCONNECTED (0x00002000UL) ///< Set every time we transition from the connected -> disconnected state +//STRIPTHIS!START +// LifeRaft IRQ flags +#define IRQ_FLAGS_ENROLL_GRANT (0x00004000UL) ///< Set when the module has been granted an enrollment by the gateway +//STRIPTHIS!STOP +#define IRQ_FLAGS_CRYPTO_ESTABLISHED (0x00010000UL) ///< Set every time we transition from the crypto not established -> crytpto established state +#define IRQ_FLAGS_APP_TOKEN_CONFIRMED (0x00020000UL) ///< Set every time an application token is confirmed by Conductor +#define IRQ_FLAGS_DOWNLINK_REQUEST_ACK (0x00040000UL) ///< Set every time a downlink registration request is acknowledged +#define IRQ_FLAGS_INITIALIZATION_COMPLETE (0x00080000UL) ///< Set every time the MAC has completed initialization +#define IRQ_FLAGS_CRYPTO_ERROR (0x00100000UL) ///< Set when a crypto exchange attempt fails +#define IRQ_FLAGS_APP_TOKEN_ERROR (0x00200000UL) ///< Set when an application token registration fails +//STRIPTHIS!START +// LifeRaft IRQ flags +#define IRQ_FLAGS_STATUS_REQ (0x00400000UL) ///< Set when we want to request the status of the host controller +#define IRQ_FLAGS_FIRMWARE_REQ (0x00800000UL) ///< Set when we want to request the firmware data of the host controller +//STRIPTHIS!STOP +#define IRQ_FLAGS_ASSERT (0x80000000UL) ///< Set every time we transition from the connected->disconnected state + +/** + * @brief + * The operations for ll_timestamp_set(). + */ +typedef enum ll_timestamp_operation_e { + /** + * @brief + * No set operation. + * + * @details + * Just get the current timestamp. + */ + LL_TIMESTAMP_NO_OPERATION, + + /** + * @brief + * Directly set the timestamp from the provided value. + * + * @details + * The value is not applied until the command is processed by the + * module, and it does not account for transmission delay. + */ + LL_TIMESTAMP_SET_IMMEDIATE, + + /** + * @brief + * Synchronize the timestamp using the provided value which + * corresponds to the most recent event. + * + * @details + * Use this mechanism when the host directly controls the trigger + * event received by both the reference time source and the module. + * This mechanism guarantees the module that the reference value + * aligns to the module's timestamp value when the most recent + * trigger event occurred. + */ + LL_TIMESTAMP_SYNC_IMMEDIATE, + + /** + * @brief + * Intelligently synchronize the timestamp using the provided value + * accounting for possible mismatched trigger events. + * + * @details + * Use this mechanism when the host does not control the trigger + * event. When the trigger event is free-running such as with a + * GPS pulse-per-seconds (PPS) output, the reference value may + * be one event behind the module's value. This mechanism allows + * the module to detect and account for this variability. To + * correctly update the module's timestamp using this mechanism: + * + * 1. Read the reference timestamp. + * 2. Call ll_timestamp_set() + * 3. Read the reference timestamp. + * 4. Call ll_timestamp_set() + */ + LL_TIMESTAMP_SYNC +} ll_timestamp_operation_t; + +/** @} (end addtogroup Module_Interface) */ + + + + +/** @} (end defgroup Module_Interface) */ + +/** @} (end addtogroup Link_Labs_Interface_Library) */ + +#endif /* __LL_IFC_CONSTS_H */ diff --git a/inc/ll_ifc_symphony.h.bak b/inc/ll_ifc_symphony.h.bak new file mode 100644 index 0000000..73ba78d --- /dev/null +++ b/inc/ll_ifc_symphony.h.bak @@ -0,0 +1,375 @@ +#ifndef __LL_IFC_SYMPHONY_H +#define __LL_IFC_SYMPHONY_H + +#include +#include +#include "ll_ifc.h" + +#ifdef __cplusplus +extern "C" { +#endif + +/** + * @addtogroup Link_Labs_Interface_Library + * @{ + */ + +/** + * @defgroup Symphony_Interface Symphony Link + * + * @brief Communicate with a Symphony Link network. + * + * Symphony Link mode allows the external host to communicate with Symphony + * Link networks, a dynamic IEEE 802.15.4 based LoRa wireless system built + * specifically for low power, wide-area connectivity. + * + * @{ + */ + +enum ll_downlink_mode { + LL_DL_OFF = 0, ///< 0x00 + LL_DL_ALWAYS_ON = 1, ///< 0x01 + LL_DL_MAILBOX = 2, ///< 0x02 +}; + +enum ll_state { + LL_STATE_IDLE_CONNECTED = 1, ///< 0x01 + LL_STATE_IDLE_DISCONNECTED = 2, ///< 0x02 + LL_STATE_INITIALIZING = 3, ///< 0x03 + LL_STATE_ERROR = -1, ///< 0xFF +}; + +enum ll_tx_state { + LL_TX_STATE_TRANSMITTING = 1, ///< 0x01 + LL_TX_STATE_SUCCESS = 2, ///< 0x02 + LL_TX_STATE_ERROR = -1, ///< 0xFF +}; + +enum ll_rx_state { + LL_RX_STATE_NO_MSG = 0, ///< 0x00 + LL_RX_STATE_RECEIVED_MSG = 1, ///< 0x01 +}; + +/** + * @brief An exposed buffer that will be used internally, but can also be used + * to hold uplink messages for 'll_message_send' to avoid double-buffering. + * The buffer has size 256 bytes. + */ +extern uint8_t *uplink_message_buff; + +extern const llabs_dl_band_cfg_t DL_BAN_FCC; ///< USA / Mexico DL Band Configuration +extern const llabs_dl_band_cfg_t DL_BAN_BRA; ///< Brazil DL Band Configuration +extern const llabs_dl_band_cfg_t DL_BAN_AUS; ///< Australia DL Band Configuration +extern const llabs_dl_band_cfg_t DL_BAN_NZL; ///< New Zealand DL Band Configuration +extern const llabs_dl_band_cfg_t DL_BAN_ETSI; ///< Europe (ETSI) DL Band Configuration + + +/** + * @brief + * Set the current configuration of the module. + * + * @details + * Sets the configuration values for the module. The module + * will only respond to values that have changed. For example, + * if the app token is set to the app token that the module already + * has, it will not try to re-register the app token. + * + * The user should call this function whenever the module is powered on. + * + * @param[in] net_token + * The network token set for this module. This determines what gateways the + * module will connect to. Use `OPEN_NET_TOKEN` if you don't have a particular + * network token. + * + * @param[in] app_token + * The app token set for this module. This is what registers your uplink + * messages with your Conductor account. + * + * @param[in] dl_mode + * The downlink mode for this module. + * + * @param[in] qos + * The quality of service level [0-15] for this module. The higher the + * quality of service, the faster uplink messages will be transmitted. + * Note that too many modules with a high quality of service may adversely + * affect network capacity. + * + * @return + * 0 - success, negative otherwise. + */ +int32_t ll_config_set(uint32_t net_token, const uint8_t app_token[APP_TOKEN_LEN], + enum ll_downlink_mode dl_mode, uint8_t qos); + +/** + * @brief + * Get the current configuration of the module. + * + * @details + * Returns the configuration set by the user (or defaults + * if the user didn't set config yet). The config parameters + * may not be in effect yet. For example, this function will return + * the downlink mode that the user requested even though + * the module may not have entered that downlink mode yet. + * + * @param[out] net_token + * The network token set for this module. + * + * @param[out] app_token + * The app token set for this module. + * + * @param[out] dl_mode + * The downlink mode requested for this module. + * + * @param[out] qos + * The quality of service level [0-15] requested for this module. + * + * @return + * 0 - success, negative otherwise. + */ +int32_t ll_config_get(uint32_t *net_token, uint8_t app_token[APP_TOKEN_LEN], + enum ll_downlink_mode * dl_mode, uint8_t *qos); + +/** + * @brief + * Gets the state of the module. + * + * @details + * Returns the state of the module as three separate states: The general + * connection state, the state of the current uplink message, and the + * state of the current downlink message. + * + * @param[out] state + * The state of the connection. If the state is `LL_STATE_ERROR`, then this + * invalidates any of the other state variables. + * + * @param[out] tx_state + * The state of the transmission. If no messages have been sent by the user since the + * last reboot, then this variable is invalid. Otherwise, it returns the result of + * the last transmission (or LL_TX_STATE_TRANSMITTING if the message is in progress). + * + * @param[out] rx_state + * The state of the received message. Either the module has a downlink message ready for + * the user to pull out with `ll_retrieve_message`, or not. Once the user pulls out the + * message using `ll_retrieve_message`, this state will be reset. + * + * @return + * 0 - success, negative otherwise. + */ +int32_t ll_get_state(enum ll_state * state, enum ll_tx_state * tx_state, enum ll_rx_state * rx_state); + +/** + *@brief + * Request. + * + *@return + * 0 - success, negative otherwise (Fails if module is not in MAILBOX mode). + */ +int32_t ll_mailbox_request(void); + +/** + *@brief + * Get the end node's application token's registration status. + * + *@param[out] is_registered + * 1=>registered, 0=>otherwise + * + *@return + * 0 - success, negative otherwise. + */ +int32_t ll_app_reg_get(uint8_t *is_registered); + +/** + *@brief + * Request a new key exchange between end node and gateway. + * + *@return + * 0 - success, negative otherwise. + */ +int32_t ll_encryption_key_exchange_request(void); + +/** + * @brief + * Get the Network Info. + * + * @param[out] net_info + * Network Info: + * All multi byte values are sent over in little-endian mode. + * Byte [0-3] : uint32_t network id (node) + * Byte [4-7] : uint32_t network id (gateway) + * Byte [8] : int8_t gateway channel + * Byte [9-12] : uint32_t gateway frequency + * Byte [13-16] : uint32_t Seconds elapsed since last beacon Rx'd + * Byte [17-18] : int16_t Downlink RSSI [dBm] + * Byte [19] : uint8_t Downlink SNR [dB] + * Byte [20-23] : uint32_t Connection Status (0=Unknown, 1=Disconnected, 2=Connected) + * + * @return + * 0 - success, negative otherwise. + */ +int32_t ll_net_info_get(llabs_network_info_t *net_info); + +/** + * @brief + * Get the Network Communication Statistics. + * + * @param[out] s + * The stats struct sent by the module. + * + * @return + * 0 - success, negative otherwise. + */ +int32_t ll_stats_get(llabs_stats_t *s); + +/** + * @brief + * Get the Downlink Band Configuration. + * + * @param[out] p_dl_band_cfg + * The band cfg struct sent by the module. + * + * @return + * 0 - success, negative otherwise. + */ +int32_t ll_dl_band_cfg_get(llabs_dl_band_cfg_t *p_dl_band_cfg); + + +/** + * @brief + * Set the Downlink Band Configuration. + * + * @param[in] p_dl_band_cfg + * The band cfg struct sent by the module. + * + * @return + * 0 - success, negative otherwise. + */ +int32_t ll_dl_band_cfg_set(const llabs_dl_band_cfg_t *p_dl_band_cfg); + +/** + * @brief + * Get the Connection Filter value. + * + * @param[out] p_f + * The current value is written to *p_f. + * 0 = Allow connections to any available devices + * 1 = Allow connection to Gateways only + * 2 = Allow connection to Repeaters only + * + * @return + * 0 - success, negative otherwise. + */ +int32_t ll_connection_filter_get(uint8_t* p_f); + +/** + * @brief + * Set the Connection Filter value. + * + * @param[in] f + * Same param ll_connection_filter_get(). + * + * @return + * 0 - success, negative otherwise. + */ +int32_t ll_connection_filter_set(uint8_t f); + +/** + * @brief + * Get the system time as number of seconds since the + * UNIX epoch 00:00:00 UTC on 1 January 1970 + * and the time the module last synchronized time with the gateway. + * + * @param[out] + * The time_info struct sent by the module. + * + * @return + * 0 - success, negative otherwise. + */ +int32_t ll_system_time_get(llabs_time_info_t *time_info); + +/** + * @brief + * Force the module to synchronize system time from the gateway. + * + * @note + * worse-case delay for synchronization is the Info Block period + * which defaults to 8 seconds. + * + * @param[in] sync_mode + * 0 - Time sync only when requested. + * 1 - Time sync opportunistically. + * + * @return + * 0 - success, negative otherwise. + */ +int32_t ll_system_time_sync(uint8_t sync_mode); + +/** + * @brief + * Request Symphony MAC to send an acknowledged uplink message. + * + * @details + * When the message finishes transmission the module will return to the idle state. + * Internally the function copies the message into a larger buffer. If you want to + * avoid having two buffers you can use the larger buffer (uplink_message_buff) + * to hold the message then call this function with that buffer. + * + * @param[in] buf + * byte array containing the data payload. + * + * @param[in] len + * length of the input buffer in bytes. + * + * @param[in] ack + * Whether or not to request an ACK from the gateway. + * + * @param[in] port + * The port number to send to. Valid user ports are 0 through 127. + * Ports 128 through 255 are reserved for predefined protocols. + * + * @return + * positive number of bytes queued, + * negative if an error. + */ +int32_t ll_message_send(uint8_t buf[], uint16_t len, bool ack, uint8_t port); + +/** + * @brief + * Retrieves a downlink message received by the module. + * + * @details + * This function should be called when the `rx_state` variable from the `get_state` + * function is `LL_RX_STATE_RECEIVED_MSG'. + * + * @param[out] buf + * The buffer into which the received message will be placed. This buffer must + * be at least 4 bytes larger than the maximum message size expected + * (4 bytes will be used to get the RSSI, SNR, and port). + * + * @param[in,out] size + * The size of the output buffer. If the message is successfully retrieved, + * this will be set to the size of the message (without the RSSI, SNR, and port). + * + * @param[out] port + * The port number associated with the message. + * + * @param[out] rssi + * The rssi of the received message. + * + * @param[out] snr + * The snr of the received message. + * + * @return + * 0 - success, negative otherwise. + */ +int32_t ll_retrieve_message(uint8_t *buf, uint16_t *size, uint8_t *port, int16_t *rssi, uint8_t *snr); + +/** @} (end defgroup Symphony_Interface) */ + +/** @} (end addtogroup Link_Labs_Interface_Library) */ + + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/src/ifc_struct_defs.c.bak b/src/ifc_struct_defs.c.bak new file mode 100644 index 0000000..6747dd9 --- /dev/null +++ b/src/ifc_struct_defs.c.bak @@ -0,0 +1,148 @@ +#include +#include "ifc_struct_defs.h" + +uint8_t read_uint8(const uint8_t ** buffer) { + return *((*buffer)++); +} + +uint16_t read_uint16(const uint8_t ** buffer) { + return (((uint16_t) read_uint8(buffer)) << 8) | + ((uint16_t) read_uint8(buffer)); +} + +uint32_t read_uint32(const uint8_t ** buffer) { + return (((uint32_t) read_uint16(buffer)) << 16) | + ((uint32_t) read_uint16(buffer)); +} + +uint64_t read_uint64(const uint8_t ** buffer) { + return (((uint64_t) read_uint32(buffer)) << 32) | + ((uint64_t) read_uint32(buffer)); +} + +void write_uint8(uint8_t x, uint8_t ** buffer) { + *((*buffer)++) = x; +} + +void write_uint16(uint16_t x, uint8_t ** buffer) { + write_uint8(x >> 8, buffer); + write_uint8(x, buffer); +} + +void write_uint32(uint32_t x, uint8_t ** buffer) { + write_uint16(x >> 16, buffer); + write_uint16(x, buffer); +} + +void write_uint64(uint64_t x, uint8_t ** buffer) { + write_uint32(x >> 32, buffer); + write_uint32(x, buffer); +} + +// Parse a serialized llabs_network_info_t struct. +void ll_net_info_deserialize(const uint8_t buff[NET_INFO_BUFF_SIZE], llabs_network_info_t *net_info) +{ + uint8_t const * b = buff; + net_info->network_id_node = read_uint32(&b); + net_info->network_id_gw = read_uint32(&b); + net_info->gateway_channel = read_uint8(&b); + net_info->gateway_frequency = read_uint32(&b); + net_info->last_rx_tick = read_uint32(&b); + net_info->rssi = read_uint16(&b); + net_info->snr = read_uint8(&b); + net_info->connection_status = (llabs_connect_status_t) read_uint8(&b); + net_info->is_scanning_gateways = read_uint8(&b); + net_info->gateway_id = read_uint64(&b); + net_info->is_repeater = read_uint8(&b); +} + +// Serializes an llabs_network_info_t struct into a buffer to be sent over the host interface. +// Returns the size of the serialized struct in the buffer. +uint16_t ll_net_info_serialize(const llabs_network_info_t *net_info, uint8_t buff[NET_INFO_BUFF_SIZE]) +{ + uint8_t * buff_cpy = buff; + write_uint32(net_info->network_id_node, &buff_cpy); + write_uint32(net_info->network_id_gw, &buff_cpy); + write_uint8(net_info->gateway_channel, &buff_cpy); + write_uint32(net_info->gateway_frequency, &buff_cpy); + write_uint32(net_info->last_rx_tick, &buff_cpy); + write_uint16(net_info->rssi, &buff_cpy); + write_uint8(net_info->snr, &buff_cpy); + write_uint8(net_info->connection_status, &buff_cpy); + write_uint8(net_info->is_scanning_gateways, &buff_cpy); + write_uint64(net_info->gateway_id, &buff_cpy); + return buff_cpy - buff; +} + +void ll_dl_band_cfg_deserialize(const uint8_t buff[DL_BAND_CFG_SIZE], llabs_dl_band_cfg_t *dl_cfg) +{ + uint8_t const * b = buff; + dl_cfg->band_edge_lower = read_uint32(&b); + dl_cfg->band_edge_upper = read_uint32(&b); + dl_cfg->band_edge_guard = read_uint32(&b); + dl_cfg->chan_step_size = read_uint8(&b); + dl_cfg->chan_step_offset = read_uint8(&b); +} + +uint16_t ll_dl_band_cfg_serialize(const llabs_dl_band_cfg_t *dl_cfg, uint8_t buff[DL_BAND_CFG_SIZE]) +{ + uint8_t * b = buff; + write_uint32(dl_cfg->band_edge_lower, &b); + write_uint32(dl_cfg->band_edge_upper, &b); + write_uint32(dl_cfg->band_edge_guard, &b); + write_uint8(dl_cfg->chan_step_size, &b); + write_uint8(dl_cfg->chan_step_offset, &b); + return b - buff; +} + +void ll_stats_deserialize(const uint8_t buff[STATS_SIZE], llabs_stats_t *stats) +{ + uint8_t const * b = buff; + stats->num_send_calls = read_uint32(&b); + stats->num_pkts_transmitted = read_uint32(&b); + stats->num_gateway_scans = read_uint32(&b); + stats->num_collisions = read_uint32(&b); + stats->num_ack_successes = read_uint32(&b); + stats->num_ack_failures = read_uint32(&b); + stats->num_sync_failures = read_uint32(&b); + stats->num_canceled_pkts_ack = read_uint32(&b); + stats->num_canceled_pkts_csma = read_uint32(&b); + stats->num_rx_errors = read_uint32(&b); +} + +uint16_t ll_stats_serialize(const llabs_stats_t *stats, uint8_t buff[STATS_SIZE]) +{ + uint8_t * b = buff; + write_uint32(stats->num_send_calls, &b); + write_uint32(stats->num_pkts_transmitted, &b); + write_uint32(stats->num_gateway_scans, &b); + write_uint32(stats->num_collisions, &b); + write_uint32(stats->num_ack_successes, &b); + write_uint32(stats->num_ack_failures, &b); + write_uint32(stats->num_sync_failures, &b); + write_uint32(stats->num_canceled_pkts_ack, &b); + write_uint32(stats->num_canceled_pkts_csma, &b); + write_uint32(stats->num_rx_errors, &b); + return b - buff; +} + +void ll_time_deserialize(const uint8_t buff[TIME_INFO_SIZE], llabs_time_info_t *time_info) +{ + uint8_t const * b = buff; + time_info->sync_mode = read_uint8(&b); + time_info->curr.seconds = read_uint32(&b); + time_info->curr.millis = read_uint16(&b); + time_info->last_sync.seconds = read_uint32(&b); + time_info->last_sync.millis = read_uint16(&b); +} + +uint16_t ll_time_serialize(const llabs_time_info_t *time_info, uint8_t buff[TIME_INFO_SIZE]) +{ + uint8_t * b = buff; + write_uint8(time_info->sync_mode, &b); + write_uint32(time_info->curr.seconds, &b); + write_uint16(time_info->curr.millis, &b); + write_uint32(time_info->last_sync.seconds, &b); + write_uint16(time_info->last_sync.millis, &b); + return b - buff; +} diff --git a/src/ll_ifc.c.bak b/src/ll_ifc.c.bak new file mode 100644 index 0000000..5eb1bef --- /dev/null +++ b/src/ll_ifc.c.bak @@ -0,0 +1,692 @@ +#include "ll_ifc.h" +#include "ll_ifc_consts.h" +#include "ifc_struct_defs.h" +#include "ll_ifc_symphony.h" +#include "ll_ifc_no_mac.h" +#include +#include +#include + +#ifndef NULL // defines NULL on *some* platforms +#define NULL (0) +#endif +#define CMD_HEADER_LEN (5) +#define RESP_HEADER_LEN (6) +static uint16_t compute_checksum(uint8_t *hdr, uint16_t hdr_len, uint8_t *payload, uint16_t payload_len); +static void send_packet(opcode_t op, uint8_t message_num, uint8_t *buf, uint16_t len); +static int32_t recv_packet(opcode_t op, uint8_t message_num, uint8_t *buf, uint16_t len); + +const uint32_t OPEN_NET_TOKEN = 0x4f50454e; + +static int32_t message_num = 0; + +int32_t hal_read_write(opcode_t op, uint8_t buf_in[], uint16_t in_len, uint8_t buf_out[], uint16_t out_len) +{ + // int i; + // int curr_byte; + // int num_bytes; + + int32_t ret; + + // Error checking: + // Only valid combinations of buffer & length pairs are: + // buf == NULL, len = 0 + // buf != NULL, len > 0 + if (((buf_in != NULL) && ( in_len == 0)) || (( buf_in == NULL) && ( in_len > 0))) + { + return(LL_IFC_ERROR_INCORRECT_PARAMETER); + } + if (((buf_out != NULL) && (out_len == 0)) || ((buf_out == NULL) && (out_len > 0))) + { + return(LL_IFC_ERROR_INCORRECT_PARAMETER); + } + + // OK, inputs have been sanitized. Carry on... + send_packet(op, message_num, buf_in, in_len); + + ret = recv_packet(op, message_num, buf_out, out_len); + + message_num++; + + return(ret); +} + +int32_t hal_read_write_exact(opcode_t op, uint8_t buf_in[], uint16_t in_len, uint8_t buf_out[], uint16_t out_len) +{ + int32_t ret = hal_read_write(op, buf_in, in_len, buf_out, out_len); + if (ret >= 0) + { + if (ret != out_len) + { + return LL_IFC_ERROR_INCORRECT_RESPONSE_LENGTH; + } + ret = 0; + } + return ret; +} + +char const * ll_return_code_name(int32_t return_code) +{ + switch (return_code) + { + case -LL_IFC_ACK: return "ACK"; + case -LL_IFC_NACK_CMD_NOT_SUPPORTED: return "CMD_NOT_SUPPORTED"; + case -LL_IFC_NACK_INCORRECT_CHKSUM: return "INCORRECT_CHKSUM "; + case -LL_IFC_NACK_PAYLOAD_LEN_OOR: return "PAYLOAD_LEN_OOR"; + case -LL_IFC_NACK_PAYLOAD_OOR: return "PAYLOAD_OOR"; + case -LL_IFC_NACK_BOOTUP_IN_PROGRESS: return "BOOTUP_IN_PROGRESS"; + case -LL_IFC_NACK_BUSY_TRY_AGAIN: return "BUSY_TRY_AGAIN"; + case -LL_IFC_NACK_APP_TOKEN_REG: return "APP_TOKEN_REG"; + case -LL_IFC_NACK_PAYLOAD_LEN_EXCEEDED: return "PAYLOAD_LEN_EXCEEDED"; + case -LL_IFC_NACK_NOT_IN_MAILBOX_MODE: return "NOT IN MAILBOX MODE"; + case -LL_IFC_NACK_PAYLOAD_BAD_PROPERTY: return "BAD PROPERTY ID"; + case -LL_IFC_NACK_NODATA: return "NO DATA AVAIL"; + case -LL_IFC_NACK_QUEUE_FULL: return "QUEUE FULL"; + case -LL_IFC_NACK_OTHER: return "OTHER"; + + case LL_IFC_ERROR_INCORRECT_PARAMETER: return "INCORRECT_PARAMETER"; + case LL_IFC_ERROR_INCORRECT_RESPONSE_LENGTH: return "INCORRECT_RESPONSE_LENGTH"; + case LL_IFC_ERROR_MESSAGE_NUMBER_MISMATCH: return "MESSAGE_NUMBER_MISMATCH"; + case LL_IFC_ERROR_CHECKSUM_MISMATCH: return "CHECKSUM_MISMATCH"; + case LL_IFC_ERROR_COMMAND_MISMATCH: return "COMMAND_MISMATCH"; + case LL_IFC_ERROR_HOST_INTERFACE_TIMEOUT: return "HOST_INTERFACE_TIMEOUT"; + case LL_IFC_ERROR_BUFFER_TOO_SMALL: return "BUFFER_TOO_SMALL"; + case LL_IFC_ERROR_START_OF_FRAME: return "START_OF_FRAME"; + case LL_IFC_ERROR_HEADER: return "HEADER"; + case LL_IFC_ERROR_TIMEOUT: return "TIMEOUT"; + case LL_IFC_ERROR_INCORRECT_MESSAGE_SIZE: return "INCORRECT_MESSAGE_SIZE"; + case LL_IFC_ERROR_NO_NETWORK: return "NO_NETWORK"; + + default: return "UNKNOWN"; + } +} + +char const * ll_return_code_description(int32_t return_code) +{ + switch (return_code) + { + case -LL_IFC_ACK: return "success"; + case -LL_IFC_NACK_CMD_NOT_SUPPORTED: return "Command not supported"; + case -LL_IFC_NACK_INCORRECT_CHKSUM: return "Incorrect Checksum"; + case -LL_IFC_NACK_PAYLOAD_LEN_OOR: return "Length of payload sent in command was out of range"; + case -LL_IFC_NACK_PAYLOAD_OOR: return "Payload sent in command was out of range."; + case -LL_IFC_NACK_BOOTUP_IN_PROGRESS: return "Not allowed since firmware bootup still in progress. Wait."; + case -LL_IFC_NACK_BUSY_TRY_AGAIN: return "Operation prevented by temporary event. Retry later."; + case -LL_IFC_NACK_APP_TOKEN_REG: return "Application token is not registered for this node."; + case -LL_IFC_NACK_PAYLOAD_LEN_EXCEEDED: return "Payload length is greater than the max supported length"; + case -LL_IFC_NACK_NOT_IN_MAILBOX_MODE: return "Command invalid, not in mailbox mode"; + case -LL_IFC_NACK_PAYLOAD_BAD_PROPERTY: return "Bad property ID specified"; + case -LL_IFC_NACK_NODATA: return "No msg data available to return"; + case -LL_IFC_NACK_QUEUE_FULL: return "Data cannot be enqueued for transmission, queue is full"; + case -LL_IFC_NACK_OTHER: return "Unspecified error"; + + case LL_IFC_ERROR_INCORRECT_PARAMETER: return "The parameter value was invalid"; + case LL_IFC_ERROR_INCORRECT_RESPONSE_LENGTH: return "Module response was not the expected size"; + case LL_IFC_ERROR_MESSAGE_NUMBER_MISMATCH: return "Message number in response doesn't match expected"; + case LL_IFC_ERROR_CHECKSUM_MISMATCH: return "Checksum mismatch"; + case LL_IFC_ERROR_COMMAND_MISMATCH: return "Command mismatch (responding to a different command)"; + case LL_IFC_ERROR_HOST_INTERFACE_TIMEOUT: return "Timed out waiting for Rx bytes from interface"; + case LL_IFC_ERROR_BUFFER_TOO_SMALL: return "Response larger than provided output buffer"; + case LL_IFC_ERROR_START_OF_FRAME: return "transport_read failed getting FRAME_START"; + case LL_IFC_ERROR_HEADER: return "transport_read failed getting header"; + case LL_IFC_ERROR_TIMEOUT: return "The operation timed out"; + case LL_IFC_ERROR_INCORRECT_MESSAGE_SIZE: return "The message size from the device was incorrect"; + case LL_IFC_ERROR_NO_NETWORK: return "No network was available"; + + default: return "unknown error"; + } +} + +int32_t ll_firmware_type_get(ll_firmware_type_t *t) +{ + uint8_t buf[FIRMWARE_TYPE_LEN]; + int32_t ret; + if(t == NULL) + { + return LL_IFC_ERROR_INCORRECT_PARAMETER; + } + ret = hal_read_write(OP_FIRMWARE_TYPE, NULL, 0, buf, FIRMWARE_TYPE_LEN); + if (ret == FIRMWARE_TYPE_LEN) + { + t->cpu_code = buf[0] << 8 | buf[1]; + t->functionality_code = buf[2] << 8 | buf[3]; + } + return ret; +} + +int32_t ll_hardware_type_get(ll_hardware_type_t *t) +{ + uint8_t type; + int32_t ret; + if(t == NULL) + { + return LL_IFC_ERROR_INCORRECT_PARAMETER; + } + ret = hal_read_write(OP_HARDWARE_TYPE, NULL, 0, &type, sizeof(type)); + if (ret == sizeof(type)) + { + *t = (ll_hardware_type_t) type; + } + return ret; +} + +const char * ll_hardware_type_string(ll_hardware_type_t t) +{ + switch(t) + { + case UNAVAILABLE: return "unavailable"; + case LLRLP20_V2: return "LLRLP20 v2"; + case LLRXR26_V2: return "LLRXR26 v2"; + case LLRLP20_V3: return "LLRLP20 v3"; + case LLRXR26_V3: return "LLRXR26 v3"; + default: return "unknown"; + } +} + +int32_t ll_interface_version_get(ll_version_t *version) +{ + uint8_t buf[VERSION_LEN]; + int32_t ret; + if(version == NULL) + { + return LL_IFC_ERROR_INCORRECT_PARAMETER; + } + ret = hal_read_write(OP_IFC_VERSION, NULL, 0, buf, VERSION_LEN); + if (ret == VERSION_LEN) + { + version->major = buf[0]; + version->minor = buf[1]; + version->tag = buf[2] << 8 | buf[3]; + } + return ret; +} + +int32_t ll_version_get(ll_version_t *version) +{ + uint8_t buf[VERSION_LEN]; + int32_t ret; + if(version == NULL) + { + return LL_IFC_ERROR_INCORRECT_PARAMETER; + } + ret = hal_read_write(OP_VERSION, NULL, 0, buf, VERSION_LEN); + if (ret == VERSION_LEN) + { + version->major = buf[0]; + version->minor = buf[1]; + version->tag = buf[2] << 8 | buf[3]; + } + return ret; +} + +int32_t ll_sleep_block(void) +{ + return hal_read_write(OP_SLEEP_BLOCK, (uint8_t*) "1", 1, NULL, 0); +} + +int32_t ll_sleep_unblock(void) +{ + return hal_read_write(OP_SLEEP_BLOCK, (uint8_t*) "0", 1, NULL, 0); +} + +int32_t ll_mac_mode_set(ll_mac_type_t mac_mode) +{ + if (mac_mode >= NUM_MACS) + { + return LL_IFC_ERROR_INCORRECT_PARAMETER; + } + uint8_t u8_mac_mode = (uint8_t)mac_mode; + return hal_read_write(OP_MAC_MODE_SET, &u8_mac_mode, 1, NULL, 0); +} + +int32_t ll_mac_mode_get(ll_mac_type_t *mac_mode) +{ + int32_t ret; + if (NULL == mac_mode) + { + return LL_IFC_ERROR_INCORRECT_PARAMETER; + } + uint8_t u8_mac_mode; + ret = hal_read_write(OP_MAC_MODE_GET, NULL, 0, &u8_mac_mode, sizeof(uint8_t)); + *mac_mode = (ll_mac_type_t)u8_mac_mode; + return ret; +} + +int32_t ll_antenna_set(uint8_t ant) +{ + if((ant == 1) || (ant == 2)) + { + return hal_read_write(OP_ANTENNA_SET, &ant, 1, NULL, 0); + } + else + { + return LL_IFC_ERROR_INCORRECT_PARAMETER; + } +} + +int32_t ll_antenna_get(uint8_t *ant) +{ + if (ant == NULL) + { + return LL_IFC_ERROR_INCORRECT_PARAMETER; + } + return hal_read_write(OP_ANTENNA_GET, NULL, 0, ant, 1); +} + +int32_t ll_unique_id_get(uint64_t *unique_id) +{ + uint8_t buff[8]; + int32_t ret; + int i; + if (unique_id == NULL) + { + return LL_IFC_ERROR_INCORRECT_PARAMETER; + } + ret = hal_read_write(OP_MODULE_ID, NULL, 0, buff, 8); + *unique_id = 0; + for (i = 0; i < 8; i++) + { + *unique_id |= ((uint64_t) buff[i]) << (8 * (7 - i)); + } + + return ret; +} + +int32_t ll_settings_store(void) +{ + return hal_read_write(OP_STORE_SETTINGS, NULL, 0, NULL, 0); +} + +int32_t ll_settings_delete(void) +{ + return hal_read_write(OP_DELETE_SETTINGS, NULL, 0, NULL, 0); +} + +int32_t ll_restore_defaults(void) +{ + return hal_read_write(OP_RESET_SETTINGS, NULL, 0, NULL, 0); +} + +int32_t ll_sleep(void) +{ + return hal_read_write(OP_SLEEP, NULL, 0, NULL, 0); +} + +int32_t ll_reset_mcu(void) +{ + return hal_read_write(OP_RESET_MCU, NULL, 0, NULL, 0); +} + +int32_t ll_bootloader_mode(void) +{ + send_packet(OP_TRIGGER_BOOTLOADER, message_num, NULL, 0); + return 0; +} + +/** + * @return + * 0 - success + * negative = error, as defined by hal_read_write + */ +int32_t ll_irq_flags(uint32_t flags_to_clear, uint32_t *flags) +{ + // Assuming big endian convention over the interface + + uint8_t in_buf[4]; + uint8_t out_buf[4] = {0,0,0,0}; + + in_buf[0] = (uint8_t)((flags_to_clear >> 24) & 0xFF); + in_buf[1] = (uint8_t)((flags_to_clear >> 16) & 0xFF); + in_buf[2] = (uint8_t)((flags_to_clear >> 8) & 0xFF); + in_buf[3] = (uint8_t)((flags_to_clear ) & 0xFF); + + int32_t rw_response = hal_read_write(OP_IRQ_FLAGS, in_buf, 4, out_buf, 4); + + if(rw_response > 0) + { + uint32_t flags_temp = 0; + flags_temp |= (((uint32_t)out_buf[0]) << 24); + flags_temp |= (((uint32_t)out_buf[1]) << 16); + flags_temp |= (((uint32_t)out_buf[2]) << 8); + flags_temp |= (((uint32_t)out_buf[3])); + *flags = flags_temp; + } + + return(rw_response); +} + +//STRIPTHIS!START +int32_t ll_timestamp_get(uint32_t * timestamp_us) +{ + return ll_timestamp_set(LL_TIMESTAMP_NO_OPERATION, 0, timestamp_us); +} + +int32_t ll_timestamp_set(ll_timestamp_operation_t operation, uint32_t timestamp_us, uint32_t * actual_timestamp_us) +{ + uint8_t in_buf[5]; + uint8_t * b_in = in_buf; + uint8_t out_buf[4] = {0,0,0,0}; + + if (actual_timestamp_us == NULL) + { + return LL_IFC_ERROR_INCORRECT_PARAMETER; + } + + write_uint8((uint8_t) operation, &b_in); + write_uint32(timestamp_us, &b_in); + + int32_t rw_response = hal_read_write_exact(OP_TIMESTAMP, in_buf, sizeof(in_buf), out_buf, sizeof(out_buf)); + if (rw_response >= 0) + { + uint8_t const * b_out = out_buf; + *actual_timestamp_us = read_uint32(&b_out); + rw_response = 0; + } + + return rw_response; +} + +int32_t ll_trigger_watchdog(void) +{ + uint8_t cmd_buf[2]; + cmd_buf[0] = 0x00; + cmd_buf[1] = 0x01; + return hal_read_write(OP_RESERVED1, cmd_buf, 2, NULL, 0); +} + +int32_t ll_get_assert_info(char *filename, uint16_t filename_len, uint32_t *line) +{ + uint8_t tmp_arr[4 + 20]; + int32_t ret = hal_read_write(OP_GET_ASSERT, NULL, 0, tmp_arr, 4 + 20); + if (ret > 0) + { + *line = 0; + *line += (uint32_t)(tmp_arr[0]) << 24; + *line += (uint32_t)(tmp_arr[1]) << 16; + *line += (uint32_t)(tmp_arr[2]) << 8; + *line += (uint32_t)(tmp_arr[3]) << 0; + + uint16_t cpy_len = filename_len < 20 ? filename_len : 20; + memcpy(filename, tmp_arr + 4, cpy_len); + } + return ret; +} +int32_t ll_trigger_assert(void) +{ + return hal_read_write(OP_SET_ASSERT, NULL, 0, NULL, 0); +} + +//STRIPTHIS!STOP + +int32_t ll_reset_state( void ) +{ + message_num = 0; + return 0; +} + + +/** + * @brief + * send_packet + * + * @param[in] op + * opcode of the command being sent to the module + * + * @param[in] message_num + * message_num + * + * @param[in] buf + * byte array containing the data payload to be sent to the module + * + * @param[in] len + * size of the output buffer in bytes + * + * @return + * none + */ +static void send_packet(opcode_t op, uint8_t message_num, uint8_t *buf, uint16_t len) +{ + #define SP_NUM_ZEROS (6) + #define SP_HEADER_SIZE (CMD_HEADER_LEN + SP_NUM_ZEROS) + uint8_t header_buf[SP_HEADER_SIZE]; + uint8_t checksum_buff[2]; + uint16_t computed_checksum; + uint16_t header_idx = 0; + uint16_t i; + + // Send a couple wakeup bytes, just-in-case + for (i = 0; i < SP_NUM_ZEROS; i++) + { + header_buf[header_idx ++] = 0x5F; + } + + header_buf[header_idx++] = FRAME_START; + header_buf[header_idx++] = op; + header_buf[header_idx++] = message_num; + header_buf[header_idx++] = (uint8_t)(0xFF & (len >> 8)); + header_buf[header_idx++] = (uint8_t)(0xFF & (len >> 0)); + + computed_checksum = compute_checksum(header_buf + SP_NUM_ZEROS, CMD_HEADER_LEN, buf, len); + + transport_write(header_buf, SP_HEADER_SIZE); + + if (buf != NULL) + { + transport_write(buf, len); + } + + checksum_buff[0] = (computed_checksum >> 8); + checksum_buff[1] = (computed_checksum >> 0); + transport_write(checksum_buff, 2); + +} + +/** + * @brief + * recv_packet + * + * @param[in] op + * opcode of the command that we're trying to receive + * + * @param[in] message_num + * message number of the command that we're trying to receive + * + * @param[in] buf + * byte array for storing data returned from the module + * + * @param[in] len + * size of the output buffer in bytes + * + * @return + * positive number of bytes returned, + * negative if an error + * Error Codes: + * -1 NACK received - Command not supported + * -2 NACK received - Incorrect Checksum + * -3 NACK received - Payload length out of range + * -4 NACK received - Payload out of range + * -5 NACK received - Not allowed, bootup in progress + * -6 NACK received - Busy try again + * -7 NACK received - Application token not registered + * -8 NACK received - Payload length greater than maximum supported length + * -99 NACK received - Other + * -103 Message Number in response doesn't match expected + * -104 Checksum mismatch + * -105 Command mismatch (responding to a different command) + * -106 Timed out waiting for Rx bytes from interface + * -107 Response larger than provided output buffer + * -108 transport_read failed getting FRAME_START + * -109 transport_read failed getting header + */ +static int32_t recv_packet(opcode_t op, uint8_t message_num, uint8_t *buf, uint16_t len) +{ + uint8_t header_buf[RESP_HEADER_LEN]; + uint16_t header_idx; + + uint8_t curr_byte = 0; + uint8_t checksum_buff[2]; + uint16_t computed_checksum; + int32_t ret_value = 0; + int32_t ret; + + memset(header_buf, 0, sizeof(header_buf)); + + struct time time_start, time_now; + if (gettime(&time_start) < 0) + { + return LL_IFC_ERROR_HAL_CALL_FAILED; + } + + do + { + /* Timeout of infinite Rx loop if responses never show up*/ + ret = transport_read(&curr_byte, 1); + + if (gettime(&time_now) < 0) + { + return LL_IFC_ERROR_HAL_CALL_FAILED; + } + + if(time_now.tv_sec - time_start.tv_sec > 2) + { + len = 0; + return LL_IFC_ERROR_HOST_INTERFACE_TIMEOUT; + } + } while(curr_byte != FRAME_START); + + if (ret < 0) + { + /* transport_read failed - return an error */ + return LL_IFC_ERROR_START_OF_FRAME; + } + + header_idx = 0; + header_buf[header_idx++] = FRAME_START; + + ret = transport_read(header_buf + 1, RESP_HEADER_LEN - 1); + if (ret < 0) + { + /* transport_read failed - return an error */ + return LL_IFC_ERROR_HEADER; + } + + uint16_t len_from_header = (uint16_t)header_buf[5] + ((uint16_t)header_buf[4] << 8); + + if (header_buf[1] != op) + { + // Command Byte should match what was sent + ret_value = LL_IFC_ERROR_COMMAND_MISMATCH; + } + if (header_buf[2] != message_num) + { + // Message Number should match + ret_value = LL_IFC_ERROR_MESSAGE_NUMBER_MISMATCH; + } + if (header_buf[3] != 0x00) + { + // NACK Received + // Map NACK code to error code + ret_value = 0 - header_buf[3]; + } + if (len_from_header > len) + { + // response is larger than the caller expects. + // Pull the bytes out of the Rx fifo + int32_t ret; + do + { + uint8_t temp_byte; + ret = transport_read(&temp_byte, 1); + } + while (ret == 0); + return LL_IFC_ERROR_BUFFER_TOO_SMALL; + } + else if (len_from_header < len) + { + // response is shorter than caller expects. + len = len_from_header; + } + + if (ret_value == 0) + { + + // If we got here, then we: + // 1) Received the FRAME_START in the response + // 2) The message number matched + // 3) The ACK byte was ACK (not NACK) + // 4) The received payload length is less than or equal to the size of the buffer + // allocated for the payload + + // Grab the payload if there is supposed to be one + if ((buf != NULL) && (len > 0)) + { + transport_read(buf, len); + } + } + + // Finally, make sure the checksum matches + transport_read(checksum_buff, 2); + + computed_checksum = compute_checksum(header_buf, RESP_HEADER_LEN, buf, len); + uint16_t rx_checksum = ((uint16_t)checksum_buff[0] << 8) + checksum_buff[1]; + if (rx_checksum != computed_checksum) + { + return LL_IFC_ERROR_CHECKSUM_MISMATCH; + } + + if (ret_value == 0) + { + // Success! Return the number of bytes in the payload (0 or positive number) + return len; + } + else + { + // Failure! Return an error, such as NACK response from the firmware + return ret_value; + } +} + +/** + * @brief + * compute_checksum + * + * @param[in] hdr + * header array to compute checksum on + * + * @param[in] hdr_len + * size of the header array in bytes + * + * @param[in] payload + * payload array to compute checksum on + * + * @param[in] payload_len + * size of the payload array in bytes + * + * @return + * The 8-bit checksum + */ +static uint16_t compute_checksum(uint8_t *hdr, uint16_t hdr_len, uint8_t *payload, uint16_t payload_len) +{ + uint16_t crc = 0x0; + uint16_t i; + + for (i = 0; i < hdr_len; i++) + { + crc = (crc >> 8) | (crc << 8); + crc ^= hdr[i]; + crc ^= (crc & 0xff) >> 4; + crc ^= crc << 12; + crc ^= (crc & 0xff) << 5; + } + + for (i = 0; i < payload_len; i++) + { + crc = (crc >> 8) | (crc << 8); + crc ^= payload[i]; + crc ^= (crc & 0xff) >> 4; + crc ^= crc << 12; + crc ^= (crc & 0xff) << 5; + } + + return crc; +} diff --git a/src/ll_ifc_ftp.c.bak b/src/ll_ifc_ftp.c.bak new file mode 100644 index 0000000..2deb792 --- /dev/null +++ b/src/ll_ifc_ftp.c.bak @@ -0,0 +1,866 @@ +#include // memmove +#include // for ceil +#include // for printf +#include "ll_ifc_ftp.h" +#include "ll_ifc_utils.h" + +#define LL_FTP_MSG_PACKET_TYPE_INDEX (0) +#define LL_FTP_MSG_CRC_INDEX (1) +#define LL_FTP_MSG_FILE_ID_INDEX (5) +#define LL_FTP_MSG_FILE_VERSION_INDEX (9) +#define LL_FTP_MSG_FILE_SIZE_INDEX (13) +#define LL_FTP_MSG_SEG_NUM_INDEX (17) +#define LL_FTP_MSG_NUM_SEGS_INDEX (19) +#define LL_FTP_MSG_PAYLOAD_INDEX (21) +#define LL_FTP_ACK_ACK_TYPE_INDEX (5) +#define LL_FTP_ACK_FILE_ID_INDEX (6) +#define LL_FTP_ACK_FILE_VERSION_INDEX (10) +#define LL_FTP_NAK_FILE_SEGS_INDEX (14) + +#define LL_FTP_MSG_MIN_SIZE (17) + +#define IS_MY_FILE ((ftp_msg.file_id == f->file_id) && (ftp_msg.file_version == f->file_version)) + +#define UINT16_FROM_BYTESTREAM(p) (p[0] | (p[1] << 8)) +#define UINT32_FROM_BYTESTREAM(p) (p[0] | (p[1] << 8) | (p[2] << 16) | (p[3] << 24)) + +#define UINT32_TO_BYTESTREAM(dst, src) dst[0] = src & 0xFF; \ + dst[1] = (src >> 8) & 0xFF; \ + dst[2] = (src >> 16) & 0xFF; \ + dst[3] = (src >> 24) & 0xFF; + +const uint8_t LL_FTP_MAX_NUM_RETRIES = 5; +const uint8_t LL_FTP_RETRY_INTERVAL = 15; +const uint8_t LL_FTP_PORT = 128; + +extern uint8_t ll_ul_max_port; + +typedef enum ll_ftp_msg_type +{ + TX_INIT, + TX_CANCEL, + TX_APPLY, + TX_SEGMENT, + ACK_INIT, + ACK_SEGMENT, + ACK_APPLY, + TICK, + NUM_MSG_TYPES, +} ll_ftp_msg_type_t; + +typedef enum ll_ftp_ack_type +{ + ACK_ACK = 0x00, + ACK_NAK_SEGMENT = 0xFD, + ACK_NAK = 0xFF, +} ll_ftp_ack_type_t; + +typedef struct ll_ftp_msg +{ + uint32_t crc; + uint32_t file_id; + uint32_t file_version; + uint32_t file_size; + ll_ftp_msg_type_t msg_type; + uint16_t segment_number; + uint16_t num_segs; + uint16_t payload_len; + uint8_t* payload; +} ll_ftp_msg_t; + +// Modifies the max port so we can send the message. +static ll_ftp_return_code_t ll_ftp_send_uplink(ll_ftp_t* f, size_t len) +{ + uint8_t old_max_port = ll_ul_max_port; + ll_ul_max_port = LL_FTP_PORT; + ll_ftp_return_code_t ret = f->cb.uplink(f->tx_buf, (uint16_t) len, true, LL_FTP_PORT); + ll_ul_max_port = old_max_port; + gettime(&f->time_last_msg); + return ret; +} + +// reset retry and timeout counters +static void ll_ftp_reset(ll_ftp_t *f) +{ + gettime(&f->time_last_msg); + f->retry_count = 0; +} + +// Close and reopen the file +static ll_ftp_return_code_t ll_ftp_file_reopen(ll_ftp_t *f) +{ + ll_ftp_return_code_t cb_ret; + + cb_ret = f->cb.close(f->file_id, f->file_version); + if (LL_FTP_OK == cb_ret) + { + cb_ret = f->cb.open(f->file_id, f->file_version, f->file_size); + } + + return cb_ret; +} + +static int32_t ll_ftp_parse_rx_msg(const uint8_t* buf, uint8_t len, ll_ftp_msg_t* ftp_msg) +{ + // NULL pointer signifies TICK message + if(NULL == buf) + { + ftp_msg->msg_type = TICK; + return LL_FTP_OK; + } + + // Catch invalid values + if(LL_FTP_MSG_MIN_SIZE > len) + { + return LL_FTP_INVALID_VALUE; + } + if(NUM_MSG_TYPES <= buf[LL_FTP_MSG_PACKET_TYPE_INDEX]) + { + return LL_FTP_OOR; + } + + // Stuff all messages have + ftp_msg->msg_type = buf[LL_FTP_MSG_PACKET_TYPE_INDEX]; + ftp_msg->crc = buf[LL_FTP_MSG_CRC_INDEX + 0] << 0; + ftp_msg->crc = UINT32_FROM_BYTESTREAM( (&buf[LL_FTP_MSG_CRC_INDEX]) ); + ftp_msg->file_id = UINT32_FROM_BYTESTREAM( (&buf[LL_FTP_MSG_FILE_ID_INDEX]) ); + ftp_msg->file_version = UINT32_FROM_BYTESTREAM( (&buf[LL_FTP_MSG_FILE_VERSION_INDEX]) ); + ftp_msg->file_size = UINT32_FROM_BYTESTREAM( (&buf[LL_FTP_MSG_FILE_SIZE_INDEX]) ); + + // Stuff only segments have + if(TX_SEGMENT == ftp_msg->msg_type) + { + ftp_msg->segment_number = UINT16_FROM_BYTESTREAM( (&buf[LL_FTP_MSG_SEG_NUM_INDEX]) ); + ftp_msg->num_segs = UINT16_FROM_BYTESTREAM( (&buf[LL_FTP_MSG_NUM_SEGS_INDEX]) ); + ftp_msg->payload = (uint8_t*) &buf[LL_FTP_MSG_PAYLOAD_INDEX]; + ftp_msg->payload_len = len - LL_FTP_MSG_PAYLOAD_INDEX; // implicit payload length + } + + // check crc + uint32_t crc = crc32(0, (uint8_t*) &buf[LL_FTP_MSG_FILE_ID_INDEX], len - LL_FTP_MSG_FILE_ID_INDEX); + int32_t ret = (crc == ftp_msg->crc) ? LL_FTP_OK : LL_FTP_ERROR; + + return ret; +} + +// Update segments cache array for successfully received and written segments +static void ll_ftp_seg_num_track(ll_ftp_t* f, uint16_t seg_num) +{ + if(MAX_NUM_SEGMENTS >= seg_num) + { + uint16_t base = seg_num >> 5; // divide by 32 + f->rx_segs[base] |= (1 << (0x1F & seg_num)); // bit shift a maximum of 5 bits + } +} + +static bool ll_ftp_transfer_is_complete(ll_ftp_t* f) +{ + bool ret = true; + uint32_t i; + uint16_t base_max = f->num_segs >> 5; // divide by 32 + + for(i = 0; i <= base_max; i++) + { + if(i != base_max) + { + if(0xFFFFFFFF != f->rx_segs[i]) + { + ret = false; + break; + } + } + else + { + uint32_t j; + uint32_t num_segs_mod = f->num_segs & 0x1F; // mod by 32 + for(j = 0; j < num_segs_mod; j++) + { + if(!((f->rx_segs[base_max] >> j) & 0x1)) + { + ret = false; + break; + } + } + } + } + + return ret; +} + +static uint16_t ll_ftp_get_missing_segs(ll_ftp_t* f, bool fill_buf) +{ + uint16_t num_missing_segs = 0; + uint32_t i, j; + uint16_t seg_num; + uint8_t num_segs_base; + uint8_t idx; + uint16_t total_payload = fill_buf ? BASE_UL_MSG_LEN : 0; + + uint16_t base_max = f->num_segs >> 5; // divide by 32 + for(i = 0; i <= base_max; i++) + { + num_segs_base = (i != base_max) ? 32 : f->num_segs & 0x1F; // mod by 32 + + for(j = 0; j < num_segs_base; j++) + { + if(!((f->rx_segs[i] >> j) & 0x1)) + { + if((MAX_NUM_RETRY_SEGS <= num_missing_segs) && fill_buf) + { + // request complete retransmission + return 0xFFFF; + } + + seg_num = (i << 5) + j; // i * 32 + j + + idx = num_missing_segs * 2; + + // Only fill the buffer up to the maximum number of segments we can request in + // a single payload + if ((fill_buf) && ((total_payload + sizeof(seg_num)) <= LL_FTP_TX_BUF_SIZE)) + { + f->tx_buf[LL_FTP_NAK_FILE_SEGS_INDEX + idx] = seg_num & 0x00FF; + f->tx_buf[LL_FTP_NAK_FILE_SEGS_INDEX + idx + 1] = (seg_num >> 8) & 0x00FF; + + total_payload += sizeof(seg_num); + num_missing_segs++; + } + } + } + } + + return num_missing_segs; +} + +static uint16_t ll_ftp_ack_init_generate(ll_ftp_t* f, bool ack) +{ + f->tx_buf[LL_FTP_MSG_PACKET_TYPE_INDEX] = ACK_INIT; + if (ack) + { + f->tx_buf[LL_FTP_ACK_ACK_TYPE_INDEX] = ACK_ACK; + } + else + { + f->tx_buf[LL_FTP_ACK_ACK_TYPE_INDEX] = ACK_NAK; + } + UINT32_TO_BYTESTREAM((&f->tx_buf[LL_FTP_ACK_FILE_ID_INDEX]), f->file_id); + UINT32_TO_BYTESTREAM((&f->tx_buf[LL_FTP_ACK_FILE_VERSION_INDEX]), f->file_version); + + + uint32_t crc = crc32(0, &f->tx_buf[LL_FTP_ACK_ACK_TYPE_INDEX], BASE_UL_MSG_LEN - LL_FTP_ACK_ACK_TYPE_INDEX); + UINT32_TO_BYTESTREAM((&f->tx_buf[LL_FTP_MSG_CRC_INDEX]), crc); + + return BASE_UL_MSG_LEN; +} + +static uint16_t ll_ftp_ack_segs_complete_generate(ll_ftp_t* f) +{ + f->tx_buf[LL_FTP_MSG_PACKET_TYPE_INDEX] = ACK_SEGMENT; + f->tx_buf[LL_FTP_ACK_ACK_TYPE_INDEX] = ACK_ACK; + UINT32_TO_BYTESTREAM((&f->tx_buf[LL_FTP_ACK_FILE_ID_INDEX]), f->file_id); + UINT32_TO_BYTESTREAM((&f->tx_buf[LL_FTP_ACK_FILE_VERSION_INDEX]), f->file_version); + + uint32_t crc = crc32(0, &f->tx_buf[LL_FTP_ACK_ACK_TYPE_INDEX], BASE_UL_MSG_LEN - LL_FTP_ACK_ACK_TYPE_INDEX); + UINT32_TO_BYTESTREAM((&f->tx_buf[LL_FTP_MSG_CRC_INDEX]), crc); + + return BASE_UL_MSG_LEN; +} + +static uint16_t ll_ftp_ack_segs_request_generate(ll_ftp_t* f) +{ + f->tx_buf[LL_FTP_MSG_PACKET_TYPE_INDEX] = ACK_SEGMENT; + f->tx_buf[LL_FTP_ACK_ACK_TYPE_INDEX] = ACK_NAK_SEGMENT; + UINT32_TO_BYTESTREAM((&f->tx_buf[LL_FTP_ACK_FILE_ID_INDEX]), f->file_id); + UINT32_TO_BYTESTREAM((&f->tx_buf[LL_FTP_ACK_FILE_VERSION_INDEX]), f->file_version); + + // check max length number of retry segments + uint16_t num_missing_segs = ll_ftp_get_missing_segs(f, true); + uint16_t return_len = BASE_UL_MSG_LEN; + if(MAX_NUM_RETRY_SEGS <= num_missing_segs) + { + f->tx_buf[LL_FTP_ACK_ACK_TYPE_INDEX] = ACK_NAK; + } + else + { + return_len += num_missing_segs * sizeof(uint16_t); + } + + uint32_t crc = crc32(0, &f->tx_buf[LL_FTP_ACK_ACK_TYPE_INDEX], (size_t) return_len - LL_FTP_ACK_ACK_TYPE_INDEX); + UINT32_TO_BYTESTREAM((&f->tx_buf[LL_FTP_MSG_CRC_INDEX]), crc); + + return return_len; +} + +static uint16_t ll_ftp_ack_apply_generate(ll_ftp_t* f, bool success) +{ + f->tx_buf[LL_FTP_MSG_PACKET_TYPE_INDEX] = ACK_APPLY; + f->tx_buf[LL_FTP_ACK_ACK_TYPE_INDEX] = (success ? ACK_ACK : ACK_NAK); + UINT32_TO_BYTESTREAM((&f->tx_buf[LL_FTP_ACK_FILE_ID_INDEX]), f->file_id); + UINT32_TO_BYTESTREAM((&f->tx_buf[LL_FTP_ACK_FILE_VERSION_INDEX]), f->file_version); + + uint32_t crc = crc32(0, &f->tx_buf[LL_FTP_ACK_ACK_TYPE_INDEX], BASE_UL_MSG_LEN - LL_FTP_ACK_ACK_TYPE_INDEX); + UINT32_TO_BYTESTREAM((&f->tx_buf[LL_FTP_MSG_CRC_INDEX]), crc); + + return BASE_UL_MSG_LEN; +} + +static void ll_ftp_new_file_initialize(ll_ftp_t* f, ll_ftp_msg_t* msg) +{ + ll_ftp_reset(f); + f->file_id = msg->file_id; + f->file_version = msg->file_version; + f->file_size = msg->file_size; + f->num_segs = (uint16_t)ceil((double)f->file_size / (double)MAX_FILE_SEGMENT_BYTES); + memset(f->rx_segs, 0, sizeof(f->rx_segs[0]) * NUM_RX_SEGS_BITMASK); + + // send ACK_INIT + uint16_t len = ll_ftp_ack_init_generate(f, true); + ll_ftp_send_uplink(f, len); +} + +static void ll_ftp_state_set(ll_ftp_t* f, ll_ftp_state_t new_state) +{ + f->state = new_state; +} + +static int32_t ll_ftp_idle_start(ll_ftp_t* f) +{ + int32_t ret = LL_FTP_NO_ACTION; + + int32_t cb_ret = f->cb.close(f->file_id, f->file_version); + if(LL_FTP_OK == cb_ret) + { + f->cb.config(false); + } + ret = (LL_FTP_OK == cb_ret) ? LL_FTP_OK : LL_FTP_ERROR; + + return ret; +} + +static int32_t ll_ftp_segment_start(ll_ftp_t* f, ll_ftp_msg_t* msg) +{ + ll_ftp_return_code_t msg_ret; + int32_t ret = LL_FTP_NO_ACTION; + + int32_t cb_ret = f->cb.open(msg->file_id, msg->file_version, msg->file_size); + if (LL_FTP_OK == cb_ret) + { + ll_ftp_new_file_initialize(f, msg); + f->cb.config(true); + ret = LL_FTP_OK; + } + else if (TX_INIT == msg->msg_type || TX_SEGMENT == msg->msg_type) + { + // send ACK_INIT + uint16_t len = ll_ftp_ack_init_generate(f, false); + msg_ret = ll_ftp_send_uplink(f, len); + if (msg_ret != LL_FTP_OK) + { + ret = LL_FTP_ERROR; + } + } + + return ret; +} + +static int32_t ll_ftp_apply_start(ll_ftp_t* f) +{ + ll_ftp_return_code_t msg_ret; + int32_t ret = LL_FTP_ERROR; + + int32_t cb_ret = f->cb.close(f->file_id, f->file_version); + if(LL_FTP_OK == cb_ret) + { + uint16_t len = ll_ftp_ack_segs_complete_generate(f); + + ret = LL_FTP_OK; + msg_ret = ll_ftp_send_uplink(f, len); + if (msg_ret != LL_FTP_OK) + { + ret = LL_FTP_ERROR; + } + } + + return ret; +} + +static int32_t ll_ftp_verify_file_info(ll_ftp_t* f, uint32_t *file_crc) +{ + int32_t ret = LL_FTP_OK; + uint8_t tmp_buf[4]; + uint32_t file_size = 0; + uint32_t file_id = 0; + uint32_t file_version = 0; + ll_ftp_return_code_t cb_ret; + + cb_ret = f->cb.read(f->file_id, f->file_version, LL_FTP_HDR_OFFSET_CRC, tmp_buf, sizeof(tmp_buf)); + if (LL_FTP_OK != cb_ret) + { + return cb_ret; + } + *file_crc = UINT32_FROM_BYTESTREAM(tmp_buf); + + cb_ret = f->cb.read(f->file_id, f->file_version, LL_FTP_HDR_OFFSET_SIZE, tmp_buf, sizeof(tmp_buf)); + if (LL_FTP_OK != cb_ret) + { + return cb_ret; + } + file_size = UINT32_FROM_BYTESTREAM(tmp_buf); + + cb_ret = f->cb.read(f->file_id, f->file_version, LL_FTP_HDR_OFFSET_ID, tmp_buf, sizeof(tmp_buf)); + if (LL_FTP_OK != cb_ret) + { + return cb_ret; + } + file_id = UINT32_FROM_BYTESTREAM(tmp_buf); + + cb_ret = f->cb.read(f->file_id, f->file_version, LL_FTP_HDR_OFFSET_VERSION, tmp_buf, sizeof(tmp_buf)); + if (LL_FTP_OK != cb_ret) + { + return cb_ret; + } + file_version = UINT32_FROM_BYTESTREAM(tmp_buf); + + if (file_size != f->file_size || + file_id != f->file_id || + file_version != f->file_version) + { + ret = LL_FTP_ERROR; + } + return ret; +} + +static int32_t ll_ftp_compute_file_crc(ll_ftp_t* f, uint32_t *crc_out) +{ + uint8_t tmp_buf[16]; + uint32_t offset; + uint32_t len = sizeof(tmp_buf); + uint32_t crc = 0; + + for (offset = LL_FTP_HDR_OFFSET_SIZE; offset < (LL_FTP_HDR_LEN + f->file_size); offset += len) + { + ll_ftp_return_code_t cb_ret; + + if ((offset + len) > (LL_FTP_HDR_LEN + f->file_size)) + { + len = (LL_FTP_HDR_LEN + f->file_size) - offset; + } + + cb_ret = f->cb.read(f->file_id, f->file_version, offset, tmp_buf, len); + if (LL_FTP_OK == cb_ret) + { + crc = crc32(crc, tmp_buf, len); + } + } + *crc_out = crc; + + return LL_FTP_OK; +} + +static int32_t ll_ftp_verify_file(ll_ftp_t* f) +{ + int32_t ret = LL_FTP_OK; + uint32_t file_crc = 0; + + ret = ll_ftp_verify_file_info(f, &file_crc); + + if (LL_FTP_OK == ret) + { + uint32_t crc; + ret = ll_ftp_compute_file_crc(f, &crc); + if (LL_FTP_OK == ret && (crc == file_crc)) + { + ret = LL_FTP_OK; + } + else + { + ret = LL_FTP_ERROR; + } + } + + return ret; +} + +static int32_t ll_ftp_write_segment(ll_ftp_t* f, ll_ftp_msg_t* msg) +{ + int32_t ret = LL_FTP_NO_ACTION; + + int32_t offset = msg->segment_number * MAX_FILE_SEGMENT_BYTES; + int32_t cb_ret = f->cb.write(msg->file_id, msg->file_version, offset, msg->payload, msg->payload_len); + + if(LL_FTP_OK == cb_ret) + { + ll_ftp_seg_num_track(f, msg->segment_number); + ret = LL_FTP_OK; + } + + return ret; +} + +static int32_t ll_ftp_idle_process_msg(ll_ftp_t* f, uint8_t* buf, uint8_t len) +{ + ll_ftp_msg_t ftp_msg; + int32_t ret = ll_ftp_parse_rx_msg(buf, len, &ftp_msg); + if(LL_FTP_OK != ret) + { + return ret; + } + + if((TX_INIT != ftp_msg.msg_type) && (TX_SEGMENT != ftp_msg.msg_type)) + { + return LL_FTP_INVALID_VALUE; + } + + // State transition to SEGMENT + ret = ll_ftp_segment_start(f, &ftp_msg); + if(LL_FTP_OK == ret) + { + ll_ftp_state_set(f, SEGMENT); + } + + return ret; +} + +static int32_t ll_ftp_transition_out_of_segment(ll_ftp_t* f, ll_ftp_msg_t* msg, ll_ftp_state_t next_state) +{ + int32_t ret; + + switch(next_state) + { + case IDLE: + { + ret = ll_ftp_idle_start(f); + if(LL_FTP_OK == ret) + { + ll_ftp_state_set(f, IDLE); + ll_ftp_init(f, &f->cb); + } + } + break; + case SEGMENT: + { + ret = ll_ftp_segment_start(f, msg); + if(LL_FTP_OK == ret) + { + ll_ftp_state_set(f, SEGMENT); + } + } + break; + case APPLY: + { + ret = ll_ftp_apply_start(f); + if(LL_FTP_OK == ret) + { + ll_ftp_state_set(f, APPLY); + } + else + { + ll_ftp_state_set(f, IDLE); + } + } + break; + default: + ret = LL_FTP_ERROR; + break; + } + + return ret; +} + +static int32_t ll_ftp_segment_process_msg(ll_ftp_t* f, uint8_t* buf, uint8_t len) +{ + ll_ftp_return_code_t msg_ret; + ll_ftp_msg_t ftp_msg; + int32_t ret = ll_ftp_parse_rx_msg(buf, len, &ftp_msg); + if(LL_FTP_OK != ret) + { + return ret; + } + + int32_t next_state = -1; + + ret = LL_FTP_NO_ACTION; //default value + if((TX_INIT == ftp_msg.msg_type) && !(IS_MY_FILE)) + { + next_state = SEGMENT; + } + else if ((TX_CANCEL == ftp_msg.msg_type) && (IS_MY_FILE)) + { + next_state = IDLE; + } + else if (TX_SEGMENT == ftp_msg.msg_type) + { + if(!(IS_MY_FILE)) + { + next_state = SEGMENT; // attempt to restart SEGMENT state + } + else + { + // reset retry and timeout counters + ll_ftp_reset(f); + + ret = ll_ftp_write_segment(f, &ftp_msg); + if(ll_ftp_transfer_is_complete(f)) + { + if(LL_FTP_OK == ll_ftp_verify_file(f)) + { + next_state = APPLY; + } + else + { + //keep file transfer, but clear file progress and request all segs + memset(f->rx_segs, 0, sizeof(f->rx_segs[0]) * NUM_RX_SEGS_BITMASK); + ll_ftp_reset(f); + + ret = ll_ftp_file_reopen(f); + if (LL_FTP_OK != ret) + { + next_state = IDLE; + } + } + } + } + } + else if (TX_APPLY == ftp_msg.msg_type) + { + // Only able to apply in APPLY state + // send NAK with retry segs + uint16_t len = ll_ftp_ack_segs_request_generate(f); + + ret = LL_FTP_OK; + msg_ret = ll_ftp_send_uplink(f, len); + if (msg_ret != LL_FTP_OK) + { + ret = LL_FTP_ERROR; + } + } + else if(TICK == ftp_msg.msg_type) + { + struct time time_now; + ret = LL_FTP_OK; + + // Rely on a periodic 1 Hz tick to request segments if necessary + gettime(&time_now); + if(ll_difftime(&f->time_last_msg, &time_now) >= LL_FTP_RETRY_INTERVAL) + { + if(f->retry_count < LL_FTP_MAX_NUM_RETRIES) + { + uint16_t len = ll_ftp_ack_segs_request_generate(f); + msg_ret = ll_ftp_send_uplink(f, len); + if (msg_ret != LL_FTP_OK) + { + ret = LL_FTP_ERROR; + } + + f->retry_count++; + } + else + { + next_state = IDLE; + } + } + } + + // Do state transitions out of SEGMENT + if(next_state > -1) + { + ret = ll_ftp_transition_out_of_segment(f, &ftp_msg, next_state); + } + + return ret; +} + +static int32_t ll_ftp_transition_out_of_apply(ll_ftp_t* f, ll_ftp_msg_t* msg, ll_ftp_state_t next_state, bool is_error) +{ + int32_t ret; + + switch (next_state) + { + case IDLE: + { + ret = ll_ftp_idle_start(f); + ll_ftp_init(f, &f->cb); + if(LL_FTP_OK == ret) + { + ll_ftp_state_set(f, IDLE); + } + } + break; + case SEGMENT: + { + ret = ll_ftp_segment_start(f, msg); + if(LL_FTP_OK == ret) + { + ll_ftp_state_set(f, SEGMENT); + } + } + break; + case APPLY: + { + ret = LL_FTP_NO_ACTION; + } + break; + default: + ret = LL_FTP_ERROR; + break; + } + + if(is_error) + { + ret = LL_FTP_ERROR; + } + + return ret; +} + +static int32_t ll_ftp_apply_process_msg(ll_ftp_t* f, uint8_t* buf, uint8_t len) +{ + ll_ftp_msg_t ftp_msg; + ll_ftp_return_code_t msg_ret; + int32_t ret = ll_ftp_parse_rx_msg(buf, len, &ftp_msg); + + if(LL_FTP_OK != ret) + { + return ret; + } + + int32_t next_state = -1; + + ret = LL_FTP_NO_ACTION; //default value + if((TX_INIT == ftp_msg.msg_type) && !(IS_MY_FILE)) + { + next_state = SEGMENT; + } + else if ((TX_CANCEL == ftp_msg.msg_type) && (IS_MY_FILE)) + { + next_state = IDLE; + } + else if(TX_SEGMENT == ftp_msg.msg_type) + { + if(IS_MY_FILE) + { + // reset retry and timeout counters + ll_ftp_reset(f); + } + else + { + next_state = SEGMENT; + } + } + else if ((TX_APPLY == ftp_msg.msg_type) && (IS_MY_FILE)) + { + uint16_t len; + int32_t cb_ret = f->cb.apply(f->file_id, f->file_version, f->file_size); + if(LL_FTP_OK == cb_ret) + { + len = ll_ftp_ack_apply_generate(f, true); + } + else + { + // Apply rejected. Send NAK and forget file. + len = ll_ftp_ack_apply_generate(f, false); + ret = LL_FTP_ERROR; + } + + next_state = IDLE; + msg_ret = ll_ftp_send_uplink(f, len); + if (msg_ret != LL_FTP_OK) + { + ret = LL_FTP_ERROR; + } + } + else if(TICK == ftp_msg.msg_type) + { + struct time time_now; + + ret = LL_FTP_OK; + + // Rely on a periodic 1 Hz tick to request segments if necessary + gettime(&time_now); + if(ll_difftime(&f->time_last_msg, &time_now) >= LL_FTP_RETRY_INTERVAL) + { + if(f->retry_count < LL_FTP_MAX_NUM_RETRIES) + { + uint16_t len = ll_ftp_ack_segs_complete_generate(f); + msg_ret = ll_ftp_send_uplink(f, len); + if (msg_ret != LL_FTP_OK) + { + ret = LL_FTP_ERROR; + } + + f->retry_count++; + } + else + { + next_state = IDLE; + } + } + } + + // Do state transitions out of APPLY + if(next_state > -1) + { + ret = ll_ftp_transition_out_of_apply(f, &ftp_msg, next_state, (LL_FTP_ERROR == ret)); + } + + return ret; +} + +int32_t ll_ftp_num_missing_segs_get(ll_ftp_t* f) +{ + if((0 >= f->num_segs) || (MAX_NUM_SEGMENTS < f->num_segs)) + { + return -1; + } + + return ll_ftp_get_missing_segs(f, false); +} + +int32_t ll_ftp_msg_process(ll_ftp_t* f, uint8_t* buf, uint8_t len) +{ + int32_t ret = 0; + switch (f->state) + { + case IDLE: + ret = ll_ftp_idle_process_msg(f, buf, len); + break; + case SEGMENT: + ret = ll_ftp_segment_process_msg(f, buf, len); + break; + case APPLY: + ret = ll_ftp_apply_process_msg(f, buf, len); + break; + default: + ret = LL_FTP_ERROR; + break; + } + + return ret; +} + +int32_t ll_ftp_init(ll_ftp_t* f, ll_ftp_callbacks_t* cb) +{ + if((NULL == cb->open) || (NULL == cb->read) || + (NULL == cb->write) || (NULL == cb->close) || + (NULL == cb->apply) || (NULL == cb->uplink) || + (NULL == cb->config)) + { + return LL_FTP_INVALID_VALUE; + } + + ll_ftp_state_set(f, IDLE); + f->num_segs = 0; + memset(f->rx_segs, 0, sizeof(f->rx_segs[0]) * NUM_RX_SEGS_BITMASK); + f->file_id = 0; + f->file_version = 0; + f->file_size = 0; + f->time_last_msg.tv_sec = 0; + f->time_last_msg.tv_nsec = 0; + f->retry_count = 0; + f->is_processing = false; + memset(f->tx_buf, 0, sizeof(f->tx_buf[0]) * LL_FTP_TX_BUF_SIZE); + + f->cb = *cb; + + return LL_FTP_OK; +} diff --git a/src/ll_ifc_no_mac.c.bak b/src/ll_ifc_no_mac.c.bak new file mode 100644 index 0000000..d3ce57a --- /dev/null +++ b/src/ll_ifc_no_mac.c.bak @@ -0,0 +1,368 @@ +#include "ll_ifc_no_mac.h" +#include "ll_ifc.h" +#include "ll_ifc_private.h" +#include // memset + +int32_t ll_rssi_scan_set(uint32_t u1, uint32_t u2, uint32_t u3, uint32_t u4) +{ + uint8_t buf[16]; + + memset(buf, 0, sizeof(buf)); + + // Little Endian + buf[ 0] = (u1 >> 24) & 0xFF; + buf[ 1] = (u1 >> 16) & 0xFF; + buf[ 2] = (u1 >> 8) & 0xFF; + buf[ 3] = (u1 ) & 0xFF; + + buf[ 4] = (u2 >> 24) & 0xFF; + buf[ 5] = (u2 >> 16) & 0xFF; + buf[ 6] = (u2 >> 8) & 0xFF; + buf[ 7] = (u2 ) & 0xFF; + + buf[ 8] = (u3 >> 24) & 0xFF; + buf[ 9] = (u3 >> 16) & 0xFF; + buf[10] = (u3 >> 8) & 0xFF; + buf[11] = (u3 ) & 0xFF; + + buf[12] = (u4 >> 24) & 0xFF; + buf[13] = (u4 >> 16) & 0xFF; + buf[14] = (u4 >> 8) & 0xFF; + buf[15] = (u4 ) & 0xFF; + + return hal_read_write(OP_RSSI_SET, buf, 16, NULL, 0); +} + +int32_t ll_rssi_scan_get(uint8_t buf[], uint16_t len, uint8_t *bytes_received) +{ + int32_t rw_response; + + if (buf == NULL || len <= 0 || bytes_received == NULL) + { + return LL_IFC_ERROR_INCORRECT_PARAMETER; + } + + rw_response = hal_read_write(OP_RSSI_GET, NULL, 0, buf, len); + + if (rw_response < 0) + { + *bytes_received = 0; + return(-1); + } + else + { + *bytes_received = (uint8_t) (rw_response & 0xFF); + return(0); + } +} + +int32_t ll_radio_params_get(uint8_t *sf, uint8_t *cr, uint8_t *bw, uint32_t *freq, + uint16_t *preamble_syms, uint8_t *header_enabled, uint8_t *crc_enabled, + uint8_t *iq_inverted) +{ + int32_t ret; + uint8_t buff[8]; + ret = hal_read_write(OP_GET_RADIO_PARAMS, NULL, 0, buff, 8); + + *sf = (buff[0] >> 4) + 6; + *cr = ((buff[0] >> 2) & 0x03) + 1; + *bw = buff[0] & 0x03; + + *header_enabled = buff[1] & (1u << 0u); + *crc_enabled = buff[1] & (1u << 1u); + *iq_inverted = buff[1] & (1u << 2u); + + *preamble_syms = ((uint16_t)buff[2] << 8) | (uint16_t)buff[3]; + + *freq = (uint32_t)(buff[4] << 24); + *freq |= (uint32_t)(buff[5] << 16); + *freq |= (uint32_t)(buff[6] << 8); + *freq |= (uint32_t)(buff[7] ); + + return ret; +} + +int32_t ll_radio_params_set(uint8_t flags, uint8_t sf, uint8_t cr, uint8_t bw, uint32_t freq, + uint16_t preamble_syms, uint8_t enable_header, uint8_t enable_crc, + uint8_t enable_iq_inversion) +{ + uint8_t buf[9]; + + memset(buf, 0, sizeof(buf)); + + buf[0] = flags; + + if(flags & RADIO_PARAM_FLAGS_SF) + { + if (sf < 6 || sf > 12) + { + return LL_IFC_ERROR_INCORRECT_PARAMETER; + } + sf = sf - 6; + buf[1] |= ((sf&0x07) << 4); + } + if(flags & RADIO_PARAM_FLAGS_CR) + { + if (cr < 1 || cr > 4) + { + return LL_IFC_ERROR_INCORRECT_PARAMETER; + } + cr = cr - 1; + buf[1] |= ((cr&0x03) << 2); + } + if(flags & RADIO_PARAM_FLAGS_BW) + { + if (bw > 3) + { + return LL_IFC_ERROR_INCORRECT_PARAMETER; + } + buf[1] |= ((bw&0x03) ); + } + + if ((flags & RADIO_PARAM_FLAGS_HEADER) && enable_header) + { + buf[2] |= (1u << 0u); + } + if ((flags & RADIO_PARAM_FLAGS_CRC) && enable_crc) + { + buf[2] |= (1u << 1u); + } + if ((flags & RADIO_PARAM_FLAGS_IQ) && enable_iq_inversion) + { + buf[2] |= (1u << 2u); + } + + if (flags & RADIO_PARAM_FLAGS_PREAMBLE) + { + buf[3] = (preamble_syms >> 8) & 0xFF; + buf[4] = (preamble_syms >> 0) & 0xFF; + } + + if(flags & RADIO_PARAM_FLAGS_FREQ) + { + buf[5] = (freq >> 24) & 0xFF; + buf[6] = (freq >> 16) & 0xFF; + buf[7] = (freq >> 8) & 0xFF; + buf[8] = (freq ) & 0xFF; + } + + return hal_read_write(OP_SET_RADIO_PARAMS, buf, 9, NULL, 0); +} + +int32_t ll_bandwidth_set(uint8_t bandwidth) +{ + return ll_radio_params_set(RADIO_PARAM_FLAGS_BW, 0, 0, bandwidth, 0, 0, 0, 0, 0); +} + +int32_t ll_spreading_factor_set(uint8_t sf) +{ + return ll_radio_params_set(RADIO_PARAM_FLAGS_SF, sf, 0, 0, 0, 0, 0, 0, 0); +} + +int32_t ll_coding_rate_set(uint8_t coding_rate) +{ + return ll_radio_params_set(RADIO_PARAM_FLAGS_CR, 0, coding_rate, 0, 0, 0, 0, 0, 0); +} + +int32_t ll_tx_power_set(int8_t pwr) +{ + if (pwr < -4 || pwr > 26) + { + return LL_IFC_ERROR_INCORRECT_PARAMETER; + } + return hal_read_write(OP_TX_POWER_SET, (uint8_t *)&pwr, 1, NULL, 0); +} + +int32_t ll_tx_power_get(int8_t *pwr) +{ + if (NULL == pwr) + { + return LL_IFC_ERROR_INCORRECT_PARAMETER; + } + return hal_read_write(OP_TX_POWER_GET, NULL, 0, (uint8_t *)pwr, 1); +} + +int32_t ll_frequency_set(uint32_t freq) +{ + return ll_radio_params_set(RADIO_PARAM_FLAGS_FREQ, 0, 0, 0, freq, 0, 0, 0, 0); +} + +int32_t ll_preamble_syms_set(uint16_t num_syms) +{ + return ll_radio_params_set(RADIO_PARAM_FLAGS_PREAMBLE, 0, 0, 0, 0, num_syms, 0, 0, 0); +} + +int32_t ll_header_enabled_set(uint8_t enabled) +{ + return ll_radio_params_set(RADIO_PARAM_FLAGS_HEADER, 0, 0, 0, 0, 0, enabled, 0, 0); +} + +int32_t ll_crc_enabled_set(uint8_t enabled) +{ + return ll_radio_params_set(RADIO_PARAM_FLAGS_CRC, 0, 0, 0, 0, 0, 0, enabled, 0); +} + +int32_t ll_iq_inversion_set(uint8_t inverted) +{ + return ll_radio_params_set(RADIO_PARAM_FLAGS_IQ, 0, 0, 0, 0, 0, 0, 0, inverted); +} + +int32_t ll_sync_word_set(uint8_t sync_word) +{ + return hal_read_write(OP_SYNC_WORD_SET, (uint8_t *)&sync_word, 1, NULL, 0); +} + +int32_t ll_sync_word_get(uint8_t *sync_word) +{ + if (NULL == sync_word) + { + return LL_IFC_ERROR_INCORRECT_PARAMETER; + } + return hal_read_write(OP_SYNC_WORD_GET, NULL, 0, sync_word, 1); +} + +int32_t ll_echo_mode(void) +{ + return hal_read_write(OP_PKT_ECHO, NULL, 0, NULL, 0); +} + +int32_t ll_packet_send(uint8_t buf[], uint16_t len) +{ + return ll_packet_send_queue(buf, len); +} + +int32_t ll_packet_send_queue(uint8_t buf[], uint16_t len) +{ + if (buf == NULL || len <= 0) + { + return LL_IFC_ERROR_INCORRECT_PARAMETER; + } + + uint8_t cmd_response; + + int32_t rw_response = hal_read_write(OP_PKT_SEND_QUEUE, buf, len, &cmd_response, 1); + + if (rw_response < 0) + { + return((int8_t)rw_response); + } + else + { + return(cmd_response); + } +} + +//STRIPTHIS!START +int32_t ll_packet_send_timestamp(uint32_t timestamp_us, uint8_t buf[], uint16_t len) +{ + uint8_t in_buf[4]; + uint8_t * b = in_buf; + write_uint32(timestamp_us, &b); + int32_t rw_response = hal_read_write_exact(OP_SEND_TIMESTAMP, in_buf, sizeof(in_buf), NULL, 0); + if (rw_response < 0) + { + return rw_response; + } + return ll_packet_send_queue(buf, len); +} +//STRIPTHIS!STOP + +int32_t ll_transmit_cw(void) +{ + return hal_read_write(OP_TX_CW, NULL, 0, NULL, 0); +} + +int32_t ll_packet_recv_cont(uint8_t buf[], uint16_t len, uint8_t *bytes_received, bool freq_error_requested) +{ + int32_t rw_response; + + if (buf == NULL || len == 0 || bytes_received == NULL) + { + return LL_IFC_ERROR_INCORRECT_PARAMETER; + } + + if (freq_error_requested) + { + uint8_t request_type = 0x01; + rw_response = hal_read_write(OP_PKT_RECV_CONT, &request_type, 1, buf, len); + } + else + { + rw_response = hal_read_write(OP_PKT_RECV_CONT, NULL, 0, buf, len); + } + + if (rw_response < LL_IFC_ACK) + { + *bytes_received = 0; + return rw_response; + } + else + { + *bytes_received = (uint8_t) (rw_response & 0xFF); + return(0); + } +} + +int32_t ll_packet_recv(uint16_t num_timeout_symbols, uint8_t buf[], uint16_t len, uint8_t *bytes_received) +{ + uint8_t buff[2]; + int32_t rw_response; + + if (buf == NULL || len <= 0 || bytes_received == NULL) + { + return LL_IFC_ERROR_INCORRECT_PARAMETER; + } + + // Make the uint16_t value big-endian + buff[0] = (num_timeout_symbols >> 8) & 0xFF; + buff[1] = (num_timeout_symbols >> 0) & 0xFF; + + rw_response = hal_read_write(OP_PKT_RECV, buff, sizeof(num_timeout_symbols), buf, len); + + if (rw_response < 0) + { + *bytes_received = 0; + return(-1); + } + else + { + *bytes_received = (uint8_t) (rw_response & 0xFF); + return(0); + } +} + +int32_t ll_packet_recv_with_rssi(uint16_t num_timeout_symbols, uint8_t buf[], uint16_t len, uint8_t *bytes_received, bool freq_error_requested) +{ + uint8_t local_buff[3]; + int32_t rw_response; + + if (buf == NULL || len <= 0 || bytes_received == NULL) + { + return LL_IFC_ERROR_INCORRECT_PARAMETER; + } + + // Make the uint16_t value big-endian + local_buff[0] = (num_timeout_symbols >> 8) & 0xFF; + local_buff[1] = (num_timeout_symbols) & 0xFF; + + uint16_t in_len = sizeof(num_timeout_symbols); + + if (freq_error_requested) + { + local_buff[2] = 0x01; + in_len += 1; + } + + rw_response = hal_read_write(OP_MSG_RECV_RSSI, local_buff, in_len, buf, len); + + if (rw_response < 0) + { + *bytes_received = 0; + return(-1); + } + else + { + *bytes_received = (uint8_t) (rw_response & 0xFF); + return(0); + } +} diff --git a/src/ll_ifc_symphony.c.bak b/src/ll_ifc_symphony.c.bak new file mode 100644 index 0000000..07a6f4b --- /dev/null +++ b/src/ll_ifc_symphony.c.bak @@ -0,0 +1,661 @@ +#include "ll_ifc_symphony.h" +#include "ll_ifc_private.h" +#include "ifc_struct_defs.h" +#include // memmove + +uint8_t _uplink_message_buff[256 + 2]; +uint8_t *uplink_message_buff = _uplink_message_buff + 2; +uint8_t ll_ul_max_port = 127; + +const llabs_dl_band_cfg_t DL_BAN_FCC = {902000000, 928000000, 386703, 3, 0}; // USA / Mexico +const llabs_dl_band_cfg_t DL_BAN_BRA = {916000000, 928000000, 386703, 3, 0}; // Brazil +const llabs_dl_band_cfg_t DL_BAN_AUS = {918000000, 926000000, 386703, 3, 0}; // Australia +const llabs_dl_band_cfg_t DL_BAN_NZL = {921000000, 928000000, 386703, 3, 0}; // New Zealand +const llabs_dl_band_cfg_t DL_BAN_ETSI = {869100000, 871000000, 386703, 1, 0}; // Europe + +int32_t ll_net_token_get(uint32_t *p_net_token) +{ + uint8_t buff[4]; + if (p_net_token == NULL) + { + return LL_IFC_ERROR_INCORRECT_PARAMETER; + } + int32_t ret = hal_read_write(OP_NET_TOKEN_GET, NULL, 0, buff, 4); + if (ret < 0) + { + return ret; + } + + if (4 != ret) + { + return LL_IFC_ERROR_INCORRECT_RESPONSE_LENGTH; + } + + *p_net_token = 0; + *p_net_token |= (uint32_t) buff[0] << 24; + *p_net_token |= (uint32_t) buff[1] << 16; + *p_net_token |= (uint32_t) buff[2] << 8; + *p_net_token |= (uint32_t) buff[3]; + return LL_IFC_ACK; +} + +int32_t ll_net_token_set(uint32_t net_token) +{ + if (net_token != 0xFFFFFFFF) + { + uint8_t buff[4]; + buff[0] = (net_token >> 24) & 0xFF; + buff[1] = (net_token >> 16) & 0xFF; + buff[2] = (net_token >> 8) & 0xFF; + buff[3] = (net_token) &0xFF; + int32_t ret = hal_read_write(OP_NET_TOKEN_SET, buff, 4, NULL, 0); + return (ret >= 0) ? LL_IFC_ACK : ret; + } + else + { + return LL_IFC_ERROR_INCORRECT_PARAMETER; + } +} + +static int32_t ll_app_token_set(const uint8_t *app_token, uint8_t len) +{ + if (app_token == NULL) + { + return LL_IFC_ERROR_INCORRECT_PARAMETER; + } + if (10 != len) + { + return LL_IFC_ERROR_INCORRECT_PARAMETER; + } + int32_t ret = hal_read_write(OP_APP_TOKEN_SET, (uint8_t *) app_token, 10, NULL, 0); + return (ret >= 0) ? LL_IFC_ACK : ret; +} + +static int32_t ll_app_token_get(uint8_t *app_token) +{ + if (app_token == NULL) + { + return LL_IFC_ERROR_INCORRECT_PARAMETER; + } + + int32_t ret = hal_read_write(OP_APP_TOKEN_GET, NULL, 0, app_token, 10); + if (ret < 0) + { + return ret; + } + if (10 != ret) + { + return LL_IFC_ERROR_INCORRECT_RESPONSE_LENGTH; + } + + return LL_IFC_ACK; +} + +static int32_t ll_receive_mode_set(uint8_t rx_mode) +{ + if (rx_mode >= NUM_DOWNLINK_MODES) + { + return LL_IFC_ERROR_INCORRECT_PARAMETER; + } + int32_t ret = hal_read_write(OP_RX_MODE_SET, &rx_mode, 1, NULL, 0); + return (ret >= 0) ? LL_IFC_ACK : ret; +} + +static int32_t ll_receive_mode_get(uint8_t *rx_mode) +{ + if (rx_mode == NULL) + { + return LL_IFC_ERROR_INCORRECT_PARAMETER; + } + int32_t ret = hal_read_write(OP_RX_MODE_GET, NULL, 0, rx_mode, sizeof(*rx_mode)); + return (ret >= 0) ? LL_IFC_ACK : ret; +} + +static int32_t ll_qos_request(uint8_t qos) +{ + if (qos > 15) + { + return LL_IFC_ERROR_INCORRECT_PARAMETER; + } + int32_t ret = hal_read_write(OP_QOS_REQUEST, &qos, 1, NULL, 0); + return (ret >= 0) ? LL_IFC_ACK : ret; +} + +static int32_t ll_qos_get(uint8_t *qos) +{ + if (qos == NULL) + { + return LL_IFC_ERROR_INCORRECT_PARAMETER; + } + return hal_read_write(OP_QOS_GET, NULL, 0, qos, sizeof(*qos)); +} + +static int32_t ll_scan_attempts_get(uint16_t *scan_attempts) +{ + uint8_t buf[2]; + int32_t ret = hal_read_write(OP_SCAN_ATTEMPTS_GET, NULL, 0, buf, 2); + *scan_attempts = ((uint16_t) buf[1] << 8) | buf[0]; + return (ret >= 0) ? LL_IFC_ACK : ret; +} + +static int32_t ll_scan_attempts_left_get(uint16_t *scan_attempts) +{ + uint8_t buf[2]; + int32_t ret = hal_read_write(OP_SCAN_ATTEMPTS_LEFT, NULL, 0, buf, 2); + *scan_attempts = ((uint16_t) buf[1] << 8) | buf[0]; + return (ret >= 0) ? LL_IFC_ACK : ret; +} + +int32_t ll_config_set(uint32_t net_token, const uint8_t app_token[APP_TOKEN_LEN], + enum ll_downlink_mode dl_mode, uint8_t qos) +{ + int32_t ret; + + ret = ll_net_token_set(net_token); + if (LL_IFC_ACK != ret) + { + return ret; + } + + ret = ll_app_token_set(app_token, APP_TOKEN_LEN); + if (LL_IFC_ACK != ret) + { + return ret; + } + + ret = ll_receive_mode_set(dl_mode); + if (LL_IFC_ACK != ret) + { + return ret; + } + + ret = ll_qos_request(qos); + if (LL_IFC_ACK != ret) + { + return ret; + } + + return (ret >= 0) ? LL_IFC_ACK : ret; +} + +int32_t ll_config_get(uint32_t *net_token, uint8_t app_token[APP_TOKEN_LEN], + enum ll_downlink_mode *dl_mode, uint8_t *qos) +{ + int32_t ret; + + ret = ll_net_token_get(net_token); + if (LL_IFC_ACK != ret) + { + return ret; + } + + ret = ll_app_token_get(app_token); + if (LL_IFC_ACK != ret) + { + return ret; + } + + ret = ll_receive_mode_get((uint8_t *) dl_mode); + if (LL_IFC_ACK != ret) + { + return ret; + } + + ret = ll_qos_get(qos); + if (LL_IFC_ACK != ret) + { + return ret; + } + + return (ret >= 0) ? LL_IFC_ACK : ret; +} + +int32_t ll_scan_config_set(enum ll_scan_mode scan_mode, int16_t threshold, uint16_t scan_attempts) +{ + if (scan_mode > LLABS_INFO_SCAN) + { + return LL_IFC_ERROR_INCORRECT_PARAMETER; + } + + int32_t ret = ll_scan_mode_set(scan_mode); + if (ret < LL_IFC_ACK) + { + return ret; + } + + ret = ll_threshold_set(threshold); + if (ret < LL_IFC_ACK) + { + return ret; + } + + ret = ll_scan_attempts_set(scan_attempts); + if (ret < LL_IFC_ACK) + { + return ret; + } + + return (ret >= 0) ? LL_IFC_ACK : ret; +} + +int32_t ll_scan_config_get(enum ll_scan_mode *scan_mode, int16_t *threshold, + uint16_t *scan_attempts, uint16_t *scans_left) +{ + int32_t ret = ll_scan_mode_get(scan_mode); + if (ret < LL_IFC_ACK) + { + return ret; + } + + ret = ll_threshold_get(threshold); + if (ret < LL_IFC_ACK) + { + return ret; + } + + ret = ll_scan_attempts_get(scan_attempts); + if (ret < LL_IFC_ACK) + { + return ret; + } + + ret = ll_scan_attempts_left_get(scans_left); + if (ret < LL_IFC_ACK) + { + return ret; + } + + return (ret >= 0) ? LL_IFC_ACK : ret; +} + +int32_t ll_connect_to_gw_channel(uint8_t channel) +{ + int32_t ret = hal_read_write(OP_CONN_TO_GW_CH, &channel, 1, NULL, 0); + return (ret >= 0) ? LL_IFC_ACK : ret; +} + +int32_t ll_control_messages_enabled_set(bool enable) +{ + int32_t ret = hal_read_write(OP_CTRL_MSG_ENABLED_SET, (uint8_t*)&enable, 1, NULL, 0); + return (ret >= 0) ? LL_IFC_ACK : ret; +} + +int32_t ll_control_messages_enabled_get(bool *enabled) +{ + int32_t ret = hal_read_write(OP_CTRL_MSG_ENABLED_GET, NULL, 0, (uint8_t*)enabled, 1); + return (ret >= 0) ? LL_IFC_ACK : ret; +} + +int32_t ll_cloud_gpio_activate_pin(uint8_t pin) +{ + int32_t ret = hal_read_write(OP_GPIO_ENABLE_PIN, (uint8_t*)&pin, 1, NULL, 0); + return (ret >= 0) ? LL_IFC_ACK : ret; +} + +int32_t ll_cloud_gpio_deactivate_pin(uint8_t pin) +{ + int32_t ret = hal_read_write(OP_GPIO_DISABLE_PIN, (uint8_t*)&pin, 1, NULL, 0); + return (ret >= 0) ? LL_IFC_ACK : ret; +} + +int32_t ll_cloud_gpio_get_pin_status(uint8_t pin, bool *active) +{ + int32_t ret = hal_read_write(OP_GPIO_PIN_STATUS, (uint8_t*)&pin, 1, NULL, 0); + return (ret >= 0) ? LL_IFC_ACK : ret; +} + +int32_t ll_cloud_gpio_set_pin_high(uint8_t pin) +{ + int32_t ret = hal_read_write(OP_GPIO_SET_HIGH, (uint8_t*)&pin, 1, NULL, 0); + return (ret >= 0) ? LL_IFC_ACK : ret; +} + +int32_t ll_cloud_gpio_set_pin_low(uint8_t pin) +{ + int32_t ret = hal_read_write(OP_GPIO_SET_LOW, (uint8_t*)&pin, 1, NULL, 0); + return (ret >= 0) ? LL_IFC_ACK : ret; +} + +int32_t ll_disconnect() +{ + int32_t ret = hal_read_write(OP_DISCONNECT, NULL, 0, NULL, 0); + return (ret >= 0) ? LL_IFC_ACK : ret; +} + +int32_t ll_poll_scan_result(llabs_gateway_scan_results_t *scan_result, uint8_t *num_gw) +{ + if (scan_result == NULL || num_gw == NULL) + { + return LL_IFC_ERROR_INCORRECT_PARAMETER; + } + + uint8_t buff[GW_SCAN_INFO_BUFF_SIZE]; + + int32_t ret = hal_read_write(OP_GET_SCAN_INFO, NULL, 0, buff, GW_SCAN_INFO_BUFF_SIZE); + if (ret < LL_IFC_ACK) + { + return ret; + } + + ll_gw_scan_result_deserialize(buff, scan_result, num_gw); + + return (ret >= 0) ? LL_IFC_ACK : ret; +} + +int32_t +ll_get_gateway_scan_results(llabs_gateway_scan_results_t (*scan_results)[MAX_GW_SCAN_RESULTS], + uint8_t *num_gw) +{ + uint8_t gw; + *num_gw = 0; + + do + { + llabs_gateway_scan_results_t scan_result; + + int32_t ret = ll_poll_scan_result(&scan_result, &gw); + if (ret != LL_IFC_ACK) + { + return ret; + } + + // When num_gw is uninitialized, we need to set it with the total + // amount of gateways + if (*num_gw == 0) + { + *num_gw = gw + 1; + } + + memcpy(&(*scan_results)[gw], &scan_result, sizeof(scan_result)); + + } while (gw > 0); + + return LL_IFC_ACK; +} + +int32_t ll_get_state(enum ll_state *state, enum ll_tx_state *tx_state, enum ll_rx_state *rx_state) +{ + int32_t ret = LL_IFC_ACK; + + if (NULL != state) + { + uint8_t u8_state; + ret = hal_read_write(OP_STATE, NULL, 0, &u8_state, 1); + if (LL_IFC_ACK > ret) + { + return ret; + } + *state = (enum ll_state)(int8_t) u8_state; + } + + if (NULL != tx_state) + { + uint8_t u8_tx_state; + ret = hal_read_write(OP_TX_STATE, NULL, 0, &u8_tx_state, 1); + if (LL_IFC_ACK > ret) + { + return ret; + } + *tx_state = (enum ll_tx_state)(int8_t) u8_tx_state; + } + + if (NULL != rx_state) + { + uint8_t u8_rx_state; + ret = hal_read_write(OP_RX_STATE, NULL, 0, &u8_rx_state, 1); + if (LL_IFC_ACK > ret) + { + return ret; + } + *rx_state = (enum ll_rx_state)(int8_t) u8_rx_state; + } + + return (ret >= 0) ? LL_IFC_ACK : ret; +} + +int32_t ll_mailbox_request(void) +{ + int32_t ret = hal_read_write(OP_MAILBOX_REQUEST, NULL, 0, NULL, 0); + return (ret >= 0) ? LL_IFC_ACK : ret; +} + +int32_t ll_app_reg_get(uint8_t *is_registered) +{ + if (is_registered == NULL) + { + return LL_IFC_ERROR_INCORRECT_PARAMETER; + } + int32_t ret = hal_read_write(OP_APP_TOKEN_REG_GET, NULL, 0, is_registered, 1); + return (ret >= 0) ? LL_IFC_ACK : ret; +} + +int32_t ll_encryption_key_exchange_request(void) +{ + int32_t ret = hal_read_write(OP_CRYPTO_KEY_XCHG_REQ, NULL, 0, NULL, 0); + return (ret >= 0) ? LL_IFC_ACK : ret; +} + +int32_t ll_net_info_get(llabs_network_info_t *p_net_info) +{ + uint8_t buff[NET_INFO_BUFF_SIZE]; + if (p_net_info == NULL) + { + return LL_IFC_ERROR_INCORRECT_PARAMETER; + } + + int32_t ret = hal_read_write(OP_NET_INFO_GET, NULL, 0, buff, NET_INFO_BUFF_SIZE); + if (LL_IFC_ACK > ret) + { + return ret; + } + if (NET_INFO_BUFF_SIZE != ret) + { + return LL_IFC_ERROR_INCORRECT_RESPONSE_LENGTH; + } + + ll_net_info_deserialize(buff, p_net_info); + return LL_IFC_ACK; +} + +int32_t ll_stats_get(llabs_stats_t *s) +{ + uint8_t buff[STATS_SIZE]; + if (s == NULL) + { + return LL_IFC_ERROR_INCORRECT_PARAMETER; + } + + int32_t ret = hal_read_write(OP_STATS_GET, NULL, 0, buff, STATS_SIZE); + if (LL_IFC_ACK > ret) + { + return ret; + } + if (STATS_SIZE != ret) + { + return LL_IFC_ERROR_INCORRECT_RESPONSE_LENGTH; + } + + ll_stats_deserialize(buff, s); + return LL_IFC_ACK; +} + +int32_t ll_retrieve_message(uint8_t *buf, uint16_t *size, uint8_t *port, int16_t *rssi, + uint8_t *snr) +{ + int32_t rw_response; + + if (buf == NULL || size == NULL) + { + return LL_IFC_ERROR_INCORRECT_PARAMETER; + } + + rw_response = hal_read_write(OP_MSG_RECV, NULL, 0, buf, *size); + + if (rw_response < LL_IFC_ACK) + { + *size = 0; + return rw_response; + } + + // Size is required + if ((rw_response & 0xff) <= 4) + { + *size = 0; + return LL_IFC_ERROR_INCORRECT_RESPONSE_LENGTH; + } + *size = (uint8_t)(rw_response & 0xFF) - 4; + + // Optional RSSI + if (NULL != rssi) + { + *rssi = 0; + *rssi = buf[0] + ((uint16_t) buf[1] << 8); + } + + // Optional RSSI + if (NULL != snr) + { + *snr = buf[2]; + } + + if (NULL != port) + { + *port = buf[3]; + } + + // get rid of snr and rssi in buffer + memmove(buf, buf + 4, *size); + + return LL_IFC_ACK; +} + +int32_t ll_dl_band_cfg_get(llabs_dl_band_cfg_t *p) +{ + uint8_t buff[DL_BAND_CFG_SIZE]; + if (p == NULL) + { + return LL_IFC_ERROR_INCORRECT_PARAMETER; + } + + int32_t ret = hal_read_write(OP_DL_BAND_CFG_GET, NULL, 0, buff, DL_BAND_CFG_SIZE); + if (LL_IFC_ACK > ret) + { + return ret; + } + if (DL_BAND_CFG_SIZE != ret) + { + return LL_IFC_ERROR_INCORRECT_RESPONSE_LENGTH; + } + + ll_dl_band_cfg_deserialize(buff, p); + return LL_IFC_ACK; +} + +int32_t ll_dl_band_cfg_set(const llabs_dl_band_cfg_t *p) +{ + uint8_t buff[DL_BAND_CFG_SIZE]; + if (p == NULL) + { + return LL_IFC_ERROR_INCORRECT_PARAMETER; + } + + ll_dl_band_cfg_serialize(p, buff); + int32_t ret = hal_read_write(OP_DL_BAND_CFG_SET, buff, DL_BAND_CFG_SIZE, NULL, 0); + return (ret >= 0) ? LL_IFC_ACK : ret; +} + +int32_t ll_rssi_offset_get(int8_t *rssi_offset) +{ + uint8_t raw = 0; + int32_t ret = hal_read_write(OP_RSSI_OFFSET_GET, NULL, 0, &raw, 1); + *rssi_offset = (int8_t)raw; + return (ret >= 0) ? LL_IFC_ACK : ret; +} + +int32_t ll_rssi_offset_set(int8_t rssi_offset) +{ + if (rssi_offset > 15 || rssi_offset < -15) + { + return LL_IFC_ERROR_INCORRECT_PARAMETER; + } + + int32_t ret = hal_read_write(OP_RSSI_OFFSET_SET, (uint8_t*)&rssi_offset, 1, NULL, 0); + return (ret >= 0) ? LL_IFC_ACK : ret; +} + +int32_t ll_connection_filter_get(uint8_t *p_f) +{ + if (NULL == p_f) + { + return LL_IFC_ERROR_INCORRECT_PARAMETER; + } + uint8_t f; + int32_t ret = hal_read_write(OP_CONN_FILT_GET, NULL, 0, &f, 1); + if (LL_IFC_ACK > ret) + { + return ret; + } + if (sizeof(f) != ret) + { + return LL_IFC_ERROR_INCORRECT_RESPONSE_LENGTH; + } + + *p_f = f; + return (ret >= 0) ? LL_IFC_ACK : ret; +} + +int32_t ll_connection_filter_set(uint8_t f) +{ + int32_t ret = hal_read_write(OP_CONN_FILT_SET, &f, 1, NULL, 0); + return (ret >= 0) ? LL_IFC_ACK : ret; +} + +int32_t ll_system_time_get(llabs_time_info_t *time_info) +{ + uint8_t buff[TIME_INFO_SIZE]; + if (time_info == NULL) + { + return LL_IFC_ERROR_INCORRECT_PARAMETER; + } + int32_t ret = hal_read_write(OP_SYSTEM_TIME_GET, NULL, 0, buff, STATS_SIZE); + if (LL_IFC_ACK > ret) + { + return ret; + } + if (TIME_INFO_SIZE != ret) + { + return LL_IFC_ERROR_INCORRECT_RESPONSE_LENGTH; + } + + ll_time_deserialize(buff, time_info); + return LL_IFC_ACK; +} + +int32_t ll_system_time_sync(uint8_t sync_mode) +{ + if (sync_mode > 1) + { + return LL_IFC_ERROR_INCORRECT_PARAMETER; + } + int32_t ret = hal_read_write(OP_SYSTEM_TIME_SYNC, &sync_mode, sizeof(sync_mode), NULL, 0); + return (ret >= 0) ? LL_IFC_ACK : ret; +} + +int32_t ll_message_send(uint8_t buf[], uint16_t len, bool ack, uint8_t port) +{ + if (buf == NULL || len <= 0 || len > 256) + { + return LL_IFC_ERROR_INCORRECT_PARAMETER; + } + + if (port > ll_ul_max_port) + { + return LL_IFC_ERROR_INCORRECT_PARAMETER; + } + + memmove(uplink_message_buff, buf, len); + _uplink_message_buff[0] = (uint8_t) ack; + _uplink_message_buff[1] = port; + int32_t ret = hal_read_write(OP_MSG_SEND, _uplink_message_buff, len + 2, NULL, 0); + return (ret >= 0) ? LL_IFC_ACK : ret; +} diff --git a/src/ll_ifc_symphony.c.bak.bak b/src/ll_ifc_symphony.c.bak.bak new file mode 100644 index 0000000..a52ae4c --- /dev/null +++ b/src/ll_ifc_symphony.c.bak.bak @@ -0,0 +1,661 @@ +#include "ll_ifc_symphony.h" +#include "ll_ifc_private.h" +#include "ifc_struct_defs.h" +#include // memmove + +uint8_t _uplink_message_buff[256 + 2]; +uint8_t *uplink_message_buff = _uplink_message_buff + 2; +uint8_t ll_ul_max_port = 127; + +const llabs_dl_band_cfg_t DL_BAN_FCC = {902000000, 928000000, 386703, 3, 0}; // USA / Mexico +const llabs_dl_band_cfg_t DL_BAN_BRA = {916000000, 928000000, 386703, 3, 0}; // Brazil +const llabs_dl_band_cfg_t DL_BAN_AUS = {918000000, 926000000, 386703, 3, 0}; // Australia +const llabs_dl_band_cfg_t DL_BAN_NZL = {921000000, 928000000, 386703, 3, 0}; // New Zealand +const llabs_dl_band_cfg_t DL_BAN_ETSI = {869100000, 871000000, 386703, 1, 0}; // Europe + +int32_t ll_net_token_get(uint32_t *p_net_token) +{ + uint8_t buff[4]; + if (p_net_token == NULL) + { + return LL_IFC_ERROR_INCORRECT_PARAMETER; + } + int32_t ret = hal_read_write(OP_NET_TOKEN_GET, NULL, 0, buff, 4); + if (ret < 0) + { + return ret; + } + + if (4 != ret) + { + return LL_IFC_ERROR_INCORRECT_RESPONSE_LENGTH; + } + + *p_net_token = 0; + *p_net_token |= (uint32_t)buff[0] << 24; + *p_net_token |= (uint32_t)buff[1] << 16; + *p_net_token |= (uint32_t)buff[2] << 8; + *p_net_token |= (uint32_t)buff[3]; + return ret; +} + +int32_t ll_net_token_set(uint32_t net_token) +{ + if(net_token != 0xFFFFFFFF) + { + uint8_t buff[4]; + buff[0] = (net_token >> 24) & 0xFF; + buff[1] = (net_token >> 16) & 0xFF; + buff[2] = (net_token >> 8) & 0xFF; + buff[3] = (net_token) &0xFF; + int32_t ret = hal_read_write(OP_NET_TOKEN_SET, buff, 4, NULL, 0); + return (ret >= 0) ? LL_IFC_ACK : ret; + } + else + { + return LL_IFC_ERROR_INCORRECT_PARAMETER; + } +} + +static int32_t ll_app_token_set(const uint8_t *app_token, uint8_t len) +{ + if (app_token == NULL) + { + return LL_IFC_ERROR_INCORRECT_PARAMETER; + } + if (10 != len) + { + return LL_IFC_ERROR_INCORRECT_PARAMETER; + } + int32_t ret = hal_read_write(OP_APP_TOKEN_SET, (uint8_t *) app_token, 10, NULL, 0); + return (ret >= 0) ? LL_IFC_ACK : ret; +} + +static int32_t ll_app_token_get(uint8_t *app_token) +{ + if (app_token == NULL) + { + return LL_IFC_ERROR_INCORRECT_PARAMETER; + } + + int32_t ret = hal_read_write(OP_APP_TOKEN_GET, NULL, 0, app_token, 10); + if (ret < 0) + { + return ret; + } + if (10 != ret) + { + return LL_IFC_ERROR_INCORRECT_RESPONSE_LENGTH; + } + + return LL_IFC_ACK; +} + +static int32_t ll_receive_mode_set(uint8_t rx_mode) +{ + if (rx_mode >= NUM_DOWNLINK_MODES) + { + return LL_IFC_ERROR_INCORRECT_PARAMETER; + } + int32_t ret = hal_read_write(OP_RX_MODE_SET, &rx_mode, 1, NULL, 0); + return (ret >= 0) ? LL_IFC_ACK : ret; +} + +static int32_t ll_receive_mode_get(uint8_t *rx_mode) +{ + if (rx_mode == NULL) + { + return LL_IFC_ERROR_INCORRECT_PARAMETER; + } + int32_t ret = hal_read_write(OP_RX_MODE_GET, NULL, 0, rx_mode, sizeof(*rx_mode)); + return (ret >= 0) ? LL_IFC_ACK : ret; +} + +static int32_t ll_qos_request(uint8_t qos) +{ + if (qos > 15) + { + return LL_IFC_ERROR_INCORRECT_PARAMETER; + } + int32_t ret = hal_read_write(OP_QOS_REQUEST, &qos, 1, NULL, 0); + return (ret >= 0) ? LL_IFC_ACK : ret; +} + +static int32_t ll_qos_get(uint8_t *qos) +{ + if (qos == NULL) + { + return LL_IFC_ERROR_INCORRECT_PARAMETER; + } + return hal_read_write(OP_QOS_GET, NULL, 0, qos, sizeof(*qos)); +} + +static int32_t ll_scan_attempts_get(uint16_t *scan_attempts) +{ + uint8_t buf[2]; + int32_t ret = hal_read_write(OP_SCAN_ATTEMPTS_GET, NULL, 0, buf, 2); + *scan_attempts = ((uint16_t) buf[1] << 8) | buf[0]; + return (ret >= 0) ? LL_IFC_ACK : ret; +} + +static int32_t ll_scan_attempts_left_get(uint16_t *scan_attempts) +{ + uint8_t buf[2]; + int32_t ret = hal_read_write(OP_SCAN_ATTEMPTS_LEFT, NULL, 0, buf, 2); + *scan_attempts = ((uint16_t) buf[1] << 8) | buf[0]; + return (ret >= 0) ? LL_IFC_ACK : ret; +} + +int32_t ll_config_set(uint32_t net_token, const uint8_t app_token[APP_TOKEN_LEN], + enum ll_downlink_mode dl_mode, uint8_t qos) +{ + int32_t ret; + + ret = ll_net_token_set(net_token); + if (LL_IFC_ACK != ret) + { + return ret; + } + + ret = ll_app_token_set(app_token, APP_TOKEN_LEN); + if (LL_IFC_ACK != ret) + { + return ret; + } + + ret = ll_receive_mode_set(dl_mode); + if (LL_IFC_ACK != ret) + { + return ret; + } + + ret = ll_qos_request(qos); + if (LL_IFC_ACK != ret) + { + return ret; + } + + return (ret >= 0) ? LL_IFC_ACK : ret; +} + +int32_t ll_config_get(uint32_t *net_token, uint8_t app_token[APP_TOKEN_LEN], + enum ll_downlink_mode *dl_mode, uint8_t *qos) +{ + int32_t ret; + + ret = ll_net_token_get(net_token); + if (LL_IFC_ACK != ret) + { + return ret; + } + + ret = ll_app_token_get(app_token); + if (LL_IFC_ACK != ret) + { + return ret; + } + + ret = ll_receive_mode_get((uint8_t *) dl_mode); + if (LL_IFC_ACK != ret) + { + return ret; + } + + ret = ll_qos_get(qos); + if (LL_IFC_ACK != ret) + { + return ret; + } + + return (ret >= 0) ? LL_IFC_ACK : ret; +} + +int32_t ll_scan_config_set(enum ll_scan_mode scan_mode, int16_t threshold, uint16_t scan_attempts) +{ + if (scan_mode > LLABS_INFO_SCAN) + { + return LL_IFC_ERROR_INCORRECT_PARAMETER; + } + + int32_t ret = ll_scan_mode_set(scan_mode); + if (ret < LL_IFC_ACK) + { + return ret; + } + + ret = ll_threshold_set(threshold); + if (ret < LL_IFC_ACK) + { + return ret; + } + + ret = ll_scan_attempts_set(scan_attempts); + if (ret < LL_IFC_ACK) + { + return ret; + } + + return (ret >= 0) ? LL_IFC_ACK : ret; +} + +int32_t ll_scan_config_get(enum ll_scan_mode *scan_mode, int16_t *threshold, + uint16_t *scan_attempts, uint16_t *scans_left) +{ + int32_t ret = ll_scan_mode_get(scan_mode); + if (ret < LL_IFC_ACK) + { + return ret; + } + + ret = ll_threshold_get(threshold); + if (ret < LL_IFC_ACK) + { + return ret; + } + + ret = ll_scan_attempts_get(scan_attempts); + if (ret < LL_IFC_ACK) + { + return ret; + } + + ret = ll_scan_attempts_left_get(scans_left); + if (ret < LL_IFC_ACK) + { + return ret; + } + + return (ret >= 0) ? LL_IFC_ACK : ret; +} + +int32_t ll_connect_to_gw_channel(uint8_t channel) +{ + int32_t ret = hal_read_write(OP_CONN_TO_GW_CH, &channel, 1, NULL, 0); + return (ret >= 0) ? LL_IFC_ACK : ret; +} + +int32_t ll_control_messages_enabled_set(bool enable) +{ + int32_t ret = hal_read_write(OP_CTRL_MSG_ENABLED_SET, (uint8_t*)&enable, 1, NULL, 0); + return (ret >= 0) ? LL_IFC_ACK : ret; +} + +int32_t ll_control_messages_enabled_get(bool *enabled) +{ + int32_t ret = hal_read_write(OP_CTRL_MSG_ENABLED_GET, NULL, 0, (uint8_t*)enabled, 1); + return (ret >= 0) ? LL_IFC_ACK : ret; +} + +int32_t ll_cloud_gpio_activate_pin(uint8_t pin) +{ + int32_t ret = hal_read_write(OP_GPIO_ENABLE_PIN, (uint8_t*)&pin, 1, NULL, 0); + return (ret >= 0) ? LL_IFC_ACK : ret; +} + +int32_t ll_cloud_gpio_deactivate_pin(uint8_t pin) +{ + int32_t ret = hal_read_write(OP_GPIO_DISABLE_PIN, (uint8_t*)&pin, 1, NULL, 0); + return (ret >= 0) ? LL_IFC_ACK : ret; +} + +int32_t ll_cloud_gpio_get_pin_status(uint8_t pin, bool *active) +{ + int32_t ret = hal_read_write(OP_GPIO_PIN_STATUS, (uint8_t*)&pin, 1, NULL, 0); + return (ret >= 0) ? LL_IFC_ACK : ret; +} + +int32_t ll_cloud_gpio_set_pin_high(uint8_t pin) +{ + int32_t ret = hal_read_write(OP_GPIO_SET_HIGH, (uint8_t*)&pin, 1, NULL, 0); + return (ret >= 0) ? LL_IFC_ACK : ret; +} + +int32_t ll_cloud_gpio_set_pin_low(uint8_t pin) +{ + int32_t ret = hal_read_write(OP_GPIO_SET_LOW, (uint8_t*)&pin, 1, NULL, 0); + return (ret >= 0) ? LL_IFC_ACK : ret; +} + +int32_t ll_disconnect() +{ + int32_t ret = hal_read_write(OP_DISCONNECT, NULL, 0, NULL, 0); + return (ret >= 0) ? LL_IFC_ACK : ret; +} + +int32_t ll_poll_scan_result(llabs_gateway_scan_results_t *scan_result, uint8_t *num_gw) +{ + if (scan_result == NULL || num_gw == NULL) + { + return LL_IFC_ERROR_INCORRECT_PARAMETER; + } + + uint8_t buff[GW_SCAN_INFO_BUFF_SIZE]; + + int32_t ret = hal_read_write(OP_GET_SCAN_INFO, NULL, 0, buff, GW_SCAN_INFO_BUFF_SIZE); + if (ret < LL_IFC_ACK) + { + return ret; + } + + ll_gw_scan_result_deserialize(buff, scan_result, num_gw); + + return (ret >= 0) ? LL_IFC_ACK : ret; +} + +int32_t +ll_get_gateway_scan_results(llabs_gateway_scan_results_t (*scan_results)[MAX_GW_SCAN_RESULTS], + uint8_t *num_gw) +{ + uint8_t gw; + *num_gw = 0; + + do + { + llabs_gateway_scan_results_t scan_result; + + int32_t ret = ll_poll_scan_result(&scan_result, &gw); + if (ret != LL_IFC_ACK) + { + return ret; + } + + // When num_gw is uninitialized, we need to set it with the total + // amount of gateways + if (*num_gw == 0) + { + *num_gw = gw + 1; + } + + memcpy(&(*scan_results)[gw], &scan_result, sizeof(scan_result)); + + } while (gw > 0); + + return LL_IFC_ACK; +} + +int32_t ll_get_state(enum ll_state *state, enum ll_tx_state *tx_state, enum ll_rx_state *rx_state) +{ + int32_t ret = LL_IFC_ACK; + + if (NULL != state) + { + uint8_t u8_state; + ret = hal_read_write(OP_STATE, NULL, 0, &u8_state, 1); + if (LL_IFC_ACK > ret) + { + return ret; + } + *state = (enum ll_state)(int8_t) u8_state; + } + + if (NULL != tx_state) + { + uint8_t u8_tx_state; + ret = hal_read_write(OP_TX_STATE, NULL, 0, &u8_tx_state, 1); + if (LL_IFC_ACK > ret) + { + return ret; + } + *tx_state = (enum ll_tx_state)(int8_t) u8_tx_state; + } + + if (NULL != rx_state) + { + uint8_t u8_rx_state; + ret = hal_read_write(OP_RX_STATE, NULL, 0, &u8_rx_state, 1); + if (LL_IFC_ACK > ret) + { + return ret; + } + *rx_state = (enum ll_rx_state)(int8_t) u8_rx_state; + } + + return (ret >= 0) ? LL_IFC_ACK : ret; +} + +int32_t ll_mailbox_request(void) +{ + int32_t ret = hal_read_write(OP_MAILBOX_REQUEST, NULL, 0, NULL, 0); + return (ret >= 0) ? LL_IFC_ACK : ret; +} + +int32_t ll_app_reg_get(uint8_t *is_registered) +{ + if (is_registered == NULL) + { + return LL_IFC_ERROR_INCORRECT_PARAMETER; + } + int32_t ret = hal_read_write(OP_APP_TOKEN_REG_GET, NULL, 0, is_registered, 1); + return (ret >= 0) ? LL_IFC_ACK : ret; +} + +int32_t ll_encryption_key_exchange_request(void) +{ + int32_t ret = hal_read_write(OP_CRYPTO_KEY_XCHG_REQ, NULL, 0, NULL, 0); + return (ret >= 0) ? LL_IFC_ACK : ret; +} + +int32_t ll_net_info_get(llabs_network_info_t *p_net_info) +{ + uint8_t buff[NET_INFO_BUFF_SIZE]; + if (p_net_info == NULL) + { + return LL_IFC_ERROR_INCORRECT_PARAMETER; + } + + int32_t ret = hal_read_write(OP_NET_INFO_GET, NULL, 0, buff, NET_INFO_BUFF_SIZE); + if (LL_IFC_ACK > ret) + { + return ret; + } + if (NET_INFO_BUFF_SIZE != ret) + { + return LL_IFC_ERROR_INCORRECT_RESPONSE_LENGTH; + } + + ll_net_info_deserialize(buff, p_net_info); + return LL_IFC_ACK; +} + +int32_t ll_stats_get(llabs_stats_t *s) +{ + uint8_t buff[STATS_SIZE]; + if (s == NULL) + { + return LL_IFC_ERROR_INCORRECT_PARAMETER; + } + + int32_t ret = hal_read_write(OP_STATS_GET, NULL, 0, buff, STATS_SIZE); + if (LL_IFC_ACK > ret) + { + return ret; + } + if (STATS_SIZE != ret) + { + return LL_IFC_ERROR_INCORRECT_RESPONSE_LENGTH; + } + + ll_stats_deserialize(buff, s); + return LL_IFC_ACK; +} + +int32_t ll_retrieve_message(uint8_t *buf, uint16_t *size, uint8_t *port, int16_t *rssi, + uint8_t *snr) +{ + int32_t rw_response; + + if (buf == NULL || size == NULL) + { + return LL_IFC_ERROR_INCORRECT_PARAMETER; + } + + rw_response = hal_read_write(OP_MSG_RECV, NULL, 0, buf, *size); + + if (rw_response < LL_IFC_ACK) + { + *size = 0; + return rw_response; + } + + // Size is required + if ((rw_response & 0xff) <= 4) + { + *size = 0; + return LL_IFC_ERROR_INCORRECT_RESPONSE_LENGTH; + } + *size = (uint8_t)(rw_response & 0xFF) - 4; + + // Optional RSSI + if (NULL != rssi) + { + *rssi = 0; + *rssi = buf[0] + ((uint16_t) buf[1] << 8); + } + + // Optional RSSI + if (NULL != snr) + { + *snr = buf[2]; + } + + if (NULL != port) + { + *port = buf[3]; + } + + // get rid of snr and rssi in buffer + memmove(buf, buf + 4, *size); + + return LL_IFC_ACK; +} + +int32_t ll_dl_band_cfg_get(llabs_dl_band_cfg_t *p) +{ + uint8_t buff[DL_BAND_CFG_SIZE]; + if (p == NULL) + { + return LL_IFC_ERROR_INCORRECT_PARAMETER; + } + + int32_t ret = hal_read_write(OP_DL_BAND_CFG_GET, NULL, 0, buff, DL_BAND_CFG_SIZE); + if (LL_IFC_ACK > ret) + { + return ret; + } + if (DL_BAND_CFG_SIZE != ret) + { + return LL_IFC_ERROR_INCORRECT_RESPONSE_LENGTH; + } + + ll_dl_band_cfg_deserialize(buff, p); + return LL_IFC_ACK; +} + +int32_t ll_dl_band_cfg_set(const llabs_dl_band_cfg_t *p) +{ + uint8_t buff[DL_BAND_CFG_SIZE]; + if (p == NULL) + { + return LL_IFC_ERROR_INCORRECT_PARAMETER; + } + + ll_dl_band_cfg_serialize(p, buff); + int32_t ret = hal_read_write(OP_DL_BAND_CFG_SET, buff, DL_BAND_CFG_SIZE, NULL, 0); + return (ret >= 0) ? LL_IFC_ACK : ret; +} + +int32_t ll_rssi_offset_get(int8_t *rssi_offset) +{ + uint8_t raw = 0; + int32_t ret = hal_read_write(OP_RSSI_OFFSET_GET, NULL, 0, &raw, 1); + *rssi_offset = (int8_t)raw; + return (ret >= 0) ? LL_IFC_ACK : ret; +} + +int32_t ll_rssi_offset_set(int8_t rssi_offset) +{ + if (rssi_offset > 15 || rssi_offset < -15) + { + return LL_IFC_ERROR_INCORRECT_PARAMETER; + } + + int32_t ret = hal_read_write(OP_RSSI_OFFSET_SET, (uint8_t*)&rssi_offset, 1, NULL, 0); + return (ret >= 0) ? LL_IFC_ACK : ret; +} + +int32_t ll_connection_filter_get(uint8_t *p_f) +{ + if (NULL == p_f) + { + return LL_IFC_ERROR_INCORRECT_PARAMETER; + } + uint8_t f; + int32_t ret = hal_read_write(OP_CONN_FILT_GET, NULL, 0, &f, 1); + if (LL_IFC_ACK > ret) + { + return ret; + } + if (sizeof(f) != ret) + { + return LL_IFC_ERROR_INCORRECT_RESPONSE_LENGTH; + } + + *p_f = f; + return (ret >= 0) ? LL_IFC_ACK : ret; +} + +int32_t ll_connection_filter_set(uint8_t f) +{ + int32_t ret = hal_read_write(OP_CONN_FILT_SET, &f, 1, NULL, 0); + return (ret >= 0) ? LL_IFC_ACK : ret; +} + +int32_t ll_system_time_get(llabs_time_info_t *time_info) +{ + uint8_t buff[TIME_INFO_SIZE]; + if (time_info == NULL) + { + return LL_IFC_ERROR_INCORRECT_PARAMETER; + } + int32_t ret = hal_read_write(OP_SYSTEM_TIME_GET, NULL, 0, buff, STATS_SIZE); + if (LL_IFC_ACK > ret) + { + return ret; + } + if (TIME_INFO_SIZE != ret) + { + return LL_IFC_ERROR_INCORRECT_RESPONSE_LENGTH; + } + + ll_time_deserialize(buff, time_info); + return LL_IFC_ACK; +} + +int32_t ll_system_time_sync(uint8_t sync_mode) +{ + if (sync_mode > 1) + { + return LL_IFC_ERROR_INCORRECT_PARAMETER; + } + int32_t ret = hal_read_write(OP_SYSTEM_TIME_SYNC, &sync_mode, sizeof(sync_mode), NULL, 0); + return (ret >= 0) ? LL_IFC_ACK : ret; +} + +int32_t ll_message_send(uint8_t buf[], uint16_t len, bool ack, uint8_t port) +{ + if (buf == NULL || len <= 0 || len > 256) + { + return LL_IFC_ERROR_INCORRECT_PARAMETER; + } + + if (port > ll_ul_max_port) + { + return LL_IFC_ERROR_INCORRECT_PARAMETER; + } + + memmove(uplink_message_buff, buf, len); + _uplink_message_buff[0] = (uint8_t) ack; + _uplink_message_buff[1] = port; + int32_t ret = hal_read_write(OP_MSG_SEND, _uplink_message_buff, len + 2, NULL, 0); + return (ret >= 0) ? LL_IFC_ACK : ret; +} From 3c9b351bcc9c6c93dbcaf1274c7528731c3f8651 Mon Sep 17 00:00:00 2001 From: Joe Boring Date: Fri, 9 Aug 2019 09:51:44 -0400 Subject: [PATCH 10/33] save changes --- Doxyfile | 3 +- inc/ifc_struct_defs.h | 68 +-- inc/ll_ifc_consts.h | 26 +- inc/ll_ifc_ftp.h | 2 + inc/ll_ifc_symphony.h | 17 +- inc/ll_ifc_utils.h | 1 - src/ifc_struct_defs.c | 52 +-- src/ll_ifc.c | 38 +- src/ll_ifc_ftp.c | 101 +++-- src/ll_ifc_symphony.c | 45 +- test_ftp/utils_ftp.c | 2 +- test_ifc_lib/Makefile | 8 +- test_ifc_lib/main.c | 6 +- test_ifc_lib/test_ifc_lib_gen.c | 408 ------------------ test_ifc_lib/test_ifc_lib_gen.h | 83 ---- test_ifc_lib/test_ifc_lib_nomac.c | 323 -------------- test_ifc_lib/test_ifc_lib_nomac.h | 64 --- test_ifc_lib/test_ifc_lib_symphony.c | 622 --------------------------- test_ifc_lib/test_ifc_lib_symphony.h | 105 ----- test_ifc_lib/utils_ifc_lib.c | 22 +- test_utils/Makefile | 163 ------- test_utils/main.c | 20 - test_utils/test_ifc_lib_utils.c | 236 ---------- test_utils/test_ifc_lib_utils.h | 21 - test_utils/utils.c | 196 --------- test_utils/utils.h | 10 - 26 files changed, 233 insertions(+), 2409 deletions(-) delete mode 100644 test_ifc_lib/test_ifc_lib_gen.c delete mode 100644 test_ifc_lib/test_ifc_lib_gen.h delete mode 100644 test_ifc_lib/test_ifc_lib_nomac.c delete mode 100644 test_ifc_lib/test_ifc_lib_nomac.h delete mode 100644 test_ifc_lib/test_ifc_lib_symphony.c delete mode 100644 test_ifc_lib/test_ifc_lib_symphony.h delete mode 100644 test_utils/Makefile delete mode 100644 test_utils/main.c delete mode 100644 test_utils/test_ifc_lib_utils.c delete mode 100644 test_utils/test_ifc_lib_utils.h delete mode 100644 test_utils/utils.c delete mode 100644 test_utils/utils.h diff --git a/Doxyfile b/Doxyfile index 1ab0e4e..2cbdbb8 100644 --- a/Doxyfile +++ b/Doxyfile @@ -38,7 +38,7 @@ PROJECT_NAME = "Link Labs Interface Library" # could be handy for archiving the generated documentation or if some version # control system is used. -PROJECT_NUMBER = 0.7.0 +PROJECT_NUMBER = 0.3.1 # Using the PROJECT_BRIEF tag one can provide an optional one line description # for a project that appears at the top of each page and should give viewer a @@ -59,7 +59,6 @@ PROJECT_LOGO = logo.png # left blank the current directory will be used. OUTPUT_DIRECTORY = docs/build - # If the CREATE_SUBDIRS tag is set to YES then doxygen will create 4096 sub- # directories (in 2 levels) under the output directory of each output format and # will distribute the generated files over these directories. Enabling this diff --git a/inc/ifc_struct_defs.h b/inc/ifc_struct_defs.h index deab3d0..fe1220a 100644 --- a/inc/ifc_struct_defs.h +++ b/inc/ifc_struct_defs.h @@ -3,8 +3,6 @@ #include -#include "ll_mac_config.h" - #define NET_INFO_BUFF_SIZE (31) #define DL_BAND_CFG_SIZE (3 * 4 + 2) #define STATS_SIZE (10 * 4) @@ -17,7 +15,15 @@ #define GW_SCAN_INFO_BUFF_SIZE (MAX_GW_SCAN_RESULTS * GW_SCAN_INFO_SIZE + 1) #ifndef PACKED - #error "PACKED must be defined for the compiler platform" +#if defined ( __CC_ARM ) + #define PACKED(TYPE) __packed TYPE +#elif defined(__GNUC__) || defined(__GNU_C__) + #define PACKED __attribute__ ((packed)) +#elif defined (__ICCARM__) + #define PACKED_STRUCT __packed struct +#else + #error "PACKED must be defined for the platform!" +#endif #endif #ifdef __cplusplus @@ -35,11 +41,13 @@ extern "C" { * @{ */ -typedef enum { - LLABS_CONNECT_INITIAL = 0, ///< 0x00 - LLABS_CONNECT_DISCONNECTED, ///< 0x01 - LLABS_CONNECT_CONNECTED, ///< 0x02 - LLABS_NUM_CONNECT_STATUSES ///< 0x03 + +typedef enum +{ + LLABS_CONNECT_INITIAL = 0, ///< 0x00 + LLABS_CONNECT_DISCONNECTED, ///< 0x01 + LLABS_CONNECT_CONNECTED, ///< 0x02 + LLABS_NUM_CONNECT_STATUSES ///< 0x03 } llabs_connect_status_t; typedef struct PACKED llabs_network_info_t @@ -69,18 +77,16 @@ typedef struct PACKED llabs_dl_band_cfg typedef struct llabs_stats { - uint32_t num_send_calls; ///< Number of times SendMessage has been called successfully - uint32_t num_pkts_transmitted; ///< Number of packet transmissions (includes retries) - uint32_t num_gateway_scans; ///< Number of gateway scans - uint32_t num_collisions; ///< Number of CSMA collisions detected - uint32_t num_ack_successes; ///< Number of successful acknowledgments - uint32_t num_ack_failures; ///< Number of failed acknowledgments - uint32_t num_sync_failures; ///< Number of Sync failures - uint32_t num_canceled_pkts_ack; ///< Number of times packet was canceled due to - /// LLABS_ACK_FAIL_RETRIES - uint32_t num_canceled_pkts_csma; ///< Number of times packet was canceled due to - /// LLABS_MAX_CSMA_COLLISIONS - uint32_t num_rx_errors; ///< Number of times we received a Rx error from the back end + uint32_t num_send_calls; ///< Number of times SendMessage has been called successfully + uint32_t num_pkts_transmitted; ///< Number of packet transmissions (includes retries) + uint32_t num_gateway_scans; ///< Number of gateway scans + uint32_t num_collisions; ///< Number of CSMA collisions detected + uint32_t num_ack_successes; ///< Number of successful acknowledgments + uint32_t num_ack_failures; ///< Number of failed acknowledgments + uint32_t num_sync_failures; ///< Number of Sync failures + uint32_t num_canceled_pkts_ack; ///< Number of times packet was canceled due to LLABS_ACK_FAIL_RETRIES + uint32_t num_canceled_pkts_csma; ///< Number of times packet was canceled due to LLABS_MAX_CSMA_COLLISIONS + uint32_t num_rx_errors; ///< Number of times we received a Rx error from the back end } llabs_stats_t; typedef struct PACKED llabs_gateway_scan_results @@ -94,13 +100,13 @@ typedef struct PACKED llabs_gateway_scan_results typedef struct PACKED llabs_time { - uint32_t seconds; ///< Seconds since UNIX epoch 00:00:00 UTC on 1 January 1970 - uint16_t millis; ///< number of milliseconds since time seconds since the epoch + uint32_t seconds; ///< Seconds since UNIX epoch 00:00:00 UTC on 1 January 1970 + uint16_t millis; ///< number of milliseconds since time seconds since the epoch } llabs_time_t; typedef struct PACKED llabs_time_info { - uint8_t sync_mode; ///< 0: Time sync only when requested, 1: Time sync opportunistically + uint8_t sync_mode; ///< 0: Time sync only when requested, 1: Time sync opportunistically llabs_time_t curr; llabs_time_t last_sync; } llabs_time_info_t; @@ -155,7 +161,7 @@ uint16_t ll_time_serialize(const llabs_time_info_t *time_info, uint8_t buff[TIME * @return * The u8 read from the buffer. */ -uint8_t read_uint8(const uint8_t **buffer); +uint8_t read_uint8(const uint8_t ** buffer); /** * @brief @@ -169,7 +175,7 @@ uint8_t read_uint8(const uint8_t **buffer); * @return * The u16 read from the buffer. */ -uint16_t read_uint16(const uint8_t **buffer); +uint16_t read_uint16(const uint8_t ** buffer); /** * @brief @@ -183,7 +189,7 @@ uint16_t read_uint16(const uint8_t **buffer); * @return * The u32 read from the buffer. */ -uint32_t read_uint32(const uint8_t **buffer); +uint32_t read_uint32(const uint8_t ** buffer); /** * @brief @@ -197,7 +203,7 @@ uint32_t read_uint32(const uint8_t **buffer); * @return * The u64 read from the buffer. */ -uint64_t read_uint64(const uint8_t **buffer); +uint64_t read_uint64(const uint8_t ** buffer); /** * @brief @@ -211,7 +217,7 @@ uint64_t read_uint64(const uint8_t **buffer); * The pointer to the big-endian buffer. The pointer is * incremented to the next location past the value written. */ -void write_uint8(uint8_t x, uint8_t **buffer); +void write_uint8(uint8_t x, uint8_t ** buffer); /** * @brief @@ -225,7 +231,7 @@ void write_uint8(uint8_t x, uint8_t **buffer); * The pointer to the big-endian buffer. The pointer is * incremented to the next location past the value written. */ -void write_uint16(uint16_t x, uint8_t **buffer); +void write_uint16(uint16_t x, uint8_t ** buffer); /** * @brief @@ -239,7 +245,7 @@ void write_uint16(uint16_t x, uint8_t **buffer); * The pointer to the big-endian buffer. The pointer is * incremented to the next location past the value written. */ -void write_uint32(uint32_t x, uint8_t **buffer); +void write_uint32(uint32_t x, uint8_t ** buffer); /** * @brief @@ -253,7 +259,7 @@ void write_uint32(uint32_t x, uint8_t **buffer); * The pointer to the big-endian buffer. The pointer is * incremented to the next location past the value written. */ -void write_uint64(uint64_t x, uint8_t **buffer); +void write_uint64(uint64_t x, uint8_t ** buffer); /** @} (end defgroup ifc_serialize) */ diff --git a/inc/ll_ifc_consts.h b/inc/ll_ifc_consts.h index f6dbe89..13547a3 100644 --- a/inc/ll_ifc_consts.h +++ b/inc/ll_ifc_consts.h @@ -65,10 +65,10 @@ typedef enum OP_CONN_FILT_SET = 93, ///< 0x5D OP_CONN_FILT_GET = 94, ///< 0x5E //STRIPTHIS!START - OP_RESERVED0 = 96, ///< 0x60 - OP_RESERVED1 = 97, ///< 0x61 + OP_RESERVED0 = 96, ///< 0x5F + OP_RESERVED1 = 97, ///< 0x60 //STRIPTHIS!STOP - OP_TX_CW = 98, ///< 0x62 + OP_TX_CW = 98, ///< 0x61 OP_SYSTEM_TIME_GET = 108, ///< 0x6C OP_SYSTEM_TIME_SYNC = 109, ///< 0x6D OP_RX_MODE_SET = 110, ///< 0x6E @@ -159,8 +159,7 @@ typedef enum LLRXR26_V2 = 2, ///< 0x02 LLRLP20_V3 = 3, ///< 0x03 LLRXR26_V3 = 4, ///< 0x04 - LLREPEATER = 5, ///< 0x05 AES_TODO - Replace with official part number? - LLSLAP_HOST = 16 ///< 0x10 + LLREPEATER = 5 ///< 0x05 AES_TODO - Replace with official part number? } ll_hardware_type_t; /** @@ -172,16 +171,14 @@ typedef enum CPU_EFM32G210F128 = 1, ///< 0x01 CPU_R5F51115ADNE = 2, ///< 0x02 CPU_R5F51116ADNE = 3, ///< 0x03 - CPU_EFM32GG232F1024 = 4, ///< 0x04 - CPU_NRF52840 = 16 ///< 0x10 + CPU_EFM32GG232F1024 = 4 ///< 0x04 } cpu_code_t; typedef enum { - GATEWAY_TX_ONLY = 0, ///< 0x00 - MODULE_END_NODE = 1, ///< 0x01 - REPEATER_HOST = 2, ///< 0x02 - RADIO_INTEGRATED = 16 ///< 0x10 + GATEWAY_TX_ONLY = 0, ///< 0x00 + MODULE_END_NODE = 1, ///< 0x01 + REPEATER_HOST = 2 ///< 0x02 // TBD - How to define others ? } functionality_code_t; @@ -277,6 +274,7 @@ typedef enum ll_ifc_error_codes_e { LL_IFC_ERROR_TIMEOUT = -110, ///< The operation timed out. LL_IFC_ERROR_INCORRECT_MESSAGE_SIZE = -111, ///< The message size from the device was incorrect. LL_IFC_ERROR_NO_NETWORK = -112, ///< No network was available. + LL_IFC_ERROR_HAL_CALL_FAILED = -113, ///< A User defined function failed. /* When adding a new value, update ll_return_code_name() and ll_return_code_description() */ } ll_ifc_error_codes_t; @@ -314,6 +312,12 @@ typedef enum ll_ifc_error_codes_e { #define IRQ_CLOUD_GPIO_2_INTERRUPT (0x01000000UL) ///< Set when the cloud GPIO input is triggered #define IRQ_CLOUD_GPIO_3_INTERRUPT (0x02000000UL) ///< Set when the cloud GPIO input is triggered #define IRQ_FLAGS_ASSERT (0x80000000UL) ///< Set every time we transition from the connected->disconnected state +//STRIPTHIS!START +// LifeRaft IRQ flags +//#define IRQ_FLAGS_STATUS_REQ (0x00400000UL) ///< Set when we want to request the status of the host controller +//#define IRQ_FLAGS_FIRMWARE_REQ (0x00800000UL) ///< Set when we want to request the firmware data of the host controller +//STRIPTHIS!STOP + /** * @brief diff --git a/inc/ll_ifc_ftp.h b/inc/ll_ifc_ftp.h index fd5a10f..b0460e6 100644 --- a/inc/ll_ifc_ftp.h +++ b/inc/ll_ifc_ftp.h @@ -63,9 +63,11 @@ extern "C" { #define MAX_NUM_SEGMENTS (9800) // Can support a 1MB image #define MAX_FILE_SEGMENT_BYTES (107) +//#define NUM_RX_SEGS_BITMASK (MAX_NUM_SEGMENTS / 32) #define NUM_RX_SEGS_BITMASK (((MAX_NUM_SEGMENTS % 32) == 0) ? (MAX_NUM_SEGMENTS >> 5) : ((MAX_NUM_SEGMENTS >> 5) + 1)) #define BASE_UL_MSG_LEN (14) #define MAX_NUM_RETRY_SEGS (1024) +//#define LL_FTP_TX_BUF_SIZE (BASE_UL_MSG_LEN + MAX_NUM_RETRY_SEGS * 2) #define LL_FTP_TX_BUF_SIZE (256) // Can fit 121 segment requests per payload diff --git a/inc/ll_ifc_symphony.h b/inc/ll_ifc_symphony.h index e2d57d2..88b3f4c 100644 --- a/inc/ll_ifc_symphony.h +++ b/inc/ll_ifc_symphony.h @@ -96,7 +96,22 @@ extern const llabs_dl_band_cfg_t DL_BAN_BRA; ///< Brazil DL Band Configuration extern const llabs_dl_band_cfg_t DL_BAN_AUS; ///< Australia DL Band Configuration extern const llabs_dl_band_cfg_t DL_BAN_NZL; ///< New Zealand DL Band Configuration extern const llabs_dl_band_cfg_t DL_BAN_ETSI; ///< Europe (ETSI) DL Band Configuration - +/** + * @brief + * Set the scan attemps on the module + * + * @details + * Sets the number of times a scan will restart upon a + * failed scan before going to disconnect idle state. + * + * @param[in] scan_attempts + * The number of times the scan will restart upon a failed scan. + * 0 = Infinite Scan Attempts; Range (1, 65535) + * + * @return + * 0 - success, negative otherwise. + */ +int32_t ll_scan_attempts_set(uint16_t scan_attempts); /** * @brief diff --git a/inc/ll_ifc_utils.h b/inc/ll_ifc_utils.h index 36f975b..2fc6742 100644 --- a/inc/ll_ifc_utils.h +++ b/inc/ll_ifc_utils.h @@ -108,4 +108,3 @@ int32_t ll_difftime_from_now(struct time *a); #endif #endif //__LL_IFC_UTIL_H - diff --git a/src/ifc_struct_defs.c b/src/ifc_struct_defs.c index bc9c3bf..cee73c2 100644 --- a/src/ifc_struct_defs.c +++ b/src/ifc_struct_defs.c @@ -1,45 +1,40 @@ #include #include "ifc_struct_defs.h" -uint8_t read_uint8(const uint8_t **buffer) -{ +uint8_t read_uint8(const uint8_t ** buffer) { return *((*buffer)++); } -uint16_t read_uint16(const uint8_t **buffer) -{ - return (((uint16_t) read_uint8(buffer)) << 8) | ((uint16_t) read_uint8(buffer)); +uint16_t read_uint16(const uint8_t ** buffer) { + return (((uint16_t) read_uint8(buffer)) << 8) | + ((uint16_t) read_uint8(buffer)); } -uint32_t read_uint32(const uint8_t **buffer) -{ - return (((uint32_t) read_uint16(buffer)) << 16) | ((uint32_t) read_uint16(buffer)); +uint32_t read_uint32(const uint8_t ** buffer) { + return (((uint32_t) read_uint16(buffer)) << 16) | + ((uint32_t) read_uint16(buffer)); } -uint64_t read_uint64(const uint8_t **buffer) -{ - return (((uint64_t) read_uint32(buffer)) << 32) | ((uint64_t) read_uint32(buffer)); +uint64_t read_uint64(const uint8_t ** buffer) { + return (((uint64_t) read_uint32(buffer)) << 32) | + ((uint64_t) read_uint32(buffer)); } -void write_uint8(uint8_t x, uint8_t **buffer) -{ +void write_uint8(uint8_t x, uint8_t ** buffer) { *((*buffer)++) = x; } -void write_uint16(uint16_t x, uint8_t **buffer) -{ +void write_uint16(uint16_t x, uint8_t ** buffer) { write_uint8(x >> 8, buffer); write_uint8(x, buffer); } -void write_uint32(uint32_t x, uint8_t **buffer) -{ +void write_uint32(uint32_t x, uint8_t ** buffer) { write_uint16(x >> 16, buffer); write_uint16(x, buffer); } -void write_uint64(uint64_t x, uint8_t **buffer) -{ +void write_uint64(uint64_t x, uint8_t ** buffer) { write_uint32(x >> 32, buffer); write_uint32(x, buffer); } @@ -47,7 +42,7 @@ void write_uint64(uint64_t x, uint8_t **buffer) // Parse a serialized llabs_network_info_t struct. void ll_net_info_deserialize(const uint8_t buff[NET_INFO_BUFF_SIZE], llabs_network_info_t *net_info) { - uint8_t const *b = buff; + uint8_t const * b = buff; net_info->network_id_node = read_uint32(&b); net_info->network_id_gw = read_uint32(&b); net_info->gateway_channel = read_uint8(&b); @@ -63,10 +58,9 @@ void ll_net_info_deserialize(const uint8_t buff[NET_INFO_BUFF_SIZE], llabs_netwo // Serializes an llabs_network_info_t struct into a buffer to be sent over the host interface. // Returns the size of the serialized struct in the buffer. -uint16_t ll_net_info_serialize(const llabs_network_info_t *net_info, - uint8_t buff[NET_INFO_BUFF_SIZE]) +uint16_t ll_net_info_serialize(const llabs_network_info_t *net_info, uint8_t buff[NET_INFO_BUFF_SIZE]) { - uint8_t *buff_cpy = buff; + uint8_t * buff_cpy = buff; write_uint32(net_info->network_id_node, &buff_cpy); write_uint32(net_info->network_id_gw, &buff_cpy); write_uint8(net_info->gateway_channel, &buff_cpy); @@ -108,7 +102,7 @@ uint16_t ll_gw_scan_result_serialize(llabs_gateway_scan_results_t scan_result, c void ll_dl_band_cfg_deserialize(const uint8_t buff[DL_BAND_CFG_SIZE], llabs_dl_band_cfg_t *dl_cfg) { - uint8_t const *b = buff; + uint8_t const * b = buff; dl_cfg->band_edge_lower = read_uint32(&b); dl_cfg->band_edge_upper = read_uint32(&b); dl_cfg->band_edge_guard = read_uint32(&b); @@ -118,7 +112,7 @@ void ll_dl_band_cfg_deserialize(const uint8_t buff[DL_BAND_CFG_SIZE], llabs_dl_b uint16_t ll_dl_band_cfg_serialize(const llabs_dl_band_cfg_t *dl_cfg, uint8_t buff[DL_BAND_CFG_SIZE]) { - uint8_t *b = buff; + uint8_t * b = buff; write_uint32(dl_cfg->band_edge_lower, &b); write_uint32(dl_cfg->band_edge_upper, &b); write_uint32(dl_cfg->band_edge_guard, &b); @@ -129,7 +123,7 @@ uint16_t ll_dl_band_cfg_serialize(const llabs_dl_band_cfg_t *dl_cfg, uint8_t buf void ll_stats_deserialize(const uint8_t buff[STATS_SIZE], llabs_stats_t *stats) { - uint8_t const *b = buff; + uint8_t const * b = buff; stats->num_send_calls = read_uint32(&b); stats->num_pkts_transmitted = read_uint32(&b); stats->num_gateway_scans = read_uint32(&b); @@ -144,7 +138,7 @@ void ll_stats_deserialize(const uint8_t buff[STATS_SIZE], llabs_stats_t *stats) uint16_t ll_stats_serialize(const llabs_stats_t *stats, uint8_t buff[STATS_SIZE]) { - uint8_t *b = buff; + uint8_t * b = buff; write_uint32(stats->num_send_calls, &b); write_uint32(stats->num_pkts_transmitted, &b); write_uint32(stats->num_gateway_scans, &b); @@ -160,7 +154,7 @@ uint16_t ll_stats_serialize(const llabs_stats_t *stats, uint8_t buff[STATS_SIZE] void ll_time_deserialize(const uint8_t buff[TIME_INFO_SIZE], llabs_time_info_t *time_info) { - uint8_t const *b = buff; + uint8_t const * b = buff; time_info->sync_mode = read_uint8(&b); time_info->curr.seconds = read_uint32(&b); time_info->curr.millis = read_uint16(&b); @@ -170,7 +164,7 @@ void ll_time_deserialize(const uint8_t buff[TIME_INFO_SIZE], llabs_time_info_t * uint16_t ll_time_serialize(const llabs_time_info_t *time_info, uint8_t buff[TIME_INFO_SIZE]) { - uint8_t *b = buff; + uint8_t * b = buff; write_uint8(time_info->sync_mode, &b); write_uint32(time_info->curr.seconds, &b); write_uint16(time_info->curr.millis, &b); diff --git a/src/ll_ifc.c b/src/ll_ifc.c index 9a66099..d118c17 100644 --- a/src/ll_ifc.c +++ b/src/ll_ifc.c @@ -101,7 +101,7 @@ char const * ll_return_code_description(int32_t return_code) { switch (return_code) { - case -LL_IFC_ACK: return "Success"; + case -LL_IFC_ACK: return "success"; case -LL_IFC_NACK_CMD_NOT_SUPPORTED: return "Command not supported"; case -LL_IFC_NACK_INCORRECT_CHKSUM: return "Incorrect Checksum"; case -LL_IFC_NACK_PAYLOAD_LEN_OOR: return "Length of payload sent in command was out of range"; @@ -143,7 +143,7 @@ int32_t ll_firmware_type_get(ll_firmware_type_t *t) } ret = hal_read_write(OP_FIRMWARE_TYPE, NULL, 0, buf, FIRMWARE_TYPE_LEN); - if(ret < 0) + if (ret == 0) { return ret; } @@ -512,7 +512,7 @@ int32_t ll_reset_state( void ) */ static void send_packet(opcode_t op, uint8_t message_num, uint8_t *buf, uint16_t len) { - #define SP_NUM_ZEROS (4) + #define SP_NUM_ZEROS (6) #define SP_HEADER_SIZE (CMD_HEADER_LEN + SP_NUM_ZEROS) uint8_t header_buf[SP_HEADER_SIZE]; uint8_t checksum_buff[2]; @@ -523,7 +523,7 @@ static void send_packet(opcode_t op, uint8_t message_num, uint8_t *buf, uint16_t // Send a couple wakeup bytes, just-in-case for (i = 0; i < SP_NUM_ZEROS; i++) { - header_buf[header_idx ++] = 0xff; + header_buf[header_idx ++] = 0x5F; } header_buf[header_idx++] = FRAME_START; @@ -596,15 +596,24 @@ static int32_t recv_packet(opcode_t op, uint8_t message_num, uint8_t *buf, uint1 int32_t ret; memset(header_buf, 0, sizeof(header_buf)); - //TODO: have conditionally compiled cases for various platforms to ensure accurate timeout - clock_t max_clock = (clock_t) (1.5 * (float)CLOCKS_PER_SEC); - clock_t t = clock(); + + struct time time_start, time_now; + if (gettime(&time_start) < 0) + { + return LL_IFC_ERROR_HAL_CALL_FAILED; + } do { /* Timeout of infinite Rx loop if responses never show up*/ ret = transport_read(&curr_byte, 1); - if((clock()- t) > max_clock) + + if (gettime(&time_now) < 0) + { + return LL_IFC_ERROR_HAL_CALL_FAILED; + } + + if(time_now.tv_sec - time_start.tv_sec > 2) { len = 0; return LL_IFC_ERROR_HOST_INTERFACE_TIMEOUT; @@ -677,13 +686,20 @@ static int32_t recv_packet(opcode_t op, uint8_t message_num, uint8_t *buf, uint1 // Grab the payload if there is supposed to be one if ((buf != NULL) && (len > 0)) { - transport_read(buf, len); + ret = transport_read(buf, len); + if (ret < 0) + { + return -2; + } } } // Finally, make sure the checksum matches - transport_read(checksum_buff, 2); - + ret = transport_read(checksum_buff, 2); + if (ret < 0) + { + return -1; + } computed_checksum = compute_checksum(header_buf, RESP_HEADER_LEN, buf, len); uint16_t rx_checksum = ((uint16_t)checksum_buff[0] << 8) + checksum_buff[1]; if (rx_checksum != computed_checksum) diff --git a/src/ll_ifc_ftp.c b/src/ll_ifc_ftp.c index 6491aae..3ddd085 100644 --- a/src/ll_ifc_ftp.c +++ b/src/ll_ifc_ftp.c @@ -73,7 +73,7 @@ static ll_ftp_return_code_t ll_ftp_send_uplink(ll_ftp_t* f, size_t len) { uint8_t old_max_port = ll_ul_max_port; ll_ul_max_port = LL_FTP_PORT; - ll_ftp_return_code_t ret = f->cb.uplink(f->tx_buf, len, true, LL_FTP_PORT); + ll_ftp_return_code_t ret = f->cb.uplink(f->tx_buf, (uint16_t) len, true, LL_FTP_PORT); ll_ul_max_port = old_max_port; gettime(&f->time_last_msg); return ret; @@ -194,6 +194,7 @@ static uint16_t ll_ftp_get_missing_segs(ll_ftp_t* f, bool fill_buf) uint16_t seg_num; uint8_t num_segs_base; uint8_t idx; + uint16_t total_payload = fill_buf ? BASE_UL_MSG_LEN : 0; uint16_t base_max = f->num_segs >> 5; // divide by 32 for(i = 0; i <= base_max; i++) @@ -209,15 +210,21 @@ static uint16_t ll_ftp_get_missing_segs(ll_ftp_t* f, bool fill_buf) // request complete retransmission return 0xFFFF; } + seg_num = (i << 5) + j; // i * 32 + j - + idx = num_missing_segs * 2; - if(fill_buf) + + // Only fill the buffer up to the maximum number of segments we can request in + // a single payload + if ((fill_buf) && ((total_payload + sizeof(seg_num)) <= LL_FTP_TX_BUF_SIZE)) { f->tx_buf[LL_FTP_NAK_FILE_SEGS_INDEX + idx] = seg_num & 0x00FF; f->tx_buf[LL_FTP_NAK_FILE_SEGS_INDEX + idx + 1] = (seg_num >> 8) & 0x00FF; + + total_payload += sizeof(seg_num); + num_missing_segs++; } - num_missing_segs++; } } } @@ -225,7 +232,7 @@ static uint16_t ll_ftp_get_missing_segs(ll_ftp_t* f, bool fill_buf) return num_missing_segs; } -static uint8_t ll_ftp_ack_init_generate(ll_ftp_t* f, bool ack) +static uint16_t ll_ftp_ack_init_generate(ll_ftp_t* f, bool ack) { f->tx_buf[LL_FTP_MSG_PACKET_TYPE_INDEX] = ACK_INIT; if (ack) @@ -246,7 +253,7 @@ static uint8_t ll_ftp_ack_init_generate(ll_ftp_t* f, bool ack) return BASE_UL_MSG_LEN; } -static uint8_t ll_ftp_ack_segs_complete_generate(ll_ftp_t* f) +static uint16_t ll_ftp_ack_segs_complete_generate(ll_ftp_t* f) { f->tx_buf[LL_FTP_MSG_PACKET_TYPE_INDEX] = ACK_SEGMENT; f->tx_buf[LL_FTP_ACK_ACK_TYPE_INDEX] = ACK_ACK; @@ -259,7 +266,7 @@ static uint8_t ll_ftp_ack_segs_complete_generate(ll_ftp_t* f) return BASE_UL_MSG_LEN; } -static uint8_t ll_ftp_ack_segs_request_generate(ll_ftp_t* f) +static uint16_t ll_ftp_ack_segs_request_generate(ll_ftp_t* f) { f->tx_buf[LL_FTP_MSG_PACKET_TYPE_INDEX] = ACK_SEGMENT; f->tx_buf[LL_FTP_ACK_ACK_TYPE_INDEX] = ACK_NAK_SEGMENT; @@ -268,7 +275,7 @@ static uint8_t ll_ftp_ack_segs_request_generate(ll_ftp_t* f) // check max length number of retry segments uint16_t num_missing_segs = ll_ftp_get_missing_segs(f, true); - uint8_t return_len = BASE_UL_MSG_LEN; + uint16_t return_len = BASE_UL_MSG_LEN; if(MAX_NUM_RETRY_SEGS <= num_missing_segs) { f->tx_buf[LL_FTP_ACK_ACK_TYPE_INDEX] = ACK_NAK; @@ -278,16 +285,16 @@ static uint8_t ll_ftp_ack_segs_request_generate(ll_ftp_t* f) return_len += num_missing_segs * sizeof(uint16_t); } - uint32_t crc = crc32(0, &f->tx_buf[LL_FTP_ACK_ACK_TYPE_INDEX], return_len - LL_FTP_ACK_ACK_TYPE_INDEX); + uint32_t crc = crc32(0, &f->tx_buf[LL_FTP_ACK_ACK_TYPE_INDEX], (size_t) return_len - LL_FTP_ACK_ACK_TYPE_INDEX); UINT32_TO_BYTESTREAM((&f->tx_buf[LL_FTP_MSG_CRC_INDEX]), crc); return return_len; } -static uint8_t ll_ftp_ack_apply_generate(ll_ftp_t* f) +static uint16_t ll_ftp_ack_apply_generate(ll_ftp_t* f, bool success) { f->tx_buf[LL_FTP_MSG_PACKET_TYPE_INDEX] = ACK_APPLY; - f->tx_buf[LL_FTP_ACK_ACK_TYPE_INDEX] = ACK_ACK; + f->tx_buf[LL_FTP_ACK_ACK_TYPE_INDEX] = (success ? ACK_ACK : ACK_NAK); UINT32_TO_BYTESTREAM((&f->tx_buf[LL_FTP_ACK_FILE_ID_INDEX]), f->file_id); UINT32_TO_BYTESTREAM((&f->tx_buf[LL_FTP_ACK_FILE_VERSION_INDEX]), f->file_version); @@ -307,7 +314,7 @@ static void ll_ftp_new_file_initialize(ll_ftp_t* f, ll_ftp_msg_t* msg) memset(f->rx_segs, 0, sizeof(f->rx_segs[0]) * NUM_RX_SEGS_BITMASK); // send ACK_INIT - uint8_t len = ll_ftp_ack_init_generate(f, true); + uint16_t len = ll_ftp_ack_init_generate(f, true); ll_ftp_send_uplink(f, len); } @@ -332,6 +339,7 @@ static int32_t ll_ftp_idle_start(ll_ftp_t* f) static int32_t ll_ftp_segment_start(ll_ftp_t* f, ll_ftp_msg_t* msg) { + ll_ftp_return_code_t msg_ret; int32_t ret = LL_FTP_NO_ACTION; int32_t cb_ret = f->cb.open(msg->file_id, msg->file_version, msg->file_size); @@ -344,8 +352,12 @@ static int32_t ll_ftp_segment_start(ll_ftp_t* f, ll_ftp_msg_t* msg) else if (TX_INIT == msg->msg_type || TX_SEGMENT == msg->msg_type) { // send ACK_INIT - uint8_t len = ll_ftp_ack_init_generate(f, false); - ll_ftp_send_uplink(f, len); + uint16_t len = ll_ftp_ack_init_generate(f, false); + msg_ret = ll_ftp_send_uplink(f, len); + if (msg_ret != LL_FTP_OK) + { + ret = LL_FTP_ERROR; + } } return ret; @@ -353,14 +365,20 @@ static int32_t ll_ftp_segment_start(ll_ftp_t* f, ll_ftp_msg_t* msg) static int32_t ll_ftp_apply_start(ll_ftp_t* f) { + ll_ftp_return_code_t msg_ret; int32_t ret = LL_FTP_ERROR; int32_t cb_ret = f->cb.close(f->file_id, f->file_version); if(LL_FTP_OK == cb_ret) { - uint8_t len = ll_ftp_ack_segs_complete_generate(f); - ll_ftp_send_uplink(f, len); + uint16_t len = ll_ftp_ack_segs_complete_generate(f); + ret = LL_FTP_OK; + msg_ret = ll_ftp_send_uplink(f, len); + if (msg_ret != LL_FTP_OK) + { + ret = LL_FTP_ERROR; + } } return ret; @@ -542,6 +560,7 @@ static int32_t ll_ftp_transition_out_of_segment(ll_ftp_t* f, ll_ftp_msg_t* msg, } break; default: + ret = LL_FTP_ERROR; break; } @@ -550,6 +569,7 @@ static int32_t ll_ftp_transition_out_of_segment(ll_ftp_t* f, ll_ftp_msg_t* msg, static int32_t ll_ftp_segment_process_msg(ll_ftp_t* f, uint8_t* buf, uint8_t len) { + ll_ftp_return_code_t msg_ret; ll_ftp_msg_t ftp_msg; int32_t ret = ll_ftp_parse_rx_msg(buf, len, &ftp_msg); if(LL_FTP_OK != ret) @@ -605,13 +625,19 @@ static int32_t ll_ftp_segment_process_msg(ll_ftp_t* f, uint8_t* buf, uint8_t len { // Only able to apply in APPLY state // send NAK with retry segs - uint8_t len = ll_ftp_ack_segs_request_generate(f); - ll_ftp_send_uplink(f, len); + uint16_t len = ll_ftp_ack_segs_request_generate(f); + ret = LL_FTP_OK; + msg_ret = ll_ftp_send_uplink(f, len); + if (msg_ret != LL_FTP_OK) + { + ret = LL_FTP_ERROR; + } } else if(TICK == ftp_msg.msg_type) { struct time time_now; + ret = LL_FTP_OK; // Rely on a periodic 1 Hz tick to request segments if necessary gettime(&time_now); @@ -619,8 +645,13 @@ static int32_t ll_ftp_segment_process_msg(ll_ftp_t* f, uint8_t* buf, uint8_t len { if(f->retry_count < LL_FTP_MAX_NUM_RETRIES) { - uint8_t len = ll_ftp_ack_segs_request_generate(f); - ll_ftp_send_uplink(f, len); + uint16_t len = ll_ftp_ack_segs_request_generate(f); + msg_ret = ll_ftp_send_uplink(f, len); + if (msg_ret != LL_FTP_OK) + { + ret = LL_FTP_ERROR; + } + f->retry_count++; } else @@ -628,7 +659,6 @@ static int32_t ll_ftp_segment_process_msg(ll_ftp_t* f, uint8_t* buf, uint8_t len next_state = IDLE; } } - ret = LL_FTP_OK; } // Do state transitions out of SEGMENT @@ -686,6 +716,7 @@ static int32_t ll_ftp_transition_out_of_apply(ll_ftp_t* f, ll_ftp_msg_t* msg, ll static int32_t ll_ftp_apply_process_msg(ll_ftp_t* f, uint8_t* buf, uint8_t len) { ll_ftp_msg_t ftp_msg; + ll_ftp_return_code_t msg_ret; int32_t ret = ll_ftp_parse_rx_msg(buf, len, &ftp_msg); if(LL_FTP_OK != ret) @@ -718,23 +749,31 @@ static int32_t ll_ftp_apply_process_msg(ll_ftp_t* f, uint8_t* buf, uint8_t len) } else if ((TX_APPLY == ftp_msg.msg_type) && (IS_MY_FILE)) { + uint16_t len; int32_t cb_ret = f->cb.apply(f->file_id, f->file_version, f->file_size); if(LL_FTP_OK == cb_ret) { - uint8_t len = ll_ftp_ack_apply_generate(f); - ll_ftp_send_uplink(f, len); - next_state = IDLE; + len = ll_ftp_ack_apply_generate(f, true); } else { - // Apply rejected. Forget File. + // Apply rejected. Send NAK and forget file. + len = ll_ftp_ack_apply_generate(f, false); + ret = LL_FTP_ERROR; + } + + next_state = IDLE; + msg_ret = ll_ftp_send_uplink(f, len); + if (msg_ret != LL_FTP_OK) + { ret = LL_FTP_ERROR; - next_state = IDLE; } } else if(TICK == ftp_msg.msg_type) { struct time time_now; + + ret = LL_FTP_OK; // Rely on a periodic 1 Hz tick to request segments if necessary gettime(&time_now); @@ -742,8 +781,13 @@ static int32_t ll_ftp_apply_process_msg(ll_ftp_t* f, uint8_t* buf, uint8_t len) { if(f->retry_count < LL_FTP_MAX_NUM_RETRIES) { - uint8_t len = ll_ftp_ack_segs_complete_generate(f); - ll_ftp_send_uplink(f, len); + uint16_t len = ll_ftp_ack_segs_complete_generate(f); + msg_ret = ll_ftp_send_uplink(f, len); + if (msg_ret != LL_FTP_OK) + { + ret = LL_FTP_ERROR; + } + f->retry_count++; } else @@ -751,7 +795,6 @@ static int32_t ll_ftp_apply_process_msg(ll_ftp_t* f, uint8_t* buf, uint8_t len) next_state = IDLE; } } - ret = LL_FTP_OK; } // Do state transitions out of APPLY diff --git a/src/ll_ifc_symphony.c b/src/ll_ifc_symphony.c index b897e57..3d96d41 100644 --- a/src/ll_ifc_symphony.c +++ b/src/ll_ifc_symphony.c @@ -13,7 +13,7 @@ const llabs_dl_band_cfg_t DL_BAN_AUS = {918000000, 926000000, 386703, 3, 0}; // const llabs_dl_band_cfg_t DL_BAN_NZL = {921000000, 928000000, 386703, 3, 0}; // New Zealand const llabs_dl_band_cfg_t DL_BAN_ETSI = {869100000, 871000000, 386703, 1, 0}; // Europe -static int32_t ll_net_token_get(uint32_t *p_net_token) +int32_t ll_net_token_get(uint32_t *p_net_token) { uint8_t buff[4]; if (p_net_token == NULL) @@ -39,7 +39,7 @@ static int32_t ll_net_token_get(uint32_t *p_net_token) return LL_IFC_ACK; } -static int32_t ll_net_token_set(uint32_t net_token) +int32_t ll_net_token_set(uint32_t net_token) { if (net_token != 0xFFFFFFFF) { @@ -164,14 +164,6 @@ static int32_t ll_threshold_get(int16_t *threshold) return (ret >= 0) ? LL_IFC_ACK : ret; } -static int32_t ll_scan_attempts_set(uint16_t scan_attempts) -{ - uint8_t buf[2]; - buf[0] = scan_attempts & 0xff; - buf[1] = scan_attempts >> 8; - int32_t ret = hal_read_write(OP_SCAN_ATTEMPTS_SET, buf, 2, NULL, 0); - return (ret >= 0) ? LL_IFC_ACK : ret; -} static int32_t ll_scan_attempts_get(uint16_t *scan_attempts) { @@ -189,6 +181,16 @@ static int32_t ll_scan_attempts_left_get(uint16_t *scan_attempts) return (ret >= 0) ? LL_IFC_ACK : ret; } + +int32_t ll_scan_attempts_set(uint16_t scan_attempts) +{ + uint8_t buf[2]; + buf[0] = scan_attempts & 0xff; + buf[1] = scan_attempts >> 8; + int32_t ret = hal_read_write(OP_SCAN_ATTEMPTS_SET, buf, 2, NULL, 0); + return (ret >= 0) ? LL_IFC_ACK : ret; +} + int32_t ll_config_set(uint32_t net_token, const uint8_t app_token[APP_TOKEN_LEN], enum ll_downlink_mode dl_mode, uint8_t qos) { @@ -380,16 +382,22 @@ int32_t ll_poll_scan_result(llabs_gateway_scan_results_t *scan_result, uint8_t * return ret; } + // if only one byte returned then no gateways found. dont deserialize + if (ret == 1) + { + *num_gw = 0; + return LL_IFC_ACK; + } + ll_gw_scan_result_deserialize(buff, scan_result, num_gw); return (ret >= 0) ? LL_IFC_ACK : ret; } -int32_t -ll_get_gateway_scan_results(llabs_gateway_scan_results_t (*scan_results)[MAX_GW_SCAN_RESULTS], +int32_t ll_get_gateway_scan_results(llabs_gateway_scan_results_t (*scan_results)[MAX_GW_SCAN_RESULTS], uint8_t *num_gw) { - uint8_t gw; + uint8_t gw=0; *num_gw = 0; do @@ -397,13 +405,22 @@ ll_get_gateway_scan_results(llabs_gateway_scan_results_t (*scan_results)[MAX_GW_ llabs_gateway_scan_results_t scan_result; int32_t ret = ll_poll_scan_result(&scan_result, &gw); + // if scanning will return a NACK_BUSY (6) + // if done scanning, but no gateways will return LL_IFC_ACK but no paylaod + // if done scanning, and gateway, gw will be non zero and decrement each time called if (ret != LL_IFC_ACK) { return ret; } + // if only + if (ret == 1) + { + } // When num_gw is uninitialized, we need to set it with the total - // amount of gateways + // amount of gateways. The interface decrements num_gw to use as an index prior to + // sending so we need to add one for number. + // if (*num_gw == 0) { *num_gw = gw + 1; diff --git a/test_ftp/utils_ftp.c b/test_ftp/utils_ftp.c index 3536c13..925f273 100644 --- a/test_ftp/utils_ftp.c +++ b/test_ftp/utils_ftp.c @@ -5,7 +5,7 @@ #include #include // memset, memcpy #include "ll_ifc_symphony.h" -#include + #include #include diff --git a/test_ifc_lib/Makefile b/test_ifc_lib/Makefile index f3dae25..f25c2cf 100644 --- a/test_ifc_lib/Makefile +++ b/test_ifc_lib/Makefile @@ -91,11 +91,9 @@ $(MODULE_DIR)/embc/src/fifo.c \ ../src/ll_ifc_no_mac.c \ ../src/ll_ifc_symphony.c \ ../src/ll_ifc.c \ -test_ifc_lib_gen.c \ -test_ifc_lib_symphony.c \ -test_ifc_lib_nomac.c \ -utils_ifc_lib.c \ -main.c +../test/test_ifc_lib.c \ +../test/utils_ifc_lib.c \ +../test/main.c s_SRC += diff --git a/test_ifc_lib/main.c b/test_ifc_lib/main.c index f2a1779..35748f9 100644 --- a/test_ifc_lib/main.c +++ b/test_ifc_lib/main.c @@ -1,6 +1,4 @@ -#include "test_ifc_lib_gen.h" -#include "test_ifc_lib_symphony.h" -#include "test_ifc_lib_nomac.h" +#include "test_ifc_lib.h" #include #include @@ -14,8 +12,6 @@ int main(int argc, char* argv[]) { UnitTest tests[] = { GEN_IFC_LIB_TESTS - SYMPHONY_IFC_LIB_TESTS - NOMAC_IFC_LIB_TESTS }; return run_tests(tests); diff --git a/test_ifc_lib/test_ifc_lib_gen.c b/test_ifc_lib/test_ifc_lib_gen.c deleted file mode 100644 index a2fde21..0000000 --- a/test_ifc_lib/test_ifc_lib_gen.c +++ /dev/null @@ -1,408 +0,0 @@ -#include "ll_ifc.h" -#include "utils_ifc_lib.h" - -#include -#include -#include -#include "cmockery.h" - -void setUp(void **state) -{ - (void) state; - ifc_utils_setup(); - ll_reset_state(); -} - -void tearDown(void **state) -{ - (void) state; - ifc_utils_teardown(); -} - -void test_myself_transport_write(void **state) -{ - (void) state; - uint8_t cmd_payload[] = {1, 2, 3, 4}; - uint8_t cmd[] = {0xff, 0xff, 0xff, 0xff, 0xc4, 1, 0, 0, 4, 1, 2, 3, 4, 0, 0}; - uint8_t rsp_payload[] = {5, 6, 7, 8}; - uint8_t rsp[TRANSPORT_LEN_MAX]; - - uint16_t crc = compute_checksum(cmd + 4, sizeof(cmd) - 6); - cmd[sizeof(cmd) - 2] = (crc >> 8) & 0xff; - cmd[sizeof(cmd) - 1] = (crc >> 0) & 0xff; - - transport_expect(1, cmd_payload, sizeof(cmd_payload), 0, rsp_payload, sizeof(rsp_payload)); - assert_int_equal(0, transport_write(cmd, sizeof(cmd))); - assert_int_equal(0, transport_read(rsp, sizeof(rsp_payload) + 8)); - assert_memory_equal(rsp_payload, rsp + 6, sizeof(rsp_payload)); -} - -void test_timestamp_get(void **state) -{ - (void) state; - uint8_t cmd[] = {0x00, 0x00, 0x00, 0x00, 0x00}; - uint8_t rsp[] = {0x11, 0x22, 0x33, 0x44}; - - transport_expect(OP_TIMESTAMP, cmd, sizeof(cmd), 0, rsp, sizeof(rsp)); - - uint32_t actual_timestamp_us = 0; - assert_int_equal(0, ll_timestamp_get(&actual_timestamp_us)); - assert_int_equal(0x11223344, actual_timestamp_us); -} - -void test_timestamp_get_with_response_error(void **state) -{ - (void) state; - uint8_t cmd[] = {0x00, 0x00, 0x00, 0x00, 0x00}; - uint8_t rsp[] = {0x11, 0x22, 0x33}; // too short - - transport_expect(OP_TIMESTAMP, cmd, sizeof(cmd), 0, rsp, sizeof(rsp)); - - uint32_t actual_timestamp_us = 0; - assert_int_equal(LL_IFC_ERROR_INCORRECT_RESPONSE_LENGTH, ll_timestamp_get(&actual_timestamp_us)); -} - -void test_timestamp_get_twice_to_check_message_identifier(void **state) -{ - (void) state; - uint8_t cmd[] = {0x00, 0x00, 0x00, 0x00, 0x00}; - uint8_t rsp[] = {0x11, 0x22, 0x33, 0x44}; - - transport_expect(OP_TIMESTAMP, cmd, sizeof(cmd), 0, rsp, sizeof(rsp)); - transport_expect(OP_TIMESTAMP, cmd, sizeof(cmd), 0, rsp, sizeof(rsp)); - - uint32_t actual_timestamp_us = 0; - assert_int_equal(0, ll_timestamp_get(&actual_timestamp_us)); - assert_int_equal(0x11223344, actual_timestamp_us); - - assert_int_equal(0, ll_timestamp_get(&actual_timestamp_us)); - assert_int_equal(0x11223344, actual_timestamp_us); -} - -void test_timestamp_set(void **state) -{ - (void) state; - uint8_t cmd[] = {0x01, 0x10, 0x20, 0x30, 0x40}; - uint8_t rsp[] = {0x11, 0x22, 0x33, 0x44}; - - transport_expect(OP_TIMESTAMP, cmd, sizeof(cmd), 0, rsp, sizeof(rsp)); - - uint32_t actual_timestamp_us = 0; - assert_int_equal(0, ll_timestamp_set(1, 0x10203040, &actual_timestamp_us)); - assert_int_equal(0x11223344, actual_timestamp_us); -} - -void test_timestamp_set_with_nack(void **state) -{ - (void) state; - uint8_t cmd[] = {0x01, 0x10, 0x20, 0x30, 0x40}; - - transport_expect(OP_TIMESTAMP, cmd, sizeof(cmd), LL_IFC_NACK_BUSY_TRY_AGAIN, 0, 0); - - uint32_t actual_timestamp_us = 0; - assert_int_equal(-LL_IFC_NACK_BUSY_TRY_AGAIN, ll_timestamp_set(1, 0x10203040, &actual_timestamp_us)); -} - -void test_nack_with_payload(void **state) -{ - (void) state; - uint8_t cmd[] = {0x01, 0x10, 0x20, 0x30, 0x40}; - uint8_t rsp[] = {1}; - - transport_expect(OP_TIMESTAMP, cmd, sizeof(cmd), LL_IFC_NACK_BUSY_TRY_AGAIN, rsp, sizeof(rsp)); - - uint32_t actual_timestamp_us = 0; - // todo : indicating a CRC error does not seem correct here - assert_int_equal(-104, ll_timestamp_set(1, 0x10203040, &actual_timestamp_us)); -} - -void test_timestamp_set_with_invalid_operation(void **state) -{ - (void) state; - //TODO: not sure what this is supposed to be testing -// uint32_t actual_timestamp_us = 0; -// printf("negative\n"); -// assert_int_equal(LL_IFC_ERROR_INCORRECT_PARAMETER, -// ll_timestamp_set((ll_timestamp_operation_t) -1, -// 0x10203040, &actual_timestamp_us)); -// printf("too big\n"); -// assert_int_equal(LL_IFC_ERROR_INCORRECT_PARAMETER, -// ll_timestamp_set((ll_timestamp_operation_t) LL_TIMESTAMP_SYNC + 1, -// 0x10203040, &actual_timestamp_us)); -} - -void test_packet_send_timestamp(void **state) -{ - (void) state; - uint8_t cmd1[] = {0x10, 0x20, 0x30, 0x40}; - - uint8_t cmd2[] = {1, 2, 3, 4, 5, 6, 7, 8}; - uint8_t rsp2[] = {0}; - - transport_expect(OP_SEND_TIMESTAMP, cmd1, sizeof(cmd1), 0, 0, 0); - transport_expect(OP_PKT_SEND_QUEUE, cmd2, sizeof(cmd2), 0, rsp2, sizeof(rsp2)); - assert_int_equal(0, ll_packet_send_timestamp(0x10203040, cmd2, sizeof(cmd2))); -} - -void test_fw_type_get_null_input(void **state) -{ - (void) state; - assert_int_equal(LL_IFC_ERROR_INCORRECT_PARAMETER, ll_firmware_type_get(NULL)); -} - -void test_fw_type_get_return_oor(void **state) -{ - (void) state; - uint8_t rsp[] = {0x11, 0x22}; // too short - - transport_expect(OP_FIRMWARE_TYPE, 0, 0, 0, rsp, sizeof(rsp)); - - ll_firmware_type_t t; - assert_int_equal(LL_IFC_ERROR_INCORRECT_RESPONSE_LENGTH, ll_firmware_type_get(&t)); -} - -void test_fw_type_get_return_ok(void **state) -{ - (void) state; - uint8_t rsp[] = {0x11, 0x22, 0x33, 0x44}; - - transport_expect(OP_FIRMWARE_TYPE, 0, 0, 0, rsp, sizeof(rsp)); - - ll_firmware_type_t t; - assert_int_equal(LL_IFC_ACK, ll_firmware_type_get(&t)); - assert_int_equal(0x1122, t.cpu_code); - assert_int_equal(0x3344, t.functionality_code); -} - -void test_hw_type_get_null_input(void **state) -{ - (void) state; - assert_int_equal(LL_IFC_ERROR_INCORRECT_PARAMETER, ll_hardware_type_get(NULL)); -} - -void test_hw_type_get_return_oor(void **state) -{ - (void) state; - uint8_t rsp[] = {0x11, 0x22}; // too short - - transport_expect(OP_HARDWARE_TYPE, 0, 0, 0, rsp, sizeof(rsp)); - - ll_hardware_type_t t; - assert_int_equal(LL_IFC_ERROR_BUFFER_TOO_SMALL, ll_hardware_type_get(&t)); -} - -void test_hw_type_get_return_ok(void **state) -{ - (void) state; - uint8_t rsp[] = {0x11}; - - transport_expect(OP_HARDWARE_TYPE, 0, 0, 0, rsp, sizeof(rsp)); - - ll_hardware_type_t t; - assert_int_equal(LL_IFC_ACK, ll_hardware_type_get(&t)); - assert_int_equal(rsp[0], t); -} - -void test_ifc_version_get_null_input(void **state) -{ - (void) state; - assert_int_equal(LL_IFC_ERROR_INCORRECT_PARAMETER, ll_interface_version_get(NULL)); -} - -void test_ifc_version_get_return_oor(void **state) -{ - (void) state; - uint8_t rsp[] = {0x11, 0x22}; // too short - - transport_expect(OP_IFC_VERSION, 0, 0, 0, rsp, sizeof(rsp)); - - ll_version_t v; - assert_int_equal(LL_IFC_ERROR_INCORRECT_RESPONSE_LENGTH, ll_interface_version_get(&v)); -} - -void test_ifc_version_get_return_ok(void **state) -{ - (void) state; - uint8_t rsp[] = {0x11, 0x22, 0x33, 0x44}; - - transport_expect(OP_IFC_VERSION, 0, 0, 0, rsp, sizeof(rsp)); - - ll_version_t v; - assert_int_equal(LL_IFC_ACK, ll_interface_version_get(&v)); - assert_int_equal(0x11, v.major); - assert_int_equal(0x22, v.minor); - assert_int_equal(0x3344, v.tag); -} - -void test_version_get_null_input(void **state) -{ - (void) state; - assert_int_equal(LL_IFC_ERROR_INCORRECT_PARAMETER, ll_version_get(NULL)); -} - -void test_version_get_return_oor(void **state) -{ - (void) state; - uint8_t rsp[] = {0x11, 0x22}; // too short - - transport_expect(OP_VERSION, 0, 0, 0, rsp, sizeof(rsp)); - - ll_version_t v; - assert_int_equal(LL_IFC_ERROR_INCORRECT_RESPONSE_LENGTH, ll_version_get(&v)); -} - -void test_version_get_return_ok(void **state) -{ - (void) state; - uint8_t rsp[] = {0x11, 0x22, 0x33, 0x44}; - - transport_expect(OP_VERSION, 0, 0, 0, rsp, sizeof(rsp)); - - ll_version_t v; - assert_int_equal(LL_IFC_ACK, ll_version_get(&v)); - assert_int_equal(0x11, v.major); - assert_int_equal(0x22, v.minor); - assert_int_equal(0x3344, v.tag); -} - -void test_sleep_block_ok(void **state) -{ - (void)state; - uint8_t cmd[] = {'1'}; - - transport_expect(OP_SLEEP_BLOCK, cmd, sizeof(cmd), 0, 0, 0); - assert_int_equal(LL_IFC_ACK, ll_sleep_block()); -} - -void test_sleep_unblock_ok(void **state) -{ - (void)state; - uint8_t cmd[] = {'0'}; - - transport_expect(OP_SLEEP_BLOCK, cmd, sizeof(cmd), 0, 0, 0); - assert_int_equal(LL_IFC_ACK, ll_sleep_unblock()); -} - -void test_mac_mode_set_invalid_mode(void **state) -{ - (void) state; - assert_int_equal(LL_IFC_ERROR_INCORRECT_PARAMETER, ll_mac_mode_set(NUM_MACS)); -} - -void test_mac_mode_set_ok(void **state) -{ - (void) state; - uint8_t cmd[] = {0x03}; - - transport_expect(OP_MAC_MODE_SET, cmd, sizeof(cmd), 0, 0, 0); - assert_int_equal(LL_IFC_ACK, ll_mac_mode_set(SYMPHONY_LINK)); -} - -void test_mac_mode_get_null_input(void **state) -{ - (void) state; - assert_int_equal(LL_IFC_ERROR_INCORRECT_PARAMETER, ll_mac_mode_get(NULL)); -} - -void test_mac_mode_get_ok(void **state) -{ - (void) state; - uint8_t rsp[] = {0x03}; - ll_mac_type_t t = LORA_NO_MAC; - - transport_expect(OP_MAC_MODE_GET, 0, 0, 0, rsp, sizeof(rsp)); - assert_int_equal(LL_IFC_ACK, ll_mac_mode_get(&t)); - - assert_int_equal(SYMPHONY_LINK, t); -} - -void test_antenna_set_invalid_input(void **state) -{ - (void) state; - assert_int_equal(LL_IFC_ERROR_INCORRECT_PARAMETER, ll_antenna_set(0)); -} - -void test_antenna_set_ok(void **state) -{ - (void) state; - uint8_t cmd[] = {0x02}; - - transport_expect(OP_ANTENNA_SET, cmd, sizeof(cmd), 0, 0, 0); - assert_int_equal(LL_IFC_ACK, ll_antenna_set(2)); -} - -void test_antenna_get_invalid_input(void **state) -{ - (void) state; - assert_int_equal(LL_IFC_ERROR_INCORRECT_PARAMETER, ll_antenna_get(NULL)); -} - -void test_antenna_get_ok(void **state) -{ - (void) state; - uint8_t rsp[] = {0x02}; - uint8_t ant = 0; - - transport_expect(OP_ANTENNA_GET, 0, 0, 0, rsp, sizeof(rsp)); - assert_int_equal(LL_IFC_ACK, ll_antenna_get(&ant)); - assert_int_equal(2, ant); -} - -void test_unique_id_get_invalid_input(void **state) -{ - (void) state; - assert_int_equal(LL_IFC_ERROR_INCORRECT_PARAMETER, ll_unique_id_get(NULL)); -} - -void test_unique_id_get_oor(void **state) -{ - (void) state; - uint8_t rsp[] = {0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77}; - uint64_t uid = 0; - - transport_expect(OP_MODULE_ID, 0, 0, 0, rsp, sizeof(rsp)); - assert_int_equal(LL_IFC_ERROR_INCORRECT_RESPONSE_LENGTH, ll_unique_id_get(&uid)); -} - -void test_unique_id_get_ok(void **state) -{ - (void) state; - uint8_t rsp[] = {0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88}; - uint64_t uid = 0; - - transport_expect(OP_MODULE_ID, 0, 0, 0, rsp, sizeof(rsp)); - assert_int_equal(LL_IFC_ACK, ll_unique_id_get(&uid)); - assert_int_equal(0x1122334455667788, uid); -} - -void test_irq_flags_invalid_input(void **state) -{ - (void) state; - assert_int_equal(LL_IFC_ERROR_INCORRECT_PARAMETER, ll_irq_flags(0, NULL)); -} - -void test_irq_flags_oor(void **state) -{ - (void) state; - uint8_t cmd[] = {0xa5, 0x00, 0x00, 0x5a}; - uint8_t rsp[] = {0x11, 0x22, 0x33}; - uint32_t flags = 0; - - transport_expect(OP_IRQ_FLAGS, cmd, sizeof(cmd), 0, rsp, sizeof(rsp)); - assert_int_equal(LL_IFC_ERROR_INCORRECT_RESPONSE_LENGTH, ll_irq_flags(0xa500005a, &flags)); - assert_int_equal(0, flags); -} - -void test_irq_flags_ok(void **state) -{ - (void) state; - uint8_t cmd[] = {0xa5, 0x00, 0x00, 0x5a}; - uint8_t rsp[] = {0x11, 0x22, 0x33, 0x44}; - uint32_t flags = 0; - - transport_expect(OP_IRQ_FLAGS, cmd, sizeof(cmd), 0, rsp, sizeof(rsp)); - assert_int_equal(LL_IFC_ACK, ll_irq_flags(0xa500005a, &flags)); - assert_int_equal(0x11223344, flags); -} - - diff --git a/test_ifc_lib/test_ifc_lib_gen.h b/test_ifc_lib/test_ifc_lib_gen.h deleted file mode 100644 index a358944..0000000 --- a/test_ifc_lib/test_ifc_lib_gen.h +++ /dev/null @@ -1,83 +0,0 @@ - -void setUp(void **state); -void tearDown(void **state); - -void test_myself_transport_write(void **state); -void test_timestamp_get(void **state); -void test_timestamp_get_with_response_error(void **state); -void test_timestamp_get_twice_to_check_message_identifier(void **state); -void test_timestamp_set(void **state); -void test_timestamp_set_with_nack(void **state); -void test_nack_with_payload(void **state); -void test_timestamp_set_with_invalid_operation(void **state); -void test_packet_send_timestamp(void **state); -void test_fw_type_get_null_input(void **state); -void test_fw_type_get_return_oor(void **state); -void test_fw_type_get_return_ok(void **state); -void test_hw_type_get_null_input(void **state); -void test_hw_type_get_return_oor(void **state); -void test_hw_type_get_return_ok(void **state); -void test_ifc_version_get_null_input(void **state); -void test_ifc_version_get_return_oor(void **state); -void test_ifc_version_get_return_ok(void **state); -void test_version_get_null_input(void **state); -void test_version_get_return_oor(void **state); -void test_version_get_return_ok(void **state); -void test_sleep_block_ok(void **state); -void test_sleep_unblock_ok(void **state); -void test_mac_mode_set_invalid_mode(void **state); -void test_mac_mode_set_ok(void **state); -void test_mac_mode_get_null_input(void **state); -void test_mac_mode_get_ok(void **state); -void test_antenna_set_invalid_input(void **state); -void test_antenna_set_ok(void **state); -void test_antenna_get_invalid_input(void **state); -void test_antenna_get_ok(void **state); -void test_unique_id_get_invalid_input(void **state); -void test_unique_id_get_oor(void **state); -void test_unique_id_get_ok(void **state); -void test_irq_flags_invalid_input(void **state); -void test_irq_flags_oor(void **state); -void test_irq_flags_ok(void **state); - - -#define GEN_IFC_LIB_TESTS \ - unit_test_setup_teardown(test_myself_transport_write, setUp, tearDown), \ - unit_test_setup_teardown(test_timestamp_get, setUp, tearDown), \ - unit_test_setup_teardown(test_timestamp_get_with_response_error, setUp, tearDown), \ - unit_test_setup_teardown(test_timestamp_get_twice_to_check_message_identifier, setUp, tearDown), \ - unit_test_setup_teardown(test_timestamp_set, setUp, tearDown), \ - unit_test_setup_teardown(test_timestamp_set_with_nack, setUp, tearDown), \ - unit_test_setup_teardown(test_nack_with_payload, setUp, tearDown), \ - unit_test_setup_teardown(test_timestamp_set_with_invalid_operation, setUp, tearDown), \ - unit_test_setup_teardown(test_packet_send_timestamp, setUp, tearDown), \ - unit_test_setup_teardown(test_fw_type_get_null_input, setUp, tearDown), \ - unit_test_setup_teardown(test_fw_type_get_return_oor, setUp, tearDown), \ - unit_test_setup_teardown(test_fw_type_get_return_ok, setUp, tearDown), \ - unit_test_setup_teardown(test_hw_type_get_null_input, setUp, tearDown), \ - unit_test_setup_teardown(test_hw_type_get_return_oor, setUp, tearDown), \ - unit_test_setup_teardown(test_hw_type_get_return_ok, setUp, tearDown), \ - unit_test_setup_teardown(test_ifc_version_get_null_input, setUp, tearDown), \ - unit_test_setup_teardown(test_ifc_version_get_return_oor, setUp, tearDown), \ - unit_test_setup_teardown(test_ifc_version_get_return_ok, setUp, tearDown), \ - unit_test_setup_teardown(test_version_get_null_input, setUp, tearDown), \ - unit_test_setup_teardown(test_version_get_return_oor, setUp, tearDown), \ - unit_test_setup_teardown(test_version_get_return_ok, setUp, tearDown), \ - unit_test_setup_teardown(test_sleep_block_ok, setUp, tearDown), \ - unit_test_setup_teardown(test_sleep_unblock_ok, setUp, tearDown), \ - unit_test_setup_teardown(test_mac_mode_set_invalid_mode, setUp, tearDown), \ - unit_test_setup_teardown(test_mac_mode_set_ok, setUp, tearDown), \ - unit_test_setup_teardown(test_mac_mode_get_null_input, setUp, tearDown), \ - unit_test_setup_teardown(test_mac_mode_get_ok, setUp, tearDown), \ - unit_test_setup_teardown(test_antenna_set_invalid_input, setUp, tearDown), \ - unit_test_setup_teardown(test_antenna_set_ok, setUp, tearDown), \ - unit_test_setup_teardown(test_antenna_get_invalid_input, setUp, tearDown), \ - unit_test_setup_teardown(test_antenna_get_ok, setUp, tearDown), \ - unit_test_setup_teardown(test_unique_id_get_invalid_input, setUp, tearDown), \ - unit_test_setup_teardown(test_unique_id_get_oor, setUp, tearDown), \ - unit_test_setup_teardown(test_unique_id_get_ok, setUp, tearDown), \ - unit_test_setup_teardown(test_irq_flags_invalid_input, setUp, tearDown), \ - unit_test_setup_teardown(test_irq_flags_oor, setUp, tearDown), \ - unit_test_setup_teardown(test_irq_flags_ok, setUp, tearDown), \ - - diff --git a/test_ifc_lib/test_ifc_lib_nomac.c b/test_ifc_lib/test_ifc_lib_nomac.c deleted file mode 100644 index c835742..0000000 --- a/test_ifc_lib/test_ifc_lib_nomac.c +++ /dev/null @@ -1,323 +0,0 @@ -#include "ll_ifc_no_mac.h" -#include "ll_ifc.h" -#include "utils_ifc_lib.h" - -#include -#include -#include -#include "cmockery.h" - -void test_rssi_scan_set_ok(void **state) -{ - (void) state; - uint8_t cmd[16] = {0}; - transport_expect(OP_RSSI_SET, cmd, sizeof(cmd), 0, 0, 0); - assert_int_equal(LL_IFC_ACK, ll_rssi_scan_set(0, 0, 0, 0)); -} - -void test_rssi_scan_get_invalid(void **state) -{ - (void) state; - assert_int_equal(LL_IFC_ERROR_INCORRECT_PARAMETER, ll_rssi_scan_get(NULL, 1, 1)); - assert_int_equal(LL_IFC_ERROR_INCORRECT_PARAMETER, ll_rssi_scan_get(1, 0, 1)); - assert_int_equal(LL_IFC_ERROR_INCORRECT_PARAMETER, ll_rssi_scan_get(1, 1, NULL)); -} - -void test_rssi_scan_get_short_length(void **state) -{ - (void) state; - uint8_t buf[255] = {0}; - uint8_t bytes_received = 0xff; - - uint8_t rsp[16] = {0}; - transport_expect(OP_RSSI_GET, 0, 0, 0, rsp, sizeof(rsp)); - - assert_int_equal(LL_IFC_ERROR_BUFFER_TOO_SMALL, ll_rssi_scan_get(buf, 1, &bytes_received)); - assert_int_equal(0, bytes_received); -} - -void test_rssi_scan_get_ok(void **state) -{ - (void) state; - uint8_t buf[255] = {0}; - uint8_t bytes_received = 0xff; - - uint8_t rsp[16] = {0}; - transport_expect(OP_RSSI_GET, 0, 0, 0, rsp, sizeof(rsp)); - assert_int_equal(LL_IFC_ACK, ll_rssi_scan_get(buf, 255, &bytes_received)); - assert_int_equal(16, bytes_received); -} - -void test_radio_params_get_invalid(void **state) -{ - (void) state; - assert_int_equal(LL_IFC_ERROR_INCORRECT_PARAMETER, ll_radio_params_get(NULL, 1, 1, 1, 1, 1, 1, 1)); - assert_int_equal(LL_IFC_ERROR_INCORRECT_PARAMETER, ll_radio_params_get(1, NULL, 1, 1, 1, 1, 1, 1)); - assert_int_equal(LL_IFC_ERROR_INCORRECT_PARAMETER, ll_radio_params_get(1, 1, NULL, 1, 1, 1, 1, 1)); - assert_int_equal(LL_IFC_ERROR_INCORRECT_PARAMETER, ll_radio_params_get(1, 1, 1, NULL, 1, 1, 1, 1)); - assert_int_equal(LL_IFC_ERROR_INCORRECT_PARAMETER, ll_radio_params_get(1, 1, 1, 1, NULL, 1, 1, 1)); - assert_int_equal(LL_IFC_ERROR_INCORRECT_PARAMETER, ll_radio_params_get(1, 1, 1, 1, 1, NULL, 1, 1)); - assert_int_equal(LL_IFC_ERROR_INCORRECT_PARAMETER, ll_radio_params_get(1, 1, 1, 1, 1, 1, NULL, 1)); - assert_int_equal(LL_IFC_ERROR_INCORRECT_PARAMETER, ll_radio_params_get(1, 1, 1, 1, 1, 1, 1, NULL)); -} - -void test_radio_params_get_incorrect_length(void **state) -{ - (void) state; - uint8_t sf, cr, bw, header_enabled, crc_enabled, iq_inverted; - uint32_t freq; - uint16_t preamble_syms; - - uint8_t rsp[7] = {0}; - transport_expect(OP_GET_RADIO_PARAMS, 0, 0, 0, rsp, sizeof(rsp)); - - assert_int_equal(LL_IFC_ERROR_INCORRECT_RESPONSE_LENGTH, ll_radio_params_get(&sf, &cr, &bw, &freq, &preamble_syms, - &header_enabled, &crc_enabled, &iq_inverted)); -} - -void test_radio_params_get_ok(void **state) -{ - (void) state; - uint8_t sf, cr, bw, header_enabled, crc_enabled, iq_inverted; - uint32_t freq; - uint16_t preamble_syms; - - uint8_t rsp[] = {0x37, 0x03, 0x12, 0x34, 0x36, 0x89, 0xca, 0xc0}; - transport_expect(OP_GET_RADIO_PARAMS, 0, 0, 0, rsp, sizeof(rsp)); - - assert_int_equal(LL_IFC_ACK, ll_radio_params_get(&sf, &cr, &bw, &freq, &preamble_syms, - &header_enabled, &crc_enabled, &iq_inverted)); - assert_int_equal(9, sf); - assert_int_equal(2, cr); - assert_int_equal(3, bw); - assert_int_equal(1, header_enabled); - assert_int_equal(1, crc_enabled != 0); - assert_int_equal(0, iq_inverted); - assert_int_equal(915000000, freq); - assert_int_equal(0x1234, preamble_syms); -} - -void test_radio_params_set_invalid(void **state) -{ - (void) state; - assert_int_equal(LL_IFC_ERROR_INCORRECT_PARAMETER, ll_radio_params_set(RADIO_PARAM_FLAGS_SF, 3, 0, 0, 0, 0, 0, 0, 0)); - assert_int_equal(LL_IFC_ERROR_INCORRECT_PARAMETER, ll_radio_params_set(RADIO_PARAM_FLAGS_CR, 0, 5, 0, 0, 0, 0, 0, 0)); - assert_int_equal(LL_IFC_ERROR_INCORRECT_PARAMETER, ll_radio_params_set(RADIO_PARAM_FLAGS_BW, 0, 0, 4, 0, 0, 0, 0, 0)); -} - -void test_radio_params_set_ok(void **state) -{ - (void) state; - uint8_t flags = RADIO_PARAM_FLAGS_SF | RADIO_PARAM_FLAGS_CR | RADIO_PARAM_FLAGS_BW | RADIO_PARAM_FLAGS_HEADER | - RADIO_PARAM_FLAGS_CRC | RADIO_PARAM_FLAGS_IQ | RADIO_PARAM_FLAGS_PREAMBLE | RADIO_PARAM_FLAGS_FREQ; - uint8_t sf = 9; - uint8_t cr = 1; - uint8_t bw = 3; - uint32_t freq = 915000000; - uint16_t preamble_syms = 8; - uint8_t enable_header = 1; - uint8_t enable_crc = 1; - uint8_t enable_iq_inversion = 1; - - uint8_t cmd[] = {flags, ((sf-6)<<4)|((cr-1)<<2)|(bw), 7, 0, preamble_syms, 0x36, 0x89, 0xca, 0xc0}; - transport_expect(OP_SET_RADIO_PARAMS, cmd, sizeof(cmd), 0, 0, 0); - - assert_int_equal(LL_IFC_ACK, ll_radio_params_set(flags, sf, cr, bw, freq, preamble_syms, - enable_header, enable_crc, enable_iq_inversion)); -} - -void test_tx_power_set_invalid(void **state) -{ - (void)state; - assert_int_equal(LL_IFC_ERROR_INCORRECT_PARAMETER, ll_tx_power_set(27)); -} - -void test_tx_power_set_ok(void **state) -{ - (void)state; - - uint8_t cmd[] = {20}; - transport_expect(OP_TX_POWER_SET, cmd, sizeof(cmd), 0, 0, 0); - - assert_int_equal(LL_IFC_ACK, ll_tx_power_set(20)); -} - -void test_tx_power_get_invalid(void **state) -{ - (void)state; - assert_int_equal(LL_IFC_ERROR_INCORRECT_PARAMETER, ll_tx_power_get(NULL)); -} - -void test_tx_power_get_ok(void **state) -{ - (void)state; - uint8_t pwr = 0; - uint8_t rsp[] = {18}; - transport_expect(OP_TX_POWER_GET, 0, 0, 0, rsp, sizeof(rsp)); - - assert_int_equal(LL_IFC_ACK, ll_tx_power_get(&pwr)); - assert_int_equal(18, pwr); -} - -void test_sync_word_set_ok(void **state) -{ - (void)state; - uint8_t sync_word = 0xa5; - - uint8_t cmd[] = {0xa5}; - transport_expect(OP_SYNC_WORD_SET, cmd, sizeof(cmd), 0, 0, 0); - - assert_int_equal(LL_IFC_ACK, ll_sync_word_set(sync_word)); -} - -void test_sync_word_get_invalid(void **state) -{ - (void)state; - assert_int_equal(LL_IFC_ERROR_INCORRECT_PARAMETER, ll_sync_word_get(NULL)); -} - -void test_sync_word_get_ok(void **state) -{ - (void)state; - uint8_t sync_word = 0; - - uint8_t rsp[] = {0xa5}; - transport_expect(OP_SYNC_WORD_GET, 0, 0, 0, rsp, sizeof(rsp)); - - assert_int_equal(LL_IFC_ACK, ll_sync_word_get(&sync_word)); - assert_int_equal(0xa5, sync_word); -} - -void test_echo_mode_ok(void **state) -{ - (void)state; - transport_expect(OP_PKT_ECHO, 0, 0, 0, 0, 0); - assert_int_equal(LL_IFC_ACK, ll_echo_mode()); -} - -void test_packet_send_queue_invalid(void **state) -{ - (void)state; - assert_int_equal(LL_IFC_ERROR_INCORRECT_PARAMETER, ll_packet_send_queue(NULL, 1)); - assert_int_equal(LL_IFC_ERROR_INCORRECT_PARAMETER, ll_packet_send_queue(1, 0)); -} - -void test_packet_send_queue_queued(void **state) -{ - (void)state; - uint8_t buf[] = {0x11, 0x22, 0x33, 0x44, 0x55}; - uint16_t len = 5; - - uint8_t cmd[] = {0x11, 0x22, 0x33, 0x44, 0x55}; - uint8_t rsp[] = {1}; - transport_expect(OP_PKT_SEND_QUEUE, cmd, sizeof(cmd), 0, rsp, sizeof(rsp)); - - assert_int_equal(1, ll_packet_send_queue(buf, len)); -} - -void test_packet_send_queue_full(void **state) -{ - (void)state; - uint8_t buf[] = {0x11, 0x22, 0x33, 0x44, 0x55}; - uint16_t len = 5; - - uint8_t cmd[] = {0x11, 0x22, 0x33, 0x44, 0x55}; - uint8_t rsp[] = {0}; - transport_expect(OP_PKT_SEND_QUEUE, cmd, sizeof(cmd), 0, rsp, sizeof(rsp)); - - assert_int_equal(0, ll_packet_send_queue(buf, len)); -} - -void test_packet_send_queue_error(void **state) -{ - (void)state; - uint8_t buf[] = {0x11, 0x22, 0x33, 0x44, 0x55}; - uint16_t len = 5; - - uint8_t cmd[] = {0x11, 0x22, 0x33, 0x44, 0x55}; - uint8_t rsp[] = {-1}; - transport_expect(OP_PKT_SEND_QUEUE, cmd, sizeof(cmd), 0, rsp, sizeof(rsp)); - - assert_int_equal(-1, (int8_t)ll_packet_send_queue(buf, len)); -} - -void test_transmit_cw_ok(void **state) -{ - (void)state; - transport_expect(OP_TX_CW, 0, 0, 0, 0, 0); - assert_int_equal(LL_IFC_ACK, ll_transmit_cw()); -} - -void test_packet_recv_cont_invalid(void **state) -{ - (void)state; - assert_int_equal(LL_IFC_ERROR_INCORRECT_PARAMETER, ll_packet_recv_cont(NULL, 1, 1, false)); - assert_int_equal(LL_IFC_ERROR_INCORRECT_PARAMETER, ll_packet_recv_cont(1, 0, 1, false)); - assert_int_equal(LL_IFC_ERROR_INCORRECT_PARAMETER, ll_packet_recv_cont(1, 1, NULL, false)); -} - -void test_packet_recv_cont_small_length(void **state) -{ - (void)state; - uint8_t buf[] = {0x11, 0x22}; - uint16_t len = sizeof(buf); - uint8_t bytes_received = 0; - bool freq_error_requested = false; - - uint8_t rsp[] = {0x11, 0x22, 0x33, 0x44, 0x55}; - transport_expect(OP_PKT_RECV_CONT, 0, 0, 0, rsp, sizeof(rsp)); - assert_int_equal(LL_IFC_ERROR_BUFFER_TOO_SMALL, ll_packet_recv_cont(buf, len, &bytes_received, freq_error_requested)); -} - -void test_packet_recv_cont_ok(void **state) -{ - (void)state; - uint8_t buf[255] = {0}; - uint16_t len = sizeof(buf); - uint8_t bytes_received = 0; - bool freq_error_requested = false; - - uint8_t rsp[] = {0x11, 0x22, 0x33, 0x44, 0x55}; - transport_expect(OP_PKT_RECV_CONT, 0, 0, 0, rsp, sizeof(rsp)); - assert_int_equal(LL_IFC_ACK, ll_packet_recv_cont(buf, len, &bytes_received, freq_error_requested)); - assert_memory_equal(buf, rsp, bytes_received); -} - -void test_packet_recv_with_rssi_invalid(void **state) -{ - (void)state; - assert_int_equal(LL_IFC_ERROR_INCORRECT_PARAMETER, ll_packet_recv_with_rssi(0, NULL, 1, 1, false)); - assert_int_equal(LL_IFC_ERROR_INCORRECT_PARAMETER, ll_packet_recv_with_rssi(0, 1, 0, 1, false)); - assert_int_equal(LL_IFC_ERROR_INCORRECT_PARAMETER, ll_packet_recv_with_rssi(0, 1, 1, NULL, false)); -} - -void test_packet_recv_with_rssi_small_length(void **state) -{ - (void)state; - uint8_t buf[] = {0x11, 0x22}; - uint16_t len = sizeof(buf); - uint8_t bytes_received = 0; - uint16_t num_timeout_symbols = 0x4455; - bool freq_error_requested = false; - - uint8_t cmd[] = {0x44, 0x55}; - uint8_t rsp[] = {0x11, 0x22, 0x33, 0x44, 0x55}; - transport_expect(OP_MSG_RECV_RSSI, cmd, sizeof(cmd), 0, rsp, sizeof(rsp)); - assert_int_equal(LL_IFC_ERROR_BUFFER_TOO_SMALL, ll_packet_recv_with_rssi(num_timeout_symbols, buf, len, &bytes_received, freq_error_requested)); -} - -void test_packet_recv_with_rssi_ok(void **state) -{ - (void)state; - uint8_t buf[255] = {0}; - uint16_t len = sizeof(buf); - uint8_t bytes_received = 0; - uint16_t num_timeout_symbols = 0x4455; - bool freq_error_requested = false; - - uint8_t cmd[] = {0x44, 0x55}; - uint8_t rsp[] = {0x11, 0x22, 0x33, 0x44, 0x55}; - transport_expect(OP_MSG_RECV_RSSI, cmd, sizeof(cmd), 0, rsp, sizeof(rsp)); - assert_int_equal(LL_IFC_ACK, ll_packet_recv_with_rssi(num_timeout_symbols, buf, len, &bytes_received, freq_error_requested)); -} - diff --git a/test_ifc_lib/test_ifc_lib_nomac.h b/test_ifc_lib/test_ifc_lib_nomac.h deleted file mode 100644 index a6435fe..0000000 --- a/test_ifc_lib/test_ifc_lib_nomac.h +++ /dev/null @@ -1,64 +0,0 @@ -#include "test_ifc_lib_gen.h" - -void test_rssi_scan_set_ok(void **state); -void test_rssi_scan_get_invalid(void **state); -void test_rssi_scan_get_short_length(void **state); -void test_rssi_scan_get_ok(void **state); -void test_radio_params_get_invalid(void **state); -void test_radio_params_get_incorrect_length(void **state); -void test_radio_params_get_ok(void **state); -void test_radio_params_set_invalid(void **state); -void test_radio_params_set_ok(void **state); -void test_tx_power_set_invalid(void **state); -void test_tx_power_set_ok(void **state); -void test_tx_power_get_invalid(void **state); -void test_tx_power_get_ok(void **state); -void test_sync_word_set_ok(void **state); -void test_sync_word_get_invalid(void **state); -void test_sync_word_get_ok(void **state); -void test_echo_mode_ok(void **state); -void test_packet_send_queue_invalid(void **state); -void test_packet_send_queue_queued(void **state); -void test_packet_send_queue_full(void **state); -void test_packet_send_queue_error(void **state); -void test_transmit_cw_ok(void **state); -void test_packet_recv_cont_invalid(void **state); -void test_packet_recv_cont_small_length(void **state); -void test_packet_recv_cont_ok(void **state); -void test_packet_recv_with_rssi_invalid(void **state); -void test_packet_recv_with_rssi_small_length(void **state); -void test_packet_recv_with_rssi_ok(void **state); - -#define NOMAC_IFC_LIB_TESTS \ - unit_test_setup_teardown(test_rssi_scan_set_ok, setUp, tearDown), \ - unit_test_setup_teardown(test_rssi_scan_get_invalid, setUp, tearDown), \ - unit_test_setup_teardown(test_rssi_scan_get_short_length, setUp, tearDown), \ - unit_test_setup_teardown(test_rssi_scan_get_ok, setUp, tearDown), \ - unit_test_setup_teardown(test_radio_params_get_invalid, setUp, tearDown), \ - unit_test_setup_teardown(test_radio_params_get_incorrect_length, setUp, tearDown), \ - unit_test_setup_teardown(test_radio_params_get_ok, setUp, tearDown), \ - unit_test_setup_teardown(test_radio_params_set_invalid, setUp, tearDown), \ - unit_test_setup_teardown(test_radio_params_set_ok, setUp, tearDown), \ - unit_test_setup_teardown(test_tx_power_set_invalid, setUp, tearDown), \ - unit_test_setup_teardown(test_tx_power_set_ok, setUp, tearDown), \ - unit_test_setup_teardown(test_tx_power_get_invalid, setUp, tearDown), \ - unit_test_setup_teardown(test_tx_power_get_ok, setUp, tearDown), \ - unit_test_setup_teardown(test_sync_word_set_ok, setUp, tearDown), \ - unit_test_setup_teardown(test_sync_word_get_invalid, setUp, tearDown), \ - unit_test_setup_teardown(test_sync_word_get_ok, setUp, tearDown), \ - unit_test_setup_teardown(test_echo_mode_ok, setUp, tearDown), \ - unit_test_setup_teardown(test_packet_send_queue_invalid, setUp, tearDown), \ - unit_test_setup_teardown(test_packet_send_queue_queued, setUp, tearDown), \ - unit_test_setup_teardown(test_packet_send_queue_full, setUp, tearDown), \ - unit_test_setup_teardown(test_packet_send_queue_error, setUp, tearDown), \ - unit_test_setup_teardown(test_transmit_cw_ok, setUp, tearDown), \ - unit_test_setup_teardown(test_packet_recv_cont_invalid, setUp, tearDown), \ - unit_test_setup_teardown(test_packet_recv_cont_small_length, setUp, tearDown), \ - unit_test_setup_teardown(test_packet_recv_cont_ok, setUp, tearDown), \ - unit_test_setup_teardown(test_packet_recv_with_rssi_invalid, setUp, tearDown), \ - unit_test_setup_teardown(test_packet_recv_with_rssi_small_length, setUp, tearDown), \ - unit_test_setup_teardown(test_packet_recv_with_rssi_ok, setUp, tearDown), \ - - - - diff --git a/test_ifc_lib/test_ifc_lib_symphony.c b/test_ifc_lib/test_ifc_lib_symphony.c deleted file mode 100644 index 18ac20a..0000000 --- a/test_ifc_lib/test_ifc_lib_symphony.c +++ /dev/null @@ -1,622 +0,0 @@ -#include "ll_ifc_symphony.h" -#include "utils_ifc_lib.h" - -#include -#include -#include -#include "cmockery.h" - -void test_config_set_net_token_invalid(void **state) -{ - (void) state; - uint32_t net_token = 0xffffffff; - uint8_t app_token[] = {0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88, 0x99, 0xaa}; - enum ll_downlink_mode dl_mode = LL_DL_MAILBOX; - uint8_t qos = 8; - - assert_int_equal(LL_IFC_ERROR_INCORRECT_PARAMETER, ll_config_set(net_token, app_token, dl_mode, qos)); -} - -void test_config_set_app_token_invalid(void **state) -{ - (void) state; - uint32_t net_token = 0x11223344; - uint8_t* app_token = NULL; - enum ll_downlink_mode dl_mode = LL_DL_MAILBOX; - uint8_t qos = 8; - - uint8_t cmd[] = {0x11, 0x22, 0x33, 0x44}; - transport_expect(OP_NET_TOKEN_SET, cmd, sizeof(cmd), 0, 0, 0); - - assert_int_equal(LL_IFC_ERROR_INCORRECT_PARAMETER, ll_config_set(net_token, app_token, dl_mode, qos)); -} - -void test_config_set_dl_mode_invalid(void **state) -{ - (void) state; - uint32_t net_token = 0x11223344; - uint8_t app_token[] = {0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88, 0x99, 0xaa}; - enum ll_downlink_mode dl_mode = NUM_DOWNLINK_MODES; - uint8_t qos = 8; - - uint8_t cmd1[] = {0x11, 0x22, 0x33, 0x44}; - transport_expect(OP_NET_TOKEN_SET, cmd1, sizeof(cmd1), 0, 0, 0); - - transport_expect(OP_APP_TOKEN_SET, app_token, sizeof(app_token), 0, 0, 0); - - assert_int_equal(LL_IFC_ERROR_INCORRECT_PARAMETER, ll_config_set(net_token, app_token, dl_mode, qos)); -} - -void test_config_set_qos_invalid(void **state) -{ - (void) state; - uint32_t net_token = 0x11223344; - uint8_t app_token[] = {0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88, 0x99, 0xaa}; - enum ll_downlink_mode dl_mode = NUM_DOWNLINK_MODES; - uint8_t qos = 16; - - uint8_t cmd1[] = {0x11, 0x22, 0x33, 0x44}; - transport_expect(OP_NET_TOKEN_SET, cmd1, sizeof(cmd1), 0, 0, 0); - transport_expect(OP_APP_TOKEN_SET, app_token, sizeof(app_token), 0, 0, 0); - transport_expect(OP_RX_MODE_SET, (uint8_t*)&dl_mode, 1, 0, 0, 0); - - assert_int_equal(LL_IFC_ERROR_INCORRECT_PARAMETER, ll_config_set(net_token, app_token, dl_mode, qos)); -} - -void test_config_set_ok(void **state) -{ - (void) state; - uint32_t net_token = 0x11223344; - uint8_t app_token[] = {0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88, 0x99, 0xaa}; - enum ll_downlink_mode dl_mode = LL_DL_MAILBOX; - uint8_t qos = 8; - - uint8_t cmd1[] = {0x11, 0x22, 0x33, 0x44}; - transport_expect(OP_NET_TOKEN_SET, cmd1, sizeof(cmd1), 0, 0, 0); - transport_expect(OP_APP_TOKEN_SET, app_token, sizeof(app_token), 0, 0, 0); - transport_expect(OP_RX_MODE_SET, (uint8_t*)&dl_mode, 1, 0, 0, 0); - transport_expect(OP_QOS_REQUEST, &qos, 1, 0, 0, 0); - - assert_int_equal(LL_IFC_ACK, ll_config_set(net_token, app_token, dl_mode, qos)); -} - -void test_config_get_net_token_invalid(void **state) -{ - (void) state; - uint8_t app_token[APP_TOKEN_LEN] = {0}; - enum ll_downlink_mode dl_mode = NUM_DOWNLINK_MODES; - uint8_t qos = 0xff; - - assert_int_equal(LL_IFC_ERROR_INCORRECT_PARAMETER, ll_config_get(NULL, app_token, &dl_mode, &qos)); -} - -void test_config_get_net_token_incorrect_length(void **state) -{ - (void) state; - uint32_t net_token = 0xffffffff; - uint8_t app_token[APP_TOKEN_LEN] = {0}; - enum ll_downlink_mode dl_mode = NUM_DOWNLINK_MODES; - uint8_t qos = 0xff; - - uint8_t rsp[] = {0x11, 0x22, 0x33}; - transport_expect(OP_NET_TOKEN_GET, 0, 0, 0, rsp, sizeof(rsp)); - - assert_int_equal(LL_IFC_ERROR_INCORRECT_RESPONSE_LENGTH, ll_config_get(&net_token, app_token, &dl_mode, &qos)); - assert_int_equal(0xffffffff, net_token); -} - - -void test_config_get_app_token_invalid(void **state) -{ - (void) state; - uint32_t net_token = 0xffffffff; - enum ll_downlink_mode dl_mode = NUM_DOWNLINK_MODES; - uint8_t qos = 0xff; - - uint8_t rsp[] = {0x11, 0x22, 0x33, 0x44}; - transport_expect(OP_NET_TOKEN_GET, 0, 0, 0, rsp, sizeof(rsp)); - - assert_int_equal(LL_IFC_ERROR_INCORRECT_PARAMETER, ll_config_get(&net_token, NULL, &dl_mode, &qos)); - assert_int_equal(0x11223344, net_token); -} - -void test_config_get_app_token_incorrect_length(void **state) -{ - (void) state; - uint32_t net_token = 0xffffffff; - uint8_t app_token[APP_TOKEN_LEN] = {0}; - enum ll_downlink_mode dl_mode = NUM_DOWNLINK_MODES; - uint8_t qos = 0xff; - - uint8_t rsp1[] = {0x11, 0x22, 0x33, 0x44}; - transport_expect(OP_NET_TOKEN_GET, 0, 0, 0, rsp1, sizeof(rsp1)); - uint8_t rsp2[] = {0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88, 0x99}; - transport_expect(OP_APP_TOKEN_GET, 0, 0, 0, rsp2, sizeof(rsp2)); - - assert_int_equal(LL_IFC_ERROR_INCORRECT_RESPONSE_LENGTH, ll_config_get(&net_token, app_token, &dl_mode, &qos)); - assert_int_equal(0x11223344, net_token); -} - -void test_config_get_dl_mode_invalid(void **state) -{ - (void) state; - uint32_t net_token = 0xffffffff; - uint8_t app_token[APP_TOKEN_LEN] = {0}; - uint8_t qos = 0xff; - - uint8_t rsp[] = {0x11, 0x22, 0x33, 0x44}; - transport_expect(OP_NET_TOKEN_GET, 0, 0, 0, rsp, sizeof(rsp)); - uint8_t rsp2[] = {0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88, 0x99, 0xaa}; - transport_expect(OP_APP_TOKEN_GET, 0, 0, 0, rsp2, sizeof(rsp2)); - - assert_int_equal(LL_IFC_ERROR_INCORRECT_PARAMETER, ll_config_get(&net_token, app_token, NULL, &qos)); - assert_int_equal(0x11223344, net_token); - assert_memory_equal(app_token, rsp2, APP_TOKEN_LEN); -} - -void test_config_get_dl_mode_incorrect_length(void **state) -{ - (void) state; - uint32_t net_token = 0xffffffff; - uint8_t app_token[APP_TOKEN_LEN] = {0}; - enum ll_downlink_mode dl_mode = NUM_DOWNLINK_MODES; - uint8_t qos = 0xff; - - uint8_t rsp1[] = {0x11, 0x22, 0x33, 0x44}; - transport_expect(OP_NET_TOKEN_GET, 0, 0, 0, rsp1, sizeof(rsp1)); - uint8_t rsp2[] = {0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88, 0x99, 0xaa}; - transport_expect(OP_APP_TOKEN_GET, 0, 0, 0, rsp2, sizeof(rsp2)); - uint8_t rsp3[] = {0x11, 0x22}; - transport_expect(OP_RX_MODE_GET, 0, 0, 0, rsp3, sizeof(rsp3)); - - assert_int_equal(LL_IFC_ERROR_BUFFER_TOO_SMALL, ll_config_get(&net_token, app_token, &dl_mode, &qos)); - assert_int_equal(0x11223344, net_token); - assert_memory_equal(app_token, rsp2, APP_TOKEN_LEN); -} - -void test_config_get_qos_invalid(void **state) -{ - (void) state; - uint32_t net_token = 0xffffffff; - uint8_t app_token[APP_TOKEN_LEN] = {0}; - enum ll_downlink_mode dl_mode = NUM_DOWNLINK_MODES; - - uint8_t rsp[] = {0x11, 0x22, 0x33, 0x44}; - transport_expect(OP_NET_TOKEN_GET, 0, 0, 0, rsp, sizeof(rsp)); - uint8_t rsp2[] = {0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88, 0x99, 0xaa}; - transport_expect(OP_APP_TOKEN_GET, 0, 0, 0, rsp2, sizeof(rsp2)); - uint8_t rsp3[] = {0x02}; - transport_expect(OP_RX_MODE_GET, 0, 0, 0, rsp3, sizeof(rsp3)); - - assert_int_equal(LL_IFC_ERROR_INCORRECT_PARAMETER, ll_config_get(&net_token, app_token, &dl_mode, NULL)); - assert_int_equal(0x11223344, net_token); - assert_memory_equal(app_token, rsp2, APP_TOKEN_LEN); - assert_int_equal(LL_DL_MAILBOX, dl_mode); -} - -void test_config_get_qos_incorrect_length(void **state) -{ - (void) state; - uint32_t net_token = 0xffffffff; - uint8_t app_token[APP_TOKEN_LEN] = {0}; - enum ll_downlink_mode dl_mode = NUM_DOWNLINK_MODES; - uint8_t qos = 0xff; - - uint8_t rsp1[] = {0x11, 0x22, 0x33, 0x44}; - transport_expect(OP_NET_TOKEN_GET, 0, 0, 0, rsp1, sizeof(rsp1)); - uint8_t rsp2[] = {0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88, 0x99, 0xaa}; - transport_expect(OP_APP_TOKEN_GET, 0, 0, 0, rsp2, sizeof(rsp2)); - uint8_t rsp3[] = {0x02}; - transport_expect(OP_RX_MODE_GET, 0, 0, 0, rsp3, sizeof(rsp3)); - uint8_t rsp4[] = {0x02, 0x23}; - transport_expect(OP_QOS_GET, 0, 0, 0, rsp4, sizeof(rsp4)); - - assert_int_equal(LL_IFC_ERROR_BUFFER_TOO_SMALL, ll_config_get(&net_token, app_token, &dl_mode, &qos)); - assert_int_equal(0x11223344, net_token); - assert_memory_equal(app_token, rsp2, APP_TOKEN_LEN); - assert_int_equal(LL_DL_MAILBOX, dl_mode); - assert_int_equal(0xff, qos); -} - -void test_config_get_ok(void **state) -{ - (void) state; - uint32_t net_token = 0xffffffff; - uint8_t app_token[APP_TOKEN_LEN] = {0}; - enum ll_downlink_mode dl_mode = NUM_DOWNLINK_MODES; - uint8_t qos = 0xff; - - uint8_t rsp1[] = {0x11, 0x22, 0x33, 0x44}; - transport_expect(OP_NET_TOKEN_GET, 0, 0, 0, rsp1, sizeof(rsp1)); - uint8_t rsp2[] = {0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88, 0x99, 0xaa}; - transport_expect(OP_APP_TOKEN_GET, 0, 0, 0, rsp2, sizeof(rsp2)); - uint8_t rsp3[] = {0x02}; - transport_expect(OP_RX_MODE_GET, 0, 0, 0, rsp3, sizeof(rsp3)); - uint8_t rsp4[] = {0x07}; - transport_expect(OP_QOS_GET, 0, 0, 0, rsp4, sizeof(rsp4)); - - assert_int_equal(LL_IFC_ACK, ll_config_get(&net_token, app_token, &dl_mode, &qos)); - assert_int_equal(0x11223344, net_token); - assert_memory_equal(app_token, rsp2, APP_TOKEN_LEN); - assert_int_equal(LL_DL_MAILBOX, dl_mode); - assert_int_equal(0x07, qos); -} - -void test_get_state_all_null(void **state) -{ - (void)state; - assert_int_equal(LL_IFC_ACK, ll_get_state(NULL, NULL, NULL)); -} - -void test_get_state_ok(void **state) -{ - (void) state; - enum ll_state s = LL_STATE_ERROR; - enum ll_tx_state stx = LL_TX_STATE_ERROR; - enum ll_rx_state srx = LL_RX_STATE_NO_MSG; - - uint8_t rsp1[] = {3}; - transport_expect(OP_STATE, 0, 0, 0, rsp1, sizeof(rsp1)); - uint8_t rsp2[] = {1}; - transport_expect(OP_TX_STATE, 0, 0, 0, rsp2, sizeof(rsp2)); - uint8_t rsp3[] = {1}; - transport_expect(OP_RX_STATE, 0, 0, 0, rsp3, sizeof(rsp3)); - - assert_int_equal(LL_IFC_ACK, ll_get_state(&s, &stx, &srx)); - assert_int_equal(LL_STATE_INITIALIZING, s); - assert_int_equal(LL_TX_STATE_TRANSMITTING, stx); - assert_int_equal(LL_RX_STATE_RECEIVED_MSG, srx); -} - -void test_mailbox_request_ok(void **state) -{ - (void)state; - transport_expect(OP_MAILBOX_REQUEST, 0, 0, 0, 0, 0); - assert_int_equal(LL_IFC_ACK, ll_mailbox_request()); -} - -void test_app_reg_get_invalid(void **state) -{ - (void)state; - assert_int_equal(LL_IFC_ERROR_INCORRECT_PARAMETER, ll_app_reg_get(NULL)); -} - -void test_app_reg_get_ok(void **state) -{ - (void)state; - uint8_t is_registered = 0; - uint8_t rsp[] = {0x01}; - transport_expect(OP_APP_TOKEN_REG_GET, 0, 0, 0, rsp, sizeof(rsp)); - assert_int_equal(LL_IFC_ACK, ll_app_reg_get(&is_registered)); - assert_int_equal(1, is_registered); -} - -void test_crypto_request_ok(void **state) -{ - (void)state; - transport_expect(OP_CRYPTO_KEY_XCHG_REQ, 0, 0, 0, 0, 0); - assert_int_equal(LL_IFC_ACK, ll_encryption_key_exchange_request()); -} - -void test_net_info_get_invalid(void **state) -{ - (void)state; - assert_int_equal(LL_IFC_ERROR_INCORRECT_PARAMETER, ll_net_info_get(NULL)); -} - -void test_net_info_get_incorrect_length(void **state) -{ - (void)state; - llabs_network_info_t info; - - uint8_t rsp[NET_INFO_BUFF_SIZE - 1] = {0}; - transport_expect(OP_NET_INFO_GET, 0, 0, 0, rsp, sizeof(rsp)); - assert_int_equal(LL_IFC_ERROR_INCORRECT_RESPONSE_LENGTH, ll_net_info_get(&info)); -} - -void test_net_info_get_ok(void **state) -{ - (void)state; - llabs_network_info_t info; - - uint8_t rsp[NET_INFO_BUFF_SIZE] = {0}; - transport_expect(OP_NET_INFO_GET, 0, 0, 0, rsp, sizeof(rsp)); - assert_int_equal(LL_IFC_ACK, ll_net_info_get(&info)); -} - -void test_stats_get_invalid(void **state) -{ - (void)state; - assert_int_equal(LL_IFC_ERROR_INCORRECT_PARAMETER, ll_stats_get(NULL)); -} - -void test_stats_get_incorrect_length(void **state) -{ - (void)state; - llabs_stats_t s; - - uint8_t rsp[STATS_SIZE - 1] = {0}; - transport_expect(OP_STATS_GET, 0, 0, 0, rsp, sizeof(rsp)); - assert_int_equal(LL_IFC_ERROR_INCORRECT_RESPONSE_LENGTH, ll_stats_get(&s)); -} - -void test_stats_get_ok(void **state) -{ - (void)state; - llabs_stats_t s; - - uint8_t rsp[STATS_SIZE] = {0}; - transport_expect(OP_STATS_GET, 0, 0, 0, rsp, sizeof(rsp)); - assert_int_equal(LL_IFC_ACK, ll_stats_get(&s)); -} - -void test_retrieve_message_invalid(void **state) -{ - (void)state; - assert_int_equal(LL_IFC_ERROR_INCORRECT_PARAMETER, ll_retrieve_message(NULL, NULL, NULL, NULL, NULL)); -} - -void test_retrieve_message_small_length(void **state) -{ - (void)state; - uint8_t buff[256] = {0}; - uint16_t size = 1; - - uint8_t rsp[] = {0, 0}; - transport_expect(OP_MSG_RECV, 0, 0, 0, rsp, sizeof(rsp)); - - assert_int_equal(LL_IFC_ERROR_BUFFER_TOO_SMALL, ll_retrieve_message(buff, &size, NULL, NULL, NULL)); -} - -void test_retrieve_message_incorrect_length(void **state) -{ - (void)state; - uint8_t buff[256] = {0}; - uint16_t size = 256; - - uint8_t rsp[] = {0x11, 0x22, 0x33, 0x44}; - transport_expect(OP_MSG_RECV, 0, 0, 0, rsp, sizeof(rsp)); - - assert_int_equal(LL_IFC_ERROR_INCORRECT_RESPONSE_LENGTH, ll_retrieve_message(buff, &size, NULL, NULL, NULL)); -} - -void test_retrieve_message_ok(void **state) -{ - (void)state; - uint8_t buff[256] = {0}; - uint16_t size = 256; - uint8_t port = 0; - int16_t rssi = 0; - uint8_t snr = 0; - - uint8_t rsp[] = {0x11, 0x22, 0x33, 0x44, 0x55, 0x66}; - transport_expect(OP_MSG_RECV, 0, 0, 0, rsp, sizeof(rsp)); - - assert_int_equal(LL_IFC_ACK, ll_retrieve_message(buff, &size, &port, &rssi, &snr)); - assert_int_equal(2, size); - assert_memory_equal(buff, &rsp[4], 2); - assert_int_equal(0x44, port); - assert_int_equal(0x2211, rssi); - assert_int_equal(0x33, snr); -} - -void test_dl_band_cfg_get_invalid(void **state) -{ - (void)state; - assert_int_equal(LL_IFC_ERROR_INCORRECT_PARAMETER, ll_dl_band_cfg_get(NULL)); -} - -void test_dl_band_cfg_get_incorrect_length(void **state) -{ - (void)state; - llabs_dl_band_cfg_t cfg; - - uint8_t rsp[] = {0, 0}; - transport_expect(OP_DL_BAND_CFG_GET, 0, 0, 0, rsp, sizeof(rsp)); - - assert_int_equal(LL_IFC_ERROR_INCORRECT_RESPONSE_LENGTH, ll_dl_band_cfg_get(&cfg)); -} - -void test_dl_band_cfg_get_ok(void **state) -{ - (void)state; - llabs_dl_band_cfg_t cfg; - - uint8_t rsp[DL_BAND_CFG_SIZE] = {0}; - transport_expect(OP_DL_BAND_CFG_GET, 0, 0, 0, rsp, sizeof(rsp)); - - assert_int_equal(LL_IFC_ACK, ll_dl_band_cfg_get(&cfg)); -} - -void test_dl_band_cfg_set_invalid(void **state) -{ - (void)state; - assert_int_equal(LL_IFC_ERROR_INCORRECT_PARAMETER, ll_dl_band_cfg_set(NULL)); -} - -void test_dl_band_cfg_set_ok(void **state) -{ - (void)state; - llabs_dl_band_cfg_t cfg = {0}; - - uint8_t cmd[DL_BAND_CFG_SIZE] = {0}; - transport_expect(OP_DL_BAND_CFG_SET, cmd, sizeof(cmd), 0, 0, 0); - - assert_int_equal(LL_IFC_ACK, ll_dl_band_cfg_set(&cfg)); -} - - -void test_connection_filter_get_invalid(void **state) -{ - (void)state; - assert_int_equal(LL_IFC_ERROR_INCORRECT_PARAMETER, ll_connection_filter_get(NULL)); -} - -void test_connection_filter_get_incorrect_length(void **state) -{ - (void)state; - uint8_t f = 0xff; - - uint8_t rsp[] = {0, 0}; - transport_expect(OP_CONN_FILT_GET, 0, 0, 0, rsp, sizeof(rsp)); - assert_int_equal(LL_IFC_ERROR_BUFFER_TOO_SMALL, ll_connection_filter_get(&f)); - assert_int_equal(0xff, f); -} - -void test_connection_filter_get_ok(void **state) -{ - (void)state; - uint8_t f = 0xff; - - uint8_t rsp[] = {0x11}; - transport_expect(OP_CONN_FILT_GET, 0, 0, 0, rsp, sizeof(rsp)); - assert_int_equal(LL_IFC_ACK, ll_connection_filter_get(&f)); - assert_int_equal(0x11, f); -} - -void test_connection_filter_set_ok(void **state) -{ - (void)state; - uint8_t f = 0x11; - - uint8_t cmd[] = {0x11}; - transport_expect(OP_CONN_FILT_SET, cmd, sizeof(cmd), 0, 0, 0); - assert_int_equal(LL_IFC_ACK, ll_connection_filter_set(f)); -} - -void test_system_time_get_invalid(void **state) -{ - (void)state; - assert_int_equal(LL_IFC_ERROR_INCORRECT_PARAMETER, ll_system_time_get(NULL)); -} - -void test_system_time_get_incorrect_length(void **state) -{ - (void)state; - llabs_time_info_t info; - - uint8_t rsp[] = {0, 0}; - transport_expect(OP_SYSTEM_TIME_GET, 0, 0, 0, rsp, sizeof(rsp)); - assert_int_equal(LL_IFC_ERROR_INCORRECT_RESPONSE_LENGTH, ll_system_time_get(&info)); - //assert_int_equal(0xff, f); -} - -void test_system_time_get_ok(void **state) -{ - (void)state; - llabs_time_info_t info; - - uint8_t rsp[TIME_INFO_SIZE] = {0}; - transport_expect(OP_SYSTEM_TIME_GET, 0, 0, 0, rsp, sizeof(rsp)); - assert_int_equal(LL_IFC_ACK, ll_system_time_get(&info)); -} - -void test_system_time_sync_invalid(void **state) -{ - (void)state; - assert_int_equal(LL_IFC_ERROR_INCORRECT_PARAMETER, ll_system_time_sync(2)); -} - -void test_system_time_sync_ok(void **state) -{ - (void)state; - - uint8_t cmd[] = {1}; - transport_expect(OP_SYSTEM_TIME_SYNC, cmd, sizeof(cmd), 0, 0, 0); - assert_int_equal(LL_IFC_ACK, ll_system_time_sync(1)); -} - -void test_message_send_invalid(void **state) -{ - (void)state; - assert_int_equal(LL_IFC_ERROR_INCORRECT_PARAMETER, ll_message_send(NULL, 1, 1, 1)); - assert_int_equal(LL_IFC_ERROR_INCORRECT_PARAMETER, ll_message_send(1, 0, 1, 1)); - assert_int_equal(LL_IFC_ERROR_INCORRECT_PARAMETER, ll_message_send(1, 257, 0, 1)); - assert_int_equal(LL_IFC_ERROR_INCORRECT_PARAMETER, ll_message_send(1, 1, 1, 128)); -} - -void test_message_send_ok(void **state) -{ - (void)state; - uint8_t buf[] = {0x11, 0x22, 0x33}; - - uint8_t cmd[] = {1, 0x55, 0x11, 0x22, 0x33}; - transport_expect(OP_MSG_SEND, cmd, sizeof(cmd), 0, 0, 0); - assert_int_equal(LL_IFC_ACK, ll_message_send(buf, sizeof(buf), 1, 0x55)); -} - -void test_scan_config_set_ok(void **state) -{ - (void)state; - - int16_t threshold = 16; - uint8_t cmd[] = { threshold & 0xff, (threshold >> 8) }; - uint16_t scan_attempts = 23; - uint8_t cmd1[] = { scan_attempts & 0xff, (scan_attempts >> 8) }; - - enum ll_scan_mode scan_mode = LLABS_NORMAL_SCAN_AND_CONNECT; - - transport_expect(OP_SCAN_MODE_SET, (uint8_t*)&scan_mode, 1, 0, 0, 0); - transport_expect(OP_SCAN_THRESHOLD_SET, cmd, sizeof(cmd), 0, 0, 0); - transport_expect(OP_SCAN_ATTEMPTS_SET, cmd1, sizeof(cmd1), 0, 0, 0); - - assert_int_equal(LL_IFC_ACK, ll_scan_config_set(scan_mode, threshold, scan_attempts)); -} - -void test_scan_config_set_invalid_scan_mode(void **state) -{ - (void)state; - - int16_t threshold = 16; - uint8_t cmd[] = { threshold & 0xff, (threshold >> 8) }; - uint16_t scan_attempts = 23; - uint8_t cmd1[] = { scan_attempts & 0xff, (scan_attempts >> 8) }; - enum ll_scan_mode scan_mode = -1; - - transport_expect(OP_SCAN_MODE_SET, (uint8_t*)&scan_mode, 1, LL_IFC_ERROR_INCORRECT_PARAMETER, 0, 0); - transport_expect(OP_SCAN_THRESHOLD_SET, cmd, sizeof(cmd), 0, 0, 0); - transport_expect(OP_SCAN_ATTEMPTS_SET, cmd1, sizeof(cmd1), 0, 0, 0); - - assert_int_equal(LL_IFC_ERROR_INCORRECT_PARAMETER, ll_scan_config_set(scan_mode, threshold, scan_attempts)); -} - -void test_scan_config_get_ok(void **state) -{ - (void)state; - - // Variables - enum ll_scan_mode scan_mode = 0; - int16_t threshold = 0; - uint16_t scan_attempts = 0; - uint16_t scans_left = 0; - - // Expected Values - enum ll_scan_mode ex_scan_mode = LLABS_INFO_SCAN; - int16_t ex_threshold = -98; - uint16_t ex_scan_attempts = 560; - uint16_t ex_scans_left = 340; - - // Serialized Data "From the module" - transport_expect(OP_SCAN_MODE_GET, 0, 0, 0, (uint8_t*)&ex_scan_mode, 1); - transport_expect(OP_SCAN_THRESHOLD_GET, 0, 0, 0, (uint8_t*)&ex_threshold, 2); - transport_expect(OP_SCAN_ATTEMPTS_GET, 0, 0, 0, (uint8_t*)&ex_scan_attempts, 2); - transport_expect(OP_SCAN_ATTEMPTS_LEFT, 0, 0, 0, (uint8_t*)&ex_scans_left, 2); - - // Checks - assert_int_equal(LL_IFC_ACK, ll_scan_config_get(&scan_mode, &threshold, &scan_attempts, &scans_left)); - assert_int_equal(scan_mode, ex_scan_mode); - assert_int_equal(threshold, ex_threshold); - assert_int_equal(scan_attempts, ex_scan_attempts); - assert_int_equal(scans_left, ex_scans_left); -} - -void test_connect_to_gw_channel_ok(void **state) -{ - (void)state; - for (int i = 0; i <= 45; i += 3) - { - transport_expect(OP_CONN_TO_GW_CH, (uint8_t*)&i, 1, 0, 0, 0); - assert_int_equal(LL_IFC_ACK, ll_connect_to_gw_channel(i)); - } -} - diff --git a/test_ifc_lib/test_ifc_lib_symphony.h b/test_ifc_lib/test_ifc_lib_symphony.h deleted file mode 100644 index 668dc96..0000000 --- a/test_ifc_lib/test_ifc_lib_symphony.h +++ /dev/null @@ -1,105 +0,0 @@ -#include "test_ifc_lib_gen.h" - -void test_config_set_net_token_invalid(void **state); -void test_config_set_app_token_invalid(void **state); -void test_config_set_dl_mode_invalid(void **state); -void test_config_set_qos_invalid(void **state); -void test_config_set_ok(void **state); -void test_config_get_net_token_invalid(void **state); -void test_config_get_net_token_incorrect_length(void **state); -void test_config_get_app_token_invalid(void **state); -void test_config_get_app_token_incorrect_length(void **state); -void test_config_get_dl_mode_invalid(void **state); -void test_config_get_dl_mode_incorrect_length(void **state); -void test_config_get_qos_invalid(void **state); -void test_config_get_qos_incorrect_length(void **state); -void test_config_get_ok(void **state); -void test_get_state_all_null(void **state); -void test_get_state_ok(void **state); -void test_mailbox_request_ok(void **state); -void test_app_reg_get_invalid(void **state); -void test_app_reg_get_ok(void **state); -void test_crypto_request_ok(void **state); -void test_net_info_get_invalid(void **state); -void test_net_info_get_incorrect_length(void **state); -void test_net_info_get_ok(void **state); -void test_stats_get_invalid(void **state); -void test_stats_get_incorrect_length(void **state); -void test_stats_get_ok(void **state); -void test_dl_band_cfg_get_invalid(void **state); -void test_dl_band_cfg_get_incorrect_length(void **state); -void test_dl_band_cfg_get_ok(void **state); -void test_dl_band_cfg_set_invalid(void **state); -void test_dl_band_cfg_set_ok(void **state); -void test_connection_filter_get_invalid(void **state); -void test_connection_filter_get_incorrect_length(void **state); -void test_connection_filter_get_ok(void **state); -void test_connection_filter_set_ok(void **state); -void test_system_time_get_invalid(void **state); -void test_system_time_get_incorrect_length(void **state); -void test_system_time_get_ok(void **state); -void test_system_time_sync_invalid(void **state); -void test_system_time_sync_ok(void **state); -void test_message_send_invalid(void **state); -void test_message_send_ok(void **state); -void test_retrieve_message_invalid(void **state); -void test_retrieve_message_small_length(void **state); -void test_retrieve_message_incorrect_length(void **state); -void test_retrieve_message_ok(void **state); -void test_scan_config_set_ok(void **state); -void test_scan_config_set_invalid_scan_mode(void **state); -void test_scan_config_get_ok(void **state); -void test_connect_to_gw_channel_ok(void **state); - -#define SYMPHONY_IFC_LIB_TESTS \ - unit_test_setup_teardown(test_config_set_net_token_invalid, setUp, tearDown), \ - unit_test_setup_teardown(test_config_set_app_token_invalid, setUp, tearDown), \ - unit_test_setup_teardown(test_config_set_dl_mode_invalid, setUp, tearDown), \ - unit_test_setup_teardown(test_config_set_qos_invalid, setUp, tearDown), \ - unit_test_setup_teardown(test_config_set_ok, setUp, tearDown), \ - unit_test_setup_teardown(test_config_get_net_token_invalid, setUp, tearDown), \ - unit_test_setup_teardown(test_config_get_net_token_incorrect_length, setUp, tearDown), \ - unit_test_setup_teardown(test_config_get_app_token_invalid, setUp, tearDown), \ - unit_test_setup_teardown(test_config_get_app_token_incorrect_length, setUp, tearDown), \ - unit_test_setup_teardown(test_config_get_dl_mode_invalid, setUp, tearDown), \ - unit_test_setup_teardown(test_config_get_dl_mode_incorrect_length, setUp, tearDown), \ - unit_test_setup_teardown(test_config_get_qos_invalid, setUp, tearDown), \ - unit_test_setup_teardown(test_config_get_qos_incorrect_length, setUp, tearDown), \ - unit_test_setup_teardown(test_config_get_ok, setUp, tearDown), \ - unit_test_setup_teardown(test_get_state_all_null, setUp, tearDown), \ - unit_test_setup_teardown(test_get_state_ok, setUp, tearDown), \ - unit_test_setup_teardown(test_mailbox_request_ok, setUp, tearDown), \ - unit_test_setup_teardown(test_app_reg_get_invalid, setUp, tearDown), \ - unit_test_setup_teardown(test_app_reg_get_ok, setUp, tearDown), \ - unit_test_setup_teardown(test_crypto_request_ok, setUp, tearDown), \ - unit_test_setup_teardown(test_net_info_get_invalid, setUp, tearDown), \ - unit_test_setup_teardown(test_net_info_get_incorrect_length, setUp, tearDown), \ - unit_test_setup_teardown(test_net_info_get_ok, setUp, tearDown), \ - unit_test_setup_teardown(test_stats_get_invalid, setUp, tearDown), \ - unit_test_setup_teardown(test_stats_get_incorrect_length, setUp, tearDown), \ - unit_test_setup_teardown(test_stats_get_ok, setUp, tearDown), \ - unit_test_setup_teardown(test_dl_band_cfg_get_invalid, setUp, tearDown), \ - unit_test_setup_teardown(test_dl_band_cfg_get_incorrect_length, setUp, tearDown), \ - unit_test_setup_teardown(test_dl_band_cfg_get_ok, setUp, tearDown), \ - unit_test_setup_teardown(test_dl_band_cfg_set_invalid, setUp, tearDown), \ - unit_test_setup_teardown(test_dl_band_cfg_set_ok, setUp, tearDown), \ - unit_test_setup_teardown(test_connection_filter_get_invalid, setUp, tearDown), \ - unit_test_setup_teardown(test_connection_filter_get_incorrect_length, setUp, tearDown), \ - unit_test_setup_teardown(test_connection_filter_get_ok, setUp, tearDown), \ - unit_test_setup_teardown(test_connection_filter_set_ok, setUp, tearDown), \ - unit_test_setup_teardown(test_system_time_get_invalid, setUp, tearDown), \ - unit_test_setup_teardown(test_system_time_get_incorrect_length, setUp, tearDown), \ - unit_test_setup_teardown(test_system_time_get_ok, setUp, tearDown), \ - unit_test_setup_teardown(test_system_time_sync_invalid, setUp, tearDown), \ - unit_test_setup_teardown(test_system_time_sync_ok, setUp, tearDown), \ - unit_test_setup_teardown(test_message_send_invalid, setUp, tearDown), \ - unit_test_setup_teardown(test_message_send_ok, setUp, tearDown), \ - unit_test_setup_teardown(test_retrieve_message_invalid, setUp, tearDown), \ - unit_test_setup_teardown(test_retrieve_message_small_length, setUp, tearDown), \ - unit_test_setup_teardown(test_retrieve_message_incorrect_length, setUp, tearDown), \ - unit_test_setup_teardown(test_retrieve_message_ok, setUp, tearDown), \ - unit_test_setup_teardown(test_scan_config_set_ok, setUp, tearDown), \ - unit_test_setup_teardown(test_scan_config_set_invalid_scan_mode, setUp, tearDown), \ - unit_test_setup_teardown(test_scan_config_get_ok, setUp, tearDown), \ - unit_test_setup_teardown(test_connect_to_gw_channel_ok, setUp, tearDown), \ - diff --git a/test_ifc_lib/utils_ifc_lib.c b/test_ifc_lib/utils_ifc_lib.c index 3695b4d..23ed987 100644 --- a/test_ifc_lib/utils_ifc_lib.c +++ b/test_ifc_lib/utils_ifc_lib.c @@ -4,14 +4,13 @@ #include "embc/log.h" #include #include // memset, memcpy -#include + #include #include #include #include "cmockery.h" -//#define PRINT_ALL_BYTES struct fifo8_s * rd_fifo; @@ -135,12 +134,6 @@ int32_t transport_write(uint8_t *buff, uint16_t len) struct transport_expect_s * self = &transport_expect_; struct transport_single_s * s; -#ifdef PRINT_ALL_BYTES - printf("\nWRITE\n"); - for(int i = 0; ihead, self->tail); // "write when none expected"); assert_true(len + self->msg_len <= TRANSPORT_LEN_MAX); // "receive buffer overflow"); memcpy(&self->msg_buf[self->msg_len], buff, len); @@ -175,24 +168,17 @@ int32_t transport_read(uint8_t *buff, uint16_t len) return 1; } } - -#ifdef PRINT_ALL_BYTES - printf("\nREAD\n"); - for(int i = 0; i$(NULLDEVICE) 2>&1) -$(shell mkdir $(EXE_DIR)>$(NULLDEVICE) 2>&1) -$(shell mkdir $(LST_DIR)>$(NULLDEVICE) 2>&1) -ifeq (clean,$(findstring clean, $(MAKECMDGOALS))) - ifneq ($(filter $(MAKECMDGOALS),all debug release),) - $(shell $(RMFILES) $(OBJ_DIR)$(ALLFILES)>$(NULLDEVICE) 2>&1) - $(shell $(RMFILES) $(EXE_DIR)$(ALLFILES)>$(NULLDEVICE) 2>&1) - $(shell $(RMFILES) $(LST_DIR)$(ALLFILES)>$(NULLDEVICE) 2>&1) - endif -endif - - -#################################################################### -# Flags # -#################################################################### - -# -MMD : Don't generate dependencies on system header files. -# -MP : Add phony targets, useful when a h-file is removed from a project. -# -MF : Specify a file to write the dependencies to. -DEPFLAGS = -MMD -MP -MF $(@:.o=.d) - -# -# Add -Wa,-ahld=$(LST_DIR)/$(@F:.o=.lst) to CFLAGS to produce assembly list files -# -override CFLAGS += -Wall -Wextra -std=gnu99 -pedantic \ --ffunction-sections -fdata-sections \ -$(DEPFLAGS) - -override ASMFLAGS += -x assembler-with-cpp -Wall -Wextra - -# -# NOTE: The -Wl,--gc-sections flag may interfere with debugging using gdb. -# -#override LDFLAGS += -Wl,--gc-sections - -#LIBS = -Wl,--start-group -lgcc -lc -lnosys -Wl,--end-group -LIBS = -lm - -INCLUDEPATHS += \ --I$(MODULE_DIR)/cmockery \ --I$(MODULE_DIR)/embc/inc \ --I. \ --I../inc \ --I../src - -CTAGS_INCLUDEPATHS = $(subst -I,,$(INCLUDEPATHS)) - -#################################################################### -# Files # -#################################################################### -C_SRC += \ -$(MODULE_DIR)/cmockery/cmockery.c \ -$(MODULE_DIR)/embc/src/log.c \ -$(MODULE_DIR)/embc/src/dbc.c \ -$(MODULE_DIR)/embc/src/fifo.c \ -../src/ifc_struct_defs.c \ -../src/ll_ifc_no_mac.c \ -../src/ll_ifc_utils.c \ -../src/ll_ifc_ftp.c \ -../src/ll_ifc.c \ -utils.c \ -test_ifc_lib_utils.c \ -main.c - -s_SRC += - -S_SRC += - -#################################################################### -# Rules # -#################################################################### - -C_FILES = $(notdir $(C_SRC) ) -S_FILES = $(notdir $(S_SRC) $(s_SRC) ) -#make list of source paths, sort also removes duplicates -C_PATHS = $(sort $(dir $(C_SRC) ) ) -S_PATHS = $(sort $(dir $(S_SRC) $(s_SRC) ) ) - -C_OBJS = $(addprefix $(OBJ_DIR)/, $(C_FILES:.c=.o)) -S_OBJS = $(if $(S_SRC), $(addprefix $(OBJ_DIR)/, $(S_FILES:.S=.o))) -s_OBJS = $(if $(s_SRC), $(addprefix $(OBJ_DIR)/, $(S_FILES:.s=.o))) -C_DEPS = $(addprefix $(OBJ_DIR)/, $(C_FILES:.c=.d)) -OBJS = $(C_OBJS) $(S_OBJS) $(s_OBJS) - -vpath %.c $(C_PATHS) -vpath %.s $(S_PATHS) -vpath %.S $(S_PATHS) - -# Default build is debug -all: test - -debug: CFLAGS += -DDEBUG -O0 -g -DUNIT_TESTING -debug: $(EXE_DIR)/$(PROJECTNAME) - -# Create objects from C SRC files -$(OBJ_DIR)/%.o: %.c - @echo "Building file: $<" - $(CC) $(CFLAGS) $(INCLUDEPATHS) -c -o $@ $< - -# Assemble .s/.S files -$(OBJ_DIR)/%.o: %.s - @echo "Assembling $<" - $(CC) $(ASMFLAGS) $(INCLUDEPATHS) -c -o $@ $< - -$(OBJ_DIR)/%.o: %.S - @echo "Assembling $<" - $(CC) $(ASMFLAGS) $(INCLUDEPATHS) -c -o $@ $< - -# Link -$(EXE_DIR)/$(PROJECTNAME): $(OBJS) - @echo "Linking target: $@" - $(CC) $(LDFLAGS) $(OBJS) $(LIBS) -o $(EXE_DIR)/$(PROJECTNAME) - -test: debug - ./exe/$(PROJECTNAME) - -clean: -ifeq ($(filter $(MAKECMDGOALS),all debug release),) - $(RMDIRS) $(OBJ_DIR) $(LST_DIR) $(EXE_DIR) -endif - -# include auto-generated dependency files (explicit rules) -ifneq (clean,$(findstring clean, $(MAKECMDGOALS))) --include $(C_DEPS) -endif - -ctags: - ctags -R $(C_PATHS) $(S_PATHS) $(CTAGS_INCLUDEPATHS) diff --git a/test_utils/main.c b/test_utils/main.c deleted file mode 100644 index 874e027..0000000 --- a/test_utils/main.c +++ /dev/null @@ -1,20 +0,0 @@ -#include "test_ifc_lib_utils.h" - -#include -#include -#include -#include "cmockery.h" - - -int main(int argc, char* argv[]) { - (void) argc; - (void) argv; - - srand(time(NULL)); - - UnitTest tests[] = { - UTILS_IFC_LIB_TESTS - }; - - return run_tests(tests); -} diff --git a/test_utils/test_ifc_lib_utils.c b/test_utils/test_ifc_lib_utils.c deleted file mode 100644 index 27c43f8..0000000 --- a/test_utils/test_ifc_lib_utils.c +++ /dev/null @@ -1,236 +0,0 @@ -#include "ll_ifc.h" - -#include -#include // memset, memcpy -#include -#include -#include -#include -#include -#include "cmockery.h" - -struct time sudo_time = { 0 , 0 }; - -int32_t gettime(struct time *tp) -{ - tp->tv_sec = sudo_time.tv_sec; - tp->tv_nsec = sudo_time.tv_nsec; -} - -void setUpRandom(void **state) -{ -// srand(time(NULL)); -} - -void tearDown(void **state) -{ - // Nothing to do -} - -void test_utils_difftime_random_positive(void **state) -{ - for (unsigned int i = 0; i < 100; i++) - { - struct time now = { - .tv_sec = rand() % LONG_MAX, - .tv_nsec = rand() % LONG_MAX - }; - - struct time then = { - .tv_sec = rand() % LONG_MAX, - .tv_nsec = rand() % LONG_MAX - }; - - long sec; - long nsec; - - if (then.tv_sec < now.tv_sec) - { - sec = then.tv_sec - now.tv_sec; - nsec = then.tv_nsec - now.tv_nsec; - if (nsec < 0) - { - sec --; - } - nsec = (nsec + 1000) % 1000; - - assert_int_equal(ll_difftime(&now, &then), sec); - } - else - { - sec = now.tv_sec - then.tv_sec; - nsec = now.tv_nsec - then.tv_nsec; - if (nsec < 0) - { - sec --; - } - nsec = (nsec + 1000) % 1000; - - assert_int_equal(ll_difftime(&then, &now), sec); - } - - // printf("Passed iteration %i [ difftime = %i || now (%i:%i) || then (%i:%i) ]\n", i + 1, sec, now.tv_sec, now.tv_nsec, then.tv_sec, then.tv_nsec); - } -} - -void test_utils_difftime_random_negative(void **state) -{ - for (unsigned int i = 0; i < 100; i++) - { - struct time now = { - .tv_sec = LONG_MIN + (rand() % LONG_MAX), - .tv_nsec = LONG_MIN + (rand() % LONG_MAX) - }; - - struct time then = { - .tv_sec = rand() % LONG_MAX, - .tv_nsec = rand() % LONG_MAX - }; - - long sec; - long nsec; - - if (then.tv_sec < now.tv_sec) - { - sec = then.tv_sec - now.tv_sec; - nsec = then.tv_nsec - now.tv_nsec; - if (nsec < 0) - { - sec --; - } - nsec = (nsec + 1000) % 1000; - - assert_int_equal(ll_difftime(&now, &then), sec); - } - else - { - sec = now.tv_sec - then.tv_sec; - nsec = now.tv_nsec - then.tv_nsec; - if (nsec < 0) - { - sec --; - } - nsec = (nsec + 1000) % 1000; - - assert_int_equal(ll_difftime(&then, &now), sec); - } - - // printf("Passed iteration %i [ difftime = %i || now (%i:%i) || then (%i:%i) ]\n", i + 1, sec, now.tv_sec, now.tv_nsec, then.tv_sec, then.tv_nsec); - } -} - -void test_utils_difftime_limits(void **state) -{ - -} - -void test_utils_difftime_now_random_positive(void **state) -{ - for (unsigned int i = 0; i < 100; i++) - { - struct time time1 = { - .tv_sec = rand() % LONG_MAX, - .tv_nsec = rand() % LONG_MAX - }; - - struct time time2 = { - .tv_sec = rand() % LONG_MAX, - .tv_nsec = rand() % LONG_MAX - }; - - long sec; - long nsec; - - if (time1.tv_sec < time2.tv_sec) - { - sudo_time.tv_sec = time2.tv_sec; - sudo_time.tv_nsec = time2.tv_nsec; - - sec = time1.tv_sec - sudo_time.tv_sec; - nsec = time1.tv_nsec - sudo_time.tv_nsec; - } - else - { - sudo_time.tv_sec = time1.tv_nsec; - sudo_time.tv_nsec = time1.tv_nsec; - - sec = time2.tv_sec - sudo_time.tv_sec; - nsec = time2.tv_nsec - sudo_time.tv_nsec; - } - - if (nsec < 0) - { - sec --; - } - nsec = (nsec + 1000) % 1000; - - if (time1.tv_sec < time2.tv_sec) - { - assert_int_equal(ll_difftime_from_now(&time1), sec); - // printf("Passed iteration %i [ difftime = %i || now (%i:%i) || then (%i:%i) ]\n", i + 1, sec, sudo_time.tv_sec, sudo_time.tv_nsec, time1.tv_sec, time1.tv_nsec); - } - else - { - assert_int_equal(ll_difftime_from_now(&time2), sec); - // printf("Passed iteration %i [ difftime = %i || now (%i:%i) || then (%i:%i) ]\n", i + 1, sec, sudo_time.tv_sec, sudo_time.tv_nsec, time2.tv_sec, time2.tv_nsec); - } - } -} - -void test_utils_difftime_now_random_negative(void **state) -{ - for (unsigned int i = 0; i < 100; i++) - { - struct time time1 = { - .tv_sec = LONG_MIN + (rand() % LONG_MAX), - .tv_nsec = LONG_MIN + (rand() % LONG_MAX) - }; - - struct time time2 = { - .tv_sec = LONG_MIN + (rand() % LONG_MAX), - .tv_nsec = LONG_MIN + (rand() % LONG_MAX) - }; - - long sec; - long nsec; - - if (time1.tv_sec < time2.tv_sec) - { - sudo_time.tv_sec = time1.tv_sec; - sudo_time.tv_nsec = time1.tv_nsec; - - sec = time2.tv_sec - sudo_time.tv_sec; - nsec = time2.tv_nsec - sudo_time.tv_nsec; - } - else - { - sudo_time.tv_sec = time2.tv_nsec; - sudo_time.tv_nsec = time2.tv_nsec; - - sec = time1.tv_sec - sudo_time.tv_sec; - nsec = time1.tv_nsec - sudo_time.tv_nsec; - } - - if (nsec < 0) - { - sec --; - } - nsec = (nsec + 1000) % 1000; - - if (time1.tv_sec < time2.tv_sec) - { - assert_int_equal(ll_difftime_from_now(&time2), sec); - // printf("Passed iteration %i [ difftime = %i || now (%i:%i) || then (%i:%i) ]\n", i + 1, sec, sudo_time.tv_sec, sudo_time.tv_nsec, time1.tv_sec, time1.tv_nsec); - } - else - { - assert_int_equal(ll_difftime_from_now(&time1), sec); - // printf("Passed iteration %i [ difftime = %i || now (%i:%i) || then (%i:%i) ]\n", i + 1, sec, sudo_time.tv_sec, sudo_time.tv_nsec, time2.tv_sec, time2.tv_nsec); - } - } -} - -void test_utils_difftime_now_limits(void **state) -{ - -} diff --git a/test_utils/test_ifc_lib_utils.h b/test_utils/test_ifc_lib_utils.h deleted file mode 100644 index 901c344..0000000 --- a/test_utils/test_ifc_lib_utils.h +++ /dev/null @@ -1,21 +0,0 @@ -#include "ll_ifc_utils.h" - -void setUpRandom(void **state); -void tearDown(void **state); - -void test_utils_difftime_random_positive(void **state); -void test_utils_difftime_random_negative(void **state); -void test_utils_difftime_limits(void **state); -void test_utils_difftime_now_random_positive(void **state); -void test_utils_difftime_now_random_negative(void **state); -void test_utils_difftime_now_limits(void **state); - -#define UTILS_IFC_LIB_TESTS \ - unit_test_setup_teardown(test_utils_difftime_random_positive, setUpRandom, tearDown), \ - unit_test_setup_teardown(test_utils_difftime_random_negative, setUpRandom, tearDown), \ - unit_test(test_utils_difftime_limits), \ - unit_test(test_utils_difftime_now_limits) - - -// unit_test_setup_teardown(test_utils_difftime_now_random_positive, setUpRandom, tearDown), \ -// unit_test_setup_teardown(test_utils_difftime_now_random_negative, setUpRandom, tearDown), \ diff --git a/test_utils/utils.c b/test_utils/utils.c deleted file mode 100644 index dd7236b..0000000 --- a/test_utils/utils.c +++ /dev/null @@ -1,196 +0,0 @@ -#include "ll_ifc.h" -#include "embc/fifo.h" -#include "embc/log.h" -#include -#include // memset, memcpy -#include "ll_ifc_symphony.h" - -#include -#include -#include -#include "cmockery.h" - -#define TRANSPORT_LEN_MAX 256 -#define TRANSPORT_INVOKE_MAX 16 - -struct fifo8_s * rd_fifo; - -int32_t ll_ul_max_port = 127; - -int32_t ll_config_set(uint32_t net_token, const uint8_t app_token[APP_TOKEN_LEN], enum ll_downlink_mode dl_mode, uint8_t qos) -{ - (void) net_token; - (void) app_token; - (void) dl_mode; - (void) qos; - return 0; -} - -int32_t ll_config_get(uint32_t *net_token, uint8_t app_token[APP_TOKEN_LEN], enum ll_downlink_mode * dl_mode, uint8_t *qos) -{ - (void) net_token; - (void) app_token; - *dl_mode = LL_DL_OFF; - (void) qos; - return 0; -} - -uint32_t log_timestamp_us( void ) { - return 0; -} - -void log_printf(const char * format, ...) { - (void) format; -} - -void dbc_assert(char const *file, unsigned line, const char * msg) { - (void) file; - (void) line; - (void) msg; -} - -int32_t sleep_ms(int32_t millis) -{ - (void) millis; - return 0; -} - -struct transport_single_s { - uint8_t wr_buf[TRANSPORT_LEN_MAX]; - uint16_t wr_len; - uint8_t rd_buf[TRANSPORT_LEN_MAX]; - uint16_t rd_len; -}; - -struct transport_expect_s { - struct transport_single_s buffer[TRANSPORT_INVOKE_MAX]; - int head; - int tail; - - uint8_t message_num; - uint8_t msg_buf[TRANSPORT_LEN_MAX]; - uint16_t msg_len; -}; - -struct transport_expect_s transport_expect_; - -uint16_t compute_checksum(uint8_t const * buf, uint16_t len) -{ - uint16_t i; - uint16_t crc = 0; - for(i = 0; i < len; i++) - { - crc = (crc >> 8) | (crc << 8); - crc ^= buf[i]; - crc ^= (crc & 0xff) >> 4; - crc ^= crc << 12; - crc ^= (crc & 0xff) << 5; - } - return crc; -} - -void transport_expect( - uint8_t opcode, - uint8_t const * wr_buf, uint16_t wr_len, - uint8_t ack, - uint8_t const * rd_buf, uint16_t rd_len) -{ - uint16_t crc; - struct transport_expect_s * self = &transport_expect_; - struct transport_single_s * s; - int next = self->head + 1; - if (next >= TRANSPORT_INVOKE_MAX) - { - next = 0; - } - assert_true(next != self->tail); - assert_true(wr_len <= TRANSPORT_LEN_MAX - 11); - assert_true(rd_len <= TRANSPORT_LEN_MAX - 8); - s = &self->buffer[self->head]; - - // construct command - s->wr_len = 11 + wr_len; - s->wr_buf[0] = 0xff; - s->wr_buf[1] = 0xff; - s->wr_buf[2] = 0xff; - s->wr_buf[3] = 0xff; - s->wr_buf[4] = 0xc4; - s->wr_buf[5] = opcode; - s->wr_buf[6] = self->message_num; - s->wr_buf[7] = (wr_len >> 8) & 0xff; - s->wr_buf[8] = (wr_len >> 0) & 0xff; - memcpy(&s->wr_buf[9], wr_buf, wr_len); - crc = compute_checksum(s->wr_buf + 4, s->wr_len - 6); - s->wr_buf[s->wr_len - 2] = (crc >> 8) & 0xff; - s->wr_buf[s->wr_len - 1] = (crc >> 0) & 0xff; - - // construct response - s->rd_len = 8 + rd_len; - s->rd_buf[0] = 0xc4; - s->rd_buf[1] = opcode; - s->rd_buf[2] = self->message_num; - s->rd_buf[3] = ack; - s->rd_buf[4] = (rd_len >> 8) & 0xff; - s->rd_buf[5] = (rd_len >> 0) & 0xff; - memcpy(&s->rd_buf[6], rd_buf, rd_len); - crc = compute_checksum(s->rd_buf, s->rd_len - 2); - s->rd_buf[s->rd_len - 2] = (crc >> 8) & 0xff; - s->rd_buf[s->rd_len - 1] = (crc >> 0) & 0xff; - - self->head = next; - self->message_num++; -} - -int32_t transport_write(uint8_t *buff, uint16_t len) -{ - struct transport_expect_s * self = &transport_expect_; - struct transport_single_s * s; - - //assert_int_not_equal(self->head, self->tail); // "write when none expected"); - assert_true(len + self->msg_len <= TRANSPORT_LEN_MAX); // "receive buffer overflow"); - memcpy(&self->msg_buf[self->msg_len], buff, len); - self->msg_len += len; - - s = &self->buffer[self->tail]; - if (self->msg_len >= s->wr_len) - { - int next = self->tail + 1; - if (next >= TRANSPORT_INVOKE_MAX) - { - next = 0; - } - assert_memory_equal(s->wr_buf, self->msg_buf, s->wr_len); - memcpy(self->msg_buf, self->msg_buf + s->wr_len, self->msg_len - s->wr_len); - self->msg_len -= s->wr_len; - if (s->rd_len) { - fifo_size_t actual_size; - assert_int_equal(0, fifo8_write(rd_fifo, s->rd_buf, (fifo_size_t) s->rd_len, &actual_size)); - assert_int_equal(actual_size, s->rd_len); - } - self->tail = next; - } - return 0; -} - -int32_t transport_read(uint8_t *buff, uint16_t len) -{ - uint16_t i; - for (i = 0; i < len; ++i) { - if (fifo8_read_u8(rd_fifo, buff++)) { - return 1; - } - } - return 0; -} - -void ifc_utils_setup(void) -{ - memset(&transport_expect_, 0, sizeof(transport_expect_)); - assert_int_equal(0, fifo8_alloc(&rd_fifo, TRANSPORT_LEN_MAX + TRANSPORT_INVOKE_MAX)); - assert_true(0 != rd_fifo); -} - -void ifc_utils_teardown(void) -{ - fifo8_free(rd_fifo); -} diff --git a/test_utils/utils.h b/test_utils/utils.h deleted file mode 100644 index e718c16..0000000 --- a/test_utils/utils.h +++ /dev/null @@ -1,10 +0,0 @@ -#ifndef UTILS_H -#define UTILS_H - -#include - -void ifc_utils_setup(void); -void ifc_utils_teardown(void); - -#endif - From 7cd538114b84d6710b6fb257e2aa456418a35299 Mon Sep 17 00:00:00 2001 From: Joe Boring Date: Mon, 12 Aug 2019 18:19:01 -0400 Subject: [PATCH 11/33] Wake up Bytes Seperate wake up bytes from header --- src/ll_ifc.c | 20 ++++++++++++++++++-- 1 file changed, 18 insertions(+), 2 deletions(-) diff --git a/src/ll_ifc.c b/src/ll_ifc.c index d118c17..f1c9260 100644 --- a/src/ll_ifc.c +++ b/src/ll_ifc.c @@ -512,18 +512,34 @@ int32_t ll_reset_state( void ) */ static void send_packet(opcode_t op, uint8_t message_num, uint8_t *buf, uint16_t len) { - #define SP_NUM_ZEROS (6) + #define SP_NUM_WAKEUP_BYTES (5) + #define SP_NUM_ZEROS (3) #define SP_HEADER_SIZE (CMD_HEADER_LEN + SP_NUM_ZEROS) + uint8_t wakeupBuff_buf[SP_HEADER_SIZE]; uint8_t header_buf[SP_HEADER_SIZE]; uint8_t checksum_buff[2]; uint16_t computed_checksum; uint16_t header_idx = 0; uint16_t i; + for (i = 0; i < SP_NUM_WAKEUP_BYTES; i++) + { + wakeupBuff_buf[i] = 0x55; + } + + transport_write(wakeupBuff_buf, SP_NUM_WAKEUP_BYTES); + + for (i = 0; i < 5000; i++) + { + asm("nop"); + } + + + header_idx=0; // Send a couple wakeup bytes, just-in-case for (i = 0; i < SP_NUM_ZEROS; i++) { - header_buf[header_idx ++] = 0x5F; + header_buf[header_idx ++] = 0x07; } header_buf[header_idx++] = FRAME_START; From e95c1d23edd7e0ed7e1f3ec4b5924d02e47e66d5 Mon Sep 17 00:00:00 2001 From: Joe Boring Date: Fri, 16 Aug 2019 14:35:08 -0400 Subject: [PATCH 12/33] allow access to scan functions --- inc/ll_ifc_symphony.h | 32 ++++++++++++++++++++++++++++++++ src/ll_ifc.c | 20 ++------------------ src/ll_ifc_symphony.c | 22 +++++++--------------- 3 files changed, 41 insertions(+), 33 deletions(-) diff --git a/inc/ll_ifc_symphony.h b/inc/ll_ifc_symphony.h index 88b3f4c..f46b85c 100644 --- a/inc/ll_ifc_symphony.h +++ b/inc/ll_ifc_symphony.h @@ -230,6 +230,38 @@ int32_t ll_scan_config_set(enum ll_scan_mode scan_mode, int16_t threshold, uint1 * 0, on success, negative otherwise */ int32_t ll_scan_config_get(enum ll_scan_mode *scan_mode, int16_t *threshold, uint16_t *scan_attempts, uint16_t *scans_left); +/** + * @brief + * Get the current scan mode of the module. + * + * @details + * Returns the scan mode (NORMAL, INFO, QUICK) of the module set by the user + * (or the defualts if the user didn't get the scan mode + * yet). + * + * @param[out] scan_mode + * Pointer to the scan mode of the module. + * + * @return + * 0, on success, negative otherwise + */ +int32_t ll_scan_mode_get(enum ll_scan_mode *scan_mode); + +/** + * @brief + * Set the current scan mode of the module. + * + * @details + * Set the scan mode (NORMAL, INFO, QUICK) of the module + * + * @param[out] scan_mode + * scan mode of the module. + * + * @return + * 0, on success, negative otherwise + */ +int32_t ll_scan_mode_set(enum ll_scan_mode scan_mode); + /** * @brief diff --git a/src/ll_ifc.c b/src/ll_ifc.c index f1c9260..d118c17 100644 --- a/src/ll_ifc.c +++ b/src/ll_ifc.c @@ -512,34 +512,18 @@ int32_t ll_reset_state( void ) */ static void send_packet(opcode_t op, uint8_t message_num, uint8_t *buf, uint16_t len) { - #define SP_NUM_WAKEUP_BYTES (5) - #define SP_NUM_ZEROS (3) + #define SP_NUM_ZEROS (6) #define SP_HEADER_SIZE (CMD_HEADER_LEN + SP_NUM_ZEROS) - uint8_t wakeupBuff_buf[SP_HEADER_SIZE]; uint8_t header_buf[SP_HEADER_SIZE]; uint8_t checksum_buff[2]; uint16_t computed_checksum; uint16_t header_idx = 0; uint16_t i; - for (i = 0; i < SP_NUM_WAKEUP_BYTES; i++) - { - wakeupBuff_buf[i] = 0x55; - } - - transport_write(wakeupBuff_buf, SP_NUM_WAKEUP_BYTES); - - for (i = 0; i < 5000; i++) - { - asm("nop"); - } - - - header_idx=0; // Send a couple wakeup bytes, just-in-case for (i = 0; i < SP_NUM_ZEROS; i++) { - header_buf[header_idx ++] = 0x07; + header_buf[header_idx ++] = 0x5F; } header_buf[header_idx++] = FRAME_START; diff --git a/src/ll_ifc_symphony.c b/src/ll_ifc_symphony.c index 3d96d41..bed526a 100644 --- a/src/ll_ifc_symphony.c +++ b/src/ll_ifc_symphony.c @@ -131,14 +131,14 @@ static int32_t ll_qos_get(uint8_t *qos) return (ret >= 0) ? LL_IFC_ACK : ret; } -static int32_t ll_scan_mode_set(enum ll_scan_mode scan_mode) +int32_t ll_scan_mode_set(enum ll_scan_mode scan_mode) { uint8_t u8_scan_mode = (uint8_t) scan_mode; int32_t ret = hal_read_write(OP_SCAN_MODE_SET, &u8_scan_mode, 1, NULL, 0); return (ret >= 0) ? LL_IFC_ACK : ret; } -static int32_t ll_scan_mode_get(enum ll_scan_mode *scan_mode) +int32_t ll_scan_mode_get(enum ll_scan_mode *scan_mode) { uint8_t u8_scan_mode; int32_t ret = hal_read_write(OP_SCAN_MODE_GET, NULL, 0, &u8_scan_mode, 1); @@ -382,13 +382,6 @@ int32_t ll_poll_scan_result(llabs_gateway_scan_results_t *scan_result, uint8_t * return ret; } - // if only one byte returned then no gateways found. dont deserialize - if (ret == 1) - { - *num_gw = 0; - return LL_IFC_ACK; - } - ll_gw_scan_result_deserialize(buff, scan_result, num_gw); return (ret >= 0) ? LL_IFC_ACK : ret; @@ -406,17 +399,16 @@ int32_t ll_get_gateway_scan_results(llabs_gateway_scan_results_t (*scan_results) int32_t ret = ll_poll_scan_result(&scan_result, &gw); // if scanning will return a NACK_BUSY (6) - // if done scanning, but no gateways will return LL_IFC_ACK but no paylaod - // if done scanning, and gateway, gw will be non zero and decrement each time called + // if done scanning, but no gateways will return NACK_NO_DATA but no paylaod + // if done scanning, and gateway, will return LL_IFC_ACK and gw will be an index (0-?) + // and decrement each time called until gw is zero. Zero is a valid gateway index and last + // one in the list. + // if (ret != LL_IFC_ACK) { return ret; } - // if only - if (ret == 1) - { - } // When num_gw is uninitialized, we need to set it with the total // amount of gateways. The interface decrements num_gw to use as an index prior to // sending so we need to add one for number. From cd297e521e7d13539d0d847f57844fb15ca5b7e9 Mon Sep 17 00:00:00 2001 From: Joe Boring Date: Tue, 20 Aug 2019 16:16:29 -0400 Subject: [PATCH 13/33] Add extra wake up bytes --- src/ll_ifc.c | 20 ++++++++++++++++++-- 1 file changed, 18 insertions(+), 2 deletions(-) diff --git a/src/ll_ifc.c b/src/ll_ifc.c index d118c17..f1c9260 100644 --- a/src/ll_ifc.c +++ b/src/ll_ifc.c @@ -512,18 +512,34 @@ int32_t ll_reset_state( void ) */ static void send_packet(opcode_t op, uint8_t message_num, uint8_t *buf, uint16_t len) { - #define SP_NUM_ZEROS (6) + #define SP_NUM_WAKEUP_BYTES (5) + #define SP_NUM_ZEROS (3) #define SP_HEADER_SIZE (CMD_HEADER_LEN + SP_NUM_ZEROS) + uint8_t wakeupBuff_buf[SP_HEADER_SIZE]; uint8_t header_buf[SP_HEADER_SIZE]; uint8_t checksum_buff[2]; uint16_t computed_checksum; uint16_t header_idx = 0; uint16_t i; + for (i = 0; i < SP_NUM_WAKEUP_BYTES; i++) + { + wakeupBuff_buf[i] = 0x55; + } + + transport_write(wakeupBuff_buf, SP_NUM_WAKEUP_BYTES); + + for (i = 0; i < 5000; i++) + { + asm("nop"); + } + + + header_idx=0; // Send a couple wakeup bytes, just-in-case for (i = 0; i < SP_NUM_ZEROS; i++) { - header_buf[header_idx ++] = 0x5F; + header_buf[header_idx ++] = 0x07; } header_buf[header_idx++] = FRAME_START; From 5c4740e3a5172ed8357d0904c9cb3305120b5e99 Mon Sep 17 00:00:00 2001 From: Joe Boring Date: Mon, 26 Aug 2019 08:55:59 -0400 Subject: [PATCH 14/33] added Alt typedef dont use repeater. Reuse memory for gateway list in symphony. --- inc/ifc_struct_defs.h | 15 +++++++++++++++ 1 file changed, 15 insertions(+) diff --git a/inc/ifc_struct_defs.h b/inc/ifc_struct_defs.h index fe1220a..88428b4 100644 --- a/inc/ifc_struct_defs.h +++ b/inc/ifc_struct_defs.h @@ -98,6 +98,21 @@ typedef struct PACKED llabs_gateway_scan_results uint8_t is_repeater; } llabs_gateway_scan_results_t; +typedef struct PACKED llabs_gateway_scan_results_alt +{ + uint64_t id; + int16_t rssi; + int8_t error_count; + int8_t channel; + uint8_t is_active; +} llabs_gateway_scan_results_alt_t; + +typedef union llabs_gateway_list_data +{ + llabs_gateway_scan_results_t gw_results; + llabs_gateway_scan_results_alt_t gw_data; +}llabs_gateway_list_data_t; + typedef struct PACKED llabs_time { uint32_t seconds; ///< Seconds since UNIX epoch 00:00:00 UTC on 1 January 1970 From 5e0e2e81fdb230c0b5d9f1956f23068a8c8461cd Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=D1=82=D0=BD=CF=83=D0=BC=CE=B1=D1=95=20=D1=95=D1=82=D1=94?= =?UTF-8?q?=CE=B9=D0=B8=D0=BD=CF=83=E2=84=93z?= Date: Fri, 25 Oct 2019 10:06:29 -0400 Subject: [PATCH 15/33] Delete ll_ifc_consts.h.bak --- inc/ll_ifc_consts.h.bak | 389 ---------------------------------------- 1 file changed, 389 deletions(-) delete mode 100644 inc/ll_ifc_consts.h.bak diff --git a/inc/ll_ifc_consts.h.bak b/inc/ll_ifc_consts.h.bak deleted file mode 100644 index d99b7f0..0000000 --- a/inc/ll_ifc_consts.h.bak +++ /dev/null @@ -1,389 +0,0 @@ -#ifndef __LL_IFC_CONSTS_H -#define __LL_IFC_CONSTS_H - -#include - -/** - * @addtogroup Link_Labs_Interface_Library - * @{ - */ - -/** - * @addtogroup Module_Interface - * @brief - * @{ - */ - -#define IFC_VERSION_MAJOR (0) -#define IFC_VERSION_MINOR (8) -#define IFC_VERSION_TAG (0) - -#define APP_TOKEN_LEN (10) -#define UNIQUE_ID_LEN (8) -#define MAX_RX_MSG_LEN (128) - -extern const uint32_t OPEN_NET_TOKEN; ///< Open network token (0x4f50454e) - -typedef enum -{ - OP_VERSION = 0, ///< 0x00 - OP_IFC_VERSION = 1, ///< 0x01 - OP_STATE = 2, ///< 0x02 - OP_TX_STATE = 3, ///< 0x03 - OP_RX_STATE = 4, ///< 0x04 - OP_FREQUENCY = 6, ///< 0x06 - OP_TX_POWER_SET = 7, ///< 0x07 - OP_RESET_SETTINGS = 8, ///< 0x08 - OP_GET_RADIO_PARAMS = 9, ///< 0x09 - OP_SET_RADIO_PARAMS = 10, ///< 0x0A - OP_PKT_SEND_QUEUE = 11, ///< 0x0B - OP_TX_POWER_GET = 12, ///< 0x0C - OP_SYNC_WORD_SET = 13, ///< 0x0D - OP_SYNC_WORD_GET = 14, ///< 0x0E - OP_IRQ_FLAGS = 15, ///< 0x0F - OP_IRQ_FLAGS_MASK = 16, ///< 0x10 - OP_SLEEP = 20, ///< 0x14 - OP_SLEEP_BLOCK = 21, ///< 0x15 - OP_PKT_ECHO = 31, ///< 0x1F - OP_PKT_RECV = 40, ///< 0x28 - OP_MSG_RECV_RSSI = 41, ///< 0x29 - Deprecated for Symphony mode - OP_PKT_RECV_CONT = 42, ///< 0x2A - OP_MSG_RECV = 43, ///< 0x2B - OP_MODULE_ID = 50, ///< 0x32 - OP_STORE_SETTINGS = 51, ///< 0x33 - OP_DELETE_SETTINGS = 52, ///< 0x34 - OP_RESET_MCU = 60, ///< 0x3C - OP_TRIGGER_BOOTLOADER = 61, ///< 0x3D - OP_MAC_MODE_SET = 70, ///< 0x46 - OP_MAC_MODE_GET = 71, ///< 0x47 -//STRIPTHIS!START - OP_RESERVED_LIFERAFT0 = 72, ///< 0x48 - Liferaft Specific (Do not use!) -//STRIPTHIS!STOP - OP_MSG_SEND_ACK = 90, ///< 0x5A - Deprecated - OP_MSG_SEND_UNACK = 91, ///< 0x5B - Deprecated - OP_MSG_SEND = 92, ///< 0x5C - OP_CONN_FILT_SET = 93, ///< 0x5D - OP_CONN_FILT_GET = 94, ///< 0x5E -//STRIPTHIS!START - OP_RESERVED0 = 96, ///< 0x5F - OP_RESERVED1 = 97, ///< 0x60 -//STRIPTHIS!STOP - OP_TX_CW = 98, ///< 0x61 - OP_SYSTEM_TIME_GET = 108, ///< 0x6C - OP_SYSTEM_TIME_SYNC = 109, ///< 0x6D - OP_RX_MODE_SET = 110, ///< 0x6E - OP_RX_MODE_GET = 111, ///< 0x6F - OP_QOS_REQUEST = 112, ///< 0x70 - OP_QOS_GET = 113, ///< 0x71 - OP_ANTENNA_SET = 114, ///< 0x72 - OP_ANTENNA_GET = 115, ///< 0x73 - OP_NET_TOKEN_SET = 116, ///< 0x74 - OP_NET_TOKEN_GET = 117, ///< 0x75 - OP_NET_INFO_GET= 118, ///< 0x76 - OP_STATS_GET = 119, ///< 0x77 - OP_RSSI_SET = 120, ///< 0x78 - OP_RSSI_GET = 121, ///< 0x79 - OP_DL_BAND_CFG_GET = 122, ///< 0x7A - OP_DL_BAND_CFG_SET = 123, ///< 0x7B - OP_APP_TOKEN_SET = 124, ///< 0x7C - OP_APP_TOKEN_GET = 125, ///< 0x7D - OP_APP_TOKEN_REG_GET = 126, ///< 0x7E - OP_CRYPTO_KEY_XCHG_REQ = 128, ///< 0x80 - OP_MAILBOX_REQUEST = 129, ///< 0x81 -//STRIPTHIS!START - OP_RESERVED_LIFERAFT1 = 130, ///< 0x82 - Liferaft Specific (Do not use!) - OP_TIMESTAMP = 131, ///< 0x83 reserved, not fully implemented - OP_SEND_TIMESTAMP = 132, ///< 0x84 reserved, not fully implemented -//STRIPTHIS!STOP - OP_GET_SCAN_INFO = 133, ///< 0x85 - OP_CONN_TO_GW_CH = 134, ///< 0x86 - OP_DISCONNECT = 135, ///< 0x87 - OP_SCAN_MODE_GET = 136, ///< 0x88 - OP_SCAN_MODE_SET = 137, ///< 0x89 - OP_SCAN_THRESHOLD_GET = 138, ///< 0x8A - OP_SCAN_THRESHOLD_SET = 139, ///< 0x8B - OP_SCAN_ATTEMPTS_GET = 140, ///< 0x8C - OP_SCAN_ATTEMPTS_SET = 141, ///< 0x8D - OP_SCAN_ATTEMPTS_LEFT = 142, ///< 0x8E - OP_RSSI_OFFSET_GET = 143, ///< 0x8F - OP_RSSI_OFFSET_SET = 144, ///< 0x90 - OP_CTRL_MSG_ENABLED_SET = 145, ///< 0x91 - OP_CTRL_MSG_ENABLED_GET = 146, ///< 0x92 - OP_GPIO_ENABLE_PIN = 147, ///< 0x93 - OP_GPIO_DISABLE_PIN = 148, ///< 0x94 - OP_GPIO_PIN_STATUS = 149, ///< 0x95 - OP_GPIO_SET_HIGH = 150, ///< 0x96 - OP_GPIO_SET_LOW = 151, ///< 0x97 -//STRIPTHIS!START - OP_FCC_TEST = 245, ///< 0xF5 - OP_PER_TEST_TX = 246, ///< 0xF6 - OP_PER_TEST_RX = 247, ///< 0xF7 - OP_GET_ASSERT = 248, ///< 0xF8 - OP_SET_ASSERT = 249, ///< 0xF9 -//STRIPTHIS!STOP - OP_HARDWARE_TYPE = 254, ///< 0xFE - OP_FIRMWARE_TYPE = 255 ///< 0xFF -} opcode_t; - -typedef enum -{ - FRAME_START = 0xC4 ///< 0xC4 -} frame_t; - -typedef enum -{ - LORA_NO_MAC = 0, ///< 0x00 - DEPRECATED_MAC1, ///< 0x01 - DEPRECATED_MAC2, ///< 0x02 - SYMPHONY_LINK, ///< 0x03 - NUM_MACS, ///< Total number of MAC modes - MAC_INVALID = 255, ///< 0xFF -} ll_mac_type_t; - -/** - * version struct - */ -typedef struct { - uint8_t major; - uint8_t minor; - uint16_t tag; -} ll_version_t; - -#define VERSION_LEN (4) - -// Hardware Types -typedef enum -{ - UNAVAILABLE = 0, ///< 0x00 - LLRLP20_V2 = 1, ///< 0x01 - LLRXR26_V2 = 2, ///< 0x02 - LLRLP20_V3 = 3, ///< 0x03 - LLRXR26_V3 = 4, ///< 0x04 - LLREPEATER = 5 ///< 0x05 AES_TODO - Replace with official part number? -} ll_hardware_type_t; - -/** - * Firmware identifiers - */ -typedef enum -{ - CPU_EFM32TG210F32 = 0, ///< 0x00 - CPU_EFM32G210F128 = 1, ///< 0x01 - CPU_R5F51115ADNE = 2, ///< 0x02 - CPU_R5F51116ADNE = 3, ///< 0x03 - CPU_EFM32GG232F1024 = 4 ///< 0x04 -} cpu_code_t; - -typedef enum -{ - GATEWAY_TX_ONLY = 0, ///< 0x00 - MODULE_END_NODE = 1, ///< 0x01 - REPEATER_HOST = 2 ///< 0x02 - // TBD - How to define others ? -} functionality_code_t; - -/** - * Link Labs LORA enumeration identifiers for Bandwidth - */ -typedef enum -{ - PROPERTY_LORA_BW_MIN = 0, ///< range limit value (lower) - PROPERTY_LORA_BW_62_5 = 0, ///< 62.5KHz BW - PROPERTY_LORA_BW_125 = 1, ///< 125KHz BW - PROPERTY_LORA_BW_250 = 2, ///< 250KHz BW - PROPERTY_LORA_BW_500 = 3, ///< 500KHz BW - PROPERTY_LORA_BW_MAX, ///< range limit value (upper) -} property_bw_t; - -/** - * Link Labs LORA enumeration identifiers for Spreading Factor - */ -typedef enum -{ - PROPERTY_LORA_SF_MIN = 6, ///< range limit value (lower) - PROPERTY_LORA_SF_6 = 6, ///< SF 6 - PROPERTY_LORA_SF_7 = 7, ///< SF 7 - PROPERTY_LORA_SF_8 = 8, ///< SF 8 - PROPERTY_LORA_SF_9 = 9, ///< SF 9 - PROPERTY_LORA_SF_10 = 10, ///< SF 10 - PROPERTY_LORA_SF_11 = 11, ///< SF 11 - PROPERTY_LORA_SF_12 = 12, ///< SF 12 - PROPERTY_LORA_SF_MAX, ///< range limit value (upper) -} property_sf_t; - -/** - * Link Labs LORA enumeration identifiers for Coding rate - */ -typedef enum -{ - PROPERTY_LORA_CR_MIN = 1, ///< range limit value (lower) - PROPERTY_LORA_CR_4_5 = 1, ///< 0x01 -- 4/5 - PROPERTY_LORA_CR_4_6 = 2, ///< 0x02 -- 4/6 - PROPERTY_LORA_CR_4_7 = 3, ///< 0x03 -- 4/7 - PROPERTY_LORA_CR_4_8 = 4, ///< 0x04 -- 4/8 - PROPERTY_LORA_CR_MAX, ///< range limit value (upper) -} property_cr_t; - -typedef struct { - uint16_t cpu_code; - uint16_t functionality_code; -} ll_firmware_type_t; - -#define FIRMWARE_TYPE_LEN (4) - -/** Possible downlink modes for OP_DOWNLINK_MODE */ -typedef enum -{ - DOWNLINK_MODE_OFF = 0, ///< 0x00 - DOWNLINK_MODE_ALWAYS_ON = 1, ///< 0x01 - DOWNLINK_MODE_MAILBOX = 2, ///< 0x02 - DOWNLINK_MODE_PERIODIC = 3, ///< 0x03 - NUM_DOWNLINK_MODES, - DOWNLINK_MODE_FAILURE = 255, ///< 0xFF -} downlink_mode_t; - -/** ACK/NACK Codes */ -#define LL_IFC_ACK (0) ///< All good. -#define LL_IFC_NACK_CMD_NOT_SUPPORTED (1) ///< Command not supported. -#define LL_IFC_NACK_INCORRECT_CHKSUM (2) ///< Incorrect Checksum. -#define LL_IFC_NACK_PAYLOAD_LEN_OOR (3) ///< Length of payload sent in command was out of range. -#define LL_IFC_NACK_PAYLOAD_OOR (4) ///< Payload sent in command was out of range. -#define LL_IFC_NACK_BOOTUP_IN_PROGRESS (5) ///< Not allowed since firmware bootup still in progress. Wait. -#define LL_IFC_NACK_BUSY_TRY_AGAIN (6) ///< Operation prevented by temporary event. Re-try should work. -#define LL_IFC_NACK_APP_TOKEN_REG (7) ///< Application token is not registered for this node. -#define LL_IFC_NACK_PAYLOAD_LEN_EXCEEDED (8) ///< Payload length is greater than the max supported length -#define LL_IFC_NACK_NOT_IN_MAILBOX_MODE (9) ///< Module must be in DOWNLINK_MAILBOX mode -#define LL_IFC_NACK_PAYLOAD_BAD_PROPERTY (10) ///< Invalid property specified in command -#define LL_IFC_NACK_NODATA (11) ///< No data is available to be returned -#define LL_IFC_NACK_QUEUE_FULL (12) ///< Data could not be enqueued for transmission (queue full) -#define LL_IFC_NACK_OTHER (99) -/* When adding a new value, update ll_return_code_name() and ll_return_code_description() */ - -/** Error Codes */ -/* Note: Error codes -1 to -99 map to NACK codes received from the radio */ -typedef enum ll_ifc_error_codes_e { - LL_IFC_ERROR_INCORRECT_PARAMETER = -101, ///< The parameter value was invalid. - LL_IFC_ERROR_INCORRECT_RESPONSE_LENGTH = -102, ///< Module response was not the expected size. - LL_IFC_ERROR_MESSAGE_NUMBER_MISMATCH = -103, ///< Message number in response doesn't match expected - LL_IFC_ERROR_CHECKSUM_MISMATCH = -104, ///< Checksum mismatch - LL_IFC_ERROR_COMMAND_MISMATCH = -105, ///< Command mismatch (responding to a different command) - LL_IFC_ERROR_HOST_INTERFACE_TIMEOUT = -106, ///< Timed out waiting for Rx bytes from interface - LL_IFC_ERROR_BUFFER_TOO_SMALL = -107, ///< Response larger than provided output buffer - LL_IFC_ERROR_START_OF_FRAME = -108, ///< transport_read failed getting FRAME_START - LL_IFC_ERROR_HEADER = -109, ///< transport_read failed getting header - LL_IFC_ERROR_TIMEOUT = -110, ///< The operation timed out. - LL_IFC_ERROR_INCORRECT_MESSAGE_SIZE = -111, ///< The message size from the device was incorrect. - LL_IFC_ERROR_NO_NETWORK = -112, ///< No network was available. - LL_IFC_ERROR_HAL_CALL_FAILED = -113, ///< A User defined function failed. - /* When adding a new value, update ll_return_code_name() and ll_return_code_description() */ -} ll_ifc_error_codes_t; - - -/** Bit Definitions for OP_SET_RADIO_PARAMS */ -#define RADIO_PARAM_FLAGS_SF (1u<<0u) -#define RADIO_PARAM_FLAGS_CR (1u<<1u) -#define RADIO_PARAM_FLAGS_BW (1u<<2u) -#define RADIO_PARAM_FLAGS_FREQ (1u<<3u) -#define RADIO_PARAM_FLAGS_PREAMBLE (1u<<4u) -#define RADIO_PARAM_FLAGS_HEADER (1u<<5u) -#define RADIO_PARAM_FLAGS_CRC (1u<<6u) -#define RADIO_PARAM_FLAGS_IQ (1u<<7u) - -/** Bit Definitions for OP_IRQ_FLAGS */ -#define IRQ_FLAGS_WDOG_RESET (0x00000001UL) ///< Set every time the module reboots after a Watchdog reboot -#define IRQ_FLAGS_RESET (0x00000002UL) ///< Set every time the module reboots for any reason -#define IRQ_FLAGS_TX_DONE (0x00000010UL) ///< Set every time a Tx Queue goes from non-empty to empty -#define IRQ_FLAGS_TX_ERROR (0x00000020UL) ///< Set every time there is a Tx Error -#define IRQ_FLAGS_RX_DONE (0x00000100UL) ///< Set every time a new packet is received -#define IRQ_FLAGS_MAILBOX_EMPTY (0x00000200UL) ///< Set when a GW reports an empty mailbox -#define IRQ_FLAGS_CONNECTED (0x00001000UL) ///< Set every time we transition from the disconnected -> connected state -#define IRQ_FLAGS_DISCONNECTED (0x00002000UL) ///< Set every time we transition from the connected -> disconnected state -//STRIPTHIS!START -// LifeRaft IRQ flags -#define IRQ_FLAGS_ENROLL_GRANT (0x00004000UL) ///< Set when the module has been granted an enrollment by the gateway -//STRIPTHIS!STOP -#define IRQ_FLAGS_CRYPTO_ESTABLISHED (0x00010000UL) ///< Set every time we transition from the crypto not established -> crytpto established state -#define IRQ_FLAGS_APP_TOKEN_CONFIRMED (0x00020000UL) ///< Set every time an application token is confirmed by Conductor -#define IRQ_FLAGS_DOWNLINK_REQUEST_ACK (0x00040000UL) ///< Set every time a downlink registration request is acknowledged -#define IRQ_FLAGS_INITIALIZATION_COMPLETE (0x00080000UL) ///< Set every time the MAC has completed initialization -#define IRQ_FLAGS_CRYPTO_ERROR (0x00100000UL) ///< Set when a crypto exchange attempt fails -#define IRQ_FLAGS_APP_TOKEN_ERROR (0x00200000UL) ///< Set when an application token registration fails -#define IRQ_FLAGS_DOWNLINK_ERROR (0x00400000UL) ///< Set when a downlink registration fails -#define IRQ_CLOUD_GPIO_2_INTERRUPT (0x01000000UL) ///< Set when the cloud GPIO input is triggered -#define IRQ_CLOUD_GPIO_3_INTERRUPT (0x02000000UL) ///< Set when the cloud GPIO input is triggered -//STRIPTHIS!START -// LifeRaft IRQ flags -#define IRQ_FLAGS_STATUS_REQ (0x00400000UL) ///< Set when we want to request the status of the host controller -#define IRQ_FLAGS_FIRMWARE_REQ (0x00800000UL) ///< Set when we want to request the firmware data of the host controller -//STRIPTHIS!STOP -#define IRQ_FLAGS_ASSERT (0x80000000UL) ///< Set every time we transition from the connected->disconnected state - -/** - * @brief - * The operations for ll_timestamp_set(). - */ -typedef enum ll_timestamp_operation_e { - /** - * @brief - * No set operation. - * - * @details - * Just get the current timestamp. - */ - LL_TIMESTAMP_NO_OPERATION, - - /** - * @brief - * Directly set the timestamp from the provided value. - * - * @details - * The value is not applied until the command is processed by the - * module, and it does not account for transmission delay. - */ - LL_TIMESTAMP_SET_IMMEDIATE, - - /** - * @brief - * Synchronize the timestamp using the provided value which - * corresponds to the most recent event. - * - * @details - * Use this mechanism when the host directly controls the trigger - * event received by both the reference time source and the module. - * This mechanism guarantees the module that the reference value - * aligns to the module's timestamp value when the most recent - * trigger event occurred. - */ - LL_TIMESTAMP_SYNC_IMMEDIATE, - - /** - * @brief - * Intelligently synchronize the timestamp using the provided value - * accounting for possible mismatched trigger events. - * - * @details - * Use this mechanism when the host does not control the trigger - * event. When the trigger event is free-running such as with a - * GPS pulse-per-seconds (PPS) output, the reference value may - * be one event behind the module's value. This mechanism allows - * the module to detect and account for this variability. To - * correctly update the module's timestamp using this mechanism: - * - * 1. Read the reference timestamp. - * 2. Call ll_timestamp_set() - * 3. Read the reference timestamp. - * 4. Call ll_timestamp_set() - */ - LL_TIMESTAMP_SYNC -} ll_timestamp_operation_t; - -/** @} (end addtogroup Module_Interface) */ - - - - -/** @} (end defgroup Module_Interface) */ - -/** @} (end addtogroup Link_Labs_Interface_Library) */ - -#endif /* __LL_IFC_CONSTS_H */ From 941962e9e7d70ebc426514d43857180942135919 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=D1=82=D0=BD=CF=83=D0=BC=CE=B1=D1=95=20=D1=95=D1=82=D1=94?= =?UTF-8?q?=CE=B9=D0=B8=D0=BD=CF=83=E2=84=93z?= Date: Fri, 25 Oct 2019 10:06:37 -0400 Subject: [PATCH 16/33] Delete ll_ifc_consts.h.bak.bak --- inc/ll_ifc_consts.h.bak.bak | 367 ------------------------------------ 1 file changed, 367 deletions(-) delete mode 100644 inc/ll_ifc_consts.h.bak.bak diff --git a/inc/ll_ifc_consts.h.bak.bak b/inc/ll_ifc_consts.h.bak.bak deleted file mode 100644 index 637c95a..0000000 --- a/inc/ll_ifc_consts.h.bak.bak +++ /dev/null @@ -1,367 +0,0 @@ -#ifndef __LL_IFC_CONSTS_H -#define __LL_IFC_CONSTS_H - -#include - -/** - * @addtogroup Link_Labs_Interface_Library - * @{ - */ - -/** - * @addtogroup Module_Interface - * @brief - * @{ - */ - -#define IFC_VERSION_MAJOR (0) -#define IFC_VERSION_MINOR (6) -#define IFC_VERSION_TAG (0) - -#define APP_TOKEN_LEN (10) -#define MAX_RX_MSG_LEN (128) - -extern const uint32_t OPEN_NET_TOKEN; ///< Open network token (0x4f50454e) - -typedef enum -{ - OP_VERSION = 0, ///< 0x00 - OP_IFC_VERSION = 1, ///< 0x01 - OP_STATE = 2, ///< 0x02 - OP_TX_STATE = 3, ///< 0x03 - OP_RX_STATE = 4, ///< 0x04 - OP_FREQUENCY = 6, ///< 0x06 - OP_TX_POWER_SET = 7, ///< 0x07 - OP_RESET_SETTINGS = 8, ///< 0x08 - OP_GET_RADIO_PARAMS = 9, ///< 0x09 - OP_SET_RADIO_PARAMS = 10, ///< 0x0A - OP_PKT_SEND_QUEUE = 11, ///< 0x0B - OP_TX_POWER_GET = 12, ///< 0x0C - OP_SYNC_WORD_SET = 13, ///< 0x0D - OP_SYNC_WORD_GET = 14, ///< 0x0E - OP_IRQ_FLAGS = 15, ///< 0x0F - OP_IRQ_FLAGS_MASK = 16, ///< 0x10 - OP_SLEEP = 20, ///< 0x14 - OP_SLEEP_BLOCK = 21, ///< 0x15 - OP_PKT_ECHO = 31, ///< 0x1F - OP_PKT_RECV = 40, ///< 0x28 - OP_MSG_RECV_RSSI = 41, ///< 0x29 - Deprecated for Symphony mode - OP_PKT_RECV_CONT = 42, ///< 0x2A - OP_MSG_RECV = 43, ///< 0x2B - OP_MODULE_ID = 50, ///< 0x32 - OP_STORE_SETTINGS = 51, ///< 0x33 - OP_DELETE_SETTINGS = 52, ///< 0x34 - OP_RESET_MCU = 60, ///< 0x3C - OP_TRIGGER_BOOTLOADER = 61, ///< 0x3D - OP_MAC_MODE_SET = 70, ///< 0x46 - OP_MAC_MODE_GET = 71, ///< 0x47 -//STRIPTHIS!START - OP_RESERVED_LIFERAFT0 = 72, ///< 0x48 - Liferaft Specific (Do not use!) -//STRIPTHIS!STOP - OP_MSG_SEND_ACK = 90, ///< 0x5A - Deprecated - OP_MSG_SEND_UNACK = 91, ///< 0x5B - Deprecated - OP_MSG_SEND = 92, ///< 0x5C - OP_CONN_FILT_SET = 93, ///< 0x5D - OP_CONN_FILT_GET = 94, ///< 0x5E -//STRIPTHIS!START - OP_RESERVED0 = 96, ///< 0x60 - OP_RESERVED1 = 97, ///< 0x60 -//STRIPTHIS!STOP - OP_TX_CW = 98, ///< 0x61 - OP_SYSTEM_TIME_GET = 108, ///< 0x6C - OP_SYSTEM_TIME_SYNC = 109, ///< 0x6D - OP_RX_MODE_SET = 110, ///< 0x6E - OP_RX_MODE_GET = 111, ///< 0x6F - OP_QOS_REQUEST = 112, ///< 0x70 - OP_QOS_GET = 113, ///< 0x71 - OP_ANTENNA_SET = 114, ///< 0x72 - OP_ANTENNA_GET = 115, ///< 0x73 - OP_NET_TOKEN_SET = 116, ///< 0x74 - OP_NET_TOKEN_GET = 117, ///< 0x75 - OP_NET_INFO_GET= 118, ///< 0x76 - OP_STATS_GET = 119, ///< 0x77 - OP_RSSI_SET = 120, ///< 0x78 - OP_RSSI_GET = 121, ///< 0x79 - OP_DL_BAND_CFG_GET = 122, ///< 0x7A - OP_DL_BAND_CFG_SET = 123, ///< 0x7B - OP_APP_TOKEN_SET = 124, ///< 0x7C - OP_APP_TOKEN_GET = 125, ///< 0x7D - OP_APP_TOKEN_REG_GET = 126, ///< 0x7E - OP_CRYPTO_KEY_XCHG_REQ = 128, ///< 0x80 - OP_MAILBOX_REQUEST = 129, ///< 0x81 -//STRIPTHIS!START - OP_RESERVED_LIFERAFT1 = 130, ///< 0x82 - Liferaft Specific (Do not use!) - OP_TIMESTAMP = 131, ///< 0x83 reserved, not fully implemented - OP_SEND_TIMESTAMP = 132, ///< 0x84 reserved, not fully implemented -//STRIPTHIS!STOP - -//STRIPTHIS!START - OP_FCC_TEST = 245, ///< 0xF5 - OP_PER_TEST_TX = 246, ///< 0xF6 - OP_PER_TEST_RX = 247, ///< 0xF7 - OP_GET_ASSERT = 248, ///< 0xF8 - OP_SET_ASSERT = 249, ///< 0xF9 -//STRIPTHIS!STOP - OP_HARDWARE_TYPE = 254, ///< 0xFE - OP_FIRMWARE_TYPE = 255 ///< 0xFF -} opcode_t; - -typedef enum -{ - FRAME_START = 0xC4 ///< 0xC4 -} frame_t; - -typedef enum -{ - LORA_NO_MAC = 0, ///< 0x00 - DEPRECATED_MAC1, ///< 0x01 - DEPRECATED_MAC2, ///< 0x02 - SYMPHONY_LINK, ///< 0x03 - NUM_MACS, ///< Total number of MAC modes - MAC_INVALID = 255, ///< 0xFF -} ll_mac_type_t; - -/** - * version struct - */ -typedef struct { - uint8_t major; - uint8_t minor; - uint16_t tag; -} ll_version_t; - -#define VERSION_LEN (4) - -// Hardware Types -typedef enum -{ - UNAVAILABLE = 0, ///< 0x00 - LLRLP20_V2 = 1, ///< 0x01 - LLRXR26_V2 = 2, ///< 0x02 - LLRLP20_V3 = 3, ///< 0x03 - LLRXR26_V3 = 4, ///< 0x04 - LLREPEATER = 5 ///< 0x05 AES_TODO - Replace with official part number? -} ll_hardware_type_t; - -/** - * Firmware identifiers - */ -typedef enum -{ - CPU_EFM32TG210F32 = 0, ///< 0x00 - CPU_EFM32G210F128 = 1, ///< 0x01 - CPU_R5F51115ADNE = 2, ///< 0x02 - CPU_R5F51116ADNE = 3, ///< 0x03 - CPU_EFM32GG232F1024 = 4 ///< 0x04 -} cpu_code_t; - -typedef enum -{ - GATEWAY_TX_ONLY = 0, ///< 0x00 - MODULE_END_NODE = 1, ///< 0x01 - REPEATER_HOST = 2 ///< 0x02 - // TBD - How to define others ? -} functionality_code_t; - -/** - * Link Labs LORA enumeration identifiers for Bandwidth - */ -typedef enum -{ - PROPERTY_LORA_BW_MIN = 0, ///< range limit value (lower) - PROPERTY_LORA_BW_62_5 = 0, ///< 62.5KHz BW - PROPERTY_LORA_BW_125 = 1, ///< 125KHz BW - PROPERTY_LORA_BW_250 = 2, ///< 250KHz BW - PROPERTY_LORA_BW_500 = 3, ///< 500KHz BW - PROPERTY_LORA_BW_MAX, ///< range limit value (upper) -} property_bw_t; - -/** - * Link Labs LORA enumeration identifiers for Spreading Factor - */ -typedef enum -{ - PROPERTY_LORA_SF_MIN = 6, ///< range limit value (lower) - PROPERTY_LORA_SF_6 = 6, ///< SF 6 - PROPERTY_LORA_SF_7 = 7, ///< SF 7 - PROPERTY_LORA_SF_8 = 8, ///< SF 8 - PROPERTY_LORA_SF_9 = 9, ///< SF 9 - PROPERTY_LORA_SF_10 = 10, ///< SF 10 - PROPERTY_LORA_SF_11 = 11, ///< SF 11 - PROPERTY_LORA_SF_12 = 12, ///< SF 12 - PROPERTY_LORA_SF_MAX, ///< range limit value (upper) -} property_sf_t; - -/** - * Link Labs LORA enumeration identifiers for Coding rate - */ -typedef enum -{ - PROPERTY_LORA_CR_MIN = 1, ///< range limit value (lower) - PROPERTY_LORA_CR_4_5 = 1, ///< 0x01 -- 4/5 - PROPERTY_LORA_CR_4_6 = 2, ///< 0x02 -- 4/6 - PROPERTY_LORA_CR_4_7 = 3, ///< 0x03 -- 4/7 - PROPERTY_LORA_CR_4_8 = 4, ///< 0x04 -- 4/8 - PROPERTY_LORA_CR_MAX, ///< range limit value (upper) -} property_cr_t; - -typedef struct { - uint16_t cpu_code; - uint16_t functionality_code; -} ll_firmware_type_t; - -#define FIRMWARE_TYPE_LEN (4) - -/** Possible downlink modes for OP_DOWNLINK_MODE */ -typedef enum -{ - DOWNLINK_MODE_OFF = 0, ///< 0x00 - DOWNLINK_MODE_ALWAYS_ON = 1, ///< 0x01 - DOWNLINK_MODE_MAILBOX = 2, ///< 0x02 - DOWNLINK_MODE_PERIODIC = 3, ///< 0x03 - NUM_DOWNLINK_MODES, - DOWNLINK_MODE_FAILURE = 255, ///< 0xFF -} downlink_mode_t; - -/** ACK/NACK Codes */ -#define LL_IFC_ACK (0) ///< All good. -#define LL_IFC_NACK_CMD_NOT_SUPPORTED (1) ///< Command not supported. -#define LL_IFC_NACK_INCORRECT_CHKSUM (2) ///< Incorrect Checksum. -#define LL_IFC_NACK_PAYLOAD_LEN_OOR (3) ///< Length of payload sent in command was out of range. -#define LL_IFC_NACK_PAYLOAD_OOR (4) ///< Payload sent in command was out of range. -#define LL_IFC_NACK_BOOTUP_IN_PROGRESS (5) ///< Not allowed since firmware bootup still in progress. Wait. -#define LL_IFC_NACK_BUSY_TRY_AGAIN (6) ///< Operation prevented by temporary event. Re-try should work. -#define LL_IFC_NACK_APP_TOKEN_REG (7) ///< Application token is not registered for this node. -#define LL_IFC_NACK_PAYLOAD_LEN_EXCEEDED (8) ///< Payload length is greater than the max supported length -#define LL_IFC_NACK_NOT_IN_MAILBOX_MODE (9) ///< Module must be in DOWNLINK_MAILBOX mode -#define LL_IFC_NACK_PAYLOAD_BAD_PROPERTY (10) ///< Invalid property specified in command -#define LL_IFC_NACK_NODATA (11) ///< No data is available to be returned -#define LL_IFC_NACK_QUEUE_FULL (12) ///< Data could not be enqueued for transmission (queue full) -#define LL_IFC_NACK_OTHER (99) -/* When adding a new value, update ll_return_code_name() and ll_return_code_description() */ - -/** Error Codes */ -/* Note: Error codes -1 to -99 map to NACK codes received from the radio */ -typedef enum ll_ifc_error_codes_e { - LL_IFC_ERROR_INCORRECT_PARAMETER = -101, ///< The parameter value was invalid. - LL_IFC_ERROR_INCORRECT_RESPONSE_LENGTH = -102, ///< Module response was not the expected size. - LL_IFC_ERROR_MESSAGE_NUMBER_MISMATCH = -103, ///< Message number in response doesn't match expected - LL_IFC_ERROR_CHECKSUM_MISMATCH = -104, ///< Checksum mismatch - LL_IFC_ERROR_COMMAND_MISMATCH = -105, ///< Command mismatch (responding to a different command) - LL_IFC_ERROR_HOST_INTERFACE_TIMEOUT = -106, ///< Timed out waiting for Rx bytes from interface - LL_IFC_ERROR_BUFFER_TOO_SMALL = -107, ///< Response larger than provided output buffer - LL_IFC_ERROR_START_OF_FRAME = -108, ///< transport_read failed getting FRAME_START - LL_IFC_ERROR_HEADER = -109, ///< transport_read failed getting header - LL_IFC_ERROR_TIMEOUT = -110, ///< The operation timed out. - LL_IFC_ERROR_INCORRECT_MESSAGE_SIZE = -111, ///< The message size from the device was incorrect. - LL_IFC_ERROR_NO_NETWORK = -112, ///< No network was available. - LL_IFC_ERROR_HAL_CALL_FAILED = -113, ///< A User defined function failed. - /* When adding a new value, update ll_return_code_name() and ll_return_code_description() */ -} ll_ifc_error_codes_t; - - -/** Bit Definitions for OP_SET_RADIO_PARAMS */ -#define RADIO_PARAM_FLAGS_SF (1u<<0u) -#define RADIO_PARAM_FLAGS_CR (1u<<1u) -#define RADIO_PARAM_FLAGS_BW (1u<<2u) -#define RADIO_PARAM_FLAGS_FREQ (1u<<3u) -#define RADIO_PARAM_FLAGS_PREAMBLE (1u<<4u) -#define RADIO_PARAM_FLAGS_HEADER (1u<<5u) -#define RADIO_PARAM_FLAGS_CRC (1u<<6u) -#define RADIO_PARAM_FLAGS_IQ (1u<<7u) - -/** Bit Definitions for OP_IRQ_FLAGS */ -#define IRQ_FLAGS_WDOG_RESET (0x00000001UL) ///< Set every time the module reboots after a Watchdog reboot -#define IRQ_FLAGS_RESET (0x00000002UL) ///< Set every time the module reboots for any reason -#define IRQ_FLAGS_TX_DONE (0x00000010UL) ///< Set every time a Tx Queue goes from non-empty to empty -#define IRQ_FLAGS_TX_ERROR (0x00000020UL) ///< Set every time there is a Tx Error -#define IRQ_FLAGS_RX_DONE (0x00000100UL) ///< Set every time a new packet is received -#define IRQ_FLAGS_MAILBOX_EMPTY (0x00000200UL) ///< Set when a GW reports an empty mailbox -#define IRQ_FLAGS_CONNECTED (0x00001000UL) ///< Set every time we transition from the disconnected -> connected state -#define IRQ_FLAGS_DISCONNECTED (0x00002000UL) ///< Set every time we transition from the connected -> disconnected state -//STRIPTHIS!START -// LifeRaft IRQ flags -#define IRQ_FLAGS_ENROLL_GRANT (0x00004000UL) ///< Set when the module has been granted an enrollment by the gateway -//STRIPTHIS!STOP -#define IRQ_FLAGS_CRYPTO_ESTABLISHED (0x00010000UL) ///< Set every time we transition from the crypto not established -> crytpto established state -#define IRQ_FLAGS_APP_TOKEN_CONFIRMED (0x00020000UL) ///< Set every time an application token is confirmed by Conductor -#define IRQ_FLAGS_DOWNLINK_REQUEST_ACK (0x00040000UL) ///< Set every time a downlink registration request is acknowledged -#define IRQ_FLAGS_INITIALIZATION_COMPLETE (0x00080000UL) ///< Set every time the MAC has completed initialization -#define IRQ_FLAGS_CRYPTO_ERROR (0x00100000UL) ///< Set when a crypto exchange attempt fails -#define IRQ_FLAGS_APP_TOKEN_ERROR (0x00200000UL) ///< Set when an application token registration fails -//STRIPTHIS!START -// LifeRaft IRQ flags -#define IRQ_FLAGS_STATUS_REQ (0x00400000UL) ///< Set when we want to request the status of the host controller -#define IRQ_FLAGS_FIRMWARE_REQ (0x00800000UL) ///< Set when we want to request the firmware data of the host controller -//STRIPTHIS!STOP -#define IRQ_FLAGS_ASSERT (0x80000000UL) ///< Set every time we transition from the connected->disconnected state - -/** - * @brief - * The operations for ll_timestamp_set(). - */ -typedef enum ll_timestamp_operation_e { - /** - * @brief - * No set operation. - * - * @details - * Just get the current timestamp. - */ - LL_TIMESTAMP_NO_OPERATION, - - /** - * @brief - * Directly set the timestamp from the provided value. - * - * @details - * The value is not applied until the command is processed by the - * module, and it does not account for transmission delay. - */ - LL_TIMESTAMP_SET_IMMEDIATE, - - /** - * @brief - * Synchronize the timestamp using the provided value which - * corresponds to the most recent event. - * - * @details - * Use this mechanism when the host directly controls the trigger - * event received by both the reference time source and the module. - * This mechanism guarantees the module that the reference value - * aligns to the module's timestamp value when the most recent - * trigger event occurred. - */ - LL_TIMESTAMP_SYNC_IMMEDIATE, - - /** - * @brief - * Intelligently synchronize the timestamp using the provided value - * accounting for possible mismatched trigger events. - * - * @details - * Use this mechanism when the host does not control the trigger - * event. When the trigger event is free-running such as with a - * GPS pulse-per-seconds (PPS) output, the reference value may - * be one event behind the module's value. This mechanism allows - * the module to detect and account for this variability. To - * correctly update the module's timestamp using this mechanism: - * - * 1. Read the reference timestamp. - * 2. Call ll_timestamp_set() - * 3. Read the reference timestamp. - * 4. Call ll_timestamp_set() - */ - LL_TIMESTAMP_SYNC -} ll_timestamp_operation_t; - -/** @} (end addtogroup Module_Interface) */ - - - - -/** @} (end defgroup Module_Interface) */ - -/** @} (end addtogroup Link_Labs_Interface_Library) */ - -#endif /* __LL_IFC_CONSTS_H */ From ffa64cc56db8fcce5f98ae50c94ba7f1287bc680 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=D1=82=D0=BD=CF=83=D0=BC=CE=B1=D1=95=20=D1=95=D1=82=D1=94?= =?UTF-8?q?=CE=B9=D0=B8=D0=BD=CF=83=E2=84=93z?= Date: Fri, 25 Oct 2019 10:06:46 -0400 Subject: [PATCH 17/33] Delete ifc_struct_defs.h.bak --- inc/ifc_struct_defs.h.bak | 250 -------------------------------------- 1 file changed, 250 deletions(-) delete mode 100644 inc/ifc_struct_defs.h.bak diff --git a/inc/ifc_struct_defs.h.bak b/inc/ifc_struct_defs.h.bak deleted file mode 100644 index 7861faf..0000000 --- a/inc/ifc_struct_defs.h.bak +++ /dev/null @@ -1,250 +0,0 @@ -#ifndef __IFC_STRUCT_DEFS_H_ -#define __IFC_STRUCT_DEFS_H_ - -#include - -#define NET_INFO_BUFF_SIZE (30) -#define DL_BAND_CFG_SIZE (3 * 4 + 2) -#define STATS_SIZE (10 * 4) -#define TIME_INFO_SIZE (6 * 2 + 1) - -#ifndef PACKED -#if defined ( __CC_ARM ) - #define PACKED(TYPE) __packed TYPE -#elif defined(__GNUC__) || defined(__GNU_C__) - #define PACKED __attribute__ ((packed)) -#elif defined (__ICCARM__) - #define PACKED_STRUCT __packed struct -#else - #error "PACKED must be defined for the platform!" -#endif -#endif - -#ifdef __cplusplus -extern "C" { -#endif - -/** - * @addtogroup Link_Labs_Interface_Library - * @{ - */ - -/** - * @addtogroup Module_Interface - * @brief - * @{ - */ - - -typedef enum -{ - LLABS_CONNECT_INITIAL = 0, ///< 0x00 - LLABS_CONNECT_DISCONNECTED, ///< 0x01 - LLABS_CONNECT_CONNECTED, ///< 0x02 - LLABS_NUM_CONNECT_STATUSES ///< 0x03 -} llabs_connect_status_t; - -typedef struct PACKED llabs_network_info_t -{ - uint32_t network_id_node; - uint32_t network_id_gw; - int8_t gateway_channel; - uint32_t gateway_frequency; - uint32_t last_rx_tick; - int16_t rssi; - int8_t snr; - llabs_connect_status_t connection_status; - uint8_t is_scanning_gateways; - uint64_t gateway_id; -} llabs_network_info_t; - -// Defines the band-specific frequency parameters (FCC 902-928, etc...) -typedef struct PACKED llabs_dl_band_cfg -{ - uint32_t band_edge_lower; - uint32_t band_edge_upper; - uint32_t band_edge_guard; - uint8_t chan_step_size; - uint8_t chan_step_offset; -} llabs_dl_band_cfg_t; - -typedef struct llabs_stats -{ - uint32_t num_send_calls; ///< Number of times SendMessage has been called successfully - uint32_t num_pkts_transmitted; ///< Number of packet transmissions (includes retries) - uint32_t num_gateway_scans; ///< Number of gateway scans - uint32_t num_collisions; ///< Number of CSMA collisions detected - uint32_t num_ack_successes; ///< Number of successful acknowledgments - uint32_t num_ack_failures; ///< Number of failed acknowledgments - uint32_t num_sync_failures; ///< Number of Sync failures - uint32_t num_canceled_pkts_ack; ///< Number of times packet was canceled due to LLABS_ACK_FAIL_RETRIES - uint32_t num_canceled_pkts_csma; ///< Number of times packet was canceled due to LLABS_MAX_CSMA_COLLISIONS - uint32_t num_rx_errors; ///< Number of times we received a Rx error from the back end -} llabs_stats_t; - -typedef struct PACKED llabs_time -{ - uint32_t seconds; ///< Seconds since UNIX epoch 00:00:00 UTC on 1 January 1970 - uint16_t millis; ///< number of milliseconds since time seconds since the epoch -} llabs_time_t; - -typedef struct PACKED llabs_time_info -{ - uint8_t sync_mode; ///< 0: Time sync only when requested, 1: Time sync opportunistically - llabs_time_t curr; - llabs_time_t last_sync; -} llabs_time_info_t; - -void ll_net_info_deserialize(const uint8_t buff[NET_INFO_BUFF_SIZE], llabs_network_info_t * net_info); -uint16_t ll_net_info_serialize(const llabs_network_info_t * net_info, uint8_t buff[NET_INFO_BUFF_SIZE]); -void ll_dl_band_cfg_deserialize(const uint8_t buff[DL_BAND_CFG_SIZE], llabs_dl_band_cfg_t * dl_cfg); -uint16_t ll_dl_band_cfg_serialize(const llabs_dl_band_cfg_t * dl_cfg, uint8_t buff[DL_BAND_CFG_SIZE]); -void ll_stats_deserialize(const uint8_t buff[STATS_SIZE], llabs_stats_t * stats); -uint16_t ll_stats_serialize(const llabs_stats_t * stats, uint8_t buff[STATS_SIZE]); -void ll_time_deserialize(const uint8_t buff[TIME_INFO_SIZE], llabs_time_info_t *time_info); -uint16_t ll_time_serialize(const llabs_time_info_t *time_info, uint8_t buff[TIME_INFO_SIZE]); - - -/** @} (end addtogroup Module_Interface) */ - -/* - * @defgroup ifc_serialize Serialization utilities - * @private - * @brief Format common data types for the host IFC message - * protocol. - * - * The utility functions contained in this group serialize (marshal) and - * deserialize (unmarshal) the common integer datatypes exchanged within - * messages over the host interface. The write_* functions serialize an - * integer into a byte stream , and the read_* functions deserialize an - * integer from a byte stream. - * - * See - * serialization on Wikipedia for more details about why these functions - * exist. - */ - /** - * @{ - */ - -/** - * @brief - * Read a u8 from the buffer [not memory safe]. - * - * @private - * @param[inout] buffer - * The pointer to the big-endian buffer. The pointer is - * incremented to the next location past the value read. - * - * @return - * The u8 read from the buffer. - */ -uint8_t read_uint8(const uint8_t ** buffer); - -/** - * @brief - * Read a u16 from the buffer [not memory safe]. - * - * @private - * @param[inout] buffer - * The pointer to the big-endian buffer. The pointer is - * incremented to the next location past the value read. - * - * @return - * The u16 read from the buffer. - */ -uint16_t read_uint16(const uint8_t ** buffer); - -/** - * @brief - * Read a u32 from the buffer [not memory safe]. - * - * @private - * @param[inout] buffer - * The pointer to the big-endian buffer. The pointer is - * incremented to the next location past the value read. - * - * @return - * The u32 read from the buffer. - */ -uint32_t read_uint32(const uint8_t ** buffer); - -/** - * @brief - * Read a u64 from the buffer [not memory safe]. - * - * @private - * @param[inout] buffer - * The pointer to the big-endian buffer. The pointer is - * incremented to the next location past the value read. - * - * @return - * The u64 read from the buffer. - */ -uint64_t read_uint64(const uint8_t ** buffer); - -/** - * @brief - * Write a u8 to the buffer [not memory safe]. - * - * @private - * @param[in] x - * The u8 to write. - * - * @param[inout] buffer - * The pointer to the big-endian buffer. The pointer is - * incremented to the next location past the value written. - */ -void write_uint8(uint8_t x, uint8_t ** buffer); - -/** - * @brief - * Write a u16 to the buffer [not memory safe]. - * - * @private - * @param[in] x - * The u16 to write. - * - * @param[inout] buffer - * The pointer to the big-endian buffer. The pointer is - * incremented to the next location past the value written. - */ -void write_uint16(uint16_t x, uint8_t ** buffer); - -/** - * @brief - * Write a u32 to the buffer [not memory safe]. - * - * @private - * @param[in] x - * The u32 to write. - * - * @param[inout] buffer - * The pointer to the big-endian buffer. The pointer is - * incremented to the next location past the value written. - */ -void write_uint32(uint32_t x, uint8_t ** buffer); - -/** - * @brief - * Write a u64 to the buffer [not memory safe]. - * - * @private - * @param[in] x - * The u64 to write. - * - * @param[inout] buffer - * The pointer to the big-endian buffer. The pointer is - * incremented to the next location past the value written. - */ -void write_uint64(uint64_t x, uint8_t ** buffer); - -/** @} (end defgroup ifc_serialize) */ - -/** @} (end addtogroup Link_Labs_Interface_Library) */ - -#ifdef __cplusplus -} -#endif - -#endif From fb080b71152de86a6c24782dccd02d10172fe622 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=D1=82=D0=BD=CF=83=D0=BC=CE=B1=D1=95=20=D1=95=D1=82=D1=94?= =?UTF-8?q?=CE=B9=D0=B8=D0=BD=CF=83=E2=84=93z?= Date: Fri, 25 Oct 2019 10:06:59 -0400 Subject: [PATCH 18/33] Delete ll_ifc_symphony.h.bak --- inc/ll_ifc_symphony.h.bak | 375 -------------------------------------- 1 file changed, 375 deletions(-) delete mode 100644 inc/ll_ifc_symphony.h.bak diff --git a/inc/ll_ifc_symphony.h.bak b/inc/ll_ifc_symphony.h.bak deleted file mode 100644 index 73ba78d..0000000 --- a/inc/ll_ifc_symphony.h.bak +++ /dev/null @@ -1,375 +0,0 @@ -#ifndef __LL_IFC_SYMPHONY_H -#define __LL_IFC_SYMPHONY_H - -#include -#include -#include "ll_ifc.h" - -#ifdef __cplusplus -extern "C" { -#endif - -/** - * @addtogroup Link_Labs_Interface_Library - * @{ - */ - -/** - * @defgroup Symphony_Interface Symphony Link - * - * @brief Communicate with a Symphony Link network. - * - * Symphony Link mode allows the external host to communicate with Symphony - * Link networks, a dynamic IEEE 802.15.4 based LoRa wireless system built - * specifically for low power, wide-area connectivity. - * - * @{ - */ - -enum ll_downlink_mode { - LL_DL_OFF = 0, ///< 0x00 - LL_DL_ALWAYS_ON = 1, ///< 0x01 - LL_DL_MAILBOX = 2, ///< 0x02 -}; - -enum ll_state { - LL_STATE_IDLE_CONNECTED = 1, ///< 0x01 - LL_STATE_IDLE_DISCONNECTED = 2, ///< 0x02 - LL_STATE_INITIALIZING = 3, ///< 0x03 - LL_STATE_ERROR = -1, ///< 0xFF -}; - -enum ll_tx_state { - LL_TX_STATE_TRANSMITTING = 1, ///< 0x01 - LL_TX_STATE_SUCCESS = 2, ///< 0x02 - LL_TX_STATE_ERROR = -1, ///< 0xFF -}; - -enum ll_rx_state { - LL_RX_STATE_NO_MSG = 0, ///< 0x00 - LL_RX_STATE_RECEIVED_MSG = 1, ///< 0x01 -}; - -/** - * @brief An exposed buffer that will be used internally, but can also be used - * to hold uplink messages for 'll_message_send' to avoid double-buffering. - * The buffer has size 256 bytes. - */ -extern uint8_t *uplink_message_buff; - -extern const llabs_dl_band_cfg_t DL_BAN_FCC; ///< USA / Mexico DL Band Configuration -extern const llabs_dl_band_cfg_t DL_BAN_BRA; ///< Brazil DL Band Configuration -extern const llabs_dl_band_cfg_t DL_BAN_AUS; ///< Australia DL Band Configuration -extern const llabs_dl_band_cfg_t DL_BAN_NZL; ///< New Zealand DL Band Configuration -extern const llabs_dl_band_cfg_t DL_BAN_ETSI; ///< Europe (ETSI) DL Band Configuration - - -/** - * @brief - * Set the current configuration of the module. - * - * @details - * Sets the configuration values for the module. The module - * will only respond to values that have changed. For example, - * if the app token is set to the app token that the module already - * has, it will not try to re-register the app token. - * - * The user should call this function whenever the module is powered on. - * - * @param[in] net_token - * The network token set for this module. This determines what gateways the - * module will connect to. Use `OPEN_NET_TOKEN` if you don't have a particular - * network token. - * - * @param[in] app_token - * The app token set for this module. This is what registers your uplink - * messages with your Conductor account. - * - * @param[in] dl_mode - * The downlink mode for this module. - * - * @param[in] qos - * The quality of service level [0-15] for this module. The higher the - * quality of service, the faster uplink messages will be transmitted. - * Note that too many modules with a high quality of service may adversely - * affect network capacity. - * - * @return - * 0 - success, negative otherwise. - */ -int32_t ll_config_set(uint32_t net_token, const uint8_t app_token[APP_TOKEN_LEN], - enum ll_downlink_mode dl_mode, uint8_t qos); - -/** - * @brief - * Get the current configuration of the module. - * - * @details - * Returns the configuration set by the user (or defaults - * if the user didn't set config yet). The config parameters - * may not be in effect yet. For example, this function will return - * the downlink mode that the user requested even though - * the module may not have entered that downlink mode yet. - * - * @param[out] net_token - * The network token set for this module. - * - * @param[out] app_token - * The app token set for this module. - * - * @param[out] dl_mode - * The downlink mode requested for this module. - * - * @param[out] qos - * The quality of service level [0-15] requested for this module. - * - * @return - * 0 - success, negative otherwise. - */ -int32_t ll_config_get(uint32_t *net_token, uint8_t app_token[APP_TOKEN_LEN], - enum ll_downlink_mode * dl_mode, uint8_t *qos); - -/** - * @brief - * Gets the state of the module. - * - * @details - * Returns the state of the module as three separate states: The general - * connection state, the state of the current uplink message, and the - * state of the current downlink message. - * - * @param[out] state - * The state of the connection. If the state is `LL_STATE_ERROR`, then this - * invalidates any of the other state variables. - * - * @param[out] tx_state - * The state of the transmission. If no messages have been sent by the user since the - * last reboot, then this variable is invalid. Otherwise, it returns the result of - * the last transmission (or LL_TX_STATE_TRANSMITTING if the message is in progress). - * - * @param[out] rx_state - * The state of the received message. Either the module has a downlink message ready for - * the user to pull out with `ll_retrieve_message`, or not. Once the user pulls out the - * message using `ll_retrieve_message`, this state will be reset. - * - * @return - * 0 - success, negative otherwise. - */ -int32_t ll_get_state(enum ll_state * state, enum ll_tx_state * tx_state, enum ll_rx_state * rx_state); - -/** - *@brief - * Request. - * - *@return - * 0 - success, negative otherwise (Fails if module is not in MAILBOX mode). - */ -int32_t ll_mailbox_request(void); - -/** - *@brief - * Get the end node's application token's registration status. - * - *@param[out] is_registered - * 1=>registered, 0=>otherwise - * - *@return - * 0 - success, negative otherwise. - */ -int32_t ll_app_reg_get(uint8_t *is_registered); - -/** - *@brief - * Request a new key exchange between end node and gateway. - * - *@return - * 0 - success, negative otherwise. - */ -int32_t ll_encryption_key_exchange_request(void); - -/** - * @brief - * Get the Network Info. - * - * @param[out] net_info - * Network Info: - * All multi byte values are sent over in little-endian mode. - * Byte [0-3] : uint32_t network id (node) - * Byte [4-7] : uint32_t network id (gateway) - * Byte [8] : int8_t gateway channel - * Byte [9-12] : uint32_t gateway frequency - * Byte [13-16] : uint32_t Seconds elapsed since last beacon Rx'd - * Byte [17-18] : int16_t Downlink RSSI [dBm] - * Byte [19] : uint8_t Downlink SNR [dB] - * Byte [20-23] : uint32_t Connection Status (0=Unknown, 1=Disconnected, 2=Connected) - * - * @return - * 0 - success, negative otherwise. - */ -int32_t ll_net_info_get(llabs_network_info_t *net_info); - -/** - * @brief - * Get the Network Communication Statistics. - * - * @param[out] s - * The stats struct sent by the module. - * - * @return - * 0 - success, negative otherwise. - */ -int32_t ll_stats_get(llabs_stats_t *s); - -/** - * @brief - * Get the Downlink Band Configuration. - * - * @param[out] p_dl_band_cfg - * The band cfg struct sent by the module. - * - * @return - * 0 - success, negative otherwise. - */ -int32_t ll_dl_band_cfg_get(llabs_dl_band_cfg_t *p_dl_band_cfg); - - -/** - * @brief - * Set the Downlink Band Configuration. - * - * @param[in] p_dl_band_cfg - * The band cfg struct sent by the module. - * - * @return - * 0 - success, negative otherwise. - */ -int32_t ll_dl_band_cfg_set(const llabs_dl_band_cfg_t *p_dl_band_cfg); - -/** - * @brief - * Get the Connection Filter value. - * - * @param[out] p_f - * The current value is written to *p_f. - * 0 = Allow connections to any available devices - * 1 = Allow connection to Gateways only - * 2 = Allow connection to Repeaters only - * - * @return - * 0 - success, negative otherwise. - */ -int32_t ll_connection_filter_get(uint8_t* p_f); - -/** - * @brief - * Set the Connection Filter value. - * - * @param[in] f - * Same param ll_connection_filter_get(). - * - * @return - * 0 - success, negative otherwise. - */ -int32_t ll_connection_filter_set(uint8_t f); - -/** - * @brief - * Get the system time as number of seconds since the - * UNIX epoch 00:00:00 UTC on 1 January 1970 - * and the time the module last synchronized time with the gateway. - * - * @param[out] - * The time_info struct sent by the module. - * - * @return - * 0 - success, negative otherwise. - */ -int32_t ll_system_time_get(llabs_time_info_t *time_info); - -/** - * @brief - * Force the module to synchronize system time from the gateway. - * - * @note - * worse-case delay for synchronization is the Info Block period - * which defaults to 8 seconds. - * - * @param[in] sync_mode - * 0 - Time sync only when requested. - * 1 - Time sync opportunistically. - * - * @return - * 0 - success, negative otherwise. - */ -int32_t ll_system_time_sync(uint8_t sync_mode); - -/** - * @brief - * Request Symphony MAC to send an acknowledged uplink message. - * - * @details - * When the message finishes transmission the module will return to the idle state. - * Internally the function copies the message into a larger buffer. If you want to - * avoid having two buffers you can use the larger buffer (uplink_message_buff) - * to hold the message then call this function with that buffer. - * - * @param[in] buf - * byte array containing the data payload. - * - * @param[in] len - * length of the input buffer in bytes. - * - * @param[in] ack - * Whether or not to request an ACK from the gateway. - * - * @param[in] port - * The port number to send to. Valid user ports are 0 through 127. - * Ports 128 through 255 are reserved for predefined protocols. - * - * @return - * positive number of bytes queued, - * negative if an error. - */ -int32_t ll_message_send(uint8_t buf[], uint16_t len, bool ack, uint8_t port); - -/** - * @brief - * Retrieves a downlink message received by the module. - * - * @details - * This function should be called when the `rx_state` variable from the `get_state` - * function is `LL_RX_STATE_RECEIVED_MSG'. - * - * @param[out] buf - * The buffer into which the received message will be placed. This buffer must - * be at least 4 bytes larger than the maximum message size expected - * (4 bytes will be used to get the RSSI, SNR, and port). - * - * @param[in,out] size - * The size of the output buffer. If the message is successfully retrieved, - * this will be set to the size of the message (without the RSSI, SNR, and port). - * - * @param[out] port - * The port number associated with the message. - * - * @param[out] rssi - * The rssi of the received message. - * - * @param[out] snr - * The snr of the received message. - * - * @return - * 0 - success, negative otherwise. - */ -int32_t ll_retrieve_message(uint8_t *buf, uint16_t *size, uint8_t *port, int16_t *rssi, uint8_t *snr); - -/** @} (end defgroup Symphony_Interface) */ - -/** @} (end addtogroup Link_Labs_Interface_Library) */ - - -#ifdef __cplusplus -} -#endif - -#endif From 829059929a71bda0bb81d311ef69bc3c0a1a1e8c Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=D1=82=D0=BD=CF=83=D0=BC=CE=B1=D1=95=20=D1=95=D1=82=D1=94?= =?UTF-8?q?=CE=B9=D0=B8=D0=BD=CF=83=E2=84=93z?= Date: Fri, 25 Oct 2019 10:07:14 -0400 Subject: [PATCH 19/33] Delete ifc_struct_defs.c.bak --- src/ifc_struct_defs.c.bak | 148 -------------------------------------- 1 file changed, 148 deletions(-) delete mode 100644 src/ifc_struct_defs.c.bak diff --git a/src/ifc_struct_defs.c.bak b/src/ifc_struct_defs.c.bak deleted file mode 100644 index 6747dd9..0000000 --- a/src/ifc_struct_defs.c.bak +++ /dev/null @@ -1,148 +0,0 @@ -#include -#include "ifc_struct_defs.h" - -uint8_t read_uint8(const uint8_t ** buffer) { - return *((*buffer)++); -} - -uint16_t read_uint16(const uint8_t ** buffer) { - return (((uint16_t) read_uint8(buffer)) << 8) | - ((uint16_t) read_uint8(buffer)); -} - -uint32_t read_uint32(const uint8_t ** buffer) { - return (((uint32_t) read_uint16(buffer)) << 16) | - ((uint32_t) read_uint16(buffer)); -} - -uint64_t read_uint64(const uint8_t ** buffer) { - return (((uint64_t) read_uint32(buffer)) << 32) | - ((uint64_t) read_uint32(buffer)); -} - -void write_uint8(uint8_t x, uint8_t ** buffer) { - *((*buffer)++) = x; -} - -void write_uint16(uint16_t x, uint8_t ** buffer) { - write_uint8(x >> 8, buffer); - write_uint8(x, buffer); -} - -void write_uint32(uint32_t x, uint8_t ** buffer) { - write_uint16(x >> 16, buffer); - write_uint16(x, buffer); -} - -void write_uint64(uint64_t x, uint8_t ** buffer) { - write_uint32(x >> 32, buffer); - write_uint32(x, buffer); -} - -// Parse a serialized llabs_network_info_t struct. -void ll_net_info_deserialize(const uint8_t buff[NET_INFO_BUFF_SIZE], llabs_network_info_t *net_info) -{ - uint8_t const * b = buff; - net_info->network_id_node = read_uint32(&b); - net_info->network_id_gw = read_uint32(&b); - net_info->gateway_channel = read_uint8(&b); - net_info->gateway_frequency = read_uint32(&b); - net_info->last_rx_tick = read_uint32(&b); - net_info->rssi = read_uint16(&b); - net_info->snr = read_uint8(&b); - net_info->connection_status = (llabs_connect_status_t) read_uint8(&b); - net_info->is_scanning_gateways = read_uint8(&b); - net_info->gateway_id = read_uint64(&b); - net_info->is_repeater = read_uint8(&b); -} - -// Serializes an llabs_network_info_t struct into a buffer to be sent over the host interface. -// Returns the size of the serialized struct in the buffer. -uint16_t ll_net_info_serialize(const llabs_network_info_t *net_info, uint8_t buff[NET_INFO_BUFF_SIZE]) -{ - uint8_t * buff_cpy = buff; - write_uint32(net_info->network_id_node, &buff_cpy); - write_uint32(net_info->network_id_gw, &buff_cpy); - write_uint8(net_info->gateway_channel, &buff_cpy); - write_uint32(net_info->gateway_frequency, &buff_cpy); - write_uint32(net_info->last_rx_tick, &buff_cpy); - write_uint16(net_info->rssi, &buff_cpy); - write_uint8(net_info->snr, &buff_cpy); - write_uint8(net_info->connection_status, &buff_cpy); - write_uint8(net_info->is_scanning_gateways, &buff_cpy); - write_uint64(net_info->gateway_id, &buff_cpy); - return buff_cpy - buff; -} - -void ll_dl_band_cfg_deserialize(const uint8_t buff[DL_BAND_CFG_SIZE], llabs_dl_band_cfg_t *dl_cfg) -{ - uint8_t const * b = buff; - dl_cfg->band_edge_lower = read_uint32(&b); - dl_cfg->band_edge_upper = read_uint32(&b); - dl_cfg->band_edge_guard = read_uint32(&b); - dl_cfg->chan_step_size = read_uint8(&b); - dl_cfg->chan_step_offset = read_uint8(&b); -} - -uint16_t ll_dl_band_cfg_serialize(const llabs_dl_band_cfg_t *dl_cfg, uint8_t buff[DL_BAND_CFG_SIZE]) -{ - uint8_t * b = buff; - write_uint32(dl_cfg->band_edge_lower, &b); - write_uint32(dl_cfg->band_edge_upper, &b); - write_uint32(dl_cfg->band_edge_guard, &b); - write_uint8(dl_cfg->chan_step_size, &b); - write_uint8(dl_cfg->chan_step_offset, &b); - return b - buff; -} - -void ll_stats_deserialize(const uint8_t buff[STATS_SIZE], llabs_stats_t *stats) -{ - uint8_t const * b = buff; - stats->num_send_calls = read_uint32(&b); - stats->num_pkts_transmitted = read_uint32(&b); - stats->num_gateway_scans = read_uint32(&b); - stats->num_collisions = read_uint32(&b); - stats->num_ack_successes = read_uint32(&b); - stats->num_ack_failures = read_uint32(&b); - stats->num_sync_failures = read_uint32(&b); - stats->num_canceled_pkts_ack = read_uint32(&b); - stats->num_canceled_pkts_csma = read_uint32(&b); - stats->num_rx_errors = read_uint32(&b); -} - -uint16_t ll_stats_serialize(const llabs_stats_t *stats, uint8_t buff[STATS_SIZE]) -{ - uint8_t * b = buff; - write_uint32(stats->num_send_calls, &b); - write_uint32(stats->num_pkts_transmitted, &b); - write_uint32(stats->num_gateway_scans, &b); - write_uint32(stats->num_collisions, &b); - write_uint32(stats->num_ack_successes, &b); - write_uint32(stats->num_ack_failures, &b); - write_uint32(stats->num_sync_failures, &b); - write_uint32(stats->num_canceled_pkts_ack, &b); - write_uint32(stats->num_canceled_pkts_csma, &b); - write_uint32(stats->num_rx_errors, &b); - return b - buff; -} - -void ll_time_deserialize(const uint8_t buff[TIME_INFO_SIZE], llabs_time_info_t *time_info) -{ - uint8_t const * b = buff; - time_info->sync_mode = read_uint8(&b); - time_info->curr.seconds = read_uint32(&b); - time_info->curr.millis = read_uint16(&b); - time_info->last_sync.seconds = read_uint32(&b); - time_info->last_sync.millis = read_uint16(&b); -} - -uint16_t ll_time_serialize(const llabs_time_info_t *time_info, uint8_t buff[TIME_INFO_SIZE]) -{ - uint8_t * b = buff; - write_uint8(time_info->sync_mode, &b); - write_uint32(time_info->curr.seconds, &b); - write_uint16(time_info->curr.millis, &b); - write_uint32(time_info->last_sync.seconds, &b); - write_uint16(time_info->last_sync.millis, &b); - return b - buff; -} From 51f9e67f816b2a16bc5762c4233d94c2073531dd Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=D1=82=D0=BD=CF=83=D0=BC=CE=B1=D1=95=20=D1=95=D1=82=D1=94?= =?UTF-8?q?=CE=B9=D0=B8=D0=BD=CF=83=E2=84=93z?= Date: Fri, 25 Oct 2019 10:07:21 -0400 Subject: [PATCH 20/33] Delete ll_ifc.c.bak --- src/ll_ifc.c.bak | 692 ----------------------------------------------- 1 file changed, 692 deletions(-) delete mode 100644 src/ll_ifc.c.bak diff --git a/src/ll_ifc.c.bak b/src/ll_ifc.c.bak deleted file mode 100644 index 5eb1bef..0000000 --- a/src/ll_ifc.c.bak +++ /dev/null @@ -1,692 +0,0 @@ -#include "ll_ifc.h" -#include "ll_ifc_consts.h" -#include "ifc_struct_defs.h" -#include "ll_ifc_symphony.h" -#include "ll_ifc_no_mac.h" -#include -#include -#include - -#ifndef NULL // defines NULL on *some* platforms -#define NULL (0) -#endif -#define CMD_HEADER_LEN (5) -#define RESP_HEADER_LEN (6) -static uint16_t compute_checksum(uint8_t *hdr, uint16_t hdr_len, uint8_t *payload, uint16_t payload_len); -static void send_packet(opcode_t op, uint8_t message_num, uint8_t *buf, uint16_t len); -static int32_t recv_packet(opcode_t op, uint8_t message_num, uint8_t *buf, uint16_t len); - -const uint32_t OPEN_NET_TOKEN = 0x4f50454e; - -static int32_t message_num = 0; - -int32_t hal_read_write(opcode_t op, uint8_t buf_in[], uint16_t in_len, uint8_t buf_out[], uint16_t out_len) -{ - // int i; - // int curr_byte; - // int num_bytes; - - int32_t ret; - - // Error checking: - // Only valid combinations of buffer & length pairs are: - // buf == NULL, len = 0 - // buf != NULL, len > 0 - if (((buf_in != NULL) && ( in_len == 0)) || (( buf_in == NULL) && ( in_len > 0))) - { - return(LL_IFC_ERROR_INCORRECT_PARAMETER); - } - if (((buf_out != NULL) && (out_len == 0)) || ((buf_out == NULL) && (out_len > 0))) - { - return(LL_IFC_ERROR_INCORRECT_PARAMETER); - } - - // OK, inputs have been sanitized. Carry on... - send_packet(op, message_num, buf_in, in_len); - - ret = recv_packet(op, message_num, buf_out, out_len); - - message_num++; - - return(ret); -} - -int32_t hal_read_write_exact(opcode_t op, uint8_t buf_in[], uint16_t in_len, uint8_t buf_out[], uint16_t out_len) -{ - int32_t ret = hal_read_write(op, buf_in, in_len, buf_out, out_len); - if (ret >= 0) - { - if (ret != out_len) - { - return LL_IFC_ERROR_INCORRECT_RESPONSE_LENGTH; - } - ret = 0; - } - return ret; -} - -char const * ll_return_code_name(int32_t return_code) -{ - switch (return_code) - { - case -LL_IFC_ACK: return "ACK"; - case -LL_IFC_NACK_CMD_NOT_SUPPORTED: return "CMD_NOT_SUPPORTED"; - case -LL_IFC_NACK_INCORRECT_CHKSUM: return "INCORRECT_CHKSUM "; - case -LL_IFC_NACK_PAYLOAD_LEN_OOR: return "PAYLOAD_LEN_OOR"; - case -LL_IFC_NACK_PAYLOAD_OOR: return "PAYLOAD_OOR"; - case -LL_IFC_NACK_BOOTUP_IN_PROGRESS: return "BOOTUP_IN_PROGRESS"; - case -LL_IFC_NACK_BUSY_TRY_AGAIN: return "BUSY_TRY_AGAIN"; - case -LL_IFC_NACK_APP_TOKEN_REG: return "APP_TOKEN_REG"; - case -LL_IFC_NACK_PAYLOAD_LEN_EXCEEDED: return "PAYLOAD_LEN_EXCEEDED"; - case -LL_IFC_NACK_NOT_IN_MAILBOX_MODE: return "NOT IN MAILBOX MODE"; - case -LL_IFC_NACK_PAYLOAD_BAD_PROPERTY: return "BAD PROPERTY ID"; - case -LL_IFC_NACK_NODATA: return "NO DATA AVAIL"; - case -LL_IFC_NACK_QUEUE_FULL: return "QUEUE FULL"; - case -LL_IFC_NACK_OTHER: return "OTHER"; - - case LL_IFC_ERROR_INCORRECT_PARAMETER: return "INCORRECT_PARAMETER"; - case LL_IFC_ERROR_INCORRECT_RESPONSE_LENGTH: return "INCORRECT_RESPONSE_LENGTH"; - case LL_IFC_ERROR_MESSAGE_NUMBER_MISMATCH: return "MESSAGE_NUMBER_MISMATCH"; - case LL_IFC_ERROR_CHECKSUM_MISMATCH: return "CHECKSUM_MISMATCH"; - case LL_IFC_ERROR_COMMAND_MISMATCH: return "COMMAND_MISMATCH"; - case LL_IFC_ERROR_HOST_INTERFACE_TIMEOUT: return "HOST_INTERFACE_TIMEOUT"; - case LL_IFC_ERROR_BUFFER_TOO_SMALL: return "BUFFER_TOO_SMALL"; - case LL_IFC_ERROR_START_OF_FRAME: return "START_OF_FRAME"; - case LL_IFC_ERROR_HEADER: return "HEADER"; - case LL_IFC_ERROR_TIMEOUT: return "TIMEOUT"; - case LL_IFC_ERROR_INCORRECT_MESSAGE_SIZE: return "INCORRECT_MESSAGE_SIZE"; - case LL_IFC_ERROR_NO_NETWORK: return "NO_NETWORK"; - - default: return "UNKNOWN"; - } -} - -char const * ll_return_code_description(int32_t return_code) -{ - switch (return_code) - { - case -LL_IFC_ACK: return "success"; - case -LL_IFC_NACK_CMD_NOT_SUPPORTED: return "Command not supported"; - case -LL_IFC_NACK_INCORRECT_CHKSUM: return "Incorrect Checksum"; - case -LL_IFC_NACK_PAYLOAD_LEN_OOR: return "Length of payload sent in command was out of range"; - case -LL_IFC_NACK_PAYLOAD_OOR: return "Payload sent in command was out of range."; - case -LL_IFC_NACK_BOOTUP_IN_PROGRESS: return "Not allowed since firmware bootup still in progress. Wait."; - case -LL_IFC_NACK_BUSY_TRY_AGAIN: return "Operation prevented by temporary event. Retry later."; - case -LL_IFC_NACK_APP_TOKEN_REG: return "Application token is not registered for this node."; - case -LL_IFC_NACK_PAYLOAD_LEN_EXCEEDED: return "Payload length is greater than the max supported length"; - case -LL_IFC_NACK_NOT_IN_MAILBOX_MODE: return "Command invalid, not in mailbox mode"; - case -LL_IFC_NACK_PAYLOAD_BAD_PROPERTY: return "Bad property ID specified"; - case -LL_IFC_NACK_NODATA: return "No msg data available to return"; - case -LL_IFC_NACK_QUEUE_FULL: return "Data cannot be enqueued for transmission, queue is full"; - case -LL_IFC_NACK_OTHER: return "Unspecified error"; - - case LL_IFC_ERROR_INCORRECT_PARAMETER: return "The parameter value was invalid"; - case LL_IFC_ERROR_INCORRECT_RESPONSE_LENGTH: return "Module response was not the expected size"; - case LL_IFC_ERROR_MESSAGE_NUMBER_MISMATCH: return "Message number in response doesn't match expected"; - case LL_IFC_ERROR_CHECKSUM_MISMATCH: return "Checksum mismatch"; - case LL_IFC_ERROR_COMMAND_MISMATCH: return "Command mismatch (responding to a different command)"; - case LL_IFC_ERROR_HOST_INTERFACE_TIMEOUT: return "Timed out waiting for Rx bytes from interface"; - case LL_IFC_ERROR_BUFFER_TOO_SMALL: return "Response larger than provided output buffer"; - case LL_IFC_ERROR_START_OF_FRAME: return "transport_read failed getting FRAME_START"; - case LL_IFC_ERROR_HEADER: return "transport_read failed getting header"; - case LL_IFC_ERROR_TIMEOUT: return "The operation timed out"; - case LL_IFC_ERROR_INCORRECT_MESSAGE_SIZE: return "The message size from the device was incorrect"; - case LL_IFC_ERROR_NO_NETWORK: return "No network was available"; - - default: return "unknown error"; - } -} - -int32_t ll_firmware_type_get(ll_firmware_type_t *t) -{ - uint8_t buf[FIRMWARE_TYPE_LEN]; - int32_t ret; - if(t == NULL) - { - return LL_IFC_ERROR_INCORRECT_PARAMETER; - } - ret = hal_read_write(OP_FIRMWARE_TYPE, NULL, 0, buf, FIRMWARE_TYPE_LEN); - if (ret == FIRMWARE_TYPE_LEN) - { - t->cpu_code = buf[0] << 8 | buf[1]; - t->functionality_code = buf[2] << 8 | buf[3]; - } - return ret; -} - -int32_t ll_hardware_type_get(ll_hardware_type_t *t) -{ - uint8_t type; - int32_t ret; - if(t == NULL) - { - return LL_IFC_ERROR_INCORRECT_PARAMETER; - } - ret = hal_read_write(OP_HARDWARE_TYPE, NULL, 0, &type, sizeof(type)); - if (ret == sizeof(type)) - { - *t = (ll_hardware_type_t) type; - } - return ret; -} - -const char * ll_hardware_type_string(ll_hardware_type_t t) -{ - switch(t) - { - case UNAVAILABLE: return "unavailable"; - case LLRLP20_V2: return "LLRLP20 v2"; - case LLRXR26_V2: return "LLRXR26 v2"; - case LLRLP20_V3: return "LLRLP20 v3"; - case LLRXR26_V3: return "LLRXR26 v3"; - default: return "unknown"; - } -} - -int32_t ll_interface_version_get(ll_version_t *version) -{ - uint8_t buf[VERSION_LEN]; - int32_t ret; - if(version == NULL) - { - return LL_IFC_ERROR_INCORRECT_PARAMETER; - } - ret = hal_read_write(OP_IFC_VERSION, NULL, 0, buf, VERSION_LEN); - if (ret == VERSION_LEN) - { - version->major = buf[0]; - version->minor = buf[1]; - version->tag = buf[2] << 8 | buf[3]; - } - return ret; -} - -int32_t ll_version_get(ll_version_t *version) -{ - uint8_t buf[VERSION_LEN]; - int32_t ret; - if(version == NULL) - { - return LL_IFC_ERROR_INCORRECT_PARAMETER; - } - ret = hal_read_write(OP_VERSION, NULL, 0, buf, VERSION_LEN); - if (ret == VERSION_LEN) - { - version->major = buf[0]; - version->minor = buf[1]; - version->tag = buf[2] << 8 | buf[3]; - } - return ret; -} - -int32_t ll_sleep_block(void) -{ - return hal_read_write(OP_SLEEP_BLOCK, (uint8_t*) "1", 1, NULL, 0); -} - -int32_t ll_sleep_unblock(void) -{ - return hal_read_write(OP_SLEEP_BLOCK, (uint8_t*) "0", 1, NULL, 0); -} - -int32_t ll_mac_mode_set(ll_mac_type_t mac_mode) -{ - if (mac_mode >= NUM_MACS) - { - return LL_IFC_ERROR_INCORRECT_PARAMETER; - } - uint8_t u8_mac_mode = (uint8_t)mac_mode; - return hal_read_write(OP_MAC_MODE_SET, &u8_mac_mode, 1, NULL, 0); -} - -int32_t ll_mac_mode_get(ll_mac_type_t *mac_mode) -{ - int32_t ret; - if (NULL == mac_mode) - { - return LL_IFC_ERROR_INCORRECT_PARAMETER; - } - uint8_t u8_mac_mode; - ret = hal_read_write(OP_MAC_MODE_GET, NULL, 0, &u8_mac_mode, sizeof(uint8_t)); - *mac_mode = (ll_mac_type_t)u8_mac_mode; - return ret; -} - -int32_t ll_antenna_set(uint8_t ant) -{ - if((ant == 1) || (ant == 2)) - { - return hal_read_write(OP_ANTENNA_SET, &ant, 1, NULL, 0); - } - else - { - return LL_IFC_ERROR_INCORRECT_PARAMETER; - } -} - -int32_t ll_antenna_get(uint8_t *ant) -{ - if (ant == NULL) - { - return LL_IFC_ERROR_INCORRECT_PARAMETER; - } - return hal_read_write(OP_ANTENNA_GET, NULL, 0, ant, 1); -} - -int32_t ll_unique_id_get(uint64_t *unique_id) -{ - uint8_t buff[8]; - int32_t ret; - int i; - if (unique_id == NULL) - { - return LL_IFC_ERROR_INCORRECT_PARAMETER; - } - ret = hal_read_write(OP_MODULE_ID, NULL, 0, buff, 8); - *unique_id = 0; - for (i = 0; i < 8; i++) - { - *unique_id |= ((uint64_t) buff[i]) << (8 * (7 - i)); - } - - return ret; -} - -int32_t ll_settings_store(void) -{ - return hal_read_write(OP_STORE_SETTINGS, NULL, 0, NULL, 0); -} - -int32_t ll_settings_delete(void) -{ - return hal_read_write(OP_DELETE_SETTINGS, NULL, 0, NULL, 0); -} - -int32_t ll_restore_defaults(void) -{ - return hal_read_write(OP_RESET_SETTINGS, NULL, 0, NULL, 0); -} - -int32_t ll_sleep(void) -{ - return hal_read_write(OP_SLEEP, NULL, 0, NULL, 0); -} - -int32_t ll_reset_mcu(void) -{ - return hal_read_write(OP_RESET_MCU, NULL, 0, NULL, 0); -} - -int32_t ll_bootloader_mode(void) -{ - send_packet(OP_TRIGGER_BOOTLOADER, message_num, NULL, 0); - return 0; -} - -/** - * @return - * 0 - success - * negative = error, as defined by hal_read_write - */ -int32_t ll_irq_flags(uint32_t flags_to_clear, uint32_t *flags) -{ - // Assuming big endian convention over the interface - - uint8_t in_buf[4]; - uint8_t out_buf[4] = {0,0,0,0}; - - in_buf[0] = (uint8_t)((flags_to_clear >> 24) & 0xFF); - in_buf[1] = (uint8_t)((flags_to_clear >> 16) & 0xFF); - in_buf[2] = (uint8_t)((flags_to_clear >> 8) & 0xFF); - in_buf[3] = (uint8_t)((flags_to_clear ) & 0xFF); - - int32_t rw_response = hal_read_write(OP_IRQ_FLAGS, in_buf, 4, out_buf, 4); - - if(rw_response > 0) - { - uint32_t flags_temp = 0; - flags_temp |= (((uint32_t)out_buf[0]) << 24); - flags_temp |= (((uint32_t)out_buf[1]) << 16); - flags_temp |= (((uint32_t)out_buf[2]) << 8); - flags_temp |= (((uint32_t)out_buf[3])); - *flags = flags_temp; - } - - return(rw_response); -} - -//STRIPTHIS!START -int32_t ll_timestamp_get(uint32_t * timestamp_us) -{ - return ll_timestamp_set(LL_TIMESTAMP_NO_OPERATION, 0, timestamp_us); -} - -int32_t ll_timestamp_set(ll_timestamp_operation_t operation, uint32_t timestamp_us, uint32_t * actual_timestamp_us) -{ - uint8_t in_buf[5]; - uint8_t * b_in = in_buf; - uint8_t out_buf[4] = {0,0,0,0}; - - if (actual_timestamp_us == NULL) - { - return LL_IFC_ERROR_INCORRECT_PARAMETER; - } - - write_uint8((uint8_t) operation, &b_in); - write_uint32(timestamp_us, &b_in); - - int32_t rw_response = hal_read_write_exact(OP_TIMESTAMP, in_buf, sizeof(in_buf), out_buf, sizeof(out_buf)); - if (rw_response >= 0) - { - uint8_t const * b_out = out_buf; - *actual_timestamp_us = read_uint32(&b_out); - rw_response = 0; - } - - return rw_response; -} - -int32_t ll_trigger_watchdog(void) -{ - uint8_t cmd_buf[2]; - cmd_buf[0] = 0x00; - cmd_buf[1] = 0x01; - return hal_read_write(OP_RESERVED1, cmd_buf, 2, NULL, 0); -} - -int32_t ll_get_assert_info(char *filename, uint16_t filename_len, uint32_t *line) -{ - uint8_t tmp_arr[4 + 20]; - int32_t ret = hal_read_write(OP_GET_ASSERT, NULL, 0, tmp_arr, 4 + 20); - if (ret > 0) - { - *line = 0; - *line += (uint32_t)(tmp_arr[0]) << 24; - *line += (uint32_t)(tmp_arr[1]) << 16; - *line += (uint32_t)(tmp_arr[2]) << 8; - *line += (uint32_t)(tmp_arr[3]) << 0; - - uint16_t cpy_len = filename_len < 20 ? filename_len : 20; - memcpy(filename, tmp_arr + 4, cpy_len); - } - return ret; -} -int32_t ll_trigger_assert(void) -{ - return hal_read_write(OP_SET_ASSERT, NULL, 0, NULL, 0); -} - -//STRIPTHIS!STOP - -int32_t ll_reset_state( void ) -{ - message_num = 0; - return 0; -} - - -/** - * @brief - * send_packet - * - * @param[in] op - * opcode of the command being sent to the module - * - * @param[in] message_num - * message_num - * - * @param[in] buf - * byte array containing the data payload to be sent to the module - * - * @param[in] len - * size of the output buffer in bytes - * - * @return - * none - */ -static void send_packet(opcode_t op, uint8_t message_num, uint8_t *buf, uint16_t len) -{ - #define SP_NUM_ZEROS (6) - #define SP_HEADER_SIZE (CMD_HEADER_LEN + SP_NUM_ZEROS) - uint8_t header_buf[SP_HEADER_SIZE]; - uint8_t checksum_buff[2]; - uint16_t computed_checksum; - uint16_t header_idx = 0; - uint16_t i; - - // Send a couple wakeup bytes, just-in-case - for (i = 0; i < SP_NUM_ZEROS; i++) - { - header_buf[header_idx ++] = 0x5F; - } - - header_buf[header_idx++] = FRAME_START; - header_buf[header_idx++] = op; - header_buf[header_idx++] = message_num; - header_buf[header_idx++] = (uint8_t)(0xFF & (len >> 8)); - header_buf[header_idx++] = (uint8_t)(0xFF & (len >> 0)); - - computed_checksum = compute_checksum(header_buf + SP_NUM_ZEROS, CMD_HEADER_LEN, buf, len); - - transport_write(header_buf, SP_HEADER_SIZE); - - if (buf != NULL) - { - transport_write(buf, len); - } - - checksum_buff[0] = (computed_checksum >> 8); - checksum_buff[1] = (computed_checksum >> 0); - transport_write(checksum_buff, 2); - -} - -/** - * @brief - * recv_packet - * - * @param[in] op - * opcode of the command that we're trying to receive - * - * @param[in] message_num - * message number of the command that we're trying to receive - * - * @param[in] buf - * byte array for storing data returned from the module - * - * @param[in] len - * size of the output buffer in bytes - * - * @return - * positive number of bytes returned, - * negative if an error - * Error Codes: - * -1 NACK received - Command not supported - * -2 NACK received - Incorrect Checksum - * -3 NACK received - Payload length out of range - * -4 NACK received - Payload out of range - * -5 NACK received - Not allowed, bootup in progress - * -6 NACK received - Busy try again - * -7 NACK received - Application token not registered - * -8 NACK received - Payload length greater than maximum supported length - * -99 NACK received - Other - * -103 Message Number in response doesn't match expected - * -104 Checksum mismatch - * -105 Command mismatch (responding to a different command) - * -106 Timed out waiting for Rx bytes from interface - * -107 Response larger than provided output buffer - * -108 transport_read failed getting FRAME_START - * -109 transport_read failed getting header - */ -static int32_t recv_packet(opcode_t op, uint8_t message_num, uint8_t *buf, uint16_t len) -{ - uint8_t header_buf[RESP_HEADER_LEN]; - uint16_t header_idx; - - uint8_t curr_byte = 0; - uint8_t checksum_buff[2]; - uint16_t computed_checksum; - int32_t ret_value = 0; - int32_t ret; - - memset(header_buf, 0, sizeof(header_buf)); - - struct time time_start, time_now; - if (gettime(&time_start) < 0) - { - return LL_IFC_ERROR_HAL_CALL_FAILED; - } - - do - { - /* Timeout of infinite Rx loop if responses never show up*/ - ret = transport_read(&curr_byte, 1); - - if (gettime(&time_now) < 0) - { - return LL_IFC_ERROR_HAL_CALL_FAILED; - } - - if(time_now.tv_sec - time_start.tv_sec > 2) - { - len = 0; - return LL_IFC_ERROR_HOST_INTERFACE_TIMEOUT; - } - } while(curr_byte != FRAME_START); - - if (ret < 0) - { - /* transport_read failed - return an error */ - return LL_IFC_ERROR_START_OF_FRAME; - } - - header_idx = 0; - header_buf[header_idx++] = FRAME_START; - - ret = transport_read(header_buf + 1, RESP_HEADER_LEN - 1); - if (ret < 0) - { - /* transport_read failed - return an error */ - return LL_IFC_ERROR_HEADER; - } - - uint16_t len_from_header = (uint16_t)header_buf[5] + ((uint16_t)header_buf[4] << 8); - - if (header_buf[1] != op) - { - // Command Byte should match what was sent - ret_value = LL_IFC_ERROR_COMMAND_MISMATCH; - } - if (header_buf[2] != message_num) - { - // Message Number should match - ret_value = LL_IFC_ERROR_MESSAGE_NUMBER_MISMATCH; - } - if (header_buf[3] != 0x00) - { - // NACK Received - // Map NACK code to error code - ret_value = 0 - header_buf[3]; - } - if (len_from_header > len) - { - // response is larger than the caller expects. - // Pull the bytes out of the Rx fifo - int32_t ret; - do - { - uint8_t temp_byte; - ret = transport_read(&temp_byte, 1); - } - while (ret == 0); - return LL_IFC_ERROR_BUFFER_TOO_SMALL; - } - else if (len_from_header < len) - { - // response is shorter than caller expects. - len = len_from_header; - } - - if (ret_value == 0) - { - - // If we got here, then we: - // 1) Received the FRAME_START in the response - // 2) The message number matched - // 3) The ACK byte was ACK (not NACK) - // 4) The received payload length is less than or equal to the size of the buffer - // allocated for the payload - - // Grab the payload if there is supposed to be one - if ((buf != NULL) && (len > 0)) - { - transport_read(buf, len); - } - } - - // Finally, make sure the checksum matches - transport_read(checksum_buff, 2); - - computed_checksum = compute_checksum(header_buf, RESP_HEADER_LEN, buf, len); - uint16_t rx_checksum = ((uint16_t)checksum_buff[0] << 8) + checksum_buff[1]; - if (rx_checksum != computed_checksum) - { - return LL_IFC_ERROR_CHECKSUM_MISMATCH; - } - - if (ret_value == 0) - { - // Success! Return the number of bytes in the payload (0 or positive number) - return len; - } - else - { - // Failure! Return an error, such as NACK response from the firmware - return ret_value; - } -} - -/** - * @brief - * compute_checksum - * - * @param[in] hdr - * header array to compute checksum on - * - * @param[in] hdr_len - * size of the header array in bytes - * - * @param[in] payload - * payload array to compute checksum on - * - * @param[in] payload_len - * size of the payload array in bytes - * - * @return - * The 8-bit checksum - */ -static uint16_t compute_checksum(uint8_t *hdr, uint16_t hdr_len, uint8_t *payload, uint16_t payload_len) -{ - uint16_t crc = 0x0; - uint16_t i; - - for (i = 0; i < hdr_len; i++) - { - crc = (crc >> 8) | (crc << 8); - crc ^= hdr[i]; - crc ^= (crc & 0xff) >> 4; - crc ^= crc << 12; - crc ^= (crc & 0xff) << 5; - } - - for (i = 0; i < payload_len; i++) - { - crc = (crc >> 8) | (crc << 8); - crc ^= payload[i]; - crc ^= (crc & 0xff) >> 4; - crc ^= crc << 12; - crc ^= (crc & 0xff) << 5; - } - - return crc; -} From 62171539d0735601f479de0a8055cd96b45248d3 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=D1=82=D0=BD=CF=83=D0=BC=CE=B1=D1=95=20=D1=95=D1=82=D1=94?= =?UTF-8?q?=CE=B9=D0=B8=D0=BD=CF=83=E2=84=93z?= Date: Fri, 25 Oct 2019 10:07:28 -0400 Subject: [PATCH 21/33] Delete ll_ifc_ftp.c.bak --- src/ll_ifc_ftp.c.bak | 866 ------------------------------------------- 1 file changed, 866 deletions(-) delete mode 100644 src/ll_ifc_ftp.c.bak diff --git a/src/ll_ifc_ftp.c.bak b/src/ll_ifc_ftp.c.bak deleted file mode 100644 index 2deb792..0000000 --- a/src/ll_ifc_ftp.c.bak +++ /dev/null @@ -1,866 +0,0 @@ -#include // memmove -#include // for ceil -#include // for printf -#include "ll_ifc_ftp.h" -#include "ll_ifc_utils.h" - -#define LL_FTP_MSG_PACKET_TYPE_INDEX (0) -#define LL_FTP_MSG_CRC_INDEX (1) -#define LL_FTP_MSG_FILE_ID_INDEX (5) -#define LL_FTP_MSG_FILE_VERSION_INDEX (9) -#define LL_FTP_MSG_FILE_SIZE_INDEX (13) -#define LL_FTP_MSG_SEG_NUM_INDEX (17) -#define LL_FTP_MSG_NUM_SEGS_INDEX (19) -#define LL_FTP_MSG_PAYLOAD_INDEX (21) -#define LL_FTP_ACK_ACK_TYPE_INDEX (5) -#define LL_FTP_ACK_FILE_ID_INDEX (6) -#define LL_FTP_ACK_FILE_VERSION_INDEX (10) -#define LL_FTP_NAK_FILE_SEGS_INDEX (14) - -#define LL_FTP_MSG_MIN_SIZE (17) - -#define IS_MY_FILE ((ftp_msg.file_id == f->file_id) && (ftp_msg.file_version == f->file_version)) - -#define UINT16_FROM_BYTESTREAM(p) (p[0] | (p[1] << 8)) -#define UINT32_FROM_BYTESTREAM(p) (p[0] | (p[1] << 8) | (p[2] << 16) | (p[3] << 24)) - -#define UINT32_TO_BYTESTREAM(dst, src) dst[0] = src & 0xFF; \ - dst[1] = (src >> 8) & 0xFF; \ - dst[2] = (src >> 16) & 0xFF; \ - dst[3] = (src >> 24) & 0xFF; - -const uint8_t LL_FTP_MAX_NUM_RETRIES = 5; -const uint8_t LL_FTP_RETRY_INTERVAL = 15; -const uint8_t LL_FTP_PORT = 128; - -extern uint8_t ll_ul_max_port; - -typedef enum ll_ftp_msg_type -{ - TX_INIT, - TX_CANCEL, - TX_APPLY, - TX_SEGMENT, - ACK_INIT, - ACK_SEGMENT, - ACK_APPLY, - TICK, - NUM_MSG_TYPES, -} ll_ftp_msg_type_t; - -typedef enum ll_ftp_ack_type -{ - ACK_ACK = 0x00, - ACK_NAK_SEGMENT = 0xFD, - ACK_NAK = 0xFF, -} ll_ftp_ack_type_t; - -typedef struct ll_ftp_msg -{ - uint32_t crc; - uint32_t file_id; - uint32_t file_version; - uint32_t file_size; - ll_ftp_msg_type_t msg_type; - uint16_t segment_number; - uint16_t num_segs; - uint16_t payload_len; - uint8_t* payload; -} ll_ftp_msg_t; - -// Modifies the max port so we can send the message. -static ll_ftp_return_code_t ll_ftp_send_uplink(ll_ftp_t* f, size_t len) -{ - uint8_t old_max_port = ll_ul_max_port; - ll_ul_max_port = LL_FTP_PORT; - ll_ftp_return_code_t ret = f->cb.uplink(f->tx_buf, (uint16_t) len, true, LL_FTP_PORT); - ll_ul_max_port = old_max_port; - gettime(&f->time_last_msg); - return ret; -} - -// reset retry and timeout counters -static void ll_ftp_reset(ll_ftp_t *f) -{ - gettime(&f->time_last_msg); - f->retry_count = 0; -} - -// Close and reopen the file -static ll_ftp_return_code_t ll_ftp_file_reopen(ll_ftp_t *f) -{ - ll_ftp_return_code_t cb_ret; - - cb_ret = f->cb.close(f->file_id, f->file_version); - if (LL_FTP_OK == cb_ret) - { - cb_ret = f->cb.open(f->file_id, f->file_version, f->file_size); - } - - return cb_ret; -} - -static int32_t ll_ftp_parse_rx_msg(const uint8_t* buf, uint8_t len, ll_ftp_msg_t* ftp_msg) -{ - // NULL pointer signifies TICK message - if(NULL == buf) - { - ftp_msg->msg_type = TICK; - return LL_FTP_OK; - } - - // Catch invalid values - if(LL_FTP_MSG_MIN_SIZE > len) - { - return LL_FTP_INVALID_VALUE; - } - if(NUM_MSG_TYPES <= buf[LL_FTP_MSG_PACKET_TYPE_INDEX]) - { - return LL_FTP_OOR; - } - - // Stuff all messages have - ftp_msg->msg_type = buf[LL_FTP_MSG_PACKET_TYPE_INDEX]; - ftp_msg->crc = buf[LL_FTP_MSG_CRC_INDEX + 0] << 0; - ftp_msg->crc = UINT32_FROM_BYTESTREAM( (&buf[LL_FTP_MSG_CRC_INDEX]) ); - ftp_msg->file_id = UINT32_FROM_BYTESTREAM( (&buf[LL_FTP_MSG_FILE_ID_INDEX]) ); - ftp_msg->file_version = UINT32_FROM_BYTESTREAM( (&buf[LL_FTP_MSG_FILE_VERSION_INDEX]) ); - ftp_msg->file_size = UINT32_FROM_BYTESTREAM( (&buf[LL_FTP_MSG_FILE_SIZE_INDEX]) ); - - // Stuff only segments have - if(TX_SEGMENT == ftp_msg->msg_type) - { - ftp_msg->segment_number = UINT16_FROM_BYTESTREAM( (&buf[LL_FTP_MSG_SEG_NUM_INDEX]) ); - ftp_msg->num_segs = UINT16_FROM_BYTESTREAM( (&buf[LL_FTP_MSG_NUM_SEGS_INDEX]) ); - ftp_msg->payload = (uint8_t*) &buf[LL_FTP_MSG_PAYLOAD_INDEX]; - ftp_msg->payload_len = len - LL_FTP_MSG_PAYLOAD_INDEX; // implicit payload length - } - - // check crc - uint32_t crc = crc32(0, (uint8_t*) &buf[LL_FTP_MSG_FILE_ID_INDEX], len - LL_FTP_MSG_FILE_ID_INDEX); - int32_t ret = (crc == ftp_msg->crc) ? LL_FTP_OK : LL_FTP_ERROR; - - return ret; -} - -// Update segments cache array for successfully received and written segments -static void ll_ftp_seg_num_track(ll_ftp_t* f, uint16_t seg_num) -{ - if(MAX_NUM_SEGMENTS >= seg_num) - { - uint16_t base = seg_num >> 5; // divide by 32 - f->rx_segs[base] |= (1 << (0x1F & seg_num)); // bit shift a maximum of 5 bits - } -} - -static bool ll_ftp_transfer_is_complete(ll_ftp_t* f) -{ - bool ret = true; - uint32_t i; - uint16_t base_max = f->num_segs >> 5; // divide by 32 - - for(i = 0; i <= base_max; i++) - { - if(i != base_max) - { - if(0xFFFFFFFF != f->rx_segs[i]) - { - ret = false; - break; - } - } - else - { - uint32_t j; - uint32_t num_segs_mod = f->num_segs & 0x1F; // mod by 32 - for(j = 0; j < num_segs_mod; j++) - { - if(!((f->rx_segs[base_max] >> j) & 0x1)) - { - ret = false; - break; - } - } - } - } - - return ret; -} - -static uint16_t ll_ftp_get_missing_segs(ll_ftp_t* f, bool fill_buf) -{ - uint16_t num_missing_segs = 0; - uint32_t i, j; - uint16_t seg_num; - uint8_t num_segs_base; - uint8_t idx; - uint16_t total_payload = fill_buf ? BASE_UL_MSG_LEN : 0; - - uint16_t base_max = f->num_segs >> 5; // divide by 32 - for(i = 0; i <= base_max; i++) - { - num_segs_base = (i != base_max) ? 32 : f->num_segs & 0x1F; // mod by 32 - - for(j = 0; j < num_segs_base; j++) - { - if(!((f->rx_segs[i] >> j) & 0x1)) - { - if((MAX_NUM_RETRY_SEGS <= num_missing_segs) && fill_buf) - { - // request complete retransmission - return 0xFFFF; - } - - seg_num = (i << 5) + j; // i * 32 + j - - idx = num_missing_segs * 2; - - // Only fill the buffer up to the maximum number of segments we can request in - // a single payload - if ((fill_buf) && ((total_payload + sizeof(seg_num)) <= LL_FTP_TX_BUF_SIZE)) - { - f->tx_buf[LL_FTP_NAK_FILE_SEGS_INDEX + idx] = seg_num & 0x00FF; - f->tx_buf[LL_FTP_NAK_FILE_SEGS_INDEX + idx + 1] = (seg_num >> 8) & 0x00FF; - - total_payload += sizeof(seg_num); - num_missing_segs++; - } - } - } - } - - return num_missing_segs; -} - -static uint16_t ll_ftp_ack_init_generate(ll_ftp_t* f, bool ack) -{ - f->tx_buf[LL_FTP_MSG_PACKET_TYPE_INDEX] = ACK_INIT; - if (ack) - { - f->tx_buf[LL_FTP_ACK_ACK_TYPE_INDEX] = ACK_ACK; - } - else - { - f->tx_buf[LL_FTP_ACK_ACK_TYPE_INDEX] = ACK_NAK; - } - UINT32_TO_BYTESTREAM((&f->tx_buf[LL_FTP_ACK_FILE_ID_INDEX]), f->file_id); - UINT32_TO_BYTESTREAM((&f->tx_buf[LL_FTP_ACK_FILE_VERSION_INDEX]), f->file_version); - - - uint32_t crc = crc32(0, &f->tx_buf[LL_FTP_ACK_ACK_TYPE_INDEX], BASE_UL_MSG_LEN - LL_FTP_ACK_ACK_TYPE_INDEX); - UINT32_TO_BYTESTREAM((&f->tx_buf[LL_FTP_MSG_CRC_INDEX]), crc); - - return BASE_UL_MSG_LEN; -} - -static uint16_t ll_ftp_ack_segs_complete_generate(ll_ftp_t* f) -{ - f->tx_buf[LL_FTP_MSG_PACKET_TYPE_INDEX] = ACK_SEGMENT; - f->tx_buf[LL_FTP_ACK_ACK_TYPE_INDEX] = ACK_ACK; - UINT32_TO_BYTESTREAM((&f->tx_buf[LL_FTP_ACK_FILE_ID_INDEX]), f->file_id); - UINT32_TO_BYTESTREAM((&f->tx_buf[LL_FTP_ACK_FILE_VERSION_INDEX]), f->file_version); - - uint32_t crc = crc32(0, &f->tx_buf[LL_FTP_ACK_ACK_TYPE_INDEX], BASE_UL_MSG_LEN - LL_FTP_ACK_ACK_TYPE_INDEX); - UINT32_TO_BYTESTREAM((&f->tx_buf[LL_FTP_MSG_CRC_INDEX]), crc); - - return BASE_UL_MSG_LEN; -} - -static uint16_t ll_ftp_ack_segs_request_generate(ll_ftp_t* f) -{ - f->tx_buf[LL_FTP_MSG_PACKET_TYPE_INDEX] = ACK_SEGMENT; - f->tx_buf[LL_FTP_ACK_ACK_TYPE_INDEX] = ACK_NAK_SEGMENT; - UINT32_TO_BYTESTREAM((&f->tx_buf[LL_FTP_ACK_FILE_ID_INDEX]), f->file_id); - UINT32_TO_BYTESTREAM((&f->tx_buf[LL_FTP_ACK_FILE_VERSION_INDEX]), f->file_version); - - // check max length number of retry segments - uint16_t num_missing_segs = ll_ftp_get_missing_segs(f, true); - uint16_t return_len = BASE_UL_MSG_LEN; - if(MAX_NUM_RETRY_SEGS <= num_missing_segs) - { - f->tx_buf[LL_FTP_ACK_ACK_TYPE_INDEX] = ACK_NAK; - } - else - { - return_len += num_missing_segs * sizeof(uint16_t); - } - - uint32_t crc = crc32(0, &f->tx_buf[LL_FTP_ACK_ACK_TYPE_INDEX], (size_t) return_len - LL_FTP_ACK_ACK_TYPE_INDEX); - UINT32_TO_BYTESTREAM((&f->tx_buf[LL_FTP_MSG_CRC_INDEX]), crc); - - return return_len; -} - -static uint16_t ll_ftp_ack_apply_generate(ll_ftp_t* f, bool success) -{ - f->tx_buf[LL_FTP_MSG_PACKET_TYPE_INDEX] = ACK_APPLY; - f->tx_buf[LL_FTP_ACK_ACK_TYPE_INDEX] = (success ? ACK_ACK : ACK_NAK); - UINT32_TO_BYTESTREAM((&f->tx_buf[LL_FTP_ACK_FILE_ID_INDEX]), f->file_id); - UINT32_TO_BYTESTREAM((&f->tx_buf[LL_FTP_ACK_FILE_VERSION_INDEX]), f->file_version); - - uint32_t crc = crc32(0, &f->tx_buf[LL_FTP_ACK_ACK_TYPE_INDEX], BASE_UL_MSG_LEN - LL_FTP_ACK_ACK_TYPE_INDEX); - UINT32_TO_BYTESTREAM((&f->tx_buf[LL_FTP_MSG_CRC_INDEX]), crc); - - return BASE_UL_MSG_LEN; -} - -static void ll_ftp_new_file_initialize(ll_ftp_t* f, ll_ftp_msg_t* msg) -{ - ll_ftp_reset(f); - f->file_id = msg->file_id; - f->file_version = msg->file_version; - f->file_size = msg->file_size; - f->num_segs = (uint16_t)ceil((double)f->file_size / (double)MAX_FILE_SEGMENT_BYTES); - memset(f->rx_segs, 0, sizeof(f->rx_segs[0]) * NUM_RX_SEGS_BITMASK); - - // send ACK_INIT - uint16_t len = ll_ftp_ack_init_generate(f, true); - ll_ftp_send_uplink(f, len); -} - -static void ll_ftp_state_set(ll_ftp_t* f, ll_ftp_state_t new_state) -{ - f->state = new_state; -} - -static int32_t ll_ftp_idle_start(ll_ftp_t* f) -{ - int32_t ret = LL_FTP_NO_ACTION; - - int32_t cb_ret = f->cb.close(f->file_id, f->file_version); - if(LL_FTP_OK == cb_ret) - { - f->cb.config(false); - } - ret = (LL_FTP_OK == cb_ret) ? LL_FTP_OK : LL_FTP_ERROR; - - return ret; -} - -static int32_t ll_ftp_segment_start(ll_ftp_t* f, ll_ftp_msg_t* msg) -{ - ll_ftp_return_code_t msg_ret; - int32_t ret = LL_FTP_NO_ACTION; - - int32_t cb_ret = f->cb.open(msg->file_id, msg->file_version, msg->file_size); - if (LL_FTP_OK == cb_ret) - { - ll_ftp_new_file_initialize(f, msg); - f->cb.config(true); - ret = LL_FTP_OK; - } - else if (TX_INIT == msg->msg_type || TX_SEGMENT == msg->msg_type) - { - // send ACK_INIT - uint16_t len = ll_ftp_ack_init_generate(f, false); - msg_ret = ll_ftp_send_uplink(f, len); - if (msg_ret != LL_FTP_OK) - { - ret = LL_FTP_ERROR; - } - } - - return ret; -} - -static int32_t ll_ftp_apply_start(ll_ftp_t* f) -{ - ll_ftp_return_code_t msg_ret; - int32_t ret = LL_FTP_ERROR; - - int32_t cb_ret = f->cb.close(f->file_id, f->file_version); - if(LL_FTP_OK == cb_ret) - { - uint16_t len = ll_ftp_ack_segs_complete_generate(f); - - ret = LL_FTP_OK; - msg_ret = ll_ftp_send_uplink(f, len); - if (msg_ret != LL_FTP_OK) - { - ret = LL_FTP_ERROR; - } - } - - return ret; -} - -static int32_t ll_ftp_verify_file_info(ll_ftp_t* f, uint32_t *file_crc) -{ - int32_t ret = LL_FTP_OK; - uint8_t tmp_buf[4]; - uint32_t file_size = 0; - uint32_t file_id = 0; - uint32_t file_version = 0; - ll_ftp_return_code_t cb_ret; - - cb_ret = f->cb.read(f->file_id, f->file_version, LL_FTP_HDR_OFFSET_CRC, tmp_buf, sizeof(tmp_buf)); - if (LL_FTP_OK != cb_ret) - { - return cb_ret; - } - *file_crc = UINT32_FROM_BYTESTREAM(tmp_buf); - - cb_ret = f->cb.read(f->file_id, f->file_version, LL_FTP_HDR_OFFSET_SIZE, tmp_buf, sizeof(tmp_buf)); - if (LL_FTP_OK != cb_ret) - { - return cb_ret; - } - file_size = UINT32_FROM_BYTESTREAM(tmp_buf); - - cb_ret = f->cb.read(f->file_id, f->file_version, LL_FTP_HDR_OFFSET_ID, tmp_buf, sizeof(tmp_buf)); - if (LL_FTP_OK != cb_ret) - { - return cb_ret; - } - file_id = UINT32_FROM_BYTESTREAM(tmp_buf); - - cb_ret = f->cb.read(f->file_id, f->file_version, LL_FTP_HDR_OFFSET_VERSION, tmp_buf, sizeof(tmp_buf)); - if (LL_FTP_OK != cb_ret) - { - return cb_ret; - } - file_version = UINT32_FROM_BYTESTREAM(tmp_buf); - - if (file_size != f->file_size || - file_id != f->file_id || - file_version != f->file_version) - { - ret = LL_FTP_ERROR; - } - return ret; -} - -static int32_t ll_ftp_compute_file_crc(ll_ftp_t* f, uint32_t *crc_out) -{ - uint8_t tmp_buf[16]; - uint32_t offset; - uint32_t len = sizeof(tmp_buf); - uint32_t crc = 0; - - for (offset = LL_FTP_HDR_OFFSET_SIZE; offset < (LL_FTP_HDR_LEN + f->file_size); offset += len) - { - ll_ftp_return_code_t cb_ret; - - if ((offset + len) > (LL_FTP_HDR_LEN + f->file_size)) - { - len = (LL_FTP_HDR_LEN + f->file_size) - offset; - } - - cb_ret = f->cb.read(f->file_id, f->file_version, offset, tmp_buf, len); - if (LL_FTP_OK == cb_ret) - { - crc = crc32(crc, tmp_buf, len); - } - } - *crc_out = crc; - - return LL_FTP_OK; -} - -static int32_t ll_ftp_verify_file(ll_ftp_t* f) -{ - int32_t ret = LL_FTP_OK; - uint32_t file_crc = 0; - - ret = ll_ftp_verify_file_info(f, &file_crc); - - if (LL_FTP_OK == ret) - { - uint32_t crc; - ret = ll_ftp_compute_file_crc(f, &crc); - if (LL_FTP_OK == ret && (crc == file_crc)) - { - ret = LL_FTP_OK; - } - else - { - ret = LL_FTP_ERROR; - } - } - - return ret; -} - -static int32_t ll_ftp_write_segment(ll_ftp_t* f, ll_ftp_msg_t* msg) -{ - int32_t ret = LL_FTP_NO_ACTION; - - int32_t offset = msg->segment_number * MAX_FILE_SEGMENT_BYTES; - int32_t cb_ret = f->cb.write(msg->file_id, msg->file_version, offset, msg->payload, msg->payload_len); - - if(LL_FTP_OK == cb_ret) - { - ll_ftp_seg_num_track(f, msg->segment_number); - ret = LL_FTP_OK; - } - - return ret; -} - -static int32_t ll_ftp_idle_process_msg(ll_ftp_t* f, uint8_t* buf, uint8_t len) -{ - ll_ftp_msg_t ftp_msg; - int32_t ret = ll_ftp_parse_rx_msg(buf, len, &ftp_msg); - if(LL_FTP_OK != ret) - { - return ret; - } - - if((TX_INIT != ftp_msg.msg_type) && (TX_SEGMENT != ftp_msg.msg_type)) - { - return LL_FTP_INVALID_VALUE; - } - - // State transition to SEGMENT - ret = ll_ftp_segment_start(f, &ftp_msg); - if(LL_FTP_OK == ret) - { - ll_ftp_state_set(f, SEGMENT); - } - - return ret; -} - -static int32_t ll_ftp_transition_out_of_segment(ll_ftp_t* f, ll_ftp_msg_t* msg, ll_ftp_state_t next_state) -{ - int32_t ret; - - switch(next_state) - { - case IDLE: - { - ret = ll_ftp_idle_start(f); - if(LL_FTP_OK == ret) - { - ll_ftp_state_set(f, IDLE); - ll_ftp_init(f, &f->cb); - } - } - break; - case SEGMENT: - { - ret = ll_ftp_segment_start(f, msg); - if(LL_FTP_OK == ret) - { - ll_ftp_state_set(f, SEGMENT); - } - } - break; - case APPLY: - { - ret = ll_ftp_apply_start(f); - if(LL_FTP_OK == ret) - { - ll_ftp_state_set(f, APPLY); - } - else - { - ll_ftp_state_set(f, IDLE); - } - } - break; - default: - ret = LL_FTP_ERROR; - break; - } - - return ret; -} - -static int32_t ll_ftp_segment_process_msg(ll_ftp_t* f, uint8_t* buf, uint8_t len) -{ - ll_ftp_return_code_t msg_ret; - ll_ftp_msg_t ftp_msg; - int32_t ret = ll_ftp_parse_rx_msg(buf, len, &ftp_msg); - if(LL_FTP_OK != ret) - { - return ret; - } - - int32_t next_state = -1; - - ret = LL_FTP_NO_ACTION; //default value - if((TX_INIT == ftp_msg.msg_type) && !(IS_MY_FILE)) - { - next_state = SEGMENT; - } - else if ((TX_CANCEL == ftp_msg.msg_type) && (IS_MY_FILE)) - { - next_state = IDLE; - } - else if (TX_SEGMENT == ftp_msg.msg_type) - { - if(!(IS_MY_FILE)) - { - next_state = SEGMENT; // attempt to restart SEGMENT state - } - else - { - // reset retry and timeout counters - ll_ftp_reset(f); - - ret = ll_ftp_write_segment(f, &ftp_msg); - if(ll_ftp_transfer_is_complete(f)) - { - if(LL_FTP_OK == ll_ftp_verify_file(f)) - { - next_state = APPLY; - } - else - { - //keep file transfer, but clear file progress and request all segs - memset(f->rx_segs, 0, sizeof(f->rx_segs[0]) * NUM_RX_SEGS_BITMASK); - ll_ftp_reset(f); - - ret = ll_ftp_file_reopen(f); - if (LL_FTP_OK != ret) - { - next_state = IDLE; - } - } - } - } - } - else if (TX_APPLY == ftp_msg.msg_type) - { - // Only able to apply in APPLY state - // send NAK with retry segs - uint16_t len = ll_ftp_ack_segs_request_generate(f); - - ret = LL_FTP_OK; - msg_ret = ll_ftp_send_uplink(f, len); - if (msg_ret != LL_FTP_OK) - { - ret = LL_FTP_ERROR; - } - } - else if(TICK == ftp_msg.msg_type) - { - struct time time_now; - ret = LL_FTP_OK; - - // Rely on a periodic 1 Hz tick to request segments if necessary - gettime(&time_now); - if(ll_difftime(&f->time_last_msg, &time_now) >= LL_FTP_RETRY_INTERVAL) - { - if(f->retry_count < LL_FTP_MAX_NUM_RETRIES) - { - uint16_t len = ll_ftp_ack_segs_request_generate(f); - msg_ret = ll_ftp_send_uplink(f, len); - if (msg_ret != LL_FTP_OK) - { - ret = LL_FTP_ERROR; - } - - f->retry_count++; - } - else - { - next_state = IDLE; - } - } - } - - // Do state transitions out of SEGMENT - if(next_state > -1) - { - ret = ll_ftp_transition_out_of_segment(f, &ftp_msg, next_state); - } - - return ret; -} - -static int32_t ll_ftp_transition_out_of_apply(ll_ftp_t* f, ll_ftp_msg_t* msg, ll_ftp_state_t next_state, bool is_error) -{ - int32_t ret; - - switch (next_state) - { - case IDLE: - { - ret = ll_ftp_idle_start(f); - ll_ftp_init(f, &f->cb); - if(LL_FTP_OK == ret) - { - ll_ftp_state_set(f, IDLE); - } - } - break; - case SEGMENT: - { - ret = ll_ftp_segment_start(f, msg); - if(LL_FTP_OK == ret) - { - ll_ftp_state_set(f, SEGMENT); - } - } - break; - case APPLY: - { - ret = LL_FTP_NO_ACTION; - } - break; - default: - ret = LL_FTP_ERROR; - break; - } - - if(is_error) - { - ret = LL_FTP_ERROR; - } - - return ret; -} - -static int32_t ll_ftp_apply_process_msg(ll_ftp_t* f, uint8_t* buf, uint8_t len) -{ - ll_ftp_msg_t ftp_msg; - ll_ftp_return_code_t msg_ret; - int32_t ret = ll_ftp_parse_rx_msg(buf, len, &ftp_msg); - - if(LL_FTP_OK != ret) - { - return ret; - } - - int32_t next_state = -1; - - ret = LL_FTP_NO_ACTION; //default value - if((TX_INIT == ftp_msg.msg_type) && !(IS_MY_FILE)) - { - next_state = SEGMENT; - } - else if ((TX_CANCEL == ftp_msg.msg_type) && (IS_MY_FILE)) - { - next_state = IDLE; - } - else if(TX_SEGMENT == ftp_msg.msg_type) - { - if(IS_MY_FILE) - { - // reset retry and timeout counters - ll_ftp_reset(f); - } - else - { - next_state = SEGMENT; - } - } - else if ((TX_APPLY == ftp_msg.msg_type) && (IS_MY_FILE)) - { - uint16_t len; - int32_t cb_ret = f->cb.apply(f->file_id, f->file_version, f->file_size); - if(LL_FTP_OK == cb_ret) - { - len = ll_ftp_ack_apply_generate(f, true); - } - else - { - // Apply rejected. Send NAK and forget file. - len = ll_ftp_ack_apply_generate(f, false); - ret = LL_FTP_ERROR; - } - - next_state = IDLE; - msg_ret = ll_ftp_send_uplink(f, len); - if (msg_ret != LL_FTP_OK) - { - ret = LL_FTP_ERROR; - } - } - else if(TICK == ftp_msg.msg_type) - { - struct time time_now; - - ret = LL_FTP_OK; - - // Rely on a periodic 1 Hz tick to request segments if necessary - gettime(&time_now); - if(ll_difftime(&f->time_last_msg, &time_now) >= LL_FTP_RETRY_INTERVAL) - { - if(f->retry_count < LL_FTP_MAX_NUM_RETRIES) - { - uint16_t len = ll_ftp_ack_segs_complete_generate(f); - msg_ret = ll_ftp_send_uplink(f, len); - if (msg_ret != LL_FTP_OK) - { - ret = LL_FTP_ERROR; - } - - f->retry_count++; - } - else - { - next_state = IDLE; - } - } - } - - // Do state transitions out of APPLY - if(next_state > -1) - { - ret = ll_ftp_transition_out_of_apply(f, &ftp_msg, next_state, (LL_FTP_ERROR == ret)); - } - - return ret; -} - -int32_t ll_ftp_num_missing_segs_get(ll_ftp_t* f) -{ - if((0 >= f->num_segs) || (MAX_NUM_SEGMENTS < f->num_segs)) - { - return -1; - } - - return ll_ftp_get_missing_segs(f, false); -} - -int32_t ll_ftp_msg_process(ll_ftp_t* f, uint8_t* buf, uint8_t len) -{ - int32_t ret = 0; - switch (f->state) - { - case IDLE: - ret = ll_ftp_idle_process_msg(f, buf, len); - break; - case SEGMENT: - ret = ll_ftp_segment_process_msg(f, buf, len); - break; - case APPLY: - ret = ll_ftp_apply_process_msg(f, buf, len); - break; - default: - ret = LL_FTP_ERROR; - break; - } - - return ret; -} - -int32_t ll_ftp_init(ll_ftp_t* f, ll_ftp_callbacks_t* cb) -{ - if((NULL == cb->open) || (NULL == cb->read) || - (NULL == cb->write) || (NULL == cb->close) || - (NULL == cb->apply) || (NULL == cb->uplink) || - (NULL == cb->config)) - { - return LL_FTP_INVALID_VALUE; - } - - ll_ftp_state_set(f, IDLE); - f->num_segs = 0; - memset(f->rx_segs, 0, sizeof(f->rx_segs[0]) * NUM_RX_SEGS_BITMASK); - f->file_id = 0; - f->file_version = 0; - f->file_size = 0; - f->time_last_msg.tv_sec = 0; - f->time_last_msg.tv_nsec = 0; - f->retry_count = 0; - f->is_processing = false; - memset(f->tx_buf, 0, sizeof(f->tx_buf[0]) * LL_FTP_TX_BUF_SIZE); - - f->cb = *cb; - - return LL_FTP_OK; -} From b69a39fea9f5f609dc3eb56d0eb52c243442f9cb Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=D1=82=D0=BD=CF=83=D0=BC=CE=B1=D1=95=20=D1=95=D1=82=D1=94?= =?UTF-8?q?=CE=B9=D0=B8=D0=BD=CF=83=E2=84=93z?= Date: Fri, 25 Oct 2019 10:07:36 -0400 Subject: [PATCH 22/33] Delete ll_ifc_no_mac.c.bak --- src/ll_ifc_no_mac.c.bak | 368 ---------------------------------------- 1 file changed, 368 deletions(-) delete mode 100644 src/ll_ifc_no_mac.c.bak diff --git a/src/ll_ifc_no_mac.c.bak b/src/ll_ifc_no_mac.c.bak deleted file mode 100644 index d3ce57a..0000000 --- a/src/ll_ifc_no_mac.c.bak +++ /dev/null @@ -1,368 +0,0 @@ -#include "ll_ifc_no_mac.h" -#include "ll_ifc.h" -#include "ll_ifc_private.h" -#include // memset - -int32_t ll_rssi_scan_set(uint32_t u1, uint32_t u2, uint32_t u3, uint32_t u4) -{ - uint8_t buf[16]; - - memset(buf, 0, sizeof(buf)); - - // Little Endian - buf[ 0] = (u1 >> 24) & 0xFF; - buf[ 1] = (u1 >> 16) & 0xFF; - buf[ 2] = (u1 >> 8) & 0xFF; - buf[ 3] = (u1 ) & 0xFF; - - buf[ 4] = (u2 >> 24) & 0xFF; - buf[ 5] = (u2 >> 16) & 0xFF; - buf[ 6] = (u2 >> 8) & 0xFF; - buf[ 7] = (u2 ) & 0xFF; - - buf[ 8] = (u3 >> 24) & 0xFF; - buf[ 9] = (u3 >> 16) & 0xFF; - buf[10] = (u3 >> 8) & 0xFF; - buf[11] = (u3 ) & 0xFF; - - buf[12] = (u4 >> 24) & 0xFF; - buf[13] = (u4 >> 16) & 0xFF; - buf[14] = (u4 >> 8) & 0xFF; - buf[15] = (u4 ) & 0xFF; - - return hal_read_write(OP_RSSI_SET, buf, 16, NULL, 0); -} - -int32_t ll_rssi_scan_get(uint8_t buf[], uint16_t len, uint8_t *bytes_received) -{ - int32_t rw_response; - - if (buf == NULL || len <= 0 || bytes_received == NULL) - { - return LL_IFC_ERROR_INCORRECT_PARAMETER; - } - - rw_response = hal_read_write(OP_RSSI_GET, NULL, 0, buf, len); - - if (rw_response < 0) - { - *bytes_received = 0; - return(-1); - } - else - { - *bytes_received = (uint8_t) (rw_response & 0xFF); - return(0); - } -} - -int32_t ll_radio_params_get(uint8_t *sf, uint8_t *cr, uint8_t *bw, uint32_t *freq, - uint16_t *preamble_syms, uint8_t *header_enabled, uint8_t *crc_enabled, - uint8_t *iq_inverted) -{ - int32_t ret; - uint8_t buff[8]; - ret = hal_read_write(OP_GET_RADIO_PARAMS, NULL, 0, buff, 8); - - *sf = (buff[0] >> 4) + 6; - *cr = ((buff[0] >> 2) & 0x03) + 1; - *bw = buff[0] & 0x03; - - *header_enabled = buff[1] & (1u << 0u); - *crc_enabled = buff[1] & (1u << 1u); - *iq_inverted = buff[1] & (1u << 2u); - - *preamble_syms = ((uint16_t)buff[2] << 8) | (uint16_t)buff[3]; - - *freq = (uint32_t)(buff[4] << 24); - *freq |= (uint32_t)(buff[5] << 16); - *freq |= (uint32_t)(buff[6] << 8); - *freq |= (uint32_t)(buff[7] ); - - return ret; -} - -int32_t ll_radio_params_set(uint8_t flags, uint8_t sf, uint8_t cr, uint8_t bw, uint32_t freq, - uint16_t preamble_syms, uint8_t enable_header, uint8_t enable_crc, - uint8_t enable_iq_inversion) -{ - uint8_t buf[9]; - - memset(buf, 0, sizeof(buf)); - - buf[0] = flags; - - if(flags & RADIO_PARAM_FLAGS_SF) - { - if (sf < 6 || sf > 12) - { - return LL_IFC_ERROR_INCORRECT_PARAMETER; - } - sf = sf - 6; - buf[1] |= ((sf&0x07) << 4); - } - if(flags & RADIO_PARAM_FLAGS_CR) - { - if (cr < 1 || cr > 4) - { - return LL_IFC_ERROR_INCORRECT_PARAMETER; - } - cr = cr - 1; - buf[1] |= ((cr&0x03) << 2); - } - if(flags & RADIO_PARAM_FLAGS_BW) - { - if (bw > 3) - { - return LL_IFC_ERROR_INCORRECT_PARAMETER; - } - buf[1] |= ((bw&0x03) ); - } - - if ((flags & RADIO_PARAM_FLAGS_HEADER) && enable_header) - { - buf[2] |= (1u << 0u); - } - if ((flags & RADIO_PARAM_FLAGS_CRC) && enable_crc) - { - buf[2] |= (1u << 1u); - } - if ((flags & RADIO_PARAM_FLAGS_IQ) && enable_iq_inversion) - { - buf[2] |= (1u << 2u); - } - - if (flags & RADIO_PARAM_FLAGS_PREAMBLE) - { - buf[3] = (preamble_syms >> 8) & 0xFF; - buf[4] = (preamble_syms >> 0) & 0xFF; - } - - if(flags & RADIO_PARAM_FLAGS_FREQ) - { - buf[5] = (freq >> 24) & 0xFF; - buf[6] = (freq >> 16) & 0xFF; - buf[7] = (freq >> 8) & 0xFF; - buf[8] = (freq ) & 0xFF; - } - - return hal_read_write(OP_SET_RADIO_PARAMS, buf, 9, NULL, 0); -} - -int32_t ll_bandwidth_set(uint8_t bandwidth) -{ - return ll_radio_params_set(RADIO_PARAM_FLAGS_BW, 0, 0, bandwidth, 0, 0, 0, 0, 0); -} - -int32_t ll_spreading_factor_set(uint8_t sf) -{ - return ll_radio_params_set(RADIO_PARAM_FLAGS_SF, sf, 0, 0, 0, 0, 0, 0, 0); -} - -int32_t ll_coding_rate_set(uint8_t coding_rate) -{ - return ll_radio_params_set(RADIO_PARAM_FLAGS_CR, 0, coding_rate, 0, 0, 0, 0, 0, 0); -} - -int32_t ll_tx_power_set(int8_t pwr) -{ - if (pwr < -4 || pwr > 26) - { - return LL_IFC_ERROR_INCORRECT_PARAMETER; - } - return hal_read_write(OP_TX_POWER_SET, (uint8_t *)&pwr, 1, NULL, 0); -} - -int32_t ll_tx_power_get(int8_t *pwr) -{ - if (NULL == pwr) - { - return LL_IFC_ERROR_INCORRECT_PARAMETER; - } - return hal_read_write(OP_TX_POWER_GET, NULL, 0, (uint8_t *)pwr, 1); -} - -int32_t ll_frequency_set(uint32_t freq) -{ - return ll_radio_params_set(RADIO_PARAM_FLAGS_FREQ, 0, 0, 0, freq, 0, 0, 0, 0); -} - -int32_t ll_preamble_syms_set(uint16_t num_syms) -{ - return ll_radio_params_set(RADIO_PARAM_FLAGS_PREAMBLE, 0, 0, 0, 0, num_syms, 0, 0, 0); -} - -int32_t ll_header_enabled_set(uint8_t enabled) -{ - return ll_radio_params_set(RADIO_PARAM_FLAGS_HEADER, 0, 0, 0, 0, 0, enabled, 0, 0); -} - -int32_t ll_crc_enabled_set(uint8_t enabled) -{ - return ll_radio_params_set(RADIO_PARAM_FLAGS_CRC, 0, 0, 0, 0, 0, 0, enabled, 0); -} - -int32_t ll_iq_inversion_set(uint8_t inverted) -{ - return ll_radio_params_set(RADIO_PARAM_FLAGS_IQ, 0, 0, 0, 0, 0, 0, 0, inverted); -} - -int32_t ll_sync_word_set(uint8_t sync_word) -{ - return hal_read_write(OP_SYNC_WORD_SET, (uint8_t *)&sync_word, 1, NULL, 0); -} - -int32_t ll_sync_word_get(uint8_t *sync_word) -{ - if (NULL == sync_word) - { - return LL_IFC_ERROR_INCORRECT_PARAMETER; - } - return hal_read_write(OP_SYNC_WORD_GET, NULL, 0, sync_word, 1); -} - -int32_t ll_echo_mode(void) -{ - return hal_read_write(OP_PKT_ECHO, NULL, 0, NULL, 0); -} - -int32_t ll_packet_send(uint8_t buf[], uint16_t len) -{ - return ll_packet_send_queue(buf, len); -} - -int32_t ll_packet_send_queue(uint8_t buf[], uint16_t len) -{ - if (buf == NULL || len <= 0) - { - return LL_IFC_ERROR_INCORRECT_PARAMETER; - } - - uint8_t cmd_response; - - int32_t rw_response = hal_read_write(OP_PKT_SEND_QUEUE, buf, len, &cmd_response, 1); - - if (rw_response < 0) - { - return((int8_t)rw_response); - } - else - { - return(cmd_response); - } -} - -//STRIPTHIS!START -int32_t ll_packet_send_timestamp(uint32_t timestamp_us, uint8_t buf[], uint16_t len) -{ - uint8_t in_buf[4]; - uint8_t * b = in_buf; - write_uint32(timestamp_us, &b); - int32_t rw_response = hal_read_write_exact(OP_SEND_TIMESTAMP, in_buf, sizeof(in_buf), NULL, 0); - if (rw_response < 0) - { - return rw_response; - } - return ll_packet_send_queue(buf, len); -} -//STRIPTHIS!STOP - -int32_t ll_transmit_cw(void) -{ - return hal_read_write(OP_TX_CW, NULL, 0, NULL, 0); -} - -int32_t ll_packet_recv_cont(uint8_t buf[], uint16_t len, uint8_t *bytes_received, bool freq_error_requested) -{ - int32_t rw_response; - - if (buf == NULL || len == 0 || bytes_received == NULL) - { - return LL_IFC_ERROR_INCORRECT_PARAMETER; - } - - if (freq_error_requested) - { - uint8_t request_type = 0x01; - rw_response = hal_read_write(OP_PKT_RECV_CONT, &request_type, 1, buf, len); - } - else - { - rw_response = hal_read_write(OP_PKT_RECV_CONT, NULL, 0, buf, len); - } - - if (rw_response < LL_IFC_ACK) - { - *bytes_received = 0; - return rw_response; - } - else - { - *bytes_received = (uint8_t) (rw_response & 0xFF); - return(0); - } -} - -int32_t ll_packet_recv(uint16_t num_timeout_symbols, uint8_t buf[], uint16_t len, uint8_t *bytes_received) -{ - uint8_t buff[2]; - int32_t rw_response; - - if (buf == NULL || len <= 0 || bytes_received == NULL) - { - return LL_IFC_ERROR_INCORRECT_PARAMETER; - } - - // Make the uint16_t value big-endian - buff[0] = (num_timeout_symbols >> 8) & 0xFF; - buff[1] = (num_timeout_symbols >> 0) & 0xFF; - - rw_response = hal_read_write(OP_PKT_RECV, buff, sizeof(num_timeout_symbols), buf, len); - - if (rw_response < 0) - { - *bytes_received = 0; - return(-1); - } - else - { - *bytes_received = (uint8_t) (rw_response & 0xFF); - return(0); - } -} - -int32_t ll_packet_recv_with_rssi(uint16_t num_timeout_symbols, uint8_t buf[], uint16_t len, uint8_t *bytes_received, bool freq_error_requested) -{ - uint8_t local_buff[3]; - int32_t rw_response; - - if (buf == NULL || len <= 0 || bytes_received == NULL) - { - return LL_IFC_ERROR_INCORRECT_PARAMETER; - } - - // Make the uint16_t value big-endian - local_buff[0] = (num_timeout_symbols >> 8) & 0xFF; - local_buff[1] = (num_timeout_symbols) & 0xFF; - - uint16_t in_len = sizeof(num_timeout_symbols); - - if (freq_error_requested) - { - local_buff[2] = 0x01; - in_len += 1; - } - - rw_response = hal_read_write(OP_MSG_RECV_RSSI, local_buff, in_len, buf, len); - - if (rw_response < 0) - { - *bytes_received = 0; - return(-1); - } - else - { - *bytes_received = (uint8_t) (rw_response & 0xFF); - return(0); - } -} From 3885ca9f9d4e9949738b98cf230ad5c8894abbb4 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=D1=82=D0=BD=CF=83=D0=BC=CE=B1=D1=95=20=D1=95=D1=82=D1=94?= =?UTF-8?q?=CE=B9=D0=B8=D0=BD=CF=83=E2=84=93z?= Date: Fri, 25 Oct 2019 10:07:44 -0400 Subject: [PATCH 23/33] Delete ll_ifc_symphony.c.bak --- src/ll_ifc_symphony.c.bak | 661 -------------------------------------- 1 file changed, 661 deletions(-) delete mode 100644 src/ll_ifc_symphony.c.bak diff --git a/src/ll_ifc_symphony.c.bak b/src/ll_ifc_symphony.c.bak deleted file mode 100644 index 07a6f4b..0000000 --- a/src/ll_ifc_symphony.c.bak +++ /dev/null @@ -1,661 +0,0 @@ -#include "ll_ifc_symphony.h" -#include "ll_ifc_private.h" -#include "ifc_struct_defs.h" -#include // memmove - -uint8_t _uplink_message_buff[256 + 2]; -uint8_t *uplink_message_buff = _uplink_message_buff + 2; -uint8_t ll_ul_max_port = 127; - -const llabs_dl_band_cfg_t DL_BAN_FCC = {902000000, 928000000, 386703, 3, 0}; // USA / Mexico -const llabs_dl_band_cfg_t DL_BAN_BRA = {916000000, 928000000, 386703, 3, 0}; // Brazil -const llabs_dl_band_cfg_t DL_BAN_AUS = {918000000, 926000000, 386703, 3, 0}; // Australia -const llabs_dl_band_cfg_t DL_BAN_NZL = {921000000, 928000000, 386703, 3, 0}; // New Zealand -const llabs_dl_band_cfg_t DL_BAN_ETSI = {869100000, 871000000, 386703, 1, 0}; // Europe - -int32_t ll_net_token_get(uint32_t *p_net_token) -{ - uint8_t buff[4]; - if (p_net_token == NULL) - { - return LL_IFC_ERROR_INCORRECT_PARAMETER; - } - int32_t ret = hal_read_write(OP_NET_TOKEN_GET, NULL, 0, buff, 4); - if (ret < 0) - { - return ret; - } - - if (4 != ret) - { - return LL_IFC_ERROR_INCORRECT_RESPONSE_LENGTH; - } - - *p_net_token = 0; - *p_net_token |= (uint32_t) buff[0] << 24; - *p_net_token |= (uint32_t) buff[1] << 16; - *p_net_token |= (uint32_t) buff[2] << 8; - *p_net_token |= (uint32_t) buff[3]; - return LL_IFC_ACK; -} - -int32_t ll_net_token_set(uint32_t net_token) -{ - if (net_token != 0xFFFFFFFF) - { - uint8_t buff[4]; - buff[0] = (net_token >> 24) & 0xFF; - buff[1] = (net_token >> 16) & 0xFF; - buff[2] = (net_token >> 8) & 0xFF; - buff[3] = (net_token) &0xFF; - int32_t ret = hal_read_write(OP_NET_TOKEN_SET, buff, 4, NULL, 0); - return (ret >= 0) ? LL_IFC_ACK : ret; - } - else - { - return LL_IFC_ERROR_INCORRECT_PARAMETER; - } -} - -static int32_t ll_app_token_set(const uint8_t *app_token, uint8_t len) -{ - if (app_token == NULL) - { - return LL_IFC_ERROR_INCORRECT_PARAMETER; - } - if (10 != len) - { - return LL_IFC_ERROR_INCORRECT_PARAMETER; - } - int32_t ret = hal_read_write(OP_APP_TOKEN_SET, (uint8_t *) app_token, 10, NULL, 0); - return (ret >= 0) ? LL_IFC_ACK : ret; -} - -static int32_t ll_app_token_get(uint8_t *app_token) -{ - if (app_token == NULL) - { - return LL_IFC_ERROR_INCORRECT_PARAMETER; - } - - int32_t ret = hal_read_write(OP_APP_TOKEN_GET, NULL, 0, app_token, 10); - if (ret < 0) - { - return ret; - } - if (10 != ret) - { - return LL_IFC_ERROR_INCORRECT_RESPONSE_LENGTH; - } - - return LL_IFC_ACK; -} - -static int32_t ll_receive_mode_set(uint8_t rx_mode) -{ - if (rx_mode >= NUM_DOWNLINK_MODES) - { - return LL_IFC_ERROR_INCORRECT_PARAMETER; - } - int32_t ret = hal_read_write(OP_RX_MODE_SET, &rx_mode, 1, NULL, 0); - return (ret >= 0) ? LL_IFC_ACK : ret; -} - -static int32_t ll_receive_mode_get(uint8_t *rx_mode) -{ - if (rx_mode == NULL) - { - return LL_IFC_ERROR_INCORRECT_PARAMETER; - } - int32_t ret = hal_read_write(OP_RX_MODE_GET, NULL, 0, rx_mode, sizeof(*rx_mode)); - return (ret >= 0) ? LL_IFC_ACK : ret; -} - -static int32_t ll_qos_request(uint8_t qos) -{ - if (qos > 15) - { - return LL_IFC_ERROR_INCORRECT_PARAMETER; - } - int32_t ret = hal_read_write(OP_QOS_REQUEST, &qos, 1, NULL, 0); - return (ret >= 0) ? LL_IFC_ACK : ret; -} - -static int32_t ll_qos_get(uint8_t *qos) -{ - if (qos == NULL) - { - return LL_IFC_ERROR_INCORRECT_PARAMETER; - } - return hal_read_write(OP_QOS_GET, NULL, 0, qos, sizeof(*qos)); -} - -static int32_t ll_scan_attempts_get(uint16_t *scan_attempts) -{ - uint8_t buf[2]; - int32_t ret = hal_read_write(OP_SCAN_ATTEMPTS_GET, NULL, 0, buf, 2); - *scan_attempts = ((uint16_t) buf[1] << 8) | buf[0]; - return (ret >= 0) ? LL_IFC_ACK : ret; -} - -static int32_t ll_scan_attempts_left_get(uint16_t *scan_attempts) -{ - uint8_t buf[2]; - int32_t ret = hal_read_write(OP_SCAN_ATTEMPTS_LEFT, NULL, 0, buf, 2); - *scan_attempts = ((uint16_t) buf[1] << 8) | buf[0]; - return (ret >= 0) ? LL_IFC_ACK : ret; -} - -int32_t ll_config_set(uint32_t net_token, const uint8_t app_token[APP_TOKEN_LEN], - enum ll_downlink_mode dl_mode, uint8_t qos) -{ - int32_t ret; - - ret = ll_net_token_set(net_token); - if (LL_IFC_ACK != ret) - { - return ret; - } - - ret = ll_app_token_set(app_token, APP_TOKEN_LEN); - if (LL_IFC_ACK != ret) - { - return ret; - } - - ret = ll_receive_mode_set(dl_mode); - if (LL_IFC_ACK != ret) - { - return ret; - } - - ret = ll_qos_request(qos); - if (LL_IFC_ACK != ret) - { - return ret; - } - - return (ret >= 0) ? LL_IFC_ACK : ret; -} - -int32_t ll_config_get(uint32_t *net_token, uint8_t app_token[APP_TOKEN_LEN], - enum ll_downlink_mode *dl_mode, uint8_t *qos) -{ - int32_t ret; - - ret = ll_net_token_get(net_token); - if (LL_IFC_ACK != ret) - { - return ret; - } - - ret = ll_app_token_get(app_token); - if (LL_IFC_ACK != ret) - { - return ret; - } - - ret = ll_receive_mode_get((uint8_t *) dl_mode); - if (LL_IFC_ACK != ret) - { - return ret; - } - - ret = ll_qos_get(qos); - if (LL_IFC_ACK != ret) - { - return ret; - } - - return (ret >= 0) ? LL_IFC_ACK : ret; -} - -int32_t ll_scan_config_set(enum ll_scan_mode scan_mode, int16_t threshold, uint16_t scan_attempts) -{ - if (scan_mode > LLABS_INFO_SCAN) - { - return LL_IFC_ERROR_INCORRECT_PARAMETER; - } - - int32_t ret = ll_scan_mode_set(scan_mode); - if (ret < LL_IFC_ACK) - { - return ret; - } - - ret = ll_threshold_set(threshold); - if (ret < LL_IFC_ACK) - { - return ret; - } - - ret = ll_scan_attempts_set(scan_attempts); - if (ret < LL_IFC_ACK) - { - return ret; - } - - return (ret >= 0) ? LL_IFC_ACK : ret; -} - -int32_t ll_scan_config_get(enum ll_scan_mode *scan_mode, int16_t *threshold, - uint16_t *scan_attempts, uint16_t *scans_left) -{ - int32_t ret = ll_scan_mode_get(scan_mode); - if (ret < LL_IFC_ACK) - { - return ret; - } - - ret = ll_threshold_get(threshold); - if (ret < LL_IFC_ACK) - { - return ret; - } - - ret = ll_scan_attempts_get(scan_attempts); - if (ret < LL_IFC_ACK) - { - return ret; - } - - ret = ll_scan_attempts_left_get(scans_left); - if (ret < LL_IFC_ACK) - { - return ret; - } - - return (ret >= 0) ? LL_IFC_ACK : ret; -} - -int32_t ll_connect_to_gw_channel(uint8_t channel) -{ - int32_t ret = hal_read_write(OP_CONN_TO_GW_CH, &channel, 1, NULL, 0); - return (ret >= 0) ? LL_IFC_ACK : ret; -} - -int32_t ll_control_messages_enabled_set(bool enable) -{ - int32_t ret = hal_read_write(OP_CTRL_MSG_ENABLED_SET, (uint8_t*)&enable, 1, NULL, 0); - return (ret >= 0) ? LL_IFC_ACK : ret; -} - -int32_t ll_control_messages_enabled_get(bool *enabled) -{ - int32_t ret = hal_read_write(OP_CTRL_MSG_ENABLED_GET, NULL, 0, (uint8_t*)enabled, 1); - return (ret >= 0) ? LL_IFC_ACK : ret; -} - -int32_t ll_cloud_gpio_activate_pin(uint8_t pin) -{ - int32_t ret = hal_read_write(OP_GPIO_ENABLE_PIN, (uint8_t*)&pin, 1, NULL, 0); - return (ret >= 0) ? LL_IFC_ACK : ret; -} - -int32_t ll_cloud_gpio_deactivate_pin(uint8_t pin) -{ - int32_t ret = hal_read_write(OP_GPIO_DISABLE_PIN, (uint8_t*)&pin, 1, NULL, 0); - return (ret >= 0) ? LL_IFC_ACK : ret; -} - -int32_t ll_cloud_gpio_get_pin_status(uint8_t pin, bool *active) -{ - int32_t ret = hal_read_write(OP_GPIO_PIN_STATUS, (uint8_t*)&pin, 1, NULL, 0); - return (ret >= 0) ? LL_IFC_ACK : ret; -} - -int32_t ll_cloud_gpio_set_pin_high(uint8_t pin) -{ - int32_t ret = hal_read_write(OP_GPIO_SET_HIGH, (uint8_t*)&pin, 1, NULL, 0); - return (ret >= 0) ? LL_IFC_ACK : ret; -} - -int32_t ll_cloud_gpio_set_pin_low(uint8_t pin) -{ - int32_t ret = hal_read_write(OP_GPIO_SET_LOW, (uint8_t*)&pin, 1, NULL, 0); - return (ret >= 0) ? LL_IFC_ACK : ret; -} - -int32_t ll_disconnect() -{ - int32_t ret = hal_read_write(OP_DISCONNECT, NULL, 0, NULL, 0); - return (ret >= 0) ? LL_IFC_ACK : ret; -} - -int32_t ll_poll_scan_result(llabs_gateway_scan_results_t *scan_result, uint8_t *num_gw) -{ - if (scan_result == NULL || num_gw == NULL) - { - return LL_IFC_ERROR_INCORRECT_PARAMETER; - } - - uint8_t buff[GW_SCAN_INFO_BUFF_SIZE]; - - int32_t ret = hal_read_write(OP_GET_SCAN_INFO, NULL, 0, buff, GW_SCAN_INFO_BUFF_SIZE); - if (ret < LL_IFC_ACK) - { - return ret; - } - - ll_gw_scan_result_deserialize(buff, scan_result, num_gw); - - return (ret >= 0) ? LL_IFC_ACK : ret; -} - -int32_t -ll_get_gateway_scan_results(llabs_gateway_scan_results_t (*scan_results)[MAX_GW_SCAN_RESULTS], - uint8_t *num_gw) -{ - uint8_t gw; - *num_gw = 0; - - do - { - llabs_gateway_scan_results_t scan_result; - - int32_t ret = ll_poll_scan_result(&scan_result, &gw); - if (ret != LL_IFC_ACK) - { - return ret; - } - - // When num_gw is uninitialized, we need to set it with the total - // amount of gateways - if (*num_gw == 0) - { - *num_gw = gw + 1; - } - - memcpy(&(*scan_results)[gw], &scan_result, sizeof(scan_result)); - - } while (gw > 0); - - return LL_IFC_ACK; -} - -int32_t ll_get_state(enum ll_state *state, enum ll_tx_state *tx_state, enum ll_rx_state *rx_state) -{ - int32_t ret = LL_IFC_ACK; - - if (NULL != state) - { - uint8_t u8_state; - ret = hal_read_write(OP_STATE, NULL, 0, &u8_state, 1); - if (LL_IFC_ACK > ret) - { - return ret; - } - *state = (enum ll_state)(int8_t) u8_state; - } - - if (NULL != tx_state) - { - uint8_t u8_tx_state; - ret = hal_read_write(OP_TX_STATE, NULL, 0, &u8_tx_state, 1); - if (LL_IFC_ACK > ret) - { - return ret; - } - *tx_state = (enum ll_tx_state)(int8_t) u8_tx_state; - } - - if (NULL != rx_state) - { - uint8_t u8_rx_state; - ret = hal_read_write(OP_RX_STATE, NULL, 0, &u8_rx_state, 1); - if (LL_IFC_ACK > ret) - { - return ret; - } - *rx_state = (enum ll_rx_state)(int8_t) u8_rx_state; - } - - return (ret >= 0) ? LL_IFC_ACK : ret; -} - -int32_t ll_mailbox_request(void) -{ - int32_t ret = hal_read_write(OP_MAILBOX_REQUEST, NULL, 0, NULL, 0); - return (ret >= 0) ? LL_IFC_ACK : ret; -} - -int32_t ll_app_reg_get(uint8_t *is_registered) -{ - if (is_registered == NULL) - { - return LL_IFC_ERROR_INCORRECT_PARAMETER; - } - int32_t ret = hal_read_write(OP_APP_TOKEN_REG_GET, NULL, 0, is_registered, 1); - return (ret >= 0) ? LL_IFC_ACK : ret; -} - -int32_t ll_encryption_key_exchange_request(void) -{ - int32_t ret = hal_read_write(OP_CRYPTO_KEY_XCHG_REQ, NULL, 0, NULL, 0); - return (ret >= 0) ? LL_IFC_ACK : ret; -} - -int32_t ll_net_info_get(llabs_network_info_t *p_net_info) -{ - uint8_t buff[NET_INFO_BUFF_SIZE]; - if (p_net_info == NULL) - { - return LL_IFC_ERROR_INCORRECT_PARAMETER; - } - - int32_t ret = hal_read_write(OP_NET_INFO_GET, NULL, 0, buff, NET_INFO_BUFF_SIZE); - if (LL_IFC_ACK > ret) - { - return ret; - } - if (NET_INFO_BUFF_SIZE != ret) - { - return LL_IFC_ERROR_INCORRECT_RESPONSE_LENGTH; - } - - ll_net_info_deserialize(buff, p_net_info); - return LL_IFC_ACK; -} - -int32_t ll_stats_get(llabs_stats_t *s) -{ - uint8_t buff[STATS_SIZE]; - if (s == NULL) - { - return LL_IFC_ERROR_INCORRECT_PARAMETER; - } - - int32_t ret = hal_read_write(OP_STATS_GET, NULL, 0, buff, STATS_SIZE); - if (LL_IFC_ACK > ret) - { - return ret; - } - if (STATS_SIZE != ret) - { - return LL_IFC_ERROR_INCORRECT_RESPONSE_LENGTH; - } - - ll_stats_deserialize(buff, s); - return LL_IFC_ACK; -} - -int32_t ll_retrieve_message(uint8_t *buf, uint16_t *size, uint8_t *port, int16_t *rssi, - uint8_t *snr) -{ - int32_t rw_response; - - if (buf == NULL || size == NULL) - { - return LL_IFC_ERROR_INCORRECT_PARAMETER; - } - - rw_response = hal_read_write(OP_MSG_RECV, NULL, 0, buf, *size); - - if (rw_response < LL_IFC_ACK) - { - *size = 0; - return rw_response; - } - - // Size is required - if ((rw_response & 0xff) <= 4) - { - *size = 0; - return LL_IFC_ERROR_INCORRECT_RESPONSE_LENGTH; - } - *size = (uint8_t)(rw_response & 0xFF) - 4; - - // Optional RSSI - if (NULL != rssi) - { - *rssi = 0; - *rssi = buf[0] + ((uint16_t) buf[1] << 8); - } - - // Optional RSSI - if (NULL != snr) - { - *snr = buf[2]; - } - - if (NULL != port) - { - *port = buf[3]; - } - - // get rid of snr and rssi in buffer - memmove(buf, buf + 4, *size); - - return LL_IFC_ACK; -} - -int32_t ll_dl_band_cfg_get(llabs_dl_band_cfg_t *p) -{ - uint8_t buff[DL_BAND_CFG_SIZE]; - if (p == NULL) - { - return LL_IFC_ERROR_INCORRECT_PARAMETER; - } - - int32_t ret = hal_read_write(OP_DL_BAND_CFG_GET, NULL, 0, buff, DL_BAND_CFG_SIZE); - if (LL_IFC_ACK > ret) - { - return ret; - } - if (DL_BAND_CFG_SIZE != ret) - { - return LL_IFC_ERROR_INCORRECT_RESPONSE_LENGTH; - } - - ll_dl_band_cfg_deserialize(buff, p); - return LL_IFC_ACK; -} - -int32_t ll_dl_band_cfg_set(const llabs_dl_band_cfg_t *p) -{ - uint8_t buff[DL_BAND_CFG_SIZE]; - if (p == NULL) - { - return LL_IFC_ERROR_INCORRECT_PARAMETER; - } - - ll_dl_band_cfg_serialize(p, buff); - int32_t ret = hal_read_write(OP_DL_BAND_CFG_SET, buff, DL_BAND_CFG_SIZE, NULL, 0); - return (ret >= 0) ? LL_IFC_ACK : ret; -} - -int32_t ll_rssi_offset_get(int8_t *rssi_offset) -{ - uint8_t raw = 0; - int32_t ret = hal_read_write(OP_RSSI_OFFSET_GET, NULL, 0, &raw, 1); - *rssi_offset = (int8_t)raw; - return (ret >= 0) ? LL_IFC_ACK : ret; -} - -int32_t ll_rssi_offset_set(int8_t rssi_offset) -{ - if (rssi_offset > 15 || rssi_offset < -15) - { - return LL_IFC_ERROR_INCORRECT_PARAMETER; - } - - int32_t ret = hal_read_write(OP_RSSI_OFFSET_SET, (uint8_t*)&rssi_offset, 1, NULL, 0); - return (ret >= 0) ? LL_IFC_ACK : ret; -} - -int32_t ll_connection_filter_get(uint8_t *p_f) -{ - if (NULL == p_f) - { - return LL_IFC_ERROR_INCORRECT_PARAMETER; - } - uint8_t f; - int32_t ret = hal_read_write(OP_CONN_FILT_GET, NULL, 0, &f, 1); - if (LL_IFC_ACK > ret) - { - return ret; - } - if (sizeof(f) != ret) - { - return LL_IFC_ERROR_INCORRECT_RESPONSE_LENGTH; - } - - *p_f = f; - return (ret >= 0) ? LL_IFC_ACK : ret; -} - -int32_t ll_connection_filter_set(uint8_t f) -{ - int32_t ret = hal_read_write(OP_CONN_FILT_SET, &f, 1, NULL, 0); - return (ret >= 0) ? LL_IFC_ACK : ret; -} - -int32_t ll_system_time_get(llabs_time_info_t *time_info) -{ - uint8_t buff[TIME_INFO_SIZE]; - if (time_info == NULL) - { - return LL_IFC_ERROR_INCORRECT_PARAMETER; - } - int32_t ret = hal_read_write(OP_SYSTEM_TIME_GET, NULL, 0, buff, STATS_SIZE); - if (LL_IFC_ACK > ret) - { - return ret; - } - if (TIME_INFO_SIZE != ret) - { - return LL_IFC_ERROR_INCORRECT_RESPONSE_LENGTH; - } - - ll_time_deserialize(buff, time_info); - return LL_IFC_ACK; -} - -int32_t ll_system_time_sync(uint8_t sync_mode) -{ - if (sync_mode > 1) - { - return LL_IFC_ERROR_INCORRECT_PARAMETER; - } - int32_t ret = hal_read_write(OP_SYSTEM_TIME_SYNC, &sync_mode, sizeof(sync_mode), NULL, 0); - return (ret >= 0) ? LL_IFC_ACK : ret; -} - -int32_t ll_message_send(uint8_t buf[], uint16_t len, bool ack, uint8_t port) -{ - if (buf == NULL || len <= 0 || len > 256) - { - return LL_IFC_ERROR_INCORRECT_PARAMETER; - } - - if (port > ll_ul_max_port) - { - return LL_IFC_ERROR_INCORRECT_PARAMETER; - } - - memmove(uplink_message_buff, buf, len); - _uplink_message_buff[0] = (uint8_t) ack; - _uplink_message_buff[1] = port; - int32_t ret = hal_read_write(OP_MSG_SEND, _uplink_message_buff, len + 2, NULL, 0); - return (ret >= 0) ? LL_IFC_ACK : ret; -} From 6f07265e49f8499bbff1eb6ace09bdaae941a987 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=D1=82=D0=BD=CF=83=D0=BC=CE=B1=D1=95=20=D1=95=D1=82=D1=94?= =?UTF-8?q?=CE=B9=D0=B8=D0=BD=CF=83=E2=84=93z?= Date: Fri, 25 Oct 2019 10:07:51 -0400 Subject: [PATCH 24/33] Delete ll_ifc_symphony.c.bak.bak --- src/ll_ifc_symphony.c.bak.bak | 661 ---------------------------------- 1 file changed, 661 deletions(-) delete mode 100644 src/ll_ifc_symphony.c.bak.bak diff --git a/src/ll_ifc_symphony.c.bak.bak b/src/ll_ifc_symphony.c.bak.bak deleted file mode 100644 index a52ae4c..0000000 --- a/src/ll_ifc_symphony.c.bak.bak +++ /dev/null @@ -1,661 +0,0 @@ -#include "ll_ifc_symphony.h" -#include "ll_ifc_private.h" -#include "ifc_struct_defs.h" -#include // memmove - -uint8_t _uplink_message_buff[256 + 2]; -uint8_t *uplink_message_buff = _uplink_message_buff + 2; -uint8_t ll_ul_max_port = 127; - -const llabs_dl_band_cfg_t DL_BAN_FCC = {902000000, 928000000, 386703, 3, 0}; // USA / Mexico -const llabs_dl_band_cfg_t DL_BAN_BRA = {916000000, 928000000, 386703, 3, 0}; // Brazil -const llabs_dl_band_cfg_t DL_BAN_AUS = {918000000, 926000000, 386703, 3, 0}; // Australia -const llabs_dl_band_cfg_t DL_BAN_NZL = {921000000, 928000000, 386703, 3, 0}; // New Zealand -const llabs_dl_band_cfg_t DL_BAN_ETSI = {869100000, 871000000, 386703, 1, 0}; // Europe - -int32_t ll_net_token_get(uint32_t *p_net_token) -{ - uint8_t buff[4]; - if (p_net_token == NULL) - { - return LL_IFC_ERROR_INCORRECT_PARAMETER; - } - int32_t ret = hal_read_write(OP_NET_TOKEN_GET, NULL, 0, buff, 4); - if (ret < 0) - { - return ret; - } - - if (4 != ret) - { - return LL_IFC_ERROR_INCORRECT_RESPONSE_LENGTH; - } - - *p_net_token = 0; - *p_net_token |= (uint32_t)buff[0] << 24; - *p_net_token |= (uint32_t)buff[1] << 16; - *p_net_token |= (uint32_t)buff[2] << 8; - *p_net_token |= (uint32_t)buff[3]; - return ret; -} - -int32_t ll_net_token_set(uint32_t net_token) -{ - if(net_token != 0xFFFFFFFF) - { - uint8_t buff[4]; - buff[0] = (net_token >> 24) & 0xFF; - buff[1] = (net_token >> 16) & 0xFF; - buff[2] = (net_token >> 8) & 0xFF; - buff[3] = (net_token) &0xFF; - int32_t ret = hal_read_write(OP_NET_TOKEN_SET, buff, 4, NULL, 0); - return (ret >= 0) ? LL_IFC_ACK : ret; - } - else - { - return LL_IFC_ERROR_INCORRECT_PARAMETER; - } -} - -static int32_t ll_app_token_set(const uint8_t *app_token, uint8_t len) -{ - if (app_token == NULL) - { - return LL_IFC_ERROR_INCORRECT_PARAMETER; - } - if (10 != len) - { - return LL_IFC_ERROR_INCORRECT_PARAMETER; - } - int32_t ret = hal_read_write(OP_APP_TOKEN_SET, (uint8_t *) app_token, 10, NULL, 0); - return (ret >= 0) ? LL_IFC_ACK : ret; -} - -static int32_t ll_app_token_get(uint8_t *app_token) -{ - if (app_token == NULL) - { - return LL_IFC_ERROR_INCORRECT_PARAMETER; - } - - int32_t ret = hal_read_write(OP_APP_TOKEN_GET, NULL, 0, app_token, 10); - if (ret < 0) - { - return ret; - } - if (10 != ret) - { - return LL_IFC_ERROR_INCORRECT_RESPONSE_LENGTH; - } - - return LL_IFC_ACK; -} - -static int32_t ll_receive_mode_set(uint8_t rx_mode) -{ - if (rx_mode >= NUM_DOWNLINK_MODES) - { - return LL_IFC_ERROR_INCORRECT_PARAMETER; - } - int32_t ret = hal_read_write(OP_RX_MODE_SET, &rx_mode, 1, NULL, 0); - return (ret >= 0) ? LL_IFC_ACK : ret; -} - -static int32_t ll_receive_mode_get(uint8_t *rx_mode) -{ - if (rx_mode == NULL) - { - return LL_IFC_ERROR_INCORRECT_PARAMETER; - } - int32_t ret = hal_read_write(OP_RX_MODE_GET, NULL, 0, rx_mode, sizeof(*rx_mode)); - return (ret >= 0) ? LL_IFC_ACK : ret; -} - -static int32_t ll_qos_request(uint8_t qos) -{ - if (qos > 15) - { - return LL_IFC_ERROR_INCORRECT_PARAMETER; - } - int32_t ret = hal_read_write(OP_QOS_REQUEST, &qos, 1, NULL, 0); - return (ret >= 0) ? LL_IFC_ACK : ret; -} - -static int32_t ll_qos_get(uint8_t *qos) -{ - if (qos == NULL) - { - return LL_IFC_ERROR_INCORRECT_PARAMETER; - } - return hal_read_write(OP_QOS_GET, NULL, 0, qos, sizeof(*qos)); -} - -static int32_t ll_scan_attempts_get(uint16_t *scan_attempts) -{ - uint8_t buf[2]; - int32_t ret = hal_read_write(OP_SCAN_ATTEMPTS_GET, NULL, 0, buf, 2); - *scan_attempts = ((uint16_t) buf[1] << 8) | buf[0]; - return (ret >= 0) ? LL_IFC_ACK : ret; -} - -static int32_t ll_scan_attempts_left_get(uint16_t *scan_attempts) -{ - uint8_t buf[2]; - int32_t ret = hal_read_write(OP_SCAN_ATTEMPTS_LEFT, NULL, 0, buf, 2); - *scan_attempts = ((uint16_t) buf[1] << 8) | buf[0]; - return (ret >= 0) ? LL_IFC_ACK : ret; -} - -int32_t ll_config_set(uint32_t net_token, const uint8_t app_token[APP_TOKEN_LEN], - enum ll_downlink_mode dl_mode, uint8_t qos) -{ - int32_t ret; - - ret = ll_net_token_set(net_token); - if (LL_IFC_ACK != ret) - { - return ret; - } - - ret = ll_app_token_set(app_token, APP_TOKEN_LEN); - if (LL_IFC_ACK != ret) - { - return ret; - } - - ret = ll_receive_mode_set(dl_mode); - if (LL_IFC_ACK != ret) - { - return ret; - } - - ret = ll_qos_request(qos); - if (LL_IFC_ACK != ret) - { - return ret; - } - - return (ret >= 0) ? LL_IFC_ACK : ret; -} - -int32_t ll_config_get(uint32_t *net_token, uint8_t app_token[APP_TOKEN_LEN], - enum ll_downlink_mode *dl_mode, uint8_t *qos) -{ - int32_t ret; - - ret = ll_net_token_get(net_token); - if (LL_IFC_ACK != ret) - { - return ret; - } - - ret = ll_app_token_get(app_token); - if (LL_IFC_ACK != ret) - { - return ret; - } - - ret = ll_receive_mode_get((uint8_t *) dl_mode); - if (LL_IFC_ACK != ret) - { - return ret; - } - - ret = ll_qos_get(qos); - if (LL_IFC_ACK != ret) - { - return ret; - } - - return (ret >= 0) ? LL_IFC_ACK : ret; -} - -int32_t ll_scan_config_set(enum ll_scan_mode scan_mode, int16_t threshold, uint16_t scan_attempts) -{ - if (scan_mode > LLABS_INFO_SCAN) - { - return LL_IFC_ERROR_INCORRECT_PARAMETER; - } - - int32_t ret = ll_scan_mode_set(scan_mode); - if (ret < LL_IFC_ACK) - { - return ret; - } - - ret = ll_threshold_set(threshold); - if (ret < LL_IFC_ACK) - { - return ret; - } - - ret = ll_scan_attempts_set(scan_attempts); - if (ret < LL_IFC_ACK) - { - return ret; - } - - return (ret >= 0) ? LL_IFC_ACK : ret; -} - -int32_t ll_scan_config_get(enum ll_scan_mode *scan_mode, int16_t *threshold, - uint16_t *scan_attempts, uint16_t *scans_left) -{ - int32_t ret = ll_scan_mode_get(scan_mode); - if (ret < LL_IFC_ACK) - { - return ret; - } - - ret = ll_threshold_get(threshold); - if (ret < LL_IFC_ACK) - { - return ret; - } - - ret = ll_scan_attempts_get(scan_attempts); - if (ret < LL_IFC_ACK) - { - return ret; - } - - ret = ll_scan_attempts_left_get(scans_left); - if (ret < LL_IFC_ACK) - { - return ret; - } - - return (ret >= 0) ? LL_IFC_ACK : ret; -} - -int32_t ll_connect_to_gw_channel(uint8_t channel) -{ - int32_t ret = hal_read_write(OP_CONN_TO_GW_CH, &channel, 1, NULL, 0); - return (ret >= 0) ? LL_IFC_ACK : ret; -} - -int32_t ll_control_messages_enabled_set(bool enable) -{ - int32_t ret = hal_read_write(OP_CTRL_MSG_ENABLED_SET, (uint8_t*)&enable, 1, NULL, 0); - return (ret >= 0) ? LL_IFC_ACK : ret; -} - -int32_t ll_control_messages_enabled_get(bool *enabled) -{ - int32_t ret = hal_read_write(OP_CTRL_MSG_ENABLED_GET, NULL, 0, (uint8_t*)enabled, 1); - return (ret >= 0) ? LL_IFC_ACK : ret; -} - -int32_t ll_cloud_gpio_activate_pin(uint8_t pin) -{ - int32_t ret = hal_read_write(OP_GPIO_ENABLE_PIN, (uint8_t*)&pin, 1, NULL, 0); - return (ret >= 0) ? LL_IFC_ACK : ret; -} - -int32_t ll_cloud_gpio_deactivate_pin(uint8_t pin) -{ - int32_t ret = hal_read_write(OP_GPIO_DISABLE_PIN, (uint8_t*)&pin, 1, NULL, 0); - return (ret >= 0) ? LL_IFC_ACK : ret; -} - -int32_t ll_cloud_gpio_get_pin_status(uint8_t pin, bool *active) -{ - int32_t ret = hal_read_write(OP_GPIO_PIN_STATUS, (uint8_t*)&pin, 1, NULL, 0); - return (ret >= 0) ? LL_IFC_ACK : ret; -} - -int32_t ll_cloud_gpio_set_pin_high(uint8_t pin) -{ - int32_t ret = hal_read_write(OP_GPIO_SET_HIGH, (uint8_t*)&pin, 1, NULL, 0); - return (ret >= 0) ? LL_IFC_ACK : ret; -} - -int32_t ll_cloud_gpio_set_pin_low(uint8_t pin) -{ - int32_t ret = hal_read_write(OP_GPIO_SET_LOW, (uint8_t*)&pin, 1, NULL, 0); - return (ret >= 0) ? LL_IFC_ACK : ret; -} - -int32_t ll_disconnect() -{ - int32_t ret = hal_read_write(OP_DISCONNECT, NULL, 0, NULL, 0); - return (ret >= 0) ? LL_IFC_ACK : ret; -} - -int32_t ll_poll_scan_result(llabs_gateway_scan_results_t *scan_result, uint8_t *num_gw) -{ - if (scan_result == NULL || num_gw == NULL) - { - return LL_IFC_ERROR_INCORRECT_PARAMETER; - } - - uint8_t buff[GW_SCAN_INFO_BUFF_SIZE]; - - int32_t ret = hal_read_write(OP_GET_SCAN_INFO, NULL, 0, buff, GW_SCAN_INFO_BUFF_SIZE); - if (ret < LL_IFC_ACK) - { - return ret; - } - - ll_gw_scan_result_deserialize(buff, scan_result, num_gw); - - return (ret >= 0) ? LL_IFC_ACK : ret; -} - -int32_t -ll_get_gateway_scan_results(llabs_gateway_scan_results_t (*scan_results)[MAX_GW_SCAN_RESULTS], - uint8_t *num_gw) -{ - uint8_t gw; - *num_gw = 0; - - do - { - llabs_gateway_scan_results_t scan_result; - - int32_t ret = ll_poll_scan_result(&scan_result, &gw); - if (ret != LL_IFC_ACK) - { - return ret; - } - - // When num_gw is uninitialized, we need to set it with the total - // amount of gateways - if (*num_gw == 0) - { - *num_gw = gw + 1; - } - - memcpy(&(*scan_results)[gw], &scan_result, sizeof(scan_result)); - - } while (gw > 0); - - return LL_IFC_ACK; -} - -int32_t ll_get_state(enum ll_state *state, enum ll_tx_state *tx_state, enum ll_rx_state *rx_state) -{ - int32_t ret = LL_IFC_ACK; - - if (NULL != state) - { - uint8_t u8_state; - ret = hal_read_write(OP_STATE, NULL, 0, &u8_state, 1); - if (LL_IFC_ACK > ret) - { - return ret; - } - *state = (enum ll_state)(int8_t) u8_state; - } - - if (NULL != tx_state) - { - uint8_t u8_tx_state; - ret = hal_read_write(OP_TX_STATE, NULL, 0, &u8_tx_state, 1); - if (LL_IFC_ACK > ret) - { - return ret; - } - *tx_state = (enum ll_tx_state)(int8_t) u8_tx_state; - } - - if (NULL != rx_state) - { - uint8_t u8_rx_state; - ret = hal_read_write(OP_RX_STATE, NULL, 0, &u8_rx_state, 1); - if (LL_IFC_ACK > ret) - { - return ret; - } - *rx_state = (enum ll_rx_state)(int8_t) u8_rx_state; - } - - return (ret >= 0) ? LL_IFC_ACK : ret; -} - -int32_t ll_mailbox_request(void) -{ - int32_t ret = hal_read_write(OP_MAILBOX_REQUEST, NULL, 0, NULL, 0); - return (ret >= 0) ? LL_IFC_ACK : ret; -} - -int32_t ll_app_reg_get(uint8_t *is_registered) -{ - if (is_registered == NULL) - { - return LL_IFC_ERROR_INCORRECT_PARAMETER; - } - int32_t ret = hal_read_write(OP_APP_TOKEN_REG_GET, NULL, 0, is_registered, 1); - return (ret >= 0) ? LL_IFC_ACK : ret; -} - -int32_t ll_encryption_key_exchange_request(void) -{ - int32_t ret = hal_read_write(OP_CRYPTO_KEY_XCHG_REQ, NULL, 0, NULL, 0); - return (ret >= 0) ? LL_IFC_ACK : ret; -} - -int32_t ll_net_info_get(llabs_network_info_t *p_net_info) -{ - uint8_t buff[NET_INFO_BUFF_SIZE]; - if (p_net_info == NULL) - { - return LL_IFC_ERROR_INCORRECT_PARAMETER; - } - - int32_t ret = hal_read_write(OP_NET_INFO_GET, NULL, 0, buff, NET_INFO_BUFF_SIZE); - if (LL_IFC_ACK > ret) - { - return ret; - } - if (NET_INFO_BUFF_SIZE != ret) - { - return LL_IFC_ERROR_INCORRECT_RESPONSE_LENGTH; - } - - ll_net_info_deserialize(buff, p_net_info); - return LL_IFC_ACK; -} - -int32_t ll_stats_get(llabs_stats_t *s) -{ - uint8_t buff[STATS_SIZE]; - if (s == NULL) - { - return LL_IFC_ERROR_INCORRECT_PARAMETER; - } - - int32_t ret = hal_read_write(OP_STATS_GET, NULL, 0, buff, STATS_SIZE); - if (LL_IFC_ACK > ret) - { - return ret; - } - if (STATS_SIZE != ret) - { - return LL_IFC_ERROR_INCORRECT_RESPONSE_LENGTH; - } - - ll_stats_deserialize(buff, s); - return LL_IFC_ACK; -} - -int32_t ll_retrieve_message(uint8_t *buf, uint16_t *size, uint8_t *port, int16_t *rssi, - uint8_t *snr) -{ - int32_t rw_response; - - if (buf == NULL || size == NULL) - { - return LL_IFC_ERROR_INCORRECT_PARAMETER; - } - - rw_response = hal_read_write(OP_MSG_RECV, NULL, 0, buf, *size); - - if (rw_response < LL_IFC_ACK) - { - *size = 0; - return rw_response; - } - - // Size is required - if ((rw_response & 0xff) <= 4) - { - *size = 0; - return LL_IFC_ERROR_INCORRECT_RESPONSE_LENGTH; - } - *size = (uint8_t)(rw_response & 0xFF) - 4; - - // Optional RSSI - if (NULL != rssi) - { - *rssi = 0; - *rssi = buf[0] + ((uint16_t) buf[1] << 8); - } - - // Optional RSSI - if (NULL != snr) - { - *snr = buf[2]; - } - - if (NULL != port) - { - *port = buf[3]; - } - - // get rid of snr and rssi in buffer - memmove(buf, buf + 4, *size); - - return LL_IFC_ACK; -} - -int32_t ll_dl_band_cfg_get(llabs_dl_band_cfg_t *p) -{ - uint8_t buff[DL_BAND_CFG_SIZE]; - if (p == NULL) - { - return LL_IFC_ERROR_INCORRECT_PARAMETER; - } - - int32_t ret = hal_read_write(OP_DL_BAND_CFG_GET, NULL, 0, buff, DL_BAND_CFG_SIZE); - if (LL_IFC_ACK > ret) - { - return ret; - } - if (DL_BAND_CFG_SIZE != ret) - { - return LL_IFC_ERROR_INCORRECT_RESPONSE_LENGTH; - } - - ll_dl_band_cfg_deserialize(buff, p); - return LL_IFC_ACK; -} - -int32_t ll_dl_band_cfg_set(const llabs_dl_band_cfg_t *p) -{ - uint8_t buff[DL_BAND_CFG_SIZE]; - if (p == NULL) - { - return LL_IFC_ERROR_INCORRECT_PARAMETER; - } - - ll_dl_band_cfg_serialize(p, buff); - int32_t ret = hal_read_write(OP_DL_BAND_CFG_SET, buff, DL_BAND_CFG_SIZE, NULL, 0); - return (ret >= 0) ? LL_IFC_ACK : ret; -} - -int32_t ll_rssi_offset_get(int8_t *rssi_offset) -{ - uint8_t raw = 0; - int32_t ret = hal_read_write(OP_RSSI_OFFSET_GET, NULL, 0, &raw, 1); - *rssi_offset = (int8_t)raw; - return (ret >= 0) ? LL_IFC_ACK : ret; -} - -int32_t ll_rssi_offset_set(int8_t rssi_offset) -{ - if (rssi_offset > 15 || rssi_offset < -15) - { - return LL_IFC_ERROR_INCORRECT_PARAMETER; - } - - int32_t ret = hal_read_write(OP_RSSI_OFFSET_SET, (uint8_t*)&rssi_offset, 1, NULL, 0); - return (ret >= 0) ? LL_IFC_ACK : ret; -} - -int32_t ll_connection_filter_get(uint8_t *p_f) -{ - if (NULL == p_f) - { - return LL_IFC_ERROR_INCORRECT_PARAMETER; - } - uint8_t f; - int32_t ret = hal_read_write(OP_CONN_FILT_GET, NULL, 0, &f, 1); - if (LL_IFC_ACK > ret) - { - return ret; - } - if (sizeof(f) != ret) - { - return LL_IFC_ERROR_INCORRECT_RESPONSE_LENGTH; - } - - *p_f = f; - return (ret >= 0) ? LL_IFC_ACK : ret; -} - -int32_t ll_connection_filter_set(uint8_t f) -{ - int32_t ret = hal_read_write(OP_CONN_FILT_SET, &f, 1, NULL, 0); - return (ret >= 0) ? LL_IFC_ACK : ret; -} - -int32_t ll_system_time_get(llabs_time_info_t *time_info) -{ - uint8_t buff[TIME_INFO_SIZE]; - if (time_info == NULL) - { - return LL_IFC_ERROR_INCORRECT_PARAMETER; - } - int32_t ret = hal_read_write(OP_SYSTEM_TIME_GET, NULL, 0, buff, STATS_SIZE); - if (LL_IFC_ACK > ret) - { - return ret; - } - if (TIME_INFO_SIZE != ret) - { - return LL_IFC_ERROR_INCORRECT_RESPONSE_LENGTH; - } - - ll_time_deserialize(buff, time_info); - return LL_IFC_ACK; -} - -int32_t ll_system_time_sync(uint8_t sync_mode) -{ - if (sync_mode > 1) - { - return LL_IFC_ERROR_INCORRECT_PARAMETER; - } - int32_t ret = hal_read_write(OP_SYSTEM_TIME_SYNC, &sync_mode, sizeof(sync_mode), NULL, 0); - return (ret >= 0) ? LL_IFC_ACK : ret; -} - -int32_t ll_message_send(uint8_t buf[], uint16_t len, bool ack, uint8_t port) -{ - if (buf == NULL || len <= 0 || len > 256) - { - return LL_IFC_ERROR_INCORRECT_PARAMETER; - } - - if (port > ll_ul_max_port) - { - return LL_IFC_ERROR_INCORRECT_PARAMETER; - } - - memmove(uplink_message_buff, buf, len); - _uplink_message_buff[0] = (uint8_t) ack; - _uplink_message_buff[1] = port; - int32_t ret = hal_read_write(OP_MSG_SEND, _uplink_message_buff, len + 2, NULL, 0); - return (ret >= 0) ? LL_IFC_ACK : ret; -} From a5b637991e640876ae268fb07178933d00a31541 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=D1=82=D0=BD=CF=83=D0=BC=CE=B1=D1=95=20=D1=95=D1=82=D1=94?= =?UTF-8?q?=CE=B9=D0=B8=D0=BD=CF=83=E2=84=93z?= Date: Fri, 25 Oct 2019 10:29:01 -0400 Subject: [PATCH 25/33] Update ll_ifc.c --- src/ll_ifc.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/ll_ifc.c b/src/ll_ifc.c index f1c9260..957e412 100644 --- a/src/ll_ifc.c +++ b/src/ll_ifc.c @@ -522,7 +522,7 @@ static void send_packet(opcode_t op, uint8_t message_num, uint8_t *buf, uint16_t uint16_t header_idx = 0; uint16_t i; - for (i = 0; i < SP_NUM_WAKEUP_BYTES; i++) + for (i = 0; i < SP_NUM_WAKEUP_BYTES; i++) { wakeupBuff_buf[i] = 0x55; } From 6930a7c99b667162b7c93bf7f3f7e4b77cb71465 Mon Sep 17 00:00:00 2001 From: Scott Wohler Date: Mon, 28 Oct 2019 21:37:55 -0400 Subject: [PATCH 26/33] Minor cleanup --- src/ll_ifc.c | 5 ++--- 1 file changed, 2 insertions(+), 3 deletions(-) diff --git a/src/ll_ifc.c b/src/ll_ifc.c index 957e412..a7c0312 100644 --- a/src/ll_ifc.c +++ b/src/ll_ifc.c @@ -101,7 +101,7 @@ char const * ll_return_code_description(int32_t return_code) { switch (return_code) { - case -LL_IFC_ACK: return "success"; + case -LL_IFC_ACK: return "Success"; case -LL_IFC_NACK_CMD_NOT_SUPPORTED: return "Command not supported"; case -LL_IFC_NACK_INCORRECT_CHKSUM: return "Incorrect Checksum"; case -LL_IFC_NACK_PAYLOAD_LEN_OOR: return "Length of payload sent in command was out of range"; @@ -534,7 +534,6 @@ static void send_packet(opcode_t op, uint8_t message_num, uint8_t *buf, uint16_t asm("nop"); } - header_idx=0; // Send a couple wakeup bytes, just-in-case for (i = 0; i < SP_NUM_ZEROS; i++) @@ -711,7 +710,7 @@ static int32_t recv_packet(opcode_t op, uint8_t message_num, uint8_t *buf, uint1 } // Finally, make sure the checksum matches - ret = transport_read(checksum_buff, 2); + ret = transport_read(checksum_buff, 2); if (ret < 0) { return -1; From 24ef8b67a00557111f0a05e2710f8bb06276a41e Mon Sep 17 00:00:00 2001 From: Scott Wohler Date: Mon, 28 Oct 2019 22:08:41 -0400 Subject: [PATCH 27/33] Clean up and include compile-time for gateway builds --- src/ll_ifc.c | 38 ++++++++++++++++++++++---------------- 1 file changed, 22 insertions(+), 16 deletions(-) diff --git a/src/ll_ifc.c b/src/ll_ifc.c index a7c0312..dd6af9a 100644 --- a/src/ll_ifc.c +++ b/src/ll_ifc.c @@ -1,17 +1,26 @@ +#include +#include +#include + +#include "ifc_struct_defs.h" #include "ll_ifc.h" #include "ll_ifc_consts.h" -#include "ifc_struct_defs.h" #include "ll_ifc_symphony.h" #include "ll_ifc_no_mac.h" -#include -#include -#include + #ifndef NULL // defines NULL on *some* platforms #define NULL (0) #endif #define CMD_HEADER_LEN (5) #define RESP_HEADER_LEN (6) + +#ifdef _PLATFORM_LINUX + #define WAKEUP_BYTE (0xFF) +#else + #define WAKEUP_BYTE (0x07) +#endif + static uint16_t compute_checksum(uint8_t *hdr, uint16_t hdr_len, uint8_t *payload, uint16_t payload_len); static void send_packet(opcode_t op, uint8_t message_num, uint8_t *buf, uint16_t len); static int32_t recv_packet(opcode_t op, uint8_t message_num, uint8_t *buf, uint16_t len); @@ -515,30 +524,28 @@ static void send_packet(opcode_t op, uint8_t message_num, uint8_t *buf, uint16_t #define SP_NUM_WAKEUP_BYTES (5) #define SP_NUM_ZEROS (3) #define SP_HEADER_SIZE (CMD_HEADER_LEN + SP_NUM_ZEROS) - uint8_t wakeupBuff_buf[SP_HEADER_SIZE]; + uint8_t wakeup_buf[SP_NUM_WAKEUP_BYTES]; uint8_t header_buf[SP_HEADER_SIZE]; uint8_t checksum_buff[2]; uint16_t computed_checksum; uint16_t header_idx = 0; uint16_t i; - for (i = 0; i < SP_NUM_WAKEUP_BYTES; i++) - { - wakeupBuff_buf[i] = 0x55; - } - - transport_write(wakeupBuff_buf, SP_NUM_WAKEUP_BYTES); + // Send the wakeup bytes + memset((uint8_t *) wakeup_buf, WAKEUP_BYTE, (size_t) SP_NUM_WAKEUP_BYTES); + transport_write(wakeup_buf, SP_NUM_WAKEUP_BYTES); +#ifndef _PLATFORM_LINUX for (i = 0; i < 5000; i++) { asm("nop"); } +#endif - header_idx=0; - // Send a couple wakeup bytes, just-in-case + // Send the sync bytes for (i = 0; i < SP_NUM_ZEROS; i++) { - header_buf[header_idx ++] = 0x07; + header_buf[header_idx++] = 0x07; } header_buf[header_idx++] = FRAME_START; @@ -547,7 +554,7 @@ static void send_packet(opcode_t op, uint8_t message_num, uint8_t *buf, uint16_t header_buf[header_idx++] = (uint8_t)(0xFF & (len >> 8)); header_buf[header_idx++] = (uint8_t)(0xFF & (len >> 0)); - computed_checksum = compute_checksum(header_buf + SP_NUM_ZEROS, CMD_HEADER_LEN, buf, len); + computed_checksum = compute_checksum(&header_buf[SP_NUM_ZEROS], CMD_HEADER_LEN, buf, len); transport_write(header_buf, SP_HEADER_SIZE); @@ -559,7 +566,6 @@ static void send_packet(opcode_t op, uint8_t message_num, uint8_t *buf, uint16_t checksum_buff[0] = (computed_checksum >> 8); checksum_buff[1] = (computed_checksum >> 0); transport_write(checksum_buff, 2); - } /** From dc9b19cba8a6265ea3dc340454091ea47d677f2f Mon Sep 17 00:00:00 2001 From: Joe Boring Date: Thu, 12 Dec 2019 09:53:26 -0500 Subject: [PATCH 28/33] Adding Xmodem Functions, Trying Rx data mods There are some Rx errors, trying different things to fix. Also adding xmodem functions to program the symphony module on the AP --- inc/ll_ifc.h | 6 +- inc/ll_ifc_xmodem.h | 4 + src/ll_ifc.c | 592 +++++++++++++++++++++++++++++++--------- src/ll_ifc_symphony.c | 622 ++++++++++++++++++++++++++++++++---------- src/ll_ifc_xmodem.c | 198 +++++++++++--- 5 files changed, 1117 insertions(+), 305 deletions(-) diff --git a/inc/ll_ifc.h b/inc/ll_ifc.h index fd38e18..278f666 100644 --- a/inc/ll_ifc.h +++ b/inc/ll_ifc.h @@ -1,6 +1,6 @@ #ifndef __LL_IFC_H #define __LL_IFC_H - +#include #include "ll_ifc_utils.h" #ifdef __cplusplus @@ -78,6 +78,7 @@ extern "C" { * This function is usually a simple UART wrapper. */ int32_t transport_read(uint8_t *buff, uint16_t len); + int32_t transport_read2(uint8_t *buff, uint16_t len); /** * @brief @@ -527,6 +528,9 @@ extern "C" { */ int32_t ll_reset_state( void ); + void transport_mutex_release(void); + bool transport_mutex_grab(void); + /** @} (end defgroup Module_Interface) */ diff --git a/inc/ll_ifc_xmodem.h b/inc/ll_ifc_xmodem.h index 79cf2fe..850ffd5 100644 --- a/inc/ll_ifc_xmodem.h +++ b/inc/ll_ifc_xmodem.h @@ -102,6 +102,10 @@ int32_t ll_xmodem_prepare_module(bool is_host_ifc_active); */ int32_t ll_xmodem_send(ll_xmodem_callbacks_t *cb, uint8_t* payload, size_t len); +int32_t ll_xmodem_send_part(ll_xmodem_callbacks_t *cb, uint8_t* payload, size_t payload_len); +int32_t ll_xmodem_send_start_xfer(void); +int32_t ll_xmodem_send_EOF_validate(void); + /** @} (end defgroup XMODEM_Interface) */ /** @} (end addtogroup Link_Labs_Interface_Library) */ diff --git a/src/ll_ifc.c b/src/ll_ifc.c index dd6af9a..35163a4 100644 --- a/src/ll_ifc.c +++ b/src/ll_ifc.c @@ -8,7 +8,6 @@ #include "ll_ifc_symphony.h" #include "ll_ifc_no_mac.h" - #ifndef NULL // defines NULL on *some* platforms #define NULL (0) #endif @@ -21,9 +20,16 @@ #define WAKEUP_BYTE (0x07) #endif +#define LL_IFC_MSG_BUFF_SIZE 258 +#define LL_IFC_MSG_BUFF_IN_SIZE 126 + +static uint8_t _ll_ifc_msg_buff[LL_IFC_MSG_BUFF_SIZE]; +static uint8_t _ll_ifc_msg_in_buff[LL_IFC_MSG_BUFF_IN_SIZE]; + static uint16_t compute_checksum(uint8_t *hdr, uint16_t hdr_len, uint8_t *payload, uint16_t payload_len); static void send_packet(opcode_t op, uint8_t message_num, uint8_t *buf, uint16_t len); static int32_t recv_packet(opcode_t op, uint8_t message_num, uint8_t *buf, uint16_t len); +static int32_t recv_packet2(opcode_t op, uint8_t message_num, uint8_t *buf, uint16_t len); const uint32_t OPEN_NET_TOKEN = 0x4f50454e; @@ -49,7 +55,7 @@ int32_t hal_read_write(opcode_t op, uint8_t buf_in[], uint16_t in_len, uint8_t b // OK, inputs have been sanitized. Carry on... send_packet(op, message_num, buf_in, in_len); - ret = recv_packet(op, message_num, buf_out, out_len); + ret = recv_packet2(op, message_num, buf_out, out_len); message_num++; @@ -58,15 +64,26 @@ int32_t hal_read_write(opcode_t op, uint8_t buf_in[], uint16_t in_len, uint8_t b int32_t hal_read_write_exact(opcode_t op, uint8_t buf_in[], uint16_t in_len, uint8_t buf_out[], uint16_t out_len) { + if (!(transport_mutex_grab())) + { + return LL_IFC_ERROR_HAL_CALL_FAILED; + } + int32_t ret = hal_read_write(op, buf_in, in_len, buf_out, out_len); if (ret >= 0) { if (ret != out_len) { - return LL_IFC_ERROR_INCORRECT_RESPONSE_LENGTH; + ret = LL_IFC_ERROR_INCORRECT_RESPONSE_LENGTH; + } + else + { + ret = 0; } - ret = 0; } + + transport_mutex_release(); + return ret; } @@ -144,52 +161,68 @@ char const * ll_return_code_description(int32_t return_code) int32_t ll_firmware_type_get(ll_firmware_type_t *t) { - uint8_t buf[FIRMWARE_TYPE_LEN]; + int32_t ret; if(NULL == t) { return LL_IFC_ERROR_INCORRECT_PARAMETER; } - ret = hal_read_write(OP_FIRMWARE_TYPE, NULL, 0, buf, FIRMWARE_TYPE_LEN); - if (ret == 0) + if (!(transport_mutex_grab())) { - return ret; + return LL_IFC_ERROR_HAL_CALL_FAILED; } - if(FIRMWARE_TYPE_LEN != ret) + ret = hal_read_write(OP_FIRMWARE_TYPE, NULL, 0, &_ll_ifc_msg_buff[0], FIRMWARE_TYPE_LEN); + transport_mutex_release(); + + if (ret == 0) { - return LL_IFC_ERROR_INCORRECT_RESPONSE_LENGTH; + //return ret; + } + else if(FIRMWARE_TYPE_LEN != ret) + { + ret = LL_IFC_ERROR_INCORRECT_RESPONSE_LENGTH; + } + else + { + t->cpu_code = _ll_ifc_msg_buff[0] << 8 | _ll_ifc_msg_buff[1]; + t->functionality_code = _ll_ifc_msg_buff[2] << 8 | _ll_ifc_msg_buff[3]; } - - t->cpu_code = buf[0] << 8 | buf[1]; - t->functionality_code = buf[2] << 8 | buf[3]; return (ret >= 0) ? LL_IFC_ACK : ret; } int32_t ll_hardware_type_get(ll_hardware_type_t *t) { - uint8_t type; + int32_t ret; if(NULL == t) { return LL_IFC_ERROR_INCORRECT_PARAMETER; } - ret = hal_read_write(OP_HARDWARE_TYPE, NULL, 0, &type, sizeof(type)); - if(ret < 0) + if (!(transport_mutex_grab())) { - return ret; + return LL_IFC_ERROR_HAL_CALL_FAILED; } - if(sizeof(type) != ret) + ret = hal_read_write(OP_HARDWARE_TYPE, NULL, 0, &_ll_ifc_msg_buff[0], sizeof(uint8_t)); + + if(ret < 0) { - return LL_IFC_ERROR_INCORRECT_RESPONSE_LENGTH; + //return ret; } - - *t = (ll_hardware_type_t) type; - + else if(sizeof(uint8_t) != ret) + { + ret = LL_IFC_ERROR_INCORRECT_RESPONSE_LENGTH; + } + else + { + *t = (ll_hardware_type_t) _ll_ifc_msg_buff[0]; + } + + transport_mutex_release(); return (ret >= 0) ? LL_IFC_ACK : ret; } @@ -208,28 +241,35 @@ const char * ll_hardware_type_string(ll_hardware_type_t t) int32_t ll_interface_version_get(ll_version_t *version) { - uint8_t buf[VERSION_LEN]; int32_t ret; if(NULL == version) { return LL_IFC_ERROR_INCORRECT_PARAMETER; } - ret = hal_read_write(OP_IFC_VERSION, NULL, 0, buf, VERSION_LEN); - if(ret < 0) + if (!(transport_mutex_grab())) { - return ret; + return LL_IFC_ERROR_HAL_CALL_FAILED; } - if (VERSION_LEN != ret) + ret = hal_read_write(OP_IFC_VERSION, NULL, 0, &_ll_ifc_msg_buff[0], VERSION_LEN); + + if(ret < 0) { - return LL_IFC_ERROR_INCORRECT_RESPONSE_LENGTH; + //return ret; } - - version->major = buf[0]; - version->minor = buf[1]; - version->tag = buf[2] << 8 | buf[3]; - + else if (VERSION_LEN != ret) + { + ret = LL_IFC_ERROR_INCORRECT_RESPONSE_LENGTH; + } + else + { + version->major = _ll_ifc_msg_buff[0]; + version->minor = _ll_ifc_msg_buff[1]; + version->tag = _ll_ifc_msg_buff[2] << 8 | _ll_ifc_msg_buff[3]; + } + + transport_mutex_release(); return (ret >= 0) ? LL_IFC_ACK : ret; } @@ -242,33 +282,60 @@ int32_t ll_version_get(ll_version_t *version) return LL_IFC_ERROR_INCORRECT_PARAMETER; } - ret = hal_read_write(OP_VERSION, NULL, 0, buf, VERSION_LEN); - if(ret < 0) + if (!(transport_mutex_grab())) { - return ret; + return LL_IFC_ERROR_HAL_CALL_FAILED; } - if (VERSION_LEN != ret) + ret = hal_read_write(OP_VERSION, NULL, 0, &_ll_ifc_msg_buff[0], VERSION_LEN); + + if(ret < 0) { - return LL_IFC_ERROR_INCORRECT_RESPONSE_LENGTH; + //return ret; } - - version->major = buf[0]; - version->minor = buf[1]; - version->tag = buf[2] << 8 | buf[3]; - + else if (VERSION_LEN != ret) + { + ret = LL_IFC_ERROR_INCORRECT_RESPONSE_LENGTH; + } + else + { + version->major = _ll_ifc_msg_buff[0]; + version->minor = _ll_ifc_msg_buff[1]; + version->tag = _ll_ifc_msg_buff[2] << 8 | _ll_ifc_msg_buff[3]; + } + + transport_mutex_release(); return (ret >= 0) ? LL_IFC_ACK : ret; } int32_t ll_sleep_block(void) { - int32_t ret = hal_read_write(OP_SLEEP_BLOCK, (uint8_t*) "1", 1, NULL, 0); + if (!(transport_mutex_grab())) + { + return LL_IFC_ERROR_HAL_CALL_FAILED; + } + _ll_ifc_msg_buff[0] = '1'; + _ll_ifc_msg_buff[1] = 0; + int32_t ret = hal_read_write(OP_SLEEP_BLOCK, &_ll_ifc_msg_buff[0], 1, NULL, 0); + + transport_mutex_release(); + return (ret >= 0) ? LL_IFC_ACK : ret; } int32_t ll_sleep_unblock(void) { - int32_t ret = hal_read_write(OP_SLEEP_BLOCK, (uint8_t*) "0", 1, NULL, 0); + if (!(transport_mutex_grab())) + { + return LL_IFC_ERROR_HAL_CALL_FAILED; + } + + _ll_ifc_msg_buff[0] = '0'; + _ll_ifc_msg_buff[1] = 0; + int32_t ret = hal_read_write(OP_SLEEP_BLOCK, &_ll_ifc_msg_buff[0], 1, NULL, 0); + + transport_mutex_release(); + return (ret >= 0) ? LL_IFC_ACK : ret; } @@ -278,8 +345,17 @@ int32_t ll_mac_mode_set(ll_mac_type_t mac_mode) { return LL_IFC_ERROR_INCORRECT_PARAMETER; } - uint8_t u8_mac_mode = (uint8_t)mac_mode; - int32_t ret = hal_read_write(OP_MAC_MODE_SET, &u8_mac_mode, 1, NULL, 0); + + if (!(transport_mutex_grab())) + { + return LL_IFC_ERROR_HAL_CALL_FAILED; + } + + _ll_ifc_msg_buff[0] = (uint8_t)mac_mode; + int32_t ret = hal_read_write(OP_MAC_MODE_SET, &_ll_ifc_msg_buff[0], 1, NULL, 0); + + transport_mutex_release(); + return (ret >= 0) ? LL_IFC_ACK : ret; } @@ -291,9 +367,17 @@ int32_t ll_mac_mode_get(ll_mac_type_t *mac_mode) return LL_IFC_ERROR_INCORRECT_PARAMETER; } - uint8_t u8_mac_mode; - ret = hal_read_write(OP_MAC_MODE_GET, NULL, 0, &u8_mac_mode, sizeof(uint8_t)); - *mac_mode = (ll_mac_type_t)u8_mac_mode; + if (!(transport_mutex_grab())) + { + return LL_IFC_ERROR_HAL_CALL_FAILED; + } + + + ret = hal_read_write(OP_MAC_MODE_GET, NULL, 0, &_ll_ifc_msg_buff[0], sizeof(uint8_t)); + *mac_mode = _ll_ifc_msg_buff[0]; + + transport_mutex_release(); + return (ret >= 0) ? LL_IFC_ACK : ret; } @@ -301,7 +385,17 @@ int32_t ll_antenna_set(uint8_t ant) { if((ant == 1) || (ant == 2)) { - int32_t ret = hal_read_write(OP_ANTENNA_SET, &ant, 1, NULL, 0); + if (!(transport_mutex_grab())) + { + return LL_IFC_ERROR_HAL_CALL_FAILED; + } + + _ll_ifc_msg_buff[0] = ant; + + int32_t ret = hal_read_write(OP_ANTENNA_SET, &_ll_ifc_msg_buff[0], 1, NULL, 0); + + transport_mutex_release(); + return (ret >= 0) ? LL_IFC_ACK : ret; } else @@ -316,13 +410,22 @@ int32_t ll_antenna_get(uint8_t *ant) { return LL_IFC_ERROR_INCORRECT_PARAMETER; } - int32_t ret = hal_read_write(OP_ANTENNA_GET, NULL, 0, ant, 1); + + if (!(transport_mutex_grab())) + { + return LL_IFC_ERROR_HAL_CALL_FAILED; + } + + int32_t ret = hal_read_write(OP_ANTENNA_GET, NULL, 0, &_ll_ifc_msg_buff[0], 1); + *ant = _ll_ifc_msg_buff[0]; + + transport_mutex_release(); + return (ret >= 0) ? LL_IFC_ACK : ret; } int32_t ll_unique_id_get(uint64_t *unique_id) { - uint8_t buff[UNIQUE_ID_LEN]; int32_t ret; uint8_t i; @@ -331,53 +434,100 @@ int32_t ll_unique_id_get(uint64_t *unique_id) return LL_IFC_ERROR_INCORRECT_PARAMETER; } - ret = hal_read_write(OP_MODULE_ID, NULL, 0, buff, UNIQUE_ID_LEN); - if(ret < 0) + if (!(transport_mutex_grab())) { - return ret; + return LL_IFC_ERROR_HAL_CALL_FAILED; } - if (UNIQUE_ID_LEN != ret) + ret = hal_read_write(OP_MODULE_ID, NULL, 0, &_ll_ifc_msg_buff[0], UNIQUE_ID_LEN); + + if(ret < 0) { - return LL_IFC_ERROR_INCORRECT_RESPONSE_LENGTH; + //return ret; } - - *unique_id = 0; - for (i = 0; i < UNIQUE_ID_LEN; i++) + else if (UNIQUE_ID_LEN != ret) { - *unique_id |= ((uint64_t) buff[i]) << (8 * (7 - i)); + ret = LL_IFC_ERROR_INCORRECT_RESPONSE_LENGTH; } - + else + { + *unique_id = 0; + for (i = 0; i < UNIQUE_ID_LEN; i++) + { + *unique_id |= ((uint64_t) _ll_ifc_msg_buff[i]) << (8 * (7 - i)); + } + } + transport_mutex_release(); return (ret >= 0) ? LL_IFC_ACK : ret; } int32_t ll_settings_store(void) { + if (!(transport_mutex_grab())) + { + return LL_IFC_ERROR_HAL_CALL_FAILED; + } + int32_t ret = hal_read_write(OP_STORE_SETTINGS, NULL, 0, NULL, 0); + + transport_mutex_release(); + return (ret >= 0) ? LL_IFC_ACK : ret; } int32_t ll_settings_delete(void) { + if (!(transport_mutex_grab())) + { + return LL_IFC_ERROR_HAL_CALL_FAILED; + } + int32_t ret = hal_read_write(OP_DELETE_SETTINGS, NULL, 0, NULL, 0); + + transport_mutex_release(); + return (ret >= 0) ? LL_IFC_ACK : ret; } int32_t ll_restore_defaults(void) { + if (!(transport_mutex_grab())) + { + return LL_IFC_ERROR_HAL_CALL_FAILED; + } + int32_t ret = hal_read_write(OP_RESET_SETTINGS, NULL, 0, NULL, 0); + + transport_mutex_release(); + return (ret >= 0) ? LL_IFC_ACK : ret; } int32_t ll_sleep(void) { + if (!(transport_mutex_grab())) + { + return LL_IFC_ERROR_HAL_CALL_FAILED; + } + int32_t ret = hal_read_write(OP_SLEEP, NULL, 0, NULL, 0); + + transport_mutex_release(); + return (ret >= 0) ? LL_IFC_ACK : ret; } int32_t ll_reset_mcu(void) { + if (!(transport_mutex_grab())) + { + return LL_IFC_ERROR_HAL_CALL_FAILED; + } + int32_t ret = hal_read_write(OP_RESET_MCU, NULL, 0, NULL, 0); + + transport_mutex_release(); + return (ret >= 0) ? LL_IFC_ACK : ret; } @@ -399,34 +549,38 @@ int32_t ll_irq_flags(uint32_t flags_to_clear, uint32_t *flags) return LL_IFC_ERROR_INCORRECT_PARAMETER; } - // Assuming big endian convention over the interface - uint8_t in_buf[4]; - uint8_t out_buf[4] = {0,0,0,0}; + if (!(transport_mutex_grab())) + { + return LL_IFC_ERROR_HAL_CALL_FAILED; + } - in_buf[0] = (uint8_t)((flags_to_clear >> 24) & 0xFF); - in_buf[1] = (uint8_t)((flags_to_clear >> 16) & 0xFF); - in_buf[2] = (uint8_t)((flags_to_clear >> 8) & 0xFF); - in_buf[3] = (uint8_t)((flags_to_clear ) & 0xFF); + // Assuming big endian convention over the interface + _ll_ifc_msg_buff[0] = (uint8_t)((flags_to_clear >> 24) & 0xFF); + _ll_ifc_msg_buff[1] = (uint8_t)((flags_to_clear >> 16) & 0xFF); + _ll_ifc_msg_buff[2] = (uint8_t)((flags_to_clear >> 8) & 0xFF); + _ll_ifc_msg_buff[3] = (uint8_t)((flags_to_clear ) & 0xFF); - int32_t ret = hal_read_write(OP_IRQ_FLAGS, in_buf, 4, out_buf, 4); + int32_t ret = hal_read_write(OP_IRQ_FLAGS, &_ll_ifc_msg_buff[0], 4, &_ll_ifc_msg_in_buff[0], 4); if(ret < 0) { - return ret; + //return ret; } - - if(4 != ret) + else if(4 != ret) { - return LL_IFC_ERROR_INCORRECT_RESPONSE_LENGTH; + ret = LL_IFC_ERROR_INCORRECT_RESPONSE_LENGTH; } - - uint32_t flags_temp = 0; - flags_temp |= (((uint32_t)out_buf[0]) << 24); - flags_temp |= (((uint32_t)out_buf[1]) << 16); - flags_temp |= (((uint32_t)out_buf[2]) << 8); - flags_temp |= (((uint32_t)out_buf[3])); - *flags = flags_temp; - + else + { + uint32_t flags_temp = 0; + flags_temp |= (((uint32_t)_ll_ifc_msg_in_buff[0]) << 24); + flags_temp |= (((uint32_t)_ll_ifc_msg_in_buff[1]) << 16); + flags_temp |= (((uint32_t)_ll_ifc_msg_in_buff[2]) << 8); + flags_temp |= (((uint32_t)_ll_ifc_msg_in_buff[3])); + *flags = flags_temp; + } + + transport_mutex_release(); return (ret >= 0) ? LL_IFC_ACK : ret; } @@ -438,57 +592,90 @@ int32_t ll_timestamp_get(uint32_t * timestamp_us) int32_t ll_timestamp_set(ll_timestamp_operation_t operation, uint32_t timestamp_us, uint32_t * actual_timestamp_us) { - uint8_t in_buf[5]; - uint8_t * b_in = in_buf; - uint8_t out_buf[4] = {0,0,0,0}; + uint8_t * b_out = &_ll_ifc_msg_buff[0]; if (actual_timestamp_us == NULL) { return LL_IFC_ERROR_INCORRECT_PARAMETER; } - write_uint8((uint8_t) operation, &b_in); - write_uint32(timestamp_us, &b_in); + if (!(transport_mutex_grab())) + { + return LL_IFC_ERROR_HAL_CALL_FAILED; + } + + write_uint8((uint8_t) operation, &b_out); + write_uint32(timestamp_us, &b_out); - int32_t rw_response = hal_read_write_exact(OP_TIMESTAMP, in_buf, sizeof(in_buf), out_buf, sizeof(out_buf)); - if (rw_response >= 0) + int32_t ret = hal_read_write_exact(OP_TIMESTAMP, &_ll_ifc_msg_buff[0], 5, &_ll_ifc_msg_in_buff[0], 4); + + if (ret >= 0) { - uint8_t const * b_out = out_buf; - *actual_timestamp_us = read_uint32(&b_out); - rw_response = 0; + uint8_t const * b_in = &_ll_ifc_msg_in_buff[0]; + *actual_timestamp_us = read_uint32(&b_in); + ret = LL_IFC_ACK; } - return rw_response; + transport_mutex_release(); + + return (ret >= 0) ? LL_IFC_ACK : ret; } int32_t ll_trigger_watchdog(void) { uint8_t cmd_buf[2]; - cmd_buf[0] = 0x00; - cmd_buf[1] = 0x01; - return hal_read_write(OP_RESERVED1, cmd_buf, 2, NULL, 0); + + if (!(transport_mutex_grab())) + { + return LL_IFC_ERROR_HAL_CALL_FAILED; + } + + _ll_ifc_msg_buff[0] = 0x00; + _ll_ifc_msg_buff[1] = 0x01; + + int32_t ret = hal_read_write(OP_RESERVED1, &_ll_ifc_msg_buff[0], 2, NULL, 0); + + transport_mutex_release(); + + return ret; } int32_t ll_get_assert_info(char *filename, uint16_t filename_len, uint32_t *line) { - uint8_t tmp_arr[4 + 20]; - int32_t ret = hal_read_write(OP_GET_ASSERT, NULL, 0, tmp_arr, 4 + 20); + + if (!(transport_mutex_grab())) + { + return LL_IFC_ERROR_HAL_CALL_FAILED; + } + + int32_t ret = hal_read_write(OP_GET_ASSERT, NULL, 0, &_ll_ifc_msg_in_buff[0], 4 + 20); + if (ret > 0) { *line = 0; - *line += (uint32_t)(tmp_arr[0]) << 24; - *line += (uint32_t)(tmp_arr[1]) << 16; - *line += (uint32_t)(tmp_arr[2]) << 8; - *line += (uint32_t)(tmp_arr[3]) << 0; + *line += (uint32_t)(_ll_ifc_msg_in_buff[0]) << 24; + *line += (uint32_t)(_ll_ifc_msg_in_buff[1]) << 16; + *line += (uint32_t)(_ll_ifc_msg_in_buff[2]) << 8; + *line += (uint32_t)(_ll_ifc_msg_in_buff[3]) << 0; uint16_t cpy_len = filename_len < 20 ? filename_len : 20; - memcpy(filename, tmp_arr + 4, cpy_len); + memcpy(filename, &_ll_ifc_msg_in_buff[4], cpy_len); } + + transport_mutex_release(); return ret; } + int32_t ll_trigger_assert(void) { - return hal_read_write(OP_SET_ASSERT, NULL, 0, NULL, 0); + if (!(transport_mutex_grab())) + { + return LL_IFC_ERROR_HAL_CALL_FAILED; + } + + int32_t ret = hal_read_write(OP_SET_ASSERT, NULL, 0, NULL, 0); + transport_mutex_release(); + return ret; } //STRIPTHIS!STOP @@ -519,34 +706,35 @@ int32_t ll_reset_state( void ) * @return * none */ +#define SP_NUM_WAKEUP_BYTES (5) +#define SP_NUM_ZEROS (3) +#define SP_NUM_CKSUM_BYTES (2) +#define SP_HEADER_SIZE (CMD_HEADER_LEN + SP_NUM_ZEROS) +uint8_t wakeup_buf[SP_NUM_WAKEUP_BYTES]; +uint8_t header_buf[(SP_HEADER_SIZE>RESP_HEADER_LEN)?SP_HEADER_SIZE:RESP_HEADER_LEN]; +uint8_t checksum_buff[SP_NUM_CKSUM_BYTES]; + static void send_packet(opcode_t op, uint8_t message_num, uint8_t *buf, uint16_t len) { - #define SP_NUM_WAKEUP_BYTES (5) - #define SP_NUM_ZEROS (3) - #define SP_HEADER_SIZE (CMD_HEADER_LEN + SP_NUM_ZEROS) - uint8_t wakeup_buf[SP_NUM_WAKEUP_BYTES]; - uint8_t header_buf[SP_HEADER_SIZE]; - uint8_t checksum_buff[2]; uint16_t computed_checksum; uint16_t header_idx = 0; uint16_t i; // Send the wakeup bytes memset((uint8_t *) wakeup_buf, WAKEUP_BYTE, (size_t) SP_NUM_WAKEUP_BYTES); + transport_write(wakeup_buf, SP_NUM_WAKEUP_BYTES); #ifndef _PLATFORM_LINUX - for (i = 0; i < 5000; i++) + for (i = 0; i < 2000; i++) { asm("nop"); } #endif - // Send the sync bytes - for (i = 0; i < SP_NUM_ZEROS; i++) - { - header_buf[header_idx++] = 0x07; - } + memset((uint8_t *) header_buf, 0xFF, (size_t) SP_NUM_ZEROS); + + header_idx = SP_NUM_ZEROS; header_buf[header_idx++] = FRAME_START; header_buf[header_idx++] = op; @@ -605,13 +793,13 @@ static void send_packet(opcode_t op, uint8_t message_num, uint8_t *buf, uint16_t * -108 transport_read failed getting FRAME_START * -109 transport_read failed getting header */ +static uint8_t _ll_ifc_start_byte = 0; +static uint8_t _ll_ifc_temp_byte; + static int32_t recv_packet(opcode_t op, uint8_t message_num, uint8_t *buf, uint16_t len) { - uint8_t header_buf[RESP_HEADER_LEN]; - uint16_t header_idx; - uint8_t curr_byte = 0; - uint8_t checksum_buff[2]; + uint16_t header_idx; uint16_t computed_checksum; int32_t ret_value = 0; int32_t ret; @@ -619,6 +807,7 @@ static int32_t recv_packet(opcode_t op, uint8_t message_num, uint8_t *buf, uint1 memset(header_buf, 0, sizeof(header_buf)); struct time time_start, time_now; + if (gettime(&time_start) < 0) { return LL_IFC_ERROR_HAL_CALL_FAILED; @@ -626,12 +815,14 @@ static int32_t recv_packet(opcode_t op, uint8_t message_num, uint8_t *buf, uint1 do { + /* Timeout of infinite Rx loop if responses never show up*/ - ret = transport_read(&curr_byte, 1); + ret = transport_read(&_ll_ifc_start_byte, 1); if (gettime(&time_now) < 0) { return LL_IFC_ERROR_HAL_CALL_FAILED; + } if(time_now.tv_sec - time_start.tv_sec > 2) @@ -639,7 +830,7 @@ static int32_t recv_packet(opcode_t op, uint8_t message_num, uint8_t *buf, uint1 len = 0; return LL_IFC_ERROR_HOST_INTERFACE_TIMEOUT; } - } while(curr_byte != FRAME_START); + } while(_ll_ifc_start_byte != FRAME_START); if (ret < 0) { @@ -650,7 +841,7 @@ static int32_t recv_packet(opcode_t op, uint8_t message_num, uint8_t *buf, uint1 header_idx = 0; header_buf[header_idx++] = FRAME_START; - ret = transport_read(header_buf + 1, RESP_HEADER_LEN - 1); + ret = transport_read(&header_buf[header_idx], RESP_HEADER_LEN - 1); if (ret < 0) { /* transport_read failed - return an error */ @@ -682,10 +873,11 @@ static int32_t recv_packet(opcode_t op, uint8_t message_num, uint8_t *buf, uint1 int32_t ret; do { - uint8_t temp_byte; - ret = transport_read(&temp_byte, 1); + + ret = transport_read(&_ll_ifc_temp_byte, 1); } while (ret == 0); + return LL_IFC_ERROR_BUFFER_TOO_SMALL; } else if (len_from_header < len) @@ -719,8 +911,10 @@ static int32_t recv_packet(opcode_t op, uint8_t message_num, uint8_t *buf, uint1 ret = transport_read(checksum_buff, 2); if (ret < 0) { - return -1; + return -2; } + + computed_checksum = compute_checksum(header_buf, RESP_HEADER_LEN, buf, len); uint16_t rx_checksum = ((uint16_t)checksum_buff[0] << 8) + checksum_buff[1]; if (rx_checksum != computed_checksum) @@ -740,6 +934,150 @@ static int32_t recv_packet(opcode_t op, uint8_t message_num, uint8_t *buf, uint1 } } + + +static int32_t recv_packet2(opcode_t op, uint8_t message_num, uint8_t *buf, uint16_t len) +{ + uint8_t header_buf[RESP_HEADER_LEN]; + uint16_t header_idx; + + + + uint16_t computed_checksum; + int32_t ret_value = 0; + int32_t ret; + + memset(header_buf, 0, sizeof(header_buf)); + + struct time time_start, time_now; + + if (gettime(&time_start) < 0) + { + return LL_IFC_ERROR_HAL_CALL_FAILED; + } + + do + { + + /* Timeout of infinite Rx loop if responses never show up*/ + ret = transport_read2(&_ll_ifc_start_byte, 1); + + if (gettime(&time_now) < 0) + { + return LL_IFC_ERROR_HAL_CALL_FAILED; + + } + + if(time_now.tv_sec - time_start.tv_sec > 2) + { + len = 0; + return LL_IFC_ERROR_HOST_INTERFACE_TIMEOUT; + } + } while(_ll_ifc_start_byte != FRAME_START); + + if (ret < 0) + { + /* transport_read failed - return an error */ + return LL_IFC_ERROR_START_OF_FRAME; + } + + header_idx = 0; + header_buf[header_idx++] = FRAME_START; + + ret = transport_read2(header_buf + 1, RESP_HEADER_LEN - 1); + if (ret < 0) + { + /* transport_read failed - return an error */ + return LL_IFC_ERROR_HEADER; + } + + uint16_t len_from_header = (uint16_t)header_buf[5] + ((uint16_t)header_buf[4] << 8); + + if (header_buf[1] != op) + { + // Command Byte should match what was sent + ret_value = LL_IFC_ERROR_COMMAND_MISMATCH; + } + if (header_buf[2] != message_num) + { + // Message Number should match + ret_value = LL_IFC_ERROR_MESSAGE_NUMBER_MISMATCH; + } + if (header_buf[3] != 0x00) + { + // NACK Received + // Map NACK code to error code + ret_value = 0 - header_buf[3]; + } + if (len_from_header > len) + { + // response is larger than the caller expects. + // Pull the bytes out of the Rx fifo + int32_t ret; + do + { + + ret = transport_read2(&_ll_ifc_temp_byte, 1); + } + while (ret == 0); + + return LL_IFC_ERROR_BUFFER_TOO_SMALL; + } + else if (len_from_header < len) + { + // response is shorter than caller expects. + len = len_from_header; + } + + if (ret_value == 0) + { + + // If we got here, then we: + // 1) Received the FRAME_START in the response + // 2) The message number matched + // 3) The ACK byte was ACK (not NACK) + // 4) The received payload length is less than or equal to the size of the buffer + // allocated for the payload + + // Grab the payload if there is supposed to be one + if ((buf != NULL) && (len > 0)) + { + ret = transport_read2(buf, len); + if (ret < 0) + { + return -2; + } + } + } + + // Finally, make sure the checksum matches + ret = transport_read2(checksum_buff, 2); + if (ret < 0) + { + return -2; + } + + + computed_checksum = compute_checksum(header_buf, RESP_HEADER_LEN, buf, len); + uint16_t rx_checksum = ((uint16_t)checksum_buff[0] << 8) + checksum_buff[1]; + if (rx_checksum != computed_checksum) + { + return LL_IFC_ERROR_CHECKSUM_MISMATCH; + } + + if (ret_value == 0) + { + // Success! Return the number of bytes in the payload (0 or positive number) + return len; + } + else + { + // Failure! Return an error, such as NACK response from the firmware + return ret_value; + } +} + + /** * @brief * compute_checksum diff --git a/src/ll_ifc_symphony.c b/src/ll_ifc_symphony.c index bed526a..63cd52e 100644 --- a/src/ll_ifc_symphony.c +++ b/src/ll_ifc_symphony.c @@ -3,8 +3,16 @@ #include "ifc_struct_defs.h" #include // memmove -uint8_t _uplink_message_buff[256 + 2]; -uint8_t *uplink_message_buff = _uplink_message_buff + 2; +//uint8_t _uplink_message_buff[256 + 2]; +//uint8_t *uplink_message_buff = _uplink_message_buff + 2; + +static uint8_t _ll_ifc_message_buff[256 + 2]; +static uint8_t isMsgBuffInUse; + +//uint8_t *uplink_message_buff = _uplink_message_buff + 2; + +#define UPLINK_DATA_INDEX 2 + uint8_t ll_ul_max_port = 127; const llabs_dl_band_cfg_t DL_BAN_FCC = {902000000, 928000000, 386703, 3, 0}; // USA / Mexico @@ -13,14 +21,22 @@ const llabs_dl_band_cfg_t DL_BAN_AUS = {918000000, 926000000, 386703, 3, 0}; // const llabs_dl_band_cfg_t DL_BAN_NZL = {921000000, 928000000, 386703, 3, 0}; // New Zealand const llabs_dl_band_cfg_t DL_BAN_ETSI = {869100000, 871000000, 386703, 1, 0}; // Europe + int32_t ll_net_token_get(uint32_t *p_net_token) { - uint8_t buff[4]; if (p_net_token == NULL) { return LL_IFC_ERROR_INCORRECT_PARAMETER; } - int32_t ret = hal_read_write(OP_NET_TOKEN_GET, NULL, 0, buff, 4); + + if (!(transport_mutex_grab())) + { + return LL_IFC_ERROR_HAL_CALL_FAILED; + } + + int32_t ret = hal_read_write(OP_NET_TOKEN_GET, NULL, 0, &_ll_ifc_message_buff[0], 4); + transport_mutex_release(); + if (ret < 0) { return ret; @@ -32,10 +48,10 @@ int32_t ll_net_token_get(uint32_t *p_net_token) } *p_net_token = 0; - *p_net_token |= (uint32_t) buff[0] << 24; - *p_net_token |= (uint32_t) buff[1] << 16; - *p_net_token |= (uint32_t) buff[2] << 8; - *p_net_token |= (uint32_t) buff[3]; + *p_net_token |= (uint32_t) _ll_ifc_message_buff[0] << 24; + *p_net_token |= (uint32_t) _ll_ifc_message_buff[1] << 16; + *p_net_token |= (uint32_t) _ll_ifc_message_buff[2] << 8; + *p_net_token |= (uint32_t) _ll_ifc_message_buff[3]; return LL_IFC_ACK; } @@ -43,12 +59,19 @@ int32_t ll_net_token_set(uint32_t net_token) { if (net_token != 0xFFFFFFFF) { - uint8_t buff[4]; - buff[0] = (net_token >> 24) & 0xFF; - buff[1] = (net_token >> 16) & 0xFF; - buff[2] = (net_token >> 8) & 0xFF; - buff[3] = (net_token) &0xFF; - int32_t ret = hal_read_write(OP_NET_TOKEN_SET, buff, 4, NULL, 0); + if (!(transport_mutex_grab())) + { + return LL_IFC_ERROR_HAL_CALL_FAILED; + } + + _ll_ifc_message_buff[0] = (net_token >> 24) & 0xFF; + _ll_ifc_message_buff[1] = (net_token >> 16) & 0xFF; + _ll_ifc_message_buff[2] = (net_token >> 8) & 0xFF; + _ll_ifc_message_buff[3] = (net_token) &0xFF; + + + int32_t ret = hal_read_write(OP_NET_TOKEN_SET, &_ll_ifc_message_buff[0], 4, NULL, 0); + transport_mutex_release(); return (ret >= 0) ? LL_IFC_ACK : ret; } else @@ -63,11 +86,22 @@ static int32_t ll_app_token_set(const uint8_t *app_token, uint8_t len) { return LL_IFC_ERROR_INCORRECT_PARAMETER; } + if (10 != len) { return LL_IFC_ERROR_INCORRECT_PARAMETER; } - int32_t ret = hal_read_write(OP_APP_TOKEN_SET, (uint8_t *) app_token, 10, NULL, 0); + + if (!(transport_mutex_grab())) + { + return LL_IFC_ERROR_HAL_CALL_FAILED; + } + + memcpy(&_ll_ifc_message_buff[0], app_token, len); + + int32_t ret = hal_read_write(OP_APP_TOKEN_SET, &_ll_ifc_message_buff[0], 10, NULL, 0); + + transport_mutex_release(); return (ret >= 0) ? LL_IFC_ACK : ret; } @@ -78,7 +112,17 @@ static int32_t ll_app_token_get(uint8_t *app_token) return LL_IFC_ERROR_INCORRECT_PARAMETER; } - int32_t ret = hal_read_write(OP_APP_TOKEN_GET, NULL, 0, app_token, 10); + if (!(transport_mutex_grab())) + { + return LL_IFC_ERROR_HAL_CALL_FAILED; + } + + int32_t ret = hal_read_write(OP_APP_TOKEN_GET, NULL, 0, &_ll_ifc_message_buff[0], 10); + + memcpy(app_token, &_ll_ifc_message_buff[0], 10); + + transport_mutex_release(); + if (ret < 0) { return ret; @@ -97,7 +141,15 @@ static int32_t ll_receive_mode_set(uint8_t rx_mode) { return LL_IFC_ERROR_INCORRECT_PARAMETER; } - int32_t ret = hal_read_write(OP_RX_MODE_SET, &rx_mode, 1, NULL, 0); + + if (!(transport_mutex_grab())) + { + return LL_IFC_ERROR_HAL_CALL_FAILED; + } + + _ll_ifc_message_buff[0] = rx_mode; + int32_t ret = hal_read_write(OP_RX_MODE_SET, &_ll_ifc_message_buff[0], 1, NULL, 0); + transport_mutex_release(); return (ret >= 0) ? LL_IFC_ACK : ret; } @@ -107,7 +159,17 @@ static int32_t ll_receive_mode_get(uint8_t *rx_mode) { return LL_IFC_ERROR_INCORRECT_PARAMETER; } - int32_t ret = hal_read_write(OP_RX_MODE_GET, NULL, 0, rx_mode, sizeof(*rx_mode)); + + if (!(transport_mutex_grab())) + { + return LL_IFC_ERROR_HAL_CALL_FAILED; + } + + int32_t ret = hal_read_write(OP_RX_MODE_GET, NULL, 0, &_ll_ifc_message_buff[0], sizeof(*rx_mode)); + + *rx_mode = _ll_ifc_message_buff[0]; + + transport_mutex_release(); return (ret >= 0) ? LL_IFC_ACK : ret; } @@ -117,7 +179,17 @@ static int32_t ll_qos_request(uint8_t qos) { return LL_IFC_ERROR_INCORRECT_PARAMETER; } - int32_t ret = hal_read_write(OP_QOS_REQUEST, &qos, 1, NULL, 0); + + if (!(transport_mutex_grab())) + { + return LL_IFC_ERROR_HAL_CALL_FAILED; + } + + int32_t ret = hal_read_write(OP_QOS_REQUEST, &_ll_ifc_message_buff[0], 1, NULL, 0); + + qos = _ll_ifc_message_buff[0]; + + transport_mutex_release(); return (ret >= 0) ? LL_IFC_ACK : ret; } @@ -127,67 +199,127 @@ static int32_t ll_qos_get(uint8_t *qos) { return LL_IFC_ERROR_INCORRECT_PARAMETER; } - int32_t ret = hal_read_write(OP_QOS_GET, NULL, 0, qos, sizeof(*qos)); + + if (!(transport_mutex_grab())) + { + return LL_IFC_ERROR_HAL_CALL_FAILED; + } + + int32_t ret = hal_read_write(OP_QOS_GET, NULL, 0, &_ll_ifc_message_buff[0], sizeof(*qos)); + + *qos = _ll_ifc_message_buff[0]; + + transport_mutex_release(); return (ret >= 0) ? LL_IFC_ACK : ret; } int32_t ll_scan_mode_set(enum ll_scan_mode scan_mode) { - uint8_t u8_scan_mode = (uint8_t) scan_mode; - int32_t ret = hal_read_write(OP_SCAN_MODE_SET, &u8_scan_mode, 1, NULL, 0); + + if (!(transport_mutex_grab())) + { + return LL_IFC_ERROR_HAL_CALL_FAILED; + } + + _ll_ifc_message_buff[0] = (uint8_t) scan_mode; + + int32_t ret = hal_read_write(OP_SCAN_MODE_SET, &_ll_ifc_message_buff[0], 1, NULL, 0); + transport_mutex_release(); return (ret >= 0) ? LL_IFC_ACK : ret; } int32_t ll_scan_mode_get(enum ll_scan_mode *scan_mode) { uint8_t u8_scan_mode; - int32_t ret = hal_read_write(OP_SCAN_MODE_GET, NULL, 0, &u8_scan_mode, 1); - *scan_mode = u8_scan_mode; + + if (!(transport_mutex_grab())) + { + return LL_IFC_ERROR_HAL_CALL_FAILED; + } + + int32_t ret = hal_read_write(OP_SCAN_MODE_GET, NULL, 0, &_ll_ifc_message_buff[0], 1); + + *scan_mode = _ll_ifc_message_buff[0]; + + transport_mutex_release(); return (ret >= 0) ? LL_IFC_ACK : ret; } static int32_t ll_threshold_set(int16_t threshold) { - uint8_t buf[2]; - buf[0] = threshold & 0xff; - buf[1] = threshold >> 8; + if (!(transport_mutex_grab())) + { + return LL_IFC_ERROR_HAL_CALL_FAILED; + } - int32_t ret = hal_read_write(OP_SCAN_THRESHOLD_SET, buf, 2, NULL, 0); + _ll_ifc_message_buff[0] = threshold & 0xff; + _ll_ifc_message_buff[1] = threshold >> 8; + + int32_t ret = hal_read_write(OP_SCAN_THRESHOLD_SET, &_ll_ifc_message_buff[0], 2, NULL, 0); + transport_mutex_release(); return (ret >= 0) ? LL_IFC_ACK : ret; } static int32_t ll_threshold_get(int16_t *threshold) { - uint8_t buf[2]; - int32_t ret = hal_read_write(OP_SCAN_THRESHOLD_GET, NULL, 0, buf, 2); - *threshold = ((uint16_t) buf[1] << 8) | buf[0]; + if (!(transport_mutex_grab())) + { + return LL_IFC_ERROR_HAL_CALL_FAILED; + } + + int32_t ret = hal_read_write(OP_SCAN_THRESHOLD_GET, NULL, 0, &_ll_ifc_message_buff[0], 2); + + *threshold = ((uint16_t) _ll_ifc_message_buff[1] << 8) | _ll_ifc_message_buff[0]; + + transport_mutex_release(); + return (ret >= 0) ? LL_IFC_ACK : ret; } static int32_t ll_scan_attempts_get(uint16_t *scan_attempts) { - uint8_t buf[2]; - int32_t ret = hal_read_write(OP_SCAN_ATTEMPTS_GET, NULL, 0, buf, 2); - *scan_attempts = ((uint16_t) buf[1] << 8) | buf[0]; + + if (!(transport_mutex_grab())) + { + return LL_IFC_ERROR_HAL_CALL_FAILED; + } + + int32_t ret = hal_read_write(OP_SCAN_ATTEMPTS_GET, NULL, 0, &_ll_ifc_message_buff[0], 2); + + *scan_attempts = ((uint16_t) _ll_ifc_message_buff[1] << 8) | _ll_ifc_message_buff[0]; + + transport_mutex_release(); + return (ret >= 0) ? LL_IFC_ACK : ret; } static int32_t ll_scan_attempts_left_get(uint16_t *scan_attempts) { - uint8_t buf[2]; - int32_t ret = hal_read_write(OP_SCAN_ATTEMPTS_LEFT, NULL, 0, buf, 2); - *scan_attempts = ((uint16_t) buf[1] << 8) | buf[0]; + if (!(transport_mutex_grab())) + { + return LL_IFC_ERROR_HAL_CALL_FAILED; + } + + int32_t ret = hal_read_write(OP_SCAN_ATTEMPTS_LEFT, NULL, 0, &_ll_ifc_message_buff[0], 2); + *scan_attempts = ((uint16_t) _ll_ifc_message_buff[1] << 8) | _ll_ifc_message_buff[0]; + transport_mutex_release(); return (ret >= 0) ? LL_IFC_ACK : ret; } int32_t ll_scan_attempts_set(uint16_t scan_attempts) { - uint8_t buf[2]; - buf[0] = scan_attempts & 0xff; - buf[1] = scan_attempts >> 8; - int32_t ret = hal_read_write(OP_SCAN_ATTEMPTS_SET, buf, 2, NULL, 0); + if (!(transport_mutex_grab())) + { + return LL_IFC_ERROR_HAL_CALL_FAILED; + } + + _ll_ifc_message_buff[0] = scan_attempts & 0xff; + _ll_ifc_message_buff[1] = scan_attempts >> 8; + + int32_t ret = hal_read_write(OP_SCAN_ATTEMPTS_SET, &_ll_ifc_message_buff[0], 2, NULL, 0); + transport_mutex_release(); return (ret >= 0) ? LL_IFC_ACK : ret; } @@ -315,55 +447,122 @@ int32_t ll_scan_config_get(enum ll_scan_mode *scan_mode, int16_t *threshold, int32_t ll_connect_to_gw_channel(uint8_t channel) { - int32_t ret = hal_read_write(OP_CONN_TO_GW_CH, &channel, 1, NULL, 0); + if (!(transport_mutex_grab())) + { + return LL_IFC_ERROR_HAL_CALL_FAILED; + } + + _ll_ifc_message_buff[0] = channel; + + int32_t ret = hal_read_write(OP_CONN_TO_GW_CH, &_ll_ifc_message_buff[0], 1, NULL, 0); + transport_mutex_release(); + return (ret >= 0) ? LL_IFC_ACK : ret; } int32_t ll_control_messages_enabled_set(bool enable) { - int32_t ret = hal_read_write(OP_CTRL_MSG_ENABLED_SET, (uint8_t*)&enable, 1, NULL, 0); + if (!(transport_mutex_grab())) + { + return LL_IFC_ERROR_HAL_CALL_FAILED; + } + _ll_ifc_message_buff[0] = enable; + int32_t ret = hal_read_write(OP_CTRL_MSG_ENABLED_SET, &_ll_ifc_message_buff[0], 1, NULL, 0); + transport_mutex_release(); + return (ret >= 0) ? LL_IFC_ACK : ret; } int32_t ll_control_messages_enabled_get(bool *enabled) { - int32_t ret = hal_read_write(OP_CTRL_MSG_ENABLED_GET, NULL, 0, (uint8_t*)enabled, 1); + if (!(transport_mutex_grab())) + { + return LL_IFC_ERROR_HAL_CALL_FAILED; + } + int32_t ret = hal_read_write(OP_CTRL_MSG_ENABLED_GET, NULL, 0, &_ll_ifc_message_buff[0], 1); + *enabled = _ll_ifc_message_buff[0]; + + transport_mutex_release(); + return (ret >= 0) ? LL_IFC_ACK : ret; } int32_t ll_cloud_gpio_activate_pin(uint8_t pin) { - int32_t ret = hal_read_write(OP_GPIO_ENABLE_PIN, (uint8_t*)&pin, 1, NULL, 0); + if (!(transport_mutex_grab())) + { + return LL_IFC_ERROR_HAL_CALL_FAILED; + } + _ll_ifc_message_buff[0] = pin; + int32_t ret = hal_read_write(OP_GPIO_ENABLE_PIN, &_ll_ifc_message_buff[0], 1, NULL, 0); + transport_mutex_release(); + return (ret >= 0) ? LL_IFC_ACK : ret; } int32_t ll_cloud_gpio_deactivate_pin(uint8_t pin) { - int32_t ret = hal_read_write(OP_GPIO_DISABLE_PIN, (uint8_t*)&pin, 1, NULL, 0); + if (!(transport_mutex_grab())) + { + return LL_IFC_ERROR_HAL_CALL_FAILED; + } + _ll_ifc_message_buff[0] = pin; + int32_t ret = hal_read_write(OP_GPIO_DISABLE_PIN, &_ll_ifc_message_buff[0], 1, NULL, 0); + + transport_mutex_release(); + return (ret >= 0) ? LL_IFC_ACK : ret; } int32_t ll_cloud_gpio_get_pin_status(uint8_t pin, bool *active) { - int32_t ret = hal_read_write(OP_GPIO_PIN_STATUS, (uint8_t*)&pin, 1, NULL, 0); + if (!(transport_mutex_grab())) + { + return LL_IFC_ERROR_HAL_CALL_FAILED; + } + _ll_ifc_message_buff[0] = pin; + int32_t ret = hal_read_write(OP_GPIO_PIN_STATUS, &_ll_ifc_message_buff[0], 1, NULL, 0); + + transport_mutex_release(); + return (ret >= 0) ? LL_IFC_ACK : ret; } int32_t ll_cloud_gpio_set_pin_high(uint8_t pin) { - int32_t ret = hal_read_write(OP_GPIO_SET_HIGH, (uint8_t*)&pin, 1, NULL, 0); + if (!(transport_mutex_grab())) + { + return LL_IFC_ERROR_HAL_CALL_FAILED; + } + _ll_ifc_message_buff[0] = pin; + int32_t ret = hal_read_write(OP_GPIO_SET_HIGH, &_ll_ifc_message_buff[0], 1, NULL, 0); + transport_mutex_release(); + return (ret >= 0) ? LL_IFC_ACK : ret; } int32_t ll_cloud_gpio_set_pin_low(uint8_t pin) { - int32_t ret = hal_read_write(OP_GPIO_SET_LOW, (uint8_t*)&pin, 1, NULL, 0); + if (!(transport_mutex_grab())) + { + return LL_IFC_ERROR_HAL_CALL_FAILED; + } + _ll_ifc_message_buff[0] = pin; + int32_t ret = hal_read_write(OP_GPIO_SET_LOW, &_ll_ifc_message_buff[0], 1, NULL, 0); + transport_mutex_release(); + return (ret >= 0) ? LL_IFC_ACK : ret; } int32_t ll_disconnect() { + if (!(transport_mutex_grab())) + { + return LL_IFC_ERROR_HAL_CALL_FAILED; + } int32_t ret = hal_read_write(OP_DISCONNECT, NULL, 0, NULL, 0); + transport_mutex_release(); + return (ret >= 0) ? LL_IFC_ACK : ret; } @@ -373,17 +572,25 @@ int32_t ll_poll_scan_result(llabs_gateway_scan_results_t *scan_result, uint8_t * { return LL_IFC_ERROR_INCORRECT_PARAMETER; } + + if (!(transport_mutex_grab())) + { + return LL_IFC_ERROR_HAL_CALL_FAILED; + } uint8_t buff[GW_SCAN_INFO_BUFF_SIZE]; - int32_t ret = hal_read_write(OP_GET_SCAN_INFO, NULL, 0, buff, GW_SCAN_INFO_BUFF_SIZE); + int32_t ret = hal_read_write(OP_GET_SCAN_INFO, NULL, 0, &_ll_ifc_message_buff[0], GW_SCAN_INFO_BUFF_SIZE); + if (ret < LL_IFC_ACK) { - return ret; + goto LL_POLL_SCAN_ERROR; } - ll_gw_scan_result_deserialize(buff, scan_result, num_gw); - + ll_gw_scan_result_deserialize(&_ll_ifc_message_buff[0], scan_result, num_gw); + +LL_POLL_SCAN_ERROR: + transport_mutex_release(); return (ret >= 0) ? LL_IFC_ACK : ret; } @@ -429,45 +636,59 @@ int32_t ll_get_state(enum ll_state *state, enum ll_tx_state *tx_state, enum ll_r { int32_t ret = LL_IFC_ACK; + if (!(transport_mutex_grab())) + { + return LL_IFC_ERROR_HAL_CALL_FAILED; + } + if (NULL != state) { uint8_t u8_state; - ret = hal_read_write(OP_STATE, NULL, 0, &u8_state, 1); + ret = hal_read_write(OP_STATE, NULL, 0, &_ll_ifc_message_buff[0], 1); if (LL_IFC_ACK > ret) { - return ret; + goto GET_STATE_ERROR; } - *state = (enum ll_state)(int8_t) u8_state; + *state = (enum ll_state)(int8_t)_ll_ifc_message_buff[0]; } if (NULL != tx_state) { uint8_t u8_tx_state; - ret = hal_read_write(OP_TX_STATE, NULL, 0, &u8_tx_state, 1); + ret = hal_read_write(OP_TX_STATE, NULL, 0, &_ll_ifc_message_buff[0], 1); if (LL_IFC_ACK > ret) { - return ret; + goto GET_STATE_ERROR; } - *tx_state = (enum ll_tx_state)(int8_t) u8_tx_state; + *tx_state = (enum ll_tx_state)(int8_t)_ll_ifc_message_buff[0]; } if (NULL != rx_state) { uint8_t u8_rx_state; - ret = hal_read_write(OP_RX_STATE, NULL, 0, &u8_rx_state, 1); + ret = hal_read_write(OP_RX_STATE, NULL, 0, &_ll_ifc_message_buff[0], 1); if (LL_IFC_ACK > ret) { - return ret; + goto GET_STATE_ERROR; } - *rx_state = (enum ll_rx_state)(int8_t) u8_rx_state; + *rx_state = (enum ll_rx_state)(int8_t)_ll_ifc_message_buff[0]; } +GET_STATE_ERROR: + transport_mutex_release(); return (ret >= 0) ? LL_IFC_ACK : ret; } int32_t ll_mailbox_request(void) { + if (!(transport_mutex_grab())) + { + return LL_IFC_ERROR_HAL_CALL_FAILED; + } + int32_t ret = hal_read_write(OP_MAILBOX_REQUEST, NULL, 0, NULL, 0); + transport_mutex_release(); + return (ret >= 0) ? LL_IFC_ACK : ret; } @@ -477,150 +698,218 @@ int32_t ll_app_reg_get(uint8_t *is_registered) { return LL_IFC_ERROR_INCORRECT_PARAMETER; } - int32_t ret = hal_read_write(OP_APP_TOKEN_REG_GET, NULL, 0, is_registered, 1); + + if (!(transport_mutex_grab())) + { + return LL_IFC_ERROR_HAL_CALL_FAILED; + } + + int32_t ret = hal_read_write(OP_APP_TOKEN_REG_GET, NULL, 0, &_ll_ifc_message_buff[0], 1); + *is_registered = _ll_ifc_message_buff[0]; + transport_mutex_release(); + return (ret >= 0) ? LL_IFC_ACK : ret; } int32_t ll_encryption_key_exchange_request(void) { + if (!(transport_mutex_grab())) + { + return LL_IFC_ERROR_HAL_CALL_FAILED; + } + int32_t ret = hal_read_write(OP_CRYPTO_KEY_XCHG_REQ, NULL, 0, NULL, 0); + transport_mutex_release(); + return (ret >= 0) ? LL_IFC_ACK : ret; } int32_t ll_net_info_get(llabs_network_info_t *p_net_info) { - uint8_t buff[NET_INFO_BUFF_SIZE]; if (p_net_info == NULL) { return LL_IFC_ERROR_INCORRECT_PARAMETER; } - int32_t ret = hal_read_write(OP_NET_INFO_GET, NULL, 0, buff, NET_INFO_BUFF_SIZE); + if (!(transport_mutex_grab())) + { + return LL_IFC_ERROR_HAL_CALL_FAILED; + } + + int32_t ret = hal_read_write(OP_NET_INFO_GET, NULL, 0, &_ll_ifc_message_buff[0], NET_INFO_BUFF_SIZE); + if (LL_IFC_ACK > ret) { - return ret; + // release mutex and return } - if (NET_INFO_BUFF_SIZE != ret) + else if (NET_INFO_BUFF_SIZE != ret) { - return LL_IFC_ERROR_INCORRECT_RESPONSE_LENGTH; + ret = LL_IFC_ERROR_INCORRECT_RESPONSE_LENGTH; + } + else + { + ll_net_info_deserialize(&_ll_ifc_message_buff[0], p_net_info); + ret = LL_IFC_ACK; } - ll_net_info_deserialize(buff, p_net_info); - return LL_IFC_ACK; + transport_mutex_release(); + + return ret; } int32_t ll_stats_get(llabs_stats_t *s) { - uint8_t buff[STATS_SIZE]; if (s == NULL) { return LL_IFC_ERROR_INCORRECT_PARAMETER; } - int32_t ret = hal_read_write(OP_STATS_GET, NULL, 0, buff, STATS_SIZE); + if (!(transport_mutex_grab())) + { + return LL_IFC_ERROR_HAL_CALL_FAILED; + } + + int32_t ret = hal_read_write(OP_STATS_GET, NULL, 0, &_ll_ifc_message_buff[0], STATS_SIZE); + transport_mutex_release(); + if (LL_IFC_ACK > ret) { - return ret; + // do nothing and return } - if (STATS_SIZE != ret) + else if (STATS_SIZE != ret) { - return LL_IFC_ERROR_INCORRECT_RESPONSE_LENGTH; + ret = LL_IFC_ERROR_INCORRECT_RESPONSE_LENGTH; } - - ll_stats_deserialize(buff, s); - return LL_IFC_ACK; + else + { + ll_stats_deserialize(&_ll_ifc_message_buff[0], s); + ret = LL_IFC_ACK; + } + return ret; } int32_t ll_retrieve_message(uint8_t *buf, uint16_t *size, uint8_t *port, int16_t *rssi, uint8_t *snr) { - int32_t rw_response; - if (buf == NULL || size == NULL) { return LL_IFC_ERROR_INCORRECT_PARAMETER; } - rw_response = hal_read_write(OP_MSG_RECV, NULL, 0, buf, *size); - - if (rw_response < LL_IFC_ACK) + if (!(transport_mutex_grab())) { - *size = 0; - return rw_response; + return LL_IFC_ERROR_HAL_CALL_FAILED; } - // Size is required - if ((rw_response & 0xff) <= 4) + int32_t ret = hal_read_write(OP_MSG_RECV, NULL, 0, &_ll_ifc_message_buff[0], *size); + + if (ret < LL_IFC_ACK) { *size = 0; - return LL_IFC_ERROR_INCORRECT_RESPONSE_LENGTH; } - *size = (uint8_t)(rw_response & 0xFF) - 4; - - // Optional RSSI - if (NULL != rssi) + else if ((ret & 0xff) <= 4)// Size is required { - *rssi = 0; - *rssi = buf[0] + ((uint16_t) buf[1] << 8); + *size = 0; + ret = LL_IFC_ERROR_INCORRECT_RESPONSE_LENGTH; } - - // Optional RSSI - if (NULL != snr) + else { - *snr = buf[2]; - } + *size = (uint8_t)(ret & 0xFF) - 4; - if (NULL != port) - { - *port = buf[3]; - } + // Optional RSSI + if (NULL != rssi) + { + *rssi = 0; + *rssi = _ll_ifc_message_buff[0] + ((uint16_t) _ll_ifc_message_buff[1] << 8); + } - // get rid of snr and rssi in buffer - memmove(buf, buf + 4, *size); + // Optional RSSI + if (NULL != snr) + { + *snr = _ll_ifc_message_buff[2]; + } - return LL_IFC_ACK; + if (NULL != port) + { + *port = _ll_ifc_message_buff[3]; + } + + // get rid of snr and rssi in buffer + memmove(buf, _ll_ifc_message_buff + 4, *size); + + ret = LL_IFC_ACK; + } + + transport_mutex_release(); + return ret; } int32_t ll_dl_band_cfg_get(llabs_dl_band_cfg_t *p) { - uint8_t buff[DL_BAND_CFG_SIZE]; if (p == NULL) { return LL_IFC_ERROR_INCORRECT_PARAMETER; } - int32_t ret = hal_read_write(OP_DL_BAND_CFG_GET, NULL, 0, buff, DL_BAND_CFG_SIZE); + if (!(transport_mutex_grab())) + { + return LL_IFC_ERROR_HAL_CALL_FAILED; + } + + int32_t ret = hal_read_write(OP_DL_BAND_CFG_GET, NULL, 0, &_ll_ifc_message_buff[0], DL_BAND_CFG_SIZE); + + if (LL_IFC_ACK > ret) { - return ret; } - if (DL_BAND_CFG_SIZE != ret) + else if (DL_BAND_CFG_SIZE != ret) { - return LL_IFC_ERROR_INCORRECT_RESPONSE_LENGTH; + ret = LL_IFC_ERROR_INCORRECT_RESPONSE_LENGTH; + } + else + { + ll_dl_band_cfg_deserialize(&_ll_ifc_message_buff[0], p); + ret = LL_IFC_ACK; } - ll_dl_band_cfg_deserialize(buff, p); - return LL_IFC_ACK; + transport_mutex_release(); + return ret; } int32_t ll_dl_band_cfg_set(const llabs_dl_band_cfg_t *p) { - uint8_t buff[DL_BAND_CFG_SIZE]; if (p == NULL) { return LL_IFC_ERROR_INCORRECT_PARAMETER; } - ll_dl_band_cfg_serialize(p, buff); - int32_t ret = hal_read_write(OP_DL_BAND_CFG_SET, buff, DL_BAND_CFG_SIZE, NULL, 0); + if (!(transport_mutex_grab())) + { + return LL_IFC_ERROR_HAL_CALL_FAILED; + } + + ll_dl_band_cfg_serialize(p, &_ll_ifc_message_buff[0]); + + int32_t ret = hal_read_write(OP_DL_BAND_CFG_SET, &_ll_ifc_message_buff[0], DL_BAND_CFG_SIZE, NULL, 0); + + transport_mutex_release(); + return (ret >= 0) ? LL_IFC_ACK : ret; } int32_t ll_rssi_offset_get(int8_t *rssi_offset) { - uint8_t raw = 0; - int32_t ret = hal_read_write(OP_RSSI_OFFSET_GET, NULL, 0, &raw, 1); - *rssi_offset = (int8_t)raw; + if (!(transport_mutex_grab())) + { + return LL_IFC_ERROR_HAL_CALL_FAILED; + } + + int32_t ret = hal_read_write(OP_RSSI_OFFSET_GET, NULL, 0, &_ll_ifc_message_buff[0], 1); + *rssi_offset = (int8_t)_ll_ifc_message_buff[0]; + + transport_mutex_release(); + + return (ret >= 0) ? LL_IFC_ACK : ret; } @@ -631,7 +920,16 @@ int32_t ll_rssi_offset_set(int8_t rssi_offset) return LL_IFC_ERROR_INCORRECT_PARAMETER; } - int32_t ret = hal_read_write(OP_RSSI_OFFSET_SET, (uint8_t*)&rssi_offset, 1, NULL, 0); + if (!(transport_mutex_grab())) + { + return LL_IFC_ERROR_HAL_CALL_FAILED; + } + _ll_ifc_message_buff[0] = rssi_offset; + + int32_t ret = hal_read_write(OP_RSSI_OFFSET_SET, &_ll_ifc_message_buff[0], 1, NULL, 0); + + transport_mutex_release(); + return (ret >= 0) ? LL_IFC_ACK : ret; } @@ -641,46 +939,74 @@ int32_t ll_connection_filter_get(uint8_t *p_f) { return LL_IFC_ERROR_INCORRECT_PARAMETER; } - uint8_t f; - int32_t ret = hal_read_write(OP_CONN_FILT_GET, NULL, 0, &f, 1); + + if (!(transport_mutex_grab())) + { + return LL_IFC_ERROR_HAL_CALL_FAILED; + } + + int32_t ret = hal_read_write(OP_CONN_FILT_GET, NULL, 0, &_ll_ifc_message_buff[0], 1); + + if (LL_IFC_ACK > ret) { - return ret; + } - if (sizeof(f) != ret) + else if (sizeof(uint8_t) != ret) { - return LL_IFC_ERROR_INCORRECT_RESPONSE_LENGTH; + ret = LL_IFC_ERROR_INCORRECT_RESPONSE_LENGTH; + } + else + { + *p_f = _ll_ifc_message_buff[0]; } - *p_f = f; + transport_mutex_release(); return (ret >= 0) ? LL_IFC_ACK : ret; } int32_t ll_connection_filter_set(uint8_t f) { - int32_t ret = hal_read_write(OP_CONN_FILT_SET, &f, 1, NULL, 0); + if (!(transport_mutex_grab())) + { + return LL_IFC_ERROR_HAL_CALL_FAILED; + } + + _ll_ifc_message_buff[0] = f; + int32_t ret = hal_read_write(OP_CONN_FILT_SET, &_ll_ifc_message_buff[0], 1, NULL, 0); + transport_mutex_release(); + return (ret >= 0) ? LL_IFC_ACK : ret; } int32_t ll_system_time_get(llabs_time_info_t *time_info) { - uint8_t buff[TIME_INFO_SIZE]; if (time_info == NULL) { return LL_IFC_ERROR_INCORRECT_PARAMETER; } - int32_t ret = hal_read_write(OP_SYSTEM_TIME_GET, NULL, 0, buff, STATS_SIZE); + + if (!(transport_mutex_grab())) + { + return LL_IFC_ERROR_HAL_CALL_FAILED; + } + + int32_t ret = hal_read_write(OP_SYSTEM_TIME_GET, NULL, 0, &_ll_ifc_message_buff[0], STATS_SIZE); + transport_mutex_release(); + if (LL_IFC_ACK > ret) { - return ret; } - if (TIME_INFO_SIZE != ret) + else if (TIME_INFO_SIZE != ret) { - return LL_IFC_ERROR_INCORRECT_RESPONSE_LENGTH; + ret = LL_IFC_ERROR_INCORRECT_RESPONSE_LENGTH; } - - ll_time_deserialize(buff, time_info); - return LL_IFC_ACK; + else + { + ll_time_deserialize(_ll_ifc_message_buff, time_info); + ret = LL_IFC_ACK; + } + return ret; } int32_t ll_system_time_sync(uint8_t sync_mode) @@ -689,7 +1015,14 @@ int32_t ll_system_time_sync(uint8_t sync_mode) { return LL_IFC_ERROR_INCORRECT_PARAMETER; } - int32_t ret = hal_read_write(OP_SYSTEM_TIME_SYNC, &sync_mode, sizeof(sync_mode), NULL, 0); + if (!(transport_mutex_grab())) + { + return LL_IFC_ERROR_HAL_CALL_FAILED; + } + _ll_ifc_message_buff[0] = sync_mode; + + int32_t ret = hal_read_write(OP_SYSTEM_TIME_SYNC, &_ll_ifc_message_buff[0], sizeof(sync_mode), NULL, 0); + transport_mutex_release(); return (ret >= 0) ? LL_IFC_ACK : ret; } @@ -705,9 +1038,18 @@ int32_t ll_message_send(uint8_t buf[], uint16_t len, bool ack, uint8_t port) return LL_IFC_ERROR_INCORRECT_PARAMETER; } - memmove(uplink_message_buff, buf, len); - _uplink_message_buff[0] = (uint8_t) ack; - _uplink_message_buff[1] = port; - int32_t ret = hal_read_write(OP_MSG_SEND, _uplink_message_buff, len + 2, NULL, 0); + if (!(transport_mutex_grab())) + { + return LL_IFC_ERROR_HAL_CALL_FAILED; + } + + memmove(&_ll_ifc_message_buff[2], buf, len); + _ll_ifc_message_buff[0] = (uint8_t) ack; + _ll_ifc_message_buff[1] = port; + + + int32_t ret = hal_read_write(OP_MSG_SEND, &_ll_ifc_message_buff[0], len + 2, NULL, 0); + transport_mutex_release(); + return (ret >= 0) ? LL_IFC_ACK : ret; } diff --git a/src/ll_ifc_xmodem.c b/src/ll_ifc_xmodem.c index 02c9d6a..bd09564 100644 --- a/src/ll_ifc_xmodem.c +++ b/src/ll_ifc_xmodem.c @@ -11,6 +11,16 @@ #define CAN (0x18) ///< Cancel #define CCC (0x43) ///< ASCII “C” +uint16_t s_packet_number; + +uint8_t xmodem_rx_buff[30]; +uint8_t xmodem_tx_buff[133]; + + + + + + // returns the response of the client // only if the responce is... // * ACK @@ -18,14 +28,16 @@ // * CAN // * CCC // * \n -static int32_t ll_xmodem_get_client_response(uint8_t* response) +static int32_t ll_xmodem_get_client_response(void) { struct time time_start; gettime(&time_start); + memset(xmodem_rx_buff,0,30); + do { - int32_t ret = transport_read(response, 1); + int32_t ret = transport_read(xmodem_rx_buff, 1); if (ret < -1) { return ret; @@ -36,7 +48,8 @@ static int32_t ll_xmodem_get_client_response(uint8_t* response) return -2; } } - while((ACK != *response) && (NAK != *response) && (CAN != *response) && (CCC != *response) && ('\n' != *response)); + while((ACK != xmodem_rx_buff[0]) && (NAK != xmodem_rx_buff[0]) && + (CAN != xmodem_rx_buff[0]) && (CCC != xmodem_rx_buff[0]) && ('\n' != xmodem_rx_buff[0])); return 0; } @@ -50,56 +63,58 @@ static int32_t ll_xmodem_send_packet(uint8_t* payload, uint16_t payload_len, uin } // Build XModem Packet - uint8_t packet[133] = {0x1A}, response = 0; - uint16_t crc = 0; + uint16_t crc = 0; // Initalize Packet with - memset(packet, 0x1A, 133 * sizeof(uint8_t)); + memset(xmodem_tx_buff, 0x1A, 133 * sizeof(uint8_t)); // Start of Header - packet[0] = SOH; + xmodem_tx_buff[0] = SOH; // Packet Number - packet[1] = packet_number & 0xff; - packet[2] = 0xff - packet_number; + xmodem_tx_buff[1] = packet_number & 0xff; + xmodem_tx_buff[2] = 0xff - packet_number; // Payload - memcpy(packet + 3 * sizeof(uint8_t), payload, payload_len * sizeof(uint8_t)); + memcpy(xmodem_tx_buff + 3 * sizeof(uint8_t), payload, payload_len * sizeof(uint8_t)); // CRC - crc = crc16((char *)packet + 3 * sizeof(uint8_t), 128); - packet[132] = crc & 0xff; - packet[131] = crc >> 8; + crc = crc16((char *)xmodem_tx_buff + 3 * sizeof(uint8_t), 128); + xmodem_tx_buff[132] = crc & 0xff; + xmodem_tx_buff[131] = crc >> 8; // Send XModem Packet - int32_t ret = transport_write(packet, 133); + int32_t ret = transport_write(xmodem_tx_buff, 133); if (ret < 0) { return ret; } // returns the client response - ret = ll_xmodem_get_client_response(&response); + ret = ll_xmodem_get_client_response(); if (ret < 0) { return ret; } - return response; + return xmodem_rx_buff[0]; } // send a single byte through xmodem static int32_t ll_xmodem_send_byte(uint8_t byte) { - uint8_t response = 0; struct time time_start; gettime(&time_start); + // memset(xmodem_tx_buff, 0, 133 * sizeof(uint8_t)); + + xmodem_tx_buff[0] = byte; + do { - int32_t ret = transport_write(&byte, 1); + int32_t ret = transport_write(&xmodem_tx_buff[0], 1); if (ret < 0) { return ret; } - ret = ll_xmodem_get_client_response(&response); + ret = ll_xmodem_get_client_response(); if (ret < 0) { return ret; @@ -110,33 +125,36 @@ static int32_t ll_xmodem_send_byte(uint8_t byte) return -2; } } - while (ACK != response); + while (ACK != xmodem_rx_buff[0]); - return response; + return xmodem_rx_buff[0]; } // returns 0 when the requested response is recieved, negative otherwise -static int32_t ll_xmodem_wait_for(uint8_t response) +static int32_t ll_xmodem_wait_for(uint8_t char_expected) { struct time time_start; - uint8_t res = 0; + gettime(&time_start); + // memset(xmodem_rx_buff,0,30); + do { - int32_t ret = ll_xmodem_get_client_response(&res); - if (ret < 0) + int32_t ret = transport_read(&xmodem_rx_buff[0], 1); + if (ret < -1) { return ret; } + if (ll_difftime_from_now(&time_start) >= TIMEOUT) { return -2; } } - while(response != res); + while(char_expected != xmodem_rx_buff[0]); return 0; } @@ -145,23 +163,23 @@ static int32_t ll_xmodem_wait_for(uint8_t response) // // data - location of the data // len - length of the allocated string -static int32_t ll_xmodem_parse_module_output(char* data, uint8_t len) +static int32_t ll_xmodem_parse_module_output(char* data, uint8_t len, uint16_t timeout_s) { struct time time_start; gettime(&time_start); - uint8_t buf; uint8_t i = 0; + memset(xmodem_rx_buff,0,30); do { - int32_t ret = transport_read(&buf, 1); - if (ret >= 0 && buf != 0x0 && buf != 0xff && buf != '\n' && buf != '\r') + int32_t ret = transport_read(&xmodem_rx_buff[0], 1); + if (ret >= 0 && xmodem_rx_buff[0] != 0x0 && xmodem_rx_buff[0] != 0xff && xmodem_rx_buff[0] != '\n' && xmodem_rx_buff[0] != '\r') { - data[i++] = (char) buf; + data[i++] = (char) xmodem_rx_buff[0]; } - if (ll_difftime_from_now(&time_start) >= TIMEOUT) + if (ll_difftime_from_now(&time_start) >= timeout_s) // returns seconds { return -2; } @@ -181,9 +199,11 @@ int32_t ll_xmodem_prepare_module(bool is_host_ifc_active) sleep_ms(2000); } + // memset(xmodem_tx_buff, 0, 133 * sizeof(uint8_t)); + + xmodem_tx_buff[0] = 'u'; // Send upload request to the module - uint8_t buf = 'u'; - int32_t ret = transport_write(&buf, 1); + int32_t ret = transport_write(xmodem_tx_buff, 1); if (ret < 0) { return ret; @@ -200,6 +220,110 @@ int32_t ll_xmodem_prepare_module(bool is_host_ifc_active) return 0; } +int32_t ll_xmodem_send_start_xfer(void) +{ + int32_t ret; + // Wait for the reciever to send us the start signal. + s_packet_number = 1; + ret = ll_xmodem_wait_for('C'); + return ret; +} + +//use this to send 128 bytes at a time +int32_t ll_xmodem_send_part(ll_xmodem_callbacks_t *cb, uint8_t* payload, size_t payload_len) +{ + int32_t ret; + + if (payload == NULL || payload_len < 1 || payload_len > 128) + { + return LL_IFC_ERROR_INCORRECT_PARAMETER; + } + + if (cb->progress == NULL) + { + return -5; + } + + // Send Data Payload + ret = ll_xmodem_send_packet(payload, payload_len, s_packet_number); + switch (ret) + { + case ACK: + s_packet_number++; + cb->progress(s_packet_number, payload_len); + return 0; + break; + case NAK: + return -4; + break; + case CAN: + return -3; + case CCC: // ignore start byte + return -2; + break; + default: + if (ret < 0) + { + return ret; // something broke... + } + } + +} + +int32_t ll_xmodem_send_EOF_validate(void) +{ + int32_t ret; + // Finish Transfer + ret = ll_xmodem_send_byte(EOT); + if (ret < 0) + { + return ret; + } + + // Don't sent ETB. + // Firmware download happen immediately + // verifying... happens immediately + // OK\r\n took 8 seconds + // activating was immediate after ok + + char fw_downloaded[20] = { '\0' }; + ll_xmodem_parse_module_output(fw_downloaded, 19, 3); + + + char fw_verify[15] = { '\0' }; + ll_xmodem_parse_module_output(fw_verify, 14, 12); + + char fw_activate[18] = { '\0' }; + ll_xmodem_parse_module_output(fw_activate, 17, 3); + + if (strcmp(fw_downloaded, "Firmware downloaded") != 0) + { + return -6; + } + + if (strcmp(fw_verify, "Verifying...OK") != 0) + { + // TODO: may use strstr to look for OK in what was + // returned. + return -7; + } + + if (strcmp(fw_activate, "Activating...DONE") != 0) + { + return -8; + } + + // Reboot the Module + xmodem_tx_buff[0] = 'r'; + ret = transport_write(&xmodem_tx_buff[0], 1); + if (ret < 0) + { + return ret; + } + + return 0; +} + int32_t ll_xmodem_send(ll_xmodem_callbacks_t *cb, uint8_t* payload, size_t payload_len) { if (payload == NULL || payload_len < 1) @@ -275,13 +399,13 @@ int32_t ll_xmodem_send(ll_xmodem_callbacks_t *cb, uint8_t* payload, size_t paylo } char fw_downloaded[20] = { '\0' }; - ll_xmodem_parse_module_output(fw_downloaded, 19); + ll_xmodem_parse_module_output(fw_downloaded, 19, 3); char fw_verify[15] = { '\0' }; - ll_xmodem_parse_module_output(fw_verify, 14); + ll_xmodem_parse_module_output(fw_verify, 14, 3); char fw_activate[18] = { '\0' }; - ll_xmodem_parse_module_output(fw_activate, 17); + ll_xmodem_parse_module_output(fw_activate, 17, 3); if (strcmp(fw_downloaded, "Firmware downloaded") != 0) { From de4f428a1c2a19da0214af70fe4700e699eead2a Mon Sep 17 00:00:00 2001 From: Joe Boring Date: Thu, 9 Jan 2020 16:53:59 -0500 Subject: [PATCH 29/33] updating with critical section and mutex --- inc/ll_ifc.h | 74 +++++++++++++++----- src/ll_ifc.c | 187 +++++---------------------------------------------- 2 files changed, 75 insertions(+), 186 deletions(-) diff --git a/inc/ll_ifc.h b/inc/ll_ifc.h index 278f666..14be5e6 100644 --- a/inc/ll_ifc.h +++ b/inc/ll_ifc.h @@ -78,7 +78,6 @@ extern "C" { * This function is usually a simple UART wrapper. */ int32_t transport_read(uint8_t *buff, uint16_t len); - int32_t transport_read2(uint8_t *buff, uint16_t len); /** * @brief @@ -514,22 +513,67 @@ extern "C" { #endif /** - * @brief - * Reset the host-side state maintained by the interface. - * - * @details - * The host implementation maintains a very small amount of state - * including the current message identifier. This function resets - * this internal state and is intended to allow for controlled - * testing. This function is not normally used in production code. - * - * @return - * 0 - success, negative otherwise. - */ - int32_t ll_reset_state( void ); + * @brief + * Reset the host-side state maintained by the interface. + * + * @details + * The host implementation maintains a very small amount of state + * including the current message identifier. This function resets + * this internal state and is intended to allow for controlled + * testing. This function is not normally used in production code. + * + * @return + * 0 - success, negative otherwise. + */ - void transport_mutex_release(void); + int32_t ll_reset_state( void ); + /** + * @brief + * Grabs a recursive mutex used to protect hal_read_write() in ll_ifc and + * to make multi-operation ll_ifc calls work atomically. + * + * @details + * None. + * + * @return + * 0 - success, negative otherwise. + */ bool transport_mutex_grab(void); + /** + * @brief + * Releases the mutex grabbed with transport_mutex_grab(). + * + * @details + * None. + * + * @return + * 1 - success, zero otherwise + */ + void transport_mutex_release(void); + /** + * @brief + * Implement a critical section if the communication could be interrupted for + * extended periods. + * + * @details + * None. + * + * @return + * 1 - success, zero otherwise + */ + bool transport_enter_critical(void); + /** + * @brief + * Implement a critical section if the communication could be interrupted for + * extended periods. + * + * @details + * None. + * + * @return + * 1 - success, zero otherwise. + */ + bool transport_exit_critical(void); /** @} (end defgroup Module_Interface) */ diff --git a/src/ll_ifc.c b/src/ll_ifc.c index 35163a4..8434dc0 100644 --- a/src/ll_ifc.c +++ b/src/ll_ifc.c @@ -14,11 +14,8 @@ #define CMD_HEADER_LEN (5) #define RESP_HEADER_LEN (6) -#ifdef _PLATFORM_LINUX - #define WAKEUP_BYTE (0xFF) -#else - #define WAKEUP_BYTE (0x07) -#endif + +#define WAKEUP_BYTE (0xFF) #define LL_IFC_MSG_BUFF_SIZE 258 #define LL_IFC_MSG_BUFF_IN_SIZE 126 @@ -51,12 +48,12 @@ int32_t hal_read_write(opcode_t op, uint8_t buf_in[], uint16_t in_len, uint8_t b { return(LL_IFC_ERROR_INCORRECT_PARAMETER); } - + transport_enter_critical(); // OK, inputs have been sanitized. Carry on... send_packet(op, message_num, buf_in, in_len); + ret = recv_packet(op, message_num, buf_out, out_len); - ret = recv_packet2(op, message_num, buf_out, out_len); - + transport_exit_critical(); message_num++; return(ret); @@ -713,25 +710,19 @@ int32_t ll_reset_state( void ) uint8_t wakeup_buf[SP_NUM_WAKEUP_BYTES]; uint8_t header_buf[(SP_HEADER_SIZE>RESP_HEADER_LEN)?SP_HEADER_SIZE:RESP_HEADER_LEN]; uint8_t checksum_buff[SP_NUM_CKSUM_BYTES]; +uint16_t header_idx; static void send_packet(opcode_t op, uint8_t message_num, uint8_t *buf, uint16_t len) { uint16_t computed_checksum; - uint16_t header_idx = 0; uint16_t i; + header_idx = 0; // Send the wakeup bytes memset((uint8_t *) wakeup_buf, WAKEUP_BYTE, (size_t) SP_NUM_WAKEUP_BYTES); transport_write(wakeup_buf, SP_NUM_WAKEUP_BYTES); -#ifndef _PLATFORM_LINUX - for (i = 0; i < 2000; i++) - { - asm("nop"); - } -#endif - memset((uint8_t *) header_buf, 0xFF, (size_t) SP_NUM_ZEROS); header_idx = SP_NUM_ZEROS; @@ -798,8 +789,6 @@ static uint8_t _ll_ifc_temp_byte; static int32_t recv_packet(opcode_t op, uint8_t message_num, uint8_t *buf, uint16_t len) { - - uint16_t header_idx; uint16_t computed_checksum; int32_t ret_value = 0; int32_t ret; @@ -888,7 +877,6 @@ static int32_t recv_packet(opcode_t op, uint8_t message_num, uint8_t *buf, uint1 if (ret_value == 0) { - // If we got here, then we: // 1) Received the FRAME_START in the response // 2) The message number matched @@ -905,164 +893,21 @@ static int32_t recv_packet(opcode_t op, uint8_t message_num, uint8_t *buf, uint1 return -2; } } - } - - // Finally, make sure the checksum matches - ret = transport_read(checksum_buff, 2); - if (ret < 0) - { - return -2; - } - - - computed_checksum = compute_checksum(header_buf, RESP_HEADER_LEN, buf, len); - uint16_t rx_checksum = ((uint16_t)checksum_buff[0] << 8) + checksum_buff[1]; - if (rx_checksum != computed_checksum) - { - return LL_IFC_ERROR_CHECKSUM_MISMATCH; - } - - if (ret_value == 0) - { - // Success! Return the number of bytes in the payload (0 or positive number) - return len; - } - else - { - // Failure! Return an error, such as NACK response from the firmware - return ret_value; - } -} - - - -static int32_t recv_packet2(opcode_t op, uint8_t message_num, uint8_t *buf, uint16_t len) -{ - uint8_t header_buf[RESP_HEADER_LEN]; - uint16_t header_idx; - - - uint16_t computed_checksum; - int32_t ret_value = 0; - int32_t ret; - - memset(header_buf, 0, sizeof(header_buf)); - - struct time time_start, time_now; - - if (gettime(&time_start) < 0) - { - return LL_IFC_ERROR_HAL_CALL_FAILED; - } - - do - { - - /* Timeout of infinite Rx loop if responses never show up*/ - ret = transport_read2(&_ll_ifc_start_byte, 1); - - if (gettime(&time_now) < 0) - { - return LL_IFC_ERROR_HAL_CALL_FAILED; - - } - - if(time_now.tv_sec - time_start.tv_sec > 2) + // Finally, make sure the checksum matches + ret = transport_read(checksum_buff, 2); + if (ret < 0) { - len = 0; - return LL_IFC_ERROR_HOST_INTERFACE_TIMEOUT; - } - } while(_ll_ifc_start_byte != FRAME_START); - - if (ret < 0) - { - /* transport_read failed - return an error */ - return LL_IFC_ERROR_START_OF_FRAME; - } - - header_idx = 0; - header_buf[header_idx++] = FRAME_START; - - ret = transport_read2(header_buf + 1, RESP_HEADER_LEN - 1); - if (ret < 0) - { - /* transport_read failed - return an error */ - return LL_IFC_ERROR_HEADER; - } + return -2; + } - uint16_t len_from_header = (uint16_t)header_buf[5] + ((uint16_t)header_buf[4] << 8); - - if (header_buf[1] != op) - { - // Command Byte should match what was sent - ret_value = LL_IFC_ERROR_COMMAND_MISMATCH; - } - if (header_buf[2] != message_num) - { - // Message Number should match - ret_value = LL_IFC_ERROR_MESSAGE_NUMBER_MISMATCH; - } - if (header_buf[3] != 0x00) - { - // NACK Received - // Map NACK code to error code - ret_value = 0 - header_buf[3]; - } - if (len_from_header > len) - { - // response is larger than the caller expects. - // Pull the bytes out of the Rx fifo - int32_t ret; - do + computed_checksum = compute_checksum(header_buf, RESP_HEADER_LEN, buf, len); + uint16_t rx_checksum = ((uint16_t)checksum_buff[0] << 8) + checksum_buff[1]; + if (rx_checksum != computed_checksum) { + return LL_IFC_ERROR_CHECKSUM_MISMATCH; - ret = transport_read2(&_ll_ifc_temp_byte, 1); } - while (ret == 0); - - return LL_IFC_ERROR_BUFFER_TOO_SMALL; - } - else if (len_from_header < len) - { - // response is shorter than caller expects. - len = len_from_header; - } - - if (ret_value == 0) - { - - // If we got here, then we: - // 1) Received the FRAME_START in the response - // 2) The message number matched - // 3) The ACK byte was ACK (not NACK) - // 4) The received payload length is less than or equal to the size of the buffer - // allocated for the payload - - // Grab the payload if there is supposed to be one - if ((buf != NULL) && (len > 0)) - { - ret = transport_read2(buf, len); - if (ret < 0) - { - return -2; - } - } - } - - // Finally, make sure the checksum matches - ret = transport_read2(checksum_buff, 2); - if (ret < 0) - { - return -2; - } - - - computed_checksum = compute_checksum(header_buf, RESP_HEADER_LEN, buf, len); - uint16_t rx_checksum = ((uint16_t)checksum_buff[0] << 8) + checksum_buff[1]; - if (rx_checksum != computed_checksum) - { - return LL_IFC_ERROR_CHECKSUM_MISMATCH; } if (ret_value == 0) From 459d7c3d160b73df65ab2b7d06e7d4ef462822b5 Mon Sep 17 00:00:00 2001 From: Thomas Steinholz Date: Fri, 31 Jan 2020 12:50:50 -0500 Subject: [PATCH 30/33] fix transport pc --- src/ll_ifc_transport_pc.c | 63 +++++++++++++++++++++++++++++++++++++++ 1 file changed, 63 insertions(+) diff --git a/src/ll_ifc_transport_pc.c b/src/ll_ifc_transport_pc.c index 1b7c45b..9eb9f98 100644 --- a/src/ll_ifc_transport_pc.c +++ b/src/ll_ifc_transport_pc.c @@ -321,6 +321,69 @@ int32_t transport_write(uint8_t *buff, uint16_t len) return ret; } +/** +* @brief +* Grabs a recursive mutex used to protect hal_read_write() in ll_ifc and +* to make multi-operation ll_ifc calls work atomically. +* +* @details +* None. +* +* @return +* 0 - success, negative otherwise. +*/ +bool transport_mutex_grab(void) +{ + return true; +} + +/** +* @brief +* Releases the mutex grabbed with transport_mutex_grab(). +* +* @details +* None. +* +* @return +* 1 - success, zero otherwise +*/ +void transport_mutex_release(void) +{ + return; +} + +/** +* @brief +* Implement a critical section if the communication could be interrupted for +* extended periods. +* +* @details +* None. +* +* @return +* 1 - success, zero otherwise +*/ +bool transport_enter_critical(void) +{ + return true; +} + +/** +* @brief +* Implement a critical section if the communication could be interrupted for +* extended periods. +* +* @details +* None. +* +* @return +* 1 - success, zero otherwise. +*/ +bool transport_exit_critical(void) +{ + return true; +} + static ssize_t read_with_timeout(int fd, void *bf, size_t len, time_t sec) { fd_set set; From a2a6308aae2ff26ae2c72d5250d571e66aaffb7e Mon Sep 17 00:00:00 2001 From: Joe Boring Date: Tue, 4 Feb 2020 13:50:02 -0500 Subject: [PATCH 31/33] Add an IRQ flag to indicate failed Sync --- inc/ll_ifc_consts.h | 3 +++ 1 file changed, 3 insertions(+) diff --git a/inc/ll_ifc_consts.h b/inc/ll_ifc_consts.h index 13547a3..c2f4986 100644 --- a/inc/ll_ifc_consts.h +++ b/inc/ll_ifc_consts.h @@ -296,6 +296,9 @@ typedef enum ll_ifc_error_codes_e { #define IRQ_FLAGS_TX_ERROR (0x00000020UL) ///< Set every time there is a Tx Error #define IRQ_FLAGS_RX_DONE (0x00000100UL) ///< Set every time a new packet is received #define IRQ_FLAGS_MAILBOX_EMPTY (0x00000200UL) ///< Set when a GW reports an empty mailbox + +#define IRQ_FLAGS_SYNC_FAILED (0x00000400UL) ///< Set when syncing to a channel fails + #define IRQ_FLAGS_CONNECTED (0x00001000UL) ///< Set every time we transition from the disconnected -> connected state #define IRQ_FLAGS_DISCONNECTED (0x00002000UL) ///< Set every time we transition from the connected -> disconnected state //STRIPTHIS!START From 44671aef7cb8f461300dad24f7cf863e43a91ced Mon Sep 17 00:00:00 2001 From: Joe Boring Date: Thu, 2 Apr 2020 17:48:13 -0400 Subject: [PATCH 32/33] QOS Request error fix --- src/ll_ifc_symphony.c | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/src/ll_ifc_symphony.c b/src/ll_ifc_symphony.c index 63cd52e..3956816 100644 --- a/src/ll_ifc_symphony.c +++ b/src/ll_ifc_symphony.c @@ -148,6 +148,7 @@ static int32_t ll_receive_mode_set(uint8_t rx_mode) } _ll_ifc_message_buff[0] = rx_mode; + int32_t ret = hal_read_write(OP_RX_MODE_SET, &_ll_ifc_message_buff[0], 1, NULL, 0); transport_mutex_release(); return (ret >= 0) ? LL_IFC_ACK : ret; @@ -185,9 +186,9 @@ static int32_t ll_qos_request(uint8_t qos) return LL_IFC_ERROR_HAL_CALL_FAILED; } - int32_t ret = hal_read_write(OP_QOS_REQUEST, &_ll_ifc_message_buff[0], 1, NULL, 0); + _ll_ifc_message_buff[0] = qos; - qos = _ll_ifc_message_buff[0]; + int32_t ret = hal_read_write(OP_QOS_REQUEST, &_ll_ifc_message_buff[0], 1, NULL, 0); transport_mutex_release(); return (ret >= 0) ? LL_IFC_ACK : ret; From 6d57ebf70b67ce5ebc5e00c823aed5de64097c6c Mon Sep 17 00:00:00 2001 From: Jim Date: Thu, 7 May 2020 15:29:16 -0400 Subject: [PATCH 33/33] Add Defines for the DFU DAT File --- inc/ll_ifc_ftp.h | 2 ++ 1 file changed, 2 insertions(+) diff --git a/inc/ll_ifc_ftp.h b/inc/ll_ifc_ftp.h index b0460e6..e8a61d2 100644 --- a/inc/ll_ifc_ftp.h +++ b/inc/ll_ifc_ftp.h @@ -78,6 +78,8 @@ extern "C" { #define LL_FTP_HDR_OFFSET_ID (8) #define LL_FTP_HDR_OFFSET_VERSION (12) #define LL_FTP_HDR_LEN (16) +#define LL_FTP_HDR_OFFSET_DAT_LEN (16) +#define LL_FTP_HDR_OFFSET_DAT (17) /** * @brief