summaryrefslogtreecommitdiff
path: root/lora_pkt_fwd
diff options
context:
space:
mode:
authorHarsh Sharma <harsh.sharma@multitech.com>2019-09-10 15:50:26 -0500
committerHarsh Sharma <harsh.sharma@multitech.com>2019-09-10 15:50:26 -0500
commit7eb491e070f3d98aebf6ed556f4533d3c9f929cd (patch)
tree2b6901e719fd0bf4a32b640dc4613eb720929d19 /lora_pkt_fwd
parentb87daded156a82be522b9de16e61f8d433212811 (diff)
downloadpacket_forwarder_mtac_full-7eb491e070f3d98aebf6ed556f4533d3c9f929cd.tar.gz
packet_forwarder_mtac_full-7eb491e070f3d98aebf6ed556f4533d3c9f929cd.tar.bz2
packet_forwarder_mtac_full-7eb491e070f3d98aebf6ed556f4533d3c9f929cd.zip
Added Spectral Scan Feature
Diffstat (limited to 'lora_pkt_fwd')
-rw-r--r--lora_pkt_fwd/src/lora_pkt_fwd.c551
1 files changed, 540 insertions, 11 deletions
diff --git a/lora_pkt_fwd/src/lora_pkt_fwd.c b/lora_pkt_fwd/src/lora_pkt_fwd.c
index ca19e28..6665964 100644
--- a/lora_pkt_fwd/src/lora_pkt_fwd.c
+++ b/lora_pkt_fwd/src/lora_pkt_fwd.c
@@ -45,6 +45,8 @@ Maintainer: Michael Coracin
#include <arpa/inet.h> /* IP address conversion stuff */
#include <netdb.h> /* gai_strerror */
+#include <spawn.h>
+#include <sys/wait.h>
#include <pthread.h>
#include "trace.h"
@@ -56,6 +58,8 @@ Maintainer: Michael Coracin
#include "loragw_gps.h"
#include "loragw_aux.h"
#include "loragw_reg.h"
+#include "loragw_radio.h"
+#include "loragw_fpga.h"
/* -------------------------------------------------------------------------- */
/* --- PRIVATE MACROS ------------------------------------------------------- */
@@ -93,6 +97,7 @@ Maintainer: Michael Coracin
#define PKT_PULL_RESP 3
#define PKT_PULL_ACK 4
#define PKT_TX_ACK 5
+#define PKT_SPEC_SCAN 6
#define NB_PKT_MAX 8 /* max number of packets per fetch/send cycle */
@@ -101,12 +106,11 @@ Maintainer: Michael Coracin
#define MIN_FSK_PREAMB 3 /* minimum FSK preamble length for this application */
#define STD_FSK_PREAMB 5
-#define STATUS_SIZE 200
+#define STATUS_SIZE 50000
#define TX_BUFF_SIZE ((540 * NB_PKT_MAX) + 30 + STATUS_SIZE)
#define UNIX_GPS_EPOCH_OFFSET 315964800 /* Number of seconds ellapsed between 01.Jan.1970 00:00:00
and 06.Jan.1980 00:00:00 */
-
#define DEFAULT_BEACON_FREQ_HZ 869525000
#define DEFAULT_BEACON_FREQ_NB 1
#define DEFAULT_BEACON_FREQ_STEP 0
@@ -115,6 +119,29 @@ Maintainer: Michael Coracin
#define DEFAULT_BEACON_POWER 14
#define DEFAULT_BEACON_INFODESC 0
+#define DEFAULT_START 867000000 /* start frequency, Hz */
+#define DEFAULT_STOP 870000000 /* stop frequency, Hz */
+#define DEFAULT_STEP 1000000 /* frequency step, Hz */
+#define DEFAULT_SAMPLES 65535 /* number of RSSI reads */
+#define DEFAULT_CHAN_BW LGW_SX127X_RXBW_62K5_HZ /* channel bandwidth */
+#define DEFAULT_SX127X_RSSI_OFFSET -120
+
+#define RSSI_RANGE 256
+
+#define MAX_FREQ 1000000000
+#define MIN_FREQ 800000000
+#define MIN_step 5000
+
+#define FPGA_FEATURE_SPECTRAL_SCAN 1
+#define FPGA_FEATURE_LBT 2
+
+/* When FPGA supports LBT, there are few more constraints on above constants */
+#define LBT_DEFAULT_SAMPLES 129*129 /* number of RSSI reads, hard-coded in FPGA*/
+#define LBT_MIN_STEP 100000
+
+#define HISTOGRAM_CLEAN_TIMEOUT 10000
+#define HISTOGRAM_READY_TIMEOUT 1000
+
/* -------------------------------------------------------------------------- */
/* --- PRIVATE VARIABLES (GLOBAL) ------------------------------------------- */
@@ -209,6 +236,25 @@ static struct coord_s meas_gps_err; /* GPS position of the gateway */
static pthread_mutex_t mx_stat_rep = PTHREAD_MUTEX_INITIALIZER; /* control access to the status report */
static bool report_ready = false; /* true when there is a new report to send to the server */
static char status_report[STATUS_SIZE]; /* status report as a JSON object */
+static char serialized_string[STATUS_SIZE];
+
+/* spectral scan parameters */
+static pthread_mutex_t mx_scan_config = PTHREAD_MUTEX_INITIALIZER; /* control access to the spectral scan config */
+static pthread_mutex_t mx_scan_report = PTHREAD_MUTEX_INITIALIZER; /* control access to the spectral scan config */
+static bool scan_ready = false; /* true when there is a new report to send to the server */
+
+struct scan_config_s
+{
+ uint32_t init;
+ uint32_t start;
+ uint32_t stop;
+ uint32_t step;
+ uint16_t samples;
+ int8_t rssi_floor;
+ int8_t offset;
+ uint32_t bandwidth;
+ bool read;
+} scan_config, scan_config_new, scan_config_update;
/* beacon parameters */
static uint32_t beacon_period = 0; /* set beaconing period, must be a sub-multiple of 86400, the nb of sec in a day */
@@ -258,10 +304,139 @@ void thread_gps(void);
void thread_valid(void);
void thread_jit(void);
void thread_timersync(void);
+void thread_spectralscan(void);
/* -------------------------------------------------------------------------- */
/* --- PRIVATE FUNCTIONS DEFINITION ----------------------------------------- */
+static enum lgw_sx127x_rxbw_e map_bandwidth(uint32_t bandwidth) {
+ switch (bandwidth) {
+ case 25:
+ return LGW_SX127X_RXBW_12K5_HZ;
+ case 50:
+ return LGW_SX127X_RXBW_25K_HZ;
+ case 100:
+ return LGW_SX127X_RXBW_50K_HZ;
+ case 125:
+ return LGW_SX127X_RXBW_62K5_HZ;
+ case 200:
+ return LGW_SX127X_RXBW_100K_HZ;
+ case 250:
+ return LGW_SX127X_RXBW_125K_HZ;
+ case 500:
+ return LGW_SX127X_RXBW_250K_HZ;
+ default:
+ printf("ERROR: Failed to parse spectral scan bandwidth.\n");
+ return EXIT_FAILURE;
+ }
+}
+
+static int reset_fpga(bool lbt_support, uint16_t samples) {
+ int x;
+ /* Reconnect to FPGA with sw reset and configure */
+ x = lgw_disconnect();
+ if(x != 0) {
+ printf("ERROR: Failed to disconnect from FPGA\n");
+ return EXIT_FAILURE;
+ }
+ x = lgw_connect(false, LGW_DEFAULT_NOTCH_FREQ); /* FPGA reset/configure */
+ if(x != 0) {
+ printf("ERROR: Failed to connect to FPGA\n");
+ return EXIT_FAILURE;
+ }
+ if (lbt_support == false) {
+ x = lgw_fpga_reg_w(LGW_FPGA_HISTO_NB_READ, samples-1);
+ if( x != LGW_REG_SUCCESS )
+ {
+ printf( "ERROR: Failed to configure FPGA\n" );
+ return EXIT_FAILURE;
+ }
+ }
+ return EXIT_SUCCESS;
+}
+
+static int setup_spectral_scan(bool *lbt_support, uint64_t *freq_reg, uint32_t *freq_nb) {
+
+ int x; /* return code for functions */
+ int32_t reg_val;
+
+ /* Check if FPGA supports Spectral Scan */
+ lgw_fpga_reg_r(LGW_FPGA_FEATURE, &reg_val);
+ if (TAKE_N_BITS_FROM((uint8_t)reg_val, FPGA_FEATURE_SPECTRAL_SCAN, 1) != true) {
+ printf("ERROR: Spectral Scan is not supported (0x%x)\n", (uint8_t)reg_val);
+ return EXIT_FAILURE;
+ }
+
+ /* Check if FPGA supports LBT, in order to apply proper constraints on spectral scan parameters */
+ lgw_fpga_reg_r(LGW_FPGA_FEATURE, &reg_val);
+
+ if (TAKE_N_BITS_FROM((uint8_t)reg_val, FPGA_FEATURE_LBT, 1) == true) {
+ printf("WARNING: The FPGA supports LBT, so running spectral scan with specific constraints\n");
+ printf(" => Check the parameters summary below\n");
+ /* Get start frequency from FPGA */
+ lgw_fpga_reg_r(LGW_FPGA_LBT_INITIAL_FREQ, &reg_val);
+ switch (reg_val) {
+ case 0:
+ scan_config.init = 915000000;
+ break;
+ case 1:
+ scan_config.init = 863000000;
+ break;
+ default:
+ printf("ERROR: init frequency %d is not supported\n", reg_val);
+ return EXIT_FAILURE;
+ }
+
+ /* Check parameters based on LBT constraints */
+ if (scan_config.start < scan_config.init) {
+ printf("ERROR: start frequency %d is not supported, should be >=%d\n", scan_config.start, scan_config.init);
+ return EXIT_FAILURE;
+ }
+ if (scan_config.stop > (scan_config.init + 255*LBT_MIN_STEP)) {
+ printf("ERROR: stop frequency %d is not supported, should be <%d\n", scan_config.stop, scan_config.init + 255*LBT_MIN_STEP);
+ return EXIT_FAILURE;
+ }
+ if (scan_config.step < LBT_MIN_STEP) {
+ printf("ERROR: step frequency %d is not supported, should be >=%d\n", scan_config.step, LBT_MIN_STEP);
+ return EXIT_FAILURE;
+ } else {
+ /* Ensure the given step is a multiple of LBT_MIN_STEP */
+ scan_config.step = (scan_config.step / LBT_MIN_STEP) * LBT_MIN_STEP;
+ }
+
+ /* Overload hard-coded spectral scan parameters */
+ scan_config.samples = LBT_DEFAULT_SAMPLES;
+
+ /* Spectral scan sequence is slightly different depending if LBT is there or not */
+ *lbt_support = true;
+ } else {
+ /* Reconnect to FPGA with sw reset and configure */
+ x = lgw_disconnect();
+ if(x != 0) {
+ printf("ERROR: Failed to disconnect from FPGA\n");
+ return EXIT_FAILURE;
+ }
+ x = lgw_connect(false, LGW_DEFAULT_NOTCH_FREQ); /* FPGA reset/configure */
+ if(x != 0) {
+ printf("ERROR: Failed to connect to FPGA\n");
+ return EXIT_FAILURE;
+ }
+ /* Some spectral scan options are only available when there is no LBT support */
+ x = lgw_fpga_reg_w(LGW_FPGA_HISTO_NB_READ, scan_config.samples-1);
+ if( x != LGW_REG_SUCCESS )
+ {
+ printf( "ERROR: Failed to configure FPGA\n" );
+ return EXIT_FAILURE;
+ }
+
+ /* Initialize frequency */
+ *freq_reg = ((uint64_t)scan_config.start << 19) / (uint64_t)32000000;
+ lgw_fpga_reg_w(LGW_FPGA_HISTO_SCAN_FREQ, (int32_t)freq_reg);
+ }
+ *freq_nb = (uint32_t)((scan_config.stop - scan_config.start) / scan_config.step) + 1;
+ return 0;
+}
+
static void sig_handler(int sigio) {
if (sigio == SIGQUIT) {
quit_sig = true;
@@ -992,7 +1167,6 @@ int main(void)
char *global_cfg_path= "global_conf.json"; /* contain global (typ. network-wide) configuration */
char *local_cfg_path = "local_conf.json"; /* contain node specific configuration, overwrite global parameters for parameters that are defined in both */
char *debug_cfg_path = "debug_conf.json"; /* if present, all other configuration files are ignored */
-
/* threads */
pthread_t thrid_up;
pthread_t thrid_down;
@@ -1000,6 +1174,7 @@ int main(void)
pthread_t thrid_valid;
pthread_t thrid_jit;
pthread_t thrid_timersync;
+ pthread_t thrid_spectralscan;
/* network socket creation */
struct addrinfo hints;
@@ -1249,6 +1424,13 @@ int main(void)
}
}
+ i = pthread_create( &thrid_spectralscan, NULL, (void * (*)(void *))thread_spectralscan, NULL);
+ if (i != 0) {
+ MSG("ERROR: [main] impossible to create spectral scan thread\n");
+ exit(EXIT_FAILURE);
+ }
+
+
/* configure signal handling */
sigemptyset(&sigact.sa_mask);
sigact.sa_flags = 0;
@@ -1435,6 +1617,8 @@ int main(void)
}
}
+ pthread_join(thrid_spectralscan, NULL); /* don't wait for spec scan thread */
+
/* if an exit signal was received, try to quit properly */
if (exit_sig) {
/* shut down network sockets */
@@ -1852,6 +2036,20 @@ void thread_up(void) {
exit(EXIT_FAILURE);
}
}
+ if (scan_ready == true) {
+ pthread_mutex_lock(&mx_scan_report);
+ j = snprintf((char *)(buff_up + buff_index), TX_BUFF_SIZE-buff_index, ",\"spectral_scan\":%s", serialized_string);
+ scan_ready = false;
+ pthread_mutex_unlock(&mx_scan_report);
+ if (j > 0) {
+ buff_index += j;
+ } else {
+ MSG("ERROR: [up] snprintf failed line %u\n", (__LINE__ - 5));
+ exit(EXIT_FAILURE);
+ }
+ } else {
+ pthread_mutex_unlock(&mx_scan_report);
+ }
/* end of JSON datagram payload */
buff_up[buff_index] = '}';
@@ -1921,6 +2119,7 @@ void thread_down(void) {
/* JSON parsing variables */
JSON_Value *root_val = NULL;
JSON_Object *txpk_obj = NULL;
+ JSON_Object *specscan_obj = NULL;
JSON_Value *val = NULL; /* needed to detect the absence of some fields */
const char *str; /* pointer to sub-strings in the JSON data */
short x0, x1;
@@ -2212,7 +2411,7 @@ void thread_down(void) {
}
/* if the datagram does not respect protocol, just ignore it */
- if ((msg_len < 4) || (buff_down[0] != PROTOCOL_VERSION) || ((buff_down[3] != PKT_PULL_RESP) && (buff_down[3] != PKT_PULL_ACK))) {
+ if ((msg_len < 4) || (buff_down[0] != PROTOCOL_VERSION) || ((buff_down[3] != PKT_PULL_RESP) && (buff_down[3] != PKT_PULL_ACK) && (buff_down[3] != PKT_SPEC_SCAN))) {
MSG("WARNING: [down] ignoring invalid packet len=%d, protocol_version=%d, id=%d\n",
msg_len, buff_down[0], buff_down[3]);
continue;
@@ -2236,11 +2435,12 @@ void thread_down(void) {
}
continue;
}
-
- /* the datagram is a PULL_RESP */
- buff_down[msg_len] = 0; /* add string terminator, just to be safe */
- MSG("INFO: [down] PULL_RESP received - token[%d:%d] :)\n", buff_down[1], buff_down[2]); /* very verbose */
- printf("\nJSON down: %s\n", (char *)(buff_down + 4)); /* DEBUG: display JSON payload */
+ if (buff_down[3] == PKT_PULL_RESP || buff_down[3] == PKT_SPEC_SCAN) {
+ /* the datagram is a PULL_RESP */
+ buff_down[msg_len] = 0; /* add string terminator, just to be safe */
+ MSG("INFO: [down] PULL_RESP received - token[%d:%d] :)\n", buff_down[1], buff_down[2]); /* very verbose */
+ printf("\nJSON down: %s\n", (char *)(buff_down + 4)); /* DEBUG: display JSON payload */
+ }
/* initialize TX struct and try to parse JSON */
memset(&txpkt, 0, sizeof txpkt);
@@ -2252,12 +2452,68 @@ void thread_down(void) {
/* look for JSON sub-object 'txpk' */
txpk_obj = json_object_get_object(json_value_get_object(root_val), "txpk");
- if (txpk_obj == NULL) {
- MSG("WARNING: [down] no \"txpk\" object in JSON, TX aborted\n");
+ specscan_obj = json_object_get_object(json_value_get_object(root_val), "scan");
+ if (txpk_obj == NULL && specscan_obj == NULL) {
+ MSG("WARNING: [down] no \"txpk\" or \"scan\"object in JSON, TX aborted\n");
json_value_free(root_val);
continue;
}
+ if (specscan_obj != NULL) {
+ bool valid_config = true;
+ val = json_object_get_value(specscan_obj, "start"); /* fetch value (if possible) */
+ if (json_value_get_type(val) == JSONNumber) {
+ scan_config_update.start = (uint32_t)json_value_get_number(val);
+ } else {
+ MSG("INFO: [down] start is not a number, ignoring scan config\n");
+ valid_config = false;
+ }
+ val = json_object_get_value(specscan_obj, "stop"); /* fetch value (if possible) */
+ if (json_value_get_type(val) == JSONNumber) {
+ scan_config_update.stop = (uint32_t)json_value_get_number(val);
+ } else {
+ MSG("INFO: [down] stop is not a number, ignoring scan config\n");
+ valid_config = false;
+ }
+ val = json_object_get_value(specscan_obj, "step"); /* fetch value (if possible) */
+ if (json_value_get_type(val) == JSONNumber) {
+ scan_config_update.step = (uint32_t)json_value_get_number(val);
+ } else {
+ MSG("INFO: [down] step is not a number, ignoring scan config\n");
+ valid_config = false;
+ }
+ val = json_object_get_value(specscan_obj, "samples"); /* fetch value (if possible) */
+ if (json_value_get_type(val) == JSONNumber) {
+ scan_config_update.samples = (uint32_t)json_value_get_number(val);
+ } else {
+ MSG("INFO: [down] step is not a number, ignoring scan config\n");
+ valid_config = false;
+ }
+ val = json_object_get_value(specscan_obj, "offset"); /* fetch value (if possible) */
+ if (json_value_get_type(val) == JSONNumber) {
+ scan_config_update.offset = (uint32_t)json_value_get_number(val);
+ } else {
+ MSG("INFO: [down] step is not a number, ignoring scan config\n");
+ valid_config = false;
+ }
+ val = json_object_get_value(specscan_obj, "bandwidth"); /* fetch value (if possible) */
+ if (json_value_get_type(val) == JSONNumber) {
+ scan_config_update.bandwidth = (uint32_t)json_value_get_number(val);
+ } else {
+ MSG("INFO: [down] bandwidth is not a number, ignoring scan config\n");
+ valid_config = false;
+ }
+ scan_config_update.read = false;
+ pthread_mutex_lock(&mx_scan_config);
+ if (valid_config) {
+ scan_config_new = scan_config_update;
+ }
+ pthread_mutex_unlock(&mx_scan_config);
+
+ }
+ if (txpk_obj == NULL) {
+ continue;
+ }
/* Parse "immediate" tag, or target timestamp, or UTC time to be converted by GPS (mandatory) */
i = json_object_get_boolean(txpk_obj,"imme"); /* can be 1 if true, 0 if false, or -1 if not a JSON boolean */
if (i == 1) {
@@ -2893,4 +3149,277 @@ void thread_valid(void) {
MSG("\nINFO: End of validation thread\n");
}
+/* -------------------------------------------------------------------------- */
+/* --- THREAD 6: Spectral Scan --- */
+
+void thread_spectralscan(void) {
+ struct timeval tv;
+ /* Application parameters */
+ uint16_t i, j, k; /* loop and temporary variables */
+ int x; /* return code for functions */
+ int32_t reg_val;
+
+ /* Application parameters */
+
+ /* Local var */
+ bool lbt_support = false;
+ uint16_t histogram_clean_retry = 0;
+ uint16_t histogram_ready_retry = 0;
+ uint16_t histogram_clean_counter = 0;
+ uint16_t histogram_ready_counter = 0;
+ uint16_t retry_limit = 1500;
+ int freq_idx;
+ uint32_t freq_nb;
+ int old_min = -1;
+ uint64_t freq_reg;
+ uint32_t freq;
+ uint8_t read_burst[RSSI_RANGE*2];
+ uint16_t rssi_histo;
+ uint16_t rssi_cumu;
+ uint32_t reset_counter_a = 0;
+ uint32_t reset_counter_b = 0;
+ scan_config.init = DEFAULT_START;
+ scan_config.start = DEFAULT_START;
+ scan_config.stop = DEFAULT_STOP;
+ scan_config.step = DEFAULT_STEP;
+ scan_config.samples = DEFAULT_SAMPLES;
+ scan_config.offset = DEFAULT_SX127X_RSSI_OFFSET;
+ scan_config.bandwidth = 0;
+ scan_config.read = true;
+ pthread_mutex_lock(&mx_scan_config);
+ scan_config_new = scan_config;
+ pthread_mutex_unlock(&mx_scan_config);
+
+ while (!exit_sig && !quit_sig) {
+ gettimeofday(&tv, NULL);
+ // Form the seconds of the day
+ long hms = tv.tv_sec % 86400;
+ // int hour = hms / 3600;
+ int min = (hms % 3600) / 60;
+ // int sec = (hms % 3600) % 60; // or hms % SEC_PER_MIN
+ pthread_mutex_lock(&mx_scan_config);
+ if (scan_config_new.read == false) {
+ scan_config = scan_config_new;
+ scan_config_new.read = true;
+ }
+ pthread_mutex_unlock(&mx_scan_config);
+ if (scan_config.read == false) {
+ /* Main loop */
+ setup_spectral_scan(&lbt_support, &freq_reg, &freq_nb);
+ JSON_Value *root_value = json_value_init_object();
+ JSON_Object *root_object = json_value_get_object(root_value);
+ JSON_Array *interests_arr = NULL;
+ json_object_set_number(root_object, "bandwidth", scan_config.bandwidth);
+ char eui[17];
+ sprintf(&eui[0], "%016lX", lgwm);
+ json_object_set_string(root_object, "eui", eui);
+ json_object_set_value(root_object, "results", json_value_init_array());
+ interests_arr = json_object_get_array(root_object, "results");
+ json_object_set_number(root_object, "start", scan_config.start);
+ json_object_set_number(root_object, "stop", scan_config.stop);
+ json_object_set_number(root_object, "step", scan_config.step);
+ json_object_set_number(root_object, "floor", -160);
+ json_object_set_number(root_object, "offset", scan_config.offset);
+ json_object_set_number(root_object, "samples", scan_config.samples);
+
+ struct timespec t1;
+ time_t t;
+ t = time(NULL);
+ clock_gettime(CLOCK_MONOTONIC, &t1);
+ char scan_timestamp[24];
+ strftime(scan_timestamp, sizeof scan_timestamp, "%F %T %Z", gmtime(&t));
+ json_object_set_string(root_object, "time", scan_timestamp);
+ for(j = 0; j < freq_nb; j++) {
+ /* Current frequency */
+ if (exit_sig || quit_sig) exit(EXIT_FAILURE);
+ freq = scan_config.start + j * scan_config.step;
+ struct timespec t2;
+ clock_gettime(CLOCK_MONOTONIC, &t2);
+
+ // double scan_time = difftimespec(t2, t1);
+ int scan_time = (int)(1000 * difftimespec(t2, t1));
+ if (lbt_support == false) {
+ /* Set SX127x */
+ x = lgw_setup_sx127x(freq, MOD_FSK, map_bandwidth(scan_config.bandwidth), 0);
+ if( x != 0 ) {
+ MSG( "ERROR: SX127x setup failed\n" );
+ exit(EXIT_FAILURE);
+ }
+
+ /* Start FPGA state machine for spectral scal */
+ lgw_fpga_reg_w(LGW_FPGA_CTRL_FEATURE_START, 1);
+ } else {
+ /* Do Nothing */
+ /* LBT setup has already done the necessary */
+ }
+
+ /* Clean histogram */
+ lgw_fpga_reg_w(LGW_FPGA_CTRL_CLEAR_HISTO_MEM, 1);
+ uint8_t reg_stat_old = 255;
+ uint8_t reg_stat_new;
+ /* Wait for histogram clean to start */
+ do {
+ if (histogram_clean_counter > HISTOGRAM_CLEAN_TIMEOUT) {
+ reg_stat_new = reg_val;
+ reg_stat_old = reg_stat_new;
+ if (histogram_clean_retry >= retry_limit) {
+ printf("\nHistogram clean retry limit reached.");
+ exit(EXIT_FAILURE);
+ } else {
+ reset_counter_a++;
+ printf(" - ERROR: Histogram clean timed out! Resetting FPGA and trying again\n");
+ lgw_stop();
+ lgw_start();
+ x = reset_fpga(lbt_support, scan_config.samples);
+ setup_spectral_scan(&lbt_support, &freq_reg, &freq_nb);
+ if( x != 0 ) {
+ printf( "ERROR: SX127x reset failed\n" );
+ }
+ lgw_fpga_reg_w(LGW_FPGA_CTRL_CLEAR_HISTO_MEM, 1);
+ if (lbt_support == false) {
+ x = lgw_setup_sx127x(freq, MOD_FSK, map_bandwidth(scan_config.bandwidth), 0);
+ if( x != 0 ) {
+ printf( "ERROR: SX127x setup failed\n" );
+ return EXIT_FAILURE;
+ }
+ lgw_fpga_reg_w(LGW_FPGA_CTRL_FEATURE_START, 1);
+ }
+ histogram_clean_counter = 0;
+ histogram_clean_retry++;
+ }
+ }
+ wait_ms(10);
+ lgw_fpga_reg_r(LGW_FPGA_STATUS, &reg_val);
+ histogram_clean_counter++;
+ }
+ while((TAKE_N_BITS_FROM((uint8_t)reg_val, 0, 5)) != 1); /* Clear has started */
+
+ /* Set scan frequency during clear process */
+ if (lbt_support == false) {
+ /* We can directly set the scan frequency */
+ freq_reg = ((uint64_t)freq << 19) / (uint64_t)32000000;
+ lgw_fpga_reg_w(LGW_FPGA_HISTO_SCAN_FREQ, (int32_t)freq_reg);
+ } else {
+ /* The possible scan frequencies are hard-coded in FPGA, we give an offset from init */
+ freq_idx = (freq - scan_config.init) / LBT_MIN_STEP;
+ lgw_fpga_reg_w(LGW_FPGA_SCAN_FREQ_OFFSET, freq_idx);
+ }
+
+ /* Release FPGA state machine */
+ lgw_fpga_reg_w(LGW_FPGA_CTRL_CLEAR_HISTO_MEM, 0);
+
+ /* Wait for histogram ready */
+ do {
+ if (histogram_ready_counter > HISTOGRAM_READY_TIMEOUT) {
+ if (histogram_ready_retry >= retry_limit) {
+ MSG("\nHistogram timeout retry limit reached");
+ lgw_stop();
+ lgw_start();
+ x = reset_fpga(lbt_support, scan_config.samples);
+ setup_spectral_scan(&lbt_support, &freq_reg, &freq_nb);
+ } else {
+ reset_counter_b++;
+ MSG("ERROR: Histogram ready timed out! Resetting FPGA and trying again\n");
+ x = reset_fpga(lbt_support, scan_config.samples);
+ setup_spectral_scan(&lbt_support, &freq_reg, &freq_nb);
+ if( x != 0 ) {
+ MSG( "ERROR: SX127x reset failed\n" );
+ exit(EXIT_FAILURE);
+ }
+ lgw_fpga_reg_w(LGW_FPGA_CTRL_CLEAR_HISTO_MEM, 1);
+ if (lbt_support == false) {
+ x = lgw_setup_sx127x(freq, MOD_FSK, map_bandwidth(scan_config.bandwidth), 0);
+ if( x != 0 ) {
+ MSG( "ERROR: SX127x setup failed\n" );
+ setup_spectral_scan(&lbt_support, &freq_reg, &freq_nb);
+ }
+ lgw_fpga_reg_w(LGW_FPGA_CTRL_FEATURE_START, 1);
+ }
+ histogram_ready_counter = 0;
+ histogram_ready_retry++;
+ if (lbt_support == false) {
+ freq_reg = ((uint64_t)freq << 19) / (uint64_t)32000000;
+ lgw_fpga_reg_w(LGW_FPGA_HISTO_SCAN_FREQ, (int32_t)freq_reg);
+ } else {
+ freq_idx = (freq - scan_config.init) / LBT_MIN_STEP;
+ lgw_fpga_reg_w(LGW_FPGA_SCAN_FREQ_OFFSET, freq_idx);
+ }
+ lgw_fpga_reg_w(LGW_FPGA_CTRL_CLEAR_HISTO_MEM, 0);
+ }
+ }
+ wait_ms(1000);
+ lgw_fpga_reg_r(LGW_FPGA_STATUS, &reg_val);
+ histogram_ready_counter++;
+ }
+ while((TAKE_N_BITS_FROM((uint8_t)reg_val, 5, 1)) != 1);
+
+ if (lbt_support == false) {
+ /* Stop FPGA state machine for spectral scan */
+ lgw_fpga_reg_w(LGW_FPGA_CTRL_FEATURE_START, 0);
+ } else {
+ /* Do Nothing */
+ /* LBT is running */
+ }
+
+ /* Read histogram */
+ lgw_fpga_reg_w(LGW_FPGA_CTRL_ACCESS_HISTO_MEM, 1); /* HOST gets access to FPGA RAM */
+ lgw_fpga_reg_w(LGW_FPGA_HISTO_RAM_ADDR, 0);
+ lgw_fpga_reg_rb(LGW_FPGA_HISTO_RAM_DATA, read_burst, RSSI_RANGE*2);
+ lgw_fpga_reg_w(LGW_FPGA_CTRL_ACCESS_HISTO_MEM, 0); /* FPGA gets access to RAM back */
+
+ rssi_cumu = 0;
+ k = 0;
+ char param_name[32];
+ char *seria_string = NULL;
+ JSON_Value *scan_value = json_value_init_object();
+ JSON_Object *scan_object = json_value_get_object(scan_value);
+ char scan_string[1024] = "";
+ snprintf(scan_string, sizeof scan_string, "%d, %d", freq, scan_time);
+
+ float rssi_thresh[] = {0.1,0.3,0.5,0.8,1};
+ for (i = 0; i < RSSI_RANGE; i++) {
+ rssi_histo = (uint16_t)read_burst[2*i] | ((uint16_t)read_burst[2*i+1] << 8);
+ rssi_cumu += rssi_histo;
+ if (rssi_cumu > scan_config.samples) {
+ MSG("WARNING: number of RSSI points higher than expected (%u,%u)", rssi_cumu, scan_config.samples);
+ rssi_cumu = scan_config.samples;
+ }
+ if (rssi_cumu > rssi_thresh[k]*scan_config.samples) {
+ snprintf(param_name, sizeof param_name, "rssi_%d", (uint16_t)(rssi_thresh[k]*100));
+ json_object_set_number(scan_object, param_name, -i/2.0);
+ k++;
+ }
+ if (rssi_histo > 0) {
+ char valid_hiso[1024] = "\"";
+ snprintf(valid_hiso, sizeof valid_hiso, ",%.1f,%d", (-i/2.0), rssi_histo);
+ strcat(scan_string, valid_hiso);
+ }
+ }
+ json_array_append_string(interests_arr, scan_string);
+ json_free_serialized_string(seria_string);
+ json_value_free(scan_value);
+ }
+ char array_string[5000] = "[\"";
+ for (i = 0; i < json_array_get_count(interests_arr); i++) {
+ const char * v = json_array_get_string(interests_arr, i);
+ strcat(array_string, v);
+ if (i < json_array_get_count(interests_arr) - 1 ) {
+ strcat(array_string,"\",\"");
+ }
+ }
+ strcat(array_string, "\"]");
+ json_object_set_value(root_object, "results", json_parse_string(array_string));
+ old_min = min;
+
+ pthread_mutex_lock(&mx_scan_report);
+ scan_ready = true;
+ strcpy(serialized_string, json_serialize_to_string(root_value));
+ pthread_mutex_unlock(&mx_scan_report);
+ json_value_free(root_value);
+ scan_config.read = true;
+ }
+ }
+ MSG("\nINFO: End of spectral scan thread\n");
+}
+
/* --- EOF ------------------------------------------------------------------ */