/** RadioLib SX126x Spectrum Scan This code perform a spectrum power scan using SX126x. The output is in the form of scan lines, each line has 33 power bins. First power bin corresponds to -11 dBm, the second to -15 dBm and so on. Higher number of samples in a bin corresponds to more power received at that level. To show the results in a plot, run the Python script RadioLib/extras/SX126x_Spectrum_Scan/SpectrumScan.py WARNING: This functionality is experimental and requires a binary patch to be uploaded to the SX126x device. There may be some undocumented side effects! For default module settings, see the wiki page https://github.com/jgromes/RadioLib/wiki/Default-configuration#sx126x---lora-modem For full API reference, see the GitHub Pages https://jgromes.github.io/RadioLib/ */ // #define HELTEC_NO_DISPLAY #include "FS.h" #include #include #include #include #include #include #include #include #include "WIFI_SERVER.h" #define FORMAT_LITTLEFS_IF_FAILED true // #define OSD_ENABLED true // #define WIFI_SCANNING_ENABLED true // #define BT_SCANNING_ENABLED true // Direct access to the low-level SPI communication between RadioLib and the radio module. #define RADIOLIB_LOW_LEVEL (1) // In this mode, all methods and member variables of all RadioLib classes will be made // public and so will be exposed to the user. This allows direct manipulation of the // library internals. #define RADIOLIB_GODMODE (1) #define RADIOLIB_CHECK_PARAMS (0) #include #include #include #include #include #include #ifndef LILYGO #include // This file contains a binary patch for the SX1262 #include "modules/SX126x/patches/SX126x_patch_scan.h" #endif // end ifndef LILYGO #if defined(LILYGO) // LiLyGO device does not support the auto download mode, you need to get into the // download mode manually. To do so, press and hold the BOOT button and then press the // RESET button once. After that release the BOOT button. Or OFF->ON together with BOOT // Default LilyGO code #include // #include "utilities.h" // Our Code #include "LiLyGo.h" #endif // end LILYGO #define BT_SCAN_DELAY 60 * 1 * 1000 #define WF_SCAN_DELAY 60 * 2 * 1000 long noDevicesMillis = 0, cycleCnt = 0; bool present = false; bool scanFinished = true; // time to scan BT #define BT_SCAN_TIME 10 uint64_t wf_start = 0; uint64_t bt_start = 0; #define MAX_POWER_LEVELS 33 #ifdef OSD_ENABLED #include "DFRobot_OSD.h" #define OSD_SIDE_BAR true // SPI pins #define OSD_CS 47 #define OSD_MISO 33 #define OSD_MOSI 34 #define OSD_SCK 26 #endif #define OSD_WIDTH 30 #define OSD_HEIGHT 16 #define OSD_CHART_WIDTH 15 #define OSD_CHART_HEIGHT 5 #define OSD_X_START 1 #define OSD_Y_START 16 // TODO: Calculate dynamically: // osd_steps = osd_mhz_in_bin / (FM range / LORA radio x Steps) int osd_mhz_in_bin = 5; int osd_steps = 12; int global_counter = 0; #ifdef OSD_ENABLED DFRobot_OSD osd(OSD_CS); #endif #include "global_config.h" #include "ui.h" // ----------------------------------------------------------------- // CONFIGURATION OPTIONS // ----------------------------------------------------------------- typedef enum { METHOD_RSSI = 0u, METHOD_SPECTRAL } TSCAN_METOD_ENUM; // #define SCAN_METHOD METHOD_SPECTRAL #define SCAN_METHOD // #define METHOD_SPECTRAL // Spectral scan method #define METHOD_RSSI // Uncomment this and comment METHOD_SPECTRAL fot RSSI // Output Pixel Formula // 1 = rssi / 4, 2 = (rssi / 2) - 22 or 20 // constexpr int RSSI_OUTPUT_FORMULA = 2; // Feature to scan diapasones. Other frequency settings will be ignored. // int SCAN_RANGES[] = {850890, 920950}; int SCAN_RANGES[] = {}; // MHZ per page // to put everything into one page set RANGE_PER_PAGE = FREQ_END - 800 uint64_t RANGE_PER_PAGE; // FREQ_END - CONF_FREQ_BEGIN uint64_t CONF_FREQ_END, CONF_FREQ_BEGIN; // To Enable Multi Screen scan // uint64_t RANGE_PER_PAGE = 50; // Default Range on Menu Button Switch // multiplies STEPS * N to increase scan resolution. #define SCAN_RBW_FACTOR 2 #ifdef USING_SX1280PA #define SCAN_RBW_FACTOR 2 #endif constexpr int OSD_PIXELS_PER_CHAR = (STEPS * SCAN_RBW_FACTOR) / OSD_CHART_WIDTH; #define DEFAULT_RANGE_PER_PAGE 50 // Print spectrum values pixels at once or by line bool ANIMATED_RELOAD = false; // TODO: Ignore max power lines #define UP_FILTER 5 // Trim low signals - nose level #define START_LOW 6 #define FILTER_SAMPLES_MIN constexpr bool DRAW_DETECTION_TICKS = true; int16_t max_x_rssi[STEPS] = {999}; int16_t max_x_window[STEPS / 14] = {999}; int x_window = 0; constexpr int WINDOW_SIZE = 15; // Number of samples for each frequency scan. Fewer samples = better temporal resolution. // if more than 100 it can freeze #define SAMPLES 35 //(scan time = 1294) uint64_t RANGE, range, iterations, median_frequency; float SINGLE_STEP; // #define DISABLE_PLOT_CHART false // unused // Array to store the scan results uint16_t result[RADIOLIB_SX126X_SPECTRAL_SCAN_RES_SIZE]; bool filtered_result[RADIOLIB_SX126X_SPECTRAL_SCAN_RES_SIZE]; int max_bins_array_value[MAX_POWER_LEVELS]; int max_step_range = 32; bool detected_y[STEPS]; // 20 - ??? steps // global variable // Used as a Led Light and Buzzer/count trigger bool first_run, new_pixel, detected_x = false; // drone detection flag bool detected = false; uint64_t drone_detection_level = DEFAULT_DRONE_DETECTION_LEVEL; #define TRIGGER_LEVEL -80.0 uint64_t drone_detected_frequency_start = 0; uint64_t drone_detected_frequency_end = 0; bool single_page_scan = false; // #define PRINT_DEBUG #define PRINT_PROFILE_TIME #ifdef PRINT_PROFILE_TIME uint64_t loop_start = 0; uint64_t loop_time = 0; uint64_t scan_time = 0; uint64_t scan_start_time = 0; #endif // log data via serial console, JSON format: // #define LOG_DATA_JSON true // #define WEB_SERVER true uint64_t x, y, range_item, w = WATERFALL_START, i = 0; int osd_x = 1, osd_y = 2, col = 0, max_bin = 32; uint64_t ranges_count = 0; int rssi = 0; int state = 0; int CONF_SAMPLES; #ifdef METHOD_SPECTRAL int samples = SAMPLES; #endif #ifdef METHOD_RSSI int samples = SAMPLES_RSSI; #endif uint8_t result_index = 0; uint8_t button_pressed_counter = 0; #ifndef LILYGO // #define JOYSTICK_ENABLED #endif #include "joyStick.h" // project components #if (defined(WIFI_SCANNING_ENABLED) || defined(BT_SCANNING_ENABLED)) && \ defined(OSD_ENABLED) #include "BT_WIFI_scan.h" #endif #if defined(WIFI_SCANNING_ENABLED) && defined(OSD_ENABLED) scanWiFi(osd) #endif #if defined(BT_SCANNING_ENABLED) && defined(OSD_ENABLED) scanBT(osd) #endif #ifdef OSD_ENABLED unsigned short selectFreqChar(int bin, int start_level = 0) { if (bin >= start_level) { // level when we are starting show levels symbols // you can override with your own character for example 0x100 = " " empty char return power_level[33]; } else if (bin >= 0 && bin < MAX_POWER_LEVELS) return power_level[bin]; // when wrong bin number or noc har assigned we are showing "!" char return 0x121; } void osdPrintSignalLevelChart(int col, int signal_value) { // Third line if (signal_value <= 9 && signal_value <= drone_detection_level) { osd.displayChar(13, col + 2, 0x100); osd.displayChar(14, col + 2, 0x100); osd.displayChar(12, col + 2, selectFreqChar(signal_value, drone_detection_level)); } // Second line else if (signal_value < 19 && signal_value <= drone_detection_level) { osd.displayChar(12, col + 2, 0x100); osd.displayChar(14, col + 2, 0x100); osd.displayChar(13, col + 2, selectFreqChar(signal_value, drone_detection_level)); } // First line else { // Clean Up symbol osd.displayChar(12, col + 2, 0x100); osd.displayChar(13, col + 2, 0x100); osd.displayChar(14, col + 2, selectFreqChar(signal_value, drone_detection_level)); } } void osdProcess() { // OSD enabled // memset(max_step_range, 33, 30); max_bin = 32; osd.displayString(12, 1, String(CONF_FREQ_BEGIN)); osd.displayString(12, OSD_WIDTH - 8, String(CONF_FREQ_END)); // Finding biggest in result // Skiping 0 and 32 31 to avoid overflow for (int i = 1; i < MAX_POWER_LEVELS - 3; i++) { // filter if (result[i] > 0 #if FILTER_SPECTRUM_RESULTS && ((result[i + 1] != 0 /*&& result[i + 2] != 0*/) || result[i - 1] != 0) #endif ) { max_bin = i; #ifdef PRINT_DEBUG Serial.print("MAX in bin:" + String(max_bin)); Serial.println(); #endif break; } } // max_bin contains fist not 0 index of the bin if (max_step_range > max_bin && max_bin != 0) { max_step_range = max_bin; // Store RSSI value for RSSI Method #ifdef METHOD_RSSI max_bins_array_value[col] = result[max_bin]; #endif } // Going to the next OSD step if (x % osd_steps == 0 && col < OSD_WIDTH) { // OSD SIDE BAR with frequency log #ifdef OSD_SIDE_BAR { osd.displayString(col, OSD_WIDTH - 7, String(CONF_FREQ_BEGIN + (col * osd_mhz_in_bin)) + "-" + String(max_step_range) + " "); } #endif // Test with Random Result... // max_step_range = rand() % 32; #ifdef METHOD_RSSI // With THe RSSI method we can get real RSSI value not just a bin #endif // PRINT SIGNAL CHAR ROW, COL, VALUE osdPrintSignalLevelChart(col, max_step_range); #ifdef PRINT_DEBUG Serial.println("MAX:" + String(max_step_range)); #endif max_step_range = 32; col++; } } #endif Config config; struct RadioScan : Scan { float getRSSI() override; }; float RadioScan::getRSSI() { #if defined(USING_SX1280PA) // radio.startReceive(); // get instantaneous RSSI value // When PR will be merged we can use radi.getRSSI(false); uint8_t data[3] = {0, 0, 0}; // RssiInst, Status, RFU radio.mod->SPIreadStream(RADIOLIB_SX128X_CMD_GET_RSSI_INST, data, 3); return ((float)data[0] / (-2.0)); #elif defined(USING_LR1121) // Try getRssiInst float rssi; radio.getRssiInst(&rssi); // pass the replies return rssi; #else return radio.getRSSI(false); #endif } RadioScan r; #define WATERFALL_SENSITIVITY 0.05 DecoratedBarChart *bar; WaterfallChart *waterChart; StackedChart stacked(display, 0, 0, 0, 0); UptimeClock *uptime; void init_radio() { // initialize SX1262 FSK modem at the initial frequency both.println("Init radio"); #if defined(USING_SX1280PA) state = radio.beginGFSK(CONF_FREQ_BEGIN); #elif defined(USING_LR1121) state = radio.beginGFSK(CONF_FREQ_BEGIN, 4.8F, 5.0F, 156.2F, 10, 16U, 1.7F); #else state = radio.beginFSK(CONF_FREQ_BEGIN); #endif if (state == RADIOLIB_ERR_NONE) { Serial.println(F("success!")); } else { display.println("Error:" + String(state)); Serial.print(F("failed, code ")); Serial.println(state); while (true) { delay(5); } } #ifdef METHOD_SPECTRAL // upload a patch to the SX1262 to enable spectral scan // NOTE: this patch is uploaded into volatile memory, // and must be re-uploaded on every power up both.println("Upload SX1262 patch"); // Upload binary patch into the SX126x device RAM. Patch is needed to e.g., // enable spectral scan and must be uploaded again on every power cycle. RADIOLIB_OR_HALT(radio.uploadPatch(sx126x_patch_scan, sizeof(sx126x_patch_scan))); // configure scan bandwidth and disable the data shaping #endif both.println("Setting up radio"); #ifdef USING_SX1280PA // RADIOLIB_OR_HALT(radio.setBandwidth(RADIOLIB_SX128X_LORA_BW_406_25)); #elif USING_SX1276 // Receiver bandwidth in kHz. Allowed values // are 2.6, 3.1, 3.9, 5.2, 6.3, 7.8, 10.4, 12.5, 15.6, 20.8, 25, 31.3, 41.7, // 50, 62.5, 83.3, 100, 125, 166.7, 200 and 250 kHz. RADIOLIB_OR_HALT(radio.setRxBandwidth(250)); #else RADIOLIB_OR_HALT(radio.setRxBandwidth(BANDWIDTH)); #endif // and disable the data shaping state = radio.setDataShaping(RADIOLIB_SHAPING_NONE); if (state != RADIOLIB_ERR_NONE) { Serial.println("Error:setDataShaping:" + String(state)); } both.println("Starting scanning..."); // calibrate only once ,,, at startup // TODO: check documentation (9.2.1) if we must calibrate in certain ranges #ifdef USING_SX1280PA state = radio.setFrequency(CONF_FREQ_BEGIN); if (state != RADIOLIB_ERR_NONE) { Serial.println("Error:setFrequency:" + String(state)); } state = radio.startReceive(); if (state != RADIOLIB_ERR_NONE) { Serial.println("Error:startReceive:" + String(state)); } #elif USING_SX1276 // Sets carrier frequency. Allowed values range from 137.0 MHz to 1020.0 MHz. radio.setFrequency(CONF_FREQ_BEGIN); #else radio.setFrequency(CONF_FREQ_BEGIN, true); #endif delay(50); } struct frequency_scan_result { uint64_t begin; uint64_t end; uint64_t last_epoch; int16_t rssi; // deliberately not a float; floats can pin task to wrong core forever ScanTaskResult dump; size_t readings_sz; } frequency_scan_result; TaskHandle_t logToSerial = NULL; TaskHandle_t dumpToComms = NULL; void eventListenerForReport(void *arg, Event &e) { if (e.type == EventType::DETECTED) { if (e.epoch != frequency_scan_result.last_epoch) { frequency_scan_result.dump.sz = 0; } if (frequency_scan_result.dump.sz >= frequency_scan_result.readings_sz) { size_t old_sz = frequency_scan_result.readings_sz; frequency_scan_result.readings_sz = frequency_scan_result.dump.sz + 1; uint32_t *f = new uint32_t[frequency_scan_result.readings_sz]; int16_t *r = new int16_t[frequency_scan_result.readings_sz]; if (old_sz > 0) { memcpy(f, frequency_scan_result.dump.freqs_khz, old_sz * sizeof(uint32_t)); memcpy(r, frequency_scan_result.dump.rssis, old_sz * sizeof(int16_t)); delete[] frequency_scan_result.dump.freqs_khz; delete[] frequency_scan_result.dump.rssis; } frequency_scan_result.dump.freqs_khz = f; frequency_scan_result.dump.rssis = r; } frequency_scan_result.dump.freqs_khz[frequency_scan_result.dump.sz] = e.detected.freq * 1000; // convert to kHz frequency_scan_result.dump.rssis[frequency_scan_result.dump.sz] = max(e.detected.rssi, -999.0f); frequency_scan_result.dump.sz++; if (e.epoch != frequency_scan_result.last_epoch || e.detected.rssi > frequency_scan_result.rssi) { frequency_scan_result.last_epoch = e.epoch; frequency_scan_result.rssi = e.detected.rssi; } return; } if (e.type == EventType::SCAN_TASK_COMPLETE) { // notify async communication that the data is ready if (logToSerial != NULL) { xTaskNotifyGive(logToSerial); } if (dumpToComms != NULL) { xTaskNotifyGive(dumpToComms); } return; } } ScanTask report_scans = ScanTask{ count : 0, // 0 => report none; < 0 => report forever; > 0 => report that many delay : 0 // 0 => as and when it happens; > 0 => at least once that many ms }; void dumpToCommsTask(void *parameter) { uint64_t last_epoch = frequency_scan_result.last_epoch; for (;;) { int64_t delay = report_scans.delay; if (delay == 0) { delay = (1ull << 63) - 1; } ulTaskNotifyTake(true, pdMS_TO_TICKS(delay)); if (report_scans.count == 0 || frequency_scan_result.last_epoch == last_epoch) { continue; } if (report_scans.count > 0) { report_scans.count--; } Message m; m.type = MessageType::SCAN_RESULT; m.payload.dump = frequency_scan_result.dump; Comms0->send(m); } } void logToSerialTask(void *parameter) { JsonDocument doc; char jsonOutput[200]; uint64_t last_epoch = frequency_scan_result.last_epoch; frequency_scan_result.rssi = -999; for (;;) { ulTaskNotifyTake(true, pdMS_TO_TICKS(config.log_data_json_interval)); if (frequency_scan_result.begin != frequency_scan_result.end || frequency_scan_result.last_epoch != last_epoch) { int16_t highest_value_scanned = frequency_scan_result.rssi; frequency_scan_result.rssi = -999; last_epoch = frequency_scan_result.last_epoch; if (highest_value_scanned == -999) { continue; } doc["low_range_freq"] = frequency_scan_result.begin; doc["high_range_freq"] = frequency_scan_result.end; doc["value"] = String(highest_value_scanned); serializeJson(doc, jsonOutput); Serial.println(jsonOutput); } } } void drone_sound_alarm(void *arg, Event &e); void readConfigFile() { // writeFile(LittleFS, "/text.txt", "{WIFI:{name:\"sdfsdf\", Password:\"sdfsdf\"}"); ssid = readParameterFromParameterFile(SSID); Serial.println("SSID: " + ssid); pass = readParameterFromParameterFile(PASS); Serial.println("PASS: " + pass); ip = readParameterFromParameterFile(IP); Serial.println("PASS: " + ip); gateway = readParameterFromParameterFile(GATEWAY); Serial.println("GATEWAY: " + gateway); fstart = readParameterFromParameterFile(FSTART); Serial.println("FSTART: " + fstart); fend = readParameterFromParameterFile(FEND); Serial.println("FEND: " + fend); smpls = readParameterFromParameterFile("samples"); Serial.println("SAMPLES: " + smpls); CONF_SAMPLES = (smpls == "") ? samples : atoi(smpls.c_str()); samples = CONF_SAMPLES; CONF_FREQ_BEGIN = (fstart == "") ? FREQ_BEGIN : atoi(fstart.c_str()); CONF_FREQ_END = (fend == "") ? FREQ_END : atoi(fend.c_str()); both.println("C FREQ BEGIN:" + String(CONF_FREQ_BEGIN)); both.println("C FREQ END:" + String(CONF_FREQ_END)); both.println("C SAMPLES:" + String(CONF_SAMPLES)); RANGE_PER_PAGE = CONF_FREQ_END - CONF_FREQ_BEGIN; // FREQ_END - CONF_FREQ_BEGIN RANGE = (int)(CONF_FREQ_END - CONF_FREQ_BEGIN); SINGLE_STEP = (float)(RANGE / (STEPS * SCAN_RBW_FACTOR)); range = (int)(CONF_FREQ_END - CONF_FREQ_BEGIN); iterations = RANGE / RANGE_PER_PAGE; // uint64_t range_frequency = FREQ_END - CONF_FREQ_BEGIN; median_frequency = (CONF_FREQ_BEGIN + CONF_FREQ_END) / 2; } void setup(void) { #ifdef LILYGO setupBoards(); // true for disable U8g2 display library delay(500); Serial.println("Setup LiLybeginSDCardGO board is done"); #endif // LED brightness heltec_led(25); #ifdef OSD_ENABLED osd.init(OSD_SCK, OSD_MISO, OSD_MOSI); osd.clear(); /* Write the custom character to the OSD, replacing the original character*/ /* Expand 0xe0 to 0x0e0, the high 8 bits indicate page number and the low 8 bits * indicate the inpage address.*/ osd.storeChar(0xe0, buf0); // Display Satellite icon in the left bottom corner osd.displayChar(14, 1, 0x10f); /*display String*/ osd.displayString(14, 15, " Lora SA"); osd.displayString(2, 1, " Spectral RF Analyzer"); #endif float vbat; float resolution; bt_start = millis(); wf_start = millis(); config = Config::init(); r.comms_initialized = Comms::initComms(config); if (r.comms_initialized) { Serial.println("Comms initialized fine"); } else { Serial.println("Comms did not initialize"); } pinMode(LED, OUTPUT); pinMode(BUZZER_PIN, OUTPUT); pinMode(REB_PIN, OUTPUT); heltec_setup(); #ifdef JOYSTICK_ENABLED calibrate_joy(); pinMode(JOY_BTN_PIN, INPUT_PULLUP); #endif UI_Init(&display); for (int i = 0; i < 200; i++) { button.update(); delay(10); if (button.pressed()) { r.sound_on = !r.sound_on; tone(BUZZER_PIN, 205, 100); delay(50); tone(BUZZER_PIN, 205, 100); break; } } display.clear(); #ifdef WEB_SERVER both.println("CLICK for WIFI settings."); for (int i = 0; i < 200; i++) { both.print("."); button.update(); delay(10); if (button.pressedNow()) { both.println("-----------"); both.println("Starting WIFI-SERVER..."); // Error here: E (15752) ledc: ledc_get_duty(745): LEDC is not initialized tone(BUZZER_PIN, 205, 100); delay(50); tone(BUZZER_PIN, 205, 500); tone(BUZZER_PIN, 205, 100); delay(50); serverStart(); both.println("Ready to Connect: 192.168.4.1"); delay(600); break; } } both.print("\n"); both.println("Init File System"); initLittleFS(); readConfigFile(); #endif #ifndef WEB_SERVER CONF_SAMPLES = samples; CONF_FREQ_BEGIN = FREQ_BEGIN; CONF_FREQ_END = FREQ_END; both.println("FREQ BEGIN:" + String(CONF_FREQ_BEGIN)); both.println("FREQ END:" + String(CONF_FREQ_END)); both.println("SAMPLES:" + String(CONF_SAMPLES)); RANGE_PER_PAGE = CONF_FREQ_END - CONF_FREQ_BEGIN; // FREQ_END - CONF_FREQ_BEGIN RANGE = (int)(CONF_FREQ_END - CONF_FREQ_BEGIN); SINGLE_STEP = (float)(RANGE / (STEPS * SCAN_RBW_FACTOR)); range = (int)(CONF_FREQ_END - CONF_FREQ_BEGIN); iterations = RANGE / RANGE_PER_PAGE; median_frequency = (CONF_FREQ_BEGIN + CONF_FREQ_END) / 2; #endif init_radio(); #ifndef LILYGO vbat = heltec_vbat(); both.printf("V battery: %.2fV (%d%%)\n", vbat, heltec_battery_percent(vbat)); delay(1000); #endif // end not LILYGO #ifdef WIFI_SCANNING_ENABLED WiFi.mode(WIFI_STA); WiFi.disconnect(); #endif #ifdef BT_SCANNING_ENABLED #endif delay(400); display.clear(); resolution = (float)RANGE / (STEPS * SCAN_RBW_FACTOR); single_page_scan = (RANGE_PER_PAGE == range); #ifdef DISABLED_CODE // Adjust range if it is not even to RANGE_PER_PAGE if (!single_page_scan && range % RANGE_PER_PAGE != 0) { range = range + range % RANGE_PER_PAGE; } #endif if (single_page_scan) { both.println("Single Page Screen MODE"); both.println("Multi Screen View Press P - button"); both.println("Multi Screen Res: " + String(resolution) + "Mhz/tick"); both.println( "Resolution: " + String((float)RANGE_PER_PAGE / (STEPS * SCAN_RBW_FACTOR)) + "MHz/tick"); for (int i = 0; i < 500; i++) { button.update(); delay(5); both.print("."); if (button.pressed()) { RANGE_PER_PAGE = DEFAULT_RANGE_PER_PAGE; single_page_scan = false; tone(BUZZER_PIN, 205, 100); delay(50); tone(BUZZER_PIN, 205, 100); break; } } } else { both.println("Multi Page Screen MODE"); both.println("Single screen View Press P - button"); both.println("Single screen Resol: " + String(resolution) + "Mhz/tick"); both.println( "Resolution: " + String((float)RANGE_PER_PAGE / (STEPS * SCAN_RBW_FACTOR)) + "Mhz/tick"); for (int i = 0; i < 500; i++) { button.update(); delay(10); both.print("."); if (button.pressed()) { RANGE_PER_PAGE = range; single_page_scan = true; tone(BUZZER_PIN, 205, 100); break; } } } display.clear(); Serial.println(); #ifdef METHOD_RSSI // TODO: try RADIOLIB_SX126X_RX_TIMEOUT_INF #ifdef USING_SX1280PA state = radio.startReceive(RADIOLIB_SX128X_RX_TIMEOUT_NONE); #else state = radio.startReceive(RADIOLIB_SX126X_RX_TIMEOUT_NONE); #endif if (state != RADIOLIB_ERR_NONE) { Serial.print(F("Failed to start receive mode, error code: ")); display.drawString(0, 64 - 10, "E:startReceive"); display.display(); delay(500); Serial.println(state); } #endif // waterfall start line y-axis w = WATERFALL_START; #ifdef OSD_ENABLED osd.clear(); #endif #ifdef LOG_DATA_JSON xTaskCreate(logToSerialTask, "LOG_DATA_JSON", 2048, NULL, 1, &logToSerial); #endif xTaskCreate(dumpToCommsTask, "DUMP_RESPONSE_PROCESS", 2048, NULL, 1, &dumpToComms); r.trigger_level = TRIGGER_LEVEL; stacked.reset(0, 0, display.width(), display.height()); bar = new DecoratedBarChart(display, 0, 0, display.width(), 0, CONF_FREQ_BEGIN, CONF_FREQ_END, LO_RSSI_THRESHOLD, HI_RSSI_THRESHOLD, r.trigger_level); size_t b = stacked.addChart(bar); Chart *statusBar = new StatusBar(display, 0, 0, display.width(), r); #if (WATERFALL_ENABLED == true) size_t *multiples = new size_t[6]{5, 3, 4, 15, 4, 3}; WaterfallModel *model = new WaterfallModel((size_t)display.width(), 1000, 6, multiples); model->reset(millis(), display.width()); delete[] multiples; waterChart = new WaterfallChart(display, 0, WATERFALL_START, display.width(), 0, CONF_FREQ_BEGIN, CONF_FREQ_END, r.trigger_level, WATERFALL_SENSITIVITY, model); size_t c = stacked.addChart(waterChart); stacked.setHeight(c, stacked.height - WATERFALL_START - statusBar->height); r.addEventListener(DETECTED, *waterChart); #endif size_t d = stacked.addChart(statusBar); stacked.setHeight(b, stacked.height); r.addEventListener(DETECTED, bar->bar); r.addEventListener(DETECTED, drone_sound_alarm, &r); r.addEventListener(SCAN_TASK_COMPLETE, stacked); frequency_scan_result.readings_sz = 0; frequency_scan_result.dump.sz = 0; r.addEventListener(ALL_EVENTS, eventListenerForReport, NULL); #ifdef UPTIME_CLOCK uptime = new UptimeClock(display, millis()); #endif } // Formula to translate 33 bin to approximate RSSI value int binToRSSI(int bin) { // the first the strongest RSSI in bin value is 0 return 11 + (bin * 4); } // is there an input using Hot Button or joystick bool buttonInputRequested() { if (button.pressedFor(100) #ifdef JOYSTICK_ENABLED || joy_btn_click() #endif ) { button.update(); if (button.pressedNow() #ifdef JOYSTICK_ENABLED || joy_btn_click() #endif ) { return true; } } return false; } enum ButtonEvent { NONE = 0, LONG_PRESS, SHORT_PRESS, TOO_SHORT, SUSPEND }; ButtonEvent buttonPressEvent() { button_pressed_counter = 0; // if long press stop while (button.pressedNow() #ifdef JOYSTICK_ENABLED || joy_btn_click() #endif ) { delay(10); button_pressed_counter++; if (button_pressed_counter > 150) { digitalWrite(LED, HIGH); delay(150); digitalWrite(LED, LOW); } } if (button_pressed_counter > 150) { return LONG_PRESS; } if (button_pressed_counter > 50) { if (!joy_btn_clicked) { return SUSPEND; } return SHORT_PRESS; } button.update(); return TOO_SHORT; } void drone_sound_alarm(void *arg, Event &e) { if (e.type != DETECTED) { return; } Scan &r = *((Scan *)arg); if (!r.sound_on) return; int tone_freq_db = e.detected.detected_at * 2; int drone_detection_level = r.drone_detection_level; int detection_count = r.detection_count; // If level is set to sensitive, // start beeping every 10th frequency and shorter // it improves performance less short beep delays... if (drone_detection_level <= 25) { if (tone_freq_db != 205) { tone_freq_db = 285 - tone_freq_db; } if (r.detection_count == 1 && r.sound_on) { tone(BUZZER_PIN, tone_freq_db, 10); // same action ??? but first time } if (r.detection_count % 5 == 0 && r.sound_on) { tone(BUZZER_PIN, tone_freq_db, 10); // same action ??? but every 5th time } } else { if (r.detection_count % 20 == 0 && r.sound_on) { tone(BUZZER_PIN, 205, 10); // same action ??? but every 20th detection } } } void joystickMoveCursor(int joy_x_pressed) { if (joy_x_pressed > 0) { cursor_x_position--; display.drawString(cursor_x_position, 0, String((int)r.current_frequency)); display.drawLine(cursor_x_position, 1, cursor_x_position, 10); display.display(); delay(10); } else if (joy_x_pressed < 0) { cursor_x_position++; display.drawString(cursor_x_position, 0, String((int)r.current_frequency)); display.drawLine(cursor_x_position, 1, cursor_x_position, 10); display.display(); delay(10); } if (cursor_x_position > DISPLAY_WIDTH || cursor_x_position < 0) { cursor_x_position = 0; display.drawString(cursor_x_position, 0, String((int)r.current_frequency)); display.drawLine(cursor_x_position, 1, cursor_x_position, 10); display.display(); delay(10); } } bool is_new_x_pixel(int x) { if (x % SCAN_RBW_FACTOR == 0) return true; else return false; } void check_ranges() { if (RANGE_PER_PAGE == range) { single_page_scan = true; } else { single_page_scan = false; } for (int range : SCAN_RANGES) { ranges_count++; } if (ranges_count > 0) { iterations = ranges_count; single_page_scan = false; } } void checkComms() { while (Comms0->available() > 0) { Message *m = Comms0->receive(); if (m == NULL) continue; switch (m->type) { case MessageType::SCAN: report_scans = m->payload.scan; break; } delete m; } } // MAX Frequency RSSI BIN value of the samples int max_rssi_x = 999; void loop(void) { r.led_flag = false; r.detection_count = 0; drone_detected_frequency_start = 0; ranges_count = 0; checkComms(); // reset scan time if (config.print_profile_time) { scan_time = 0; loop_start = millis(); } r.epoch++; if (!ANIMATED_RELOAD || !single_page_scan) { // clear the scan plot rectangle UI_clearPlotter(); UI_clearTopStatus(); } // do the scan range = CONF_FREQ_END - CONF_FREQ_BEGIN; if (RANGE_PER_PAGE > range) { RANGE_PER_PAGE = range; } r.fr_begin = CONF_FREQ_BEGIN; r.fr_end = r.fr_begin; // 50 is a single-screen range // TODO: Make 50 a variable with the option to show the full range iterations = range / RANGE_PER_PAGE; #if 0 // disabled code if (range % RANGE_PER_PAGE != 0) { // add more scan //++; } #endif check_ranges(); // Iterating by small ranges by 50 Mhz each pixel is 0.4 Mhz for (range_item = 0; range_item < iterations; range_item++) { range = RANGE_PER_PAGE; if (ranges_count == 0) { r.fr_begin = (range_item == 0) ? r.fr_begin : r.fr_begin + range; r.fr_end = r.fr_begin + RANGE_PER_PAGE; } else { r.fr_begin = SCAN_RANGES[range_item] / 1000; r.fr_end = SCAN_RANGES[range_item] % 1000; range = r.fr_end - r.fr_begin; } #ifdef DISABLED_CODE if (!ANIMATED_RELOAD || !single_page_scan) { // clear the scan plot rectangle UI_clearPlotter(); } #endif drone_detected_frequency_start = 0; display.setTextAlignment(TEXT_ALIGN_RIGHT); for (int i = 0; i < MAX_POWER_LEVELS; i++) { max_bins_array_value[i] = 0; } // horizontal (x axis) Frequency loop osd_x = 1, osd_y = 2, col = 0, max_bin = 0; // x loop for (x = 0; x < STEPS * SCAN_RBW_FACTOR; x++) { new_pixel = is_new_x_pixel(x); if (ANIMATED_RELOAD && SCAN_RBW_FACTOR == 1) { UI_drawCursor(x); } if (new_pixel && ANIMATED_RELOAD && SCAN_RBW_FACTOR > 1) { UI_drawCursor((int)(x / SCAN_RBW_FACTOR)); } #ifdef PRINT_PROFILE_TIME scan_start_time = millis(); #endif // Real display pixel x - axis. // Because of the SCAN_RBW_FACTOR x is not a display coordinate anymore // x > STEPS on SCAN_RBW_FACTOR int display_x = x / SCAN_RBW_FACTOR; float step = (range * ((float)x / (STEPS * SCAN_RBW_FACTOR))); r.current_frequency = r.fr_begin + step; LOG("setFrequency:%f\n", r.current_frequency); #ifdef USING_SX1280PA state = radio.setFrequency(r.current_frequency); // 1280 doesn't have calibration radio.startReceive(RADIOLIB_SX128X_RX_TIMEOUT_INF); #elif USING_SX1276 state = radio.setFrequency(freq); #else state = radio.setFrequency(r.current_frequency, true); // true = no calibration need here #endif int radio_error_count = 0; if (state != RADIOLIB_ERR_NONE) { display.drawString(0, 64 - 10, "E(" + String(state) + "):setFrequency:" + String(r.current_frequency)); Serial.println("E(" + String(state) + "):setFrequency:" + String(r.current_frequency)); display.display(); delay(2); radio_error_count++; if (radio_error_count > 10) continue; } LOG("Step:%d Freq: %f\n", x, r.current_frequency); // SpectralScan Method #ifdef METHOD_SPECTRAL { // start spectral scan third parameter is a sleep interval radio.spectralScanStart(SAMPLES, 1); // wait for spectral scan to finish radio_error_count = 0; while (radio.spectralScanGetStatus() != RADIOLIB_ERR_NONE) { Serial.println("radio.spectralScanGetStatus ERROR: "); Serial.println(radio.spectralScanGetStatus()); display.drawString(0, 64 - 20, "E:specScSta:" + String(radio.spectralScanGetStatus())); display.display(); heltec_delay(ONE_MILLISEC * 2); radio_error_count++; if (radio_error_count > 10) continue; } // read the results Array to which the results will be saved state = radio.spectralScanGetResult(result); display.drawString(0, 64 - 10, "scanGetResult:" + String(state)); } #endif #ifdef METHOD_RSSI // Spectrum analyzer using getRSSI { LOG("METHOD RSSI"); uint16_t max_rssi = r.rssiMethod(CONF_SAMPLES, result, RADIOLIB_SX126X_SPECTRAL_SCAN_RES_SIZE); if (max_x_rssi[display_x] > max_rssi) { max_x_rssi[display_x] = max_rssi; } } #endif // SCAN_METHOD == METHOD_RSSI // if this code is not executed LORA radio doesn't work // basically SX1262 requires delay // osd.displayString(12, 1, String(CONF_FREQ_BEGIN)); // osd.displayString(12, 30 - 8, String(FREQ_END)); // delay(2); #ifdef OSD_ENABLED osdProcess(); #endif #ifdef JOYSTICK_ENABLED if (display_x == cursor_x_position) { display.setColor(BLACK); display.fillRect(display_x - 20, 3, 36, 11); display.setColor(WHITE); } #endif Event event = r.detect(result, filtered_result, RADIOLIB_SX126X_SPECTRAL_SCAN_RES_SIZE, samples); event.time_ms = millis(); size_t detected_at = event.detected.detected_at; if (max_rssi_x > detected_at) { // MAx bin Value not RSSI max_rssi_x = detected_at; } detected = event.detected.detected; detected_y[display_x] = false; float rr = event.detected.rssi; r.drone_detection_level = drone_detection_level; if (event.detected.trigger) { // check if we should alarm about a drone presence if (detected_y[display_x] == false) // detection threshold match { // Set LED to ON (filtered in UI component) r.led_flag = true; if (drone_detected_frequency_start == 0) { // mark freq start drone_detected_frequency_start = r.current_frequency; } // mark freq end ... will shift right to last detected range drone_detected_frequency_end = r.current_frequency; #ifdef LOG_DATA_JSON frequency_scan_result.begin = drone_detected_frequency_start; frequency_scan_result.end = drone_detected_frequency_end; #endif if (DRAW_DETECTION_TICKS == true) { // draw vertical line on top of display for "drone detected" // frequencies #ifdef METHOD_SPECTRAL if (!detected_y[display_x]) { display.drawLine(display_x, 1, display_x, 4); detected_y[display_x] = true; } #endif } } } r.fireEvent(event); #ifdef JOYSTICK_ENABLED // Draw joystick cursor and Frequency RSSI value if (display_x == cursor_x_position) { display.drawString(display_x - 1, 0, String((int)r.current_frequency)); display.drawLine(display_x, 1, display_x, 12); // if method scan RSSI we can get exact RSSI value display.drawString(display_x + 17, 0, "-" + String((int)max_rssi_x * 4)); } #endif #ifdef PRINT_PROFILE_TIME scan_time += (millis() - scan_start_time); #endif #ifdef PRINT_DEBUG Serial.println("....\n"); #endif if (r.animated) { display.display(); } if (buttonInputRequested()) { display.setTextAlignment(TEXT_ALIGN_CENTER); display.drawString(display.width() / 2, 0, String(r.current_frequency)); display.display(); ButtonEvent e = buttonPressEvent(); if (e == LONG_PRESS) { // Remove Curent Frequency Text display.setTextAlignment(TEXT_ALIGN_CENTER); display.setColor(BLACK); display.drawString(display.width() / 2, 0, String(r.current_frequency)); display.setColor(WHITE); display.display(); break; } if (e == SUSPEND) { // Visually confirm it's off so user releases button display.displayOff(); // Deep sleep (has wait for release so we don't wake up // immediately) heltec_deep_sleep(); break; } if (e == SHORT_PRESS) break; if (e == TOO_SHORT) { String v = String(r.trigger_level) + " dB"; uint16_t w = display.getStringWidth(v); display.setTextAlignment(TEXT_ALIGN_RIGHT); // erase old drone detection level value display.setColor(BLACK); display.fillRect(display.width() - w, 0, 13, w); display.setColor(WHITE); // dt is roughly single-pixel increment float dt = bar->bar.height == 0 ? 0.0 : (LO_RSSI_THRESHOLD - HI_RSSI_THRESHOLD) / bar->bar.height; r.trigger_level += dt; if (r.trigger_level <= LO_RSSI_THRESHOLD) { r.trigger_level = HI_RSSI_THRESHOLD; } // print new value display.drawString(display.width(), 0, v); tone(BUZZER_PIN, 104, 150); bar->bar.redraw_all = true; } } // wait a little bit before the next scan, // otherwise the SX1262 hangs // Add more logic before instead of long delay... int delay_cnt = 1; #ifdef METHOD_SPECTRAL if (false && state != RADIOLIB_ERR_NONE) { if (delay_cnt == 1) { Serial.println("E:getResult"); display.drawString(0, 64 - 10, "E:getResult"); // trying to use display as delay.. display.display(); } else { heltec_delay(ONE_MILLISEC * 2); Serial.println("E:getStatus"); display.drawString(0, 64 - 10, "E:getResult"); // trying to use display as delay.. display.display(); } Serial.println("spectralScanGetStatus ERROR(" + String(radio.spectralScanGetStatus()) + ") hard delay(2) - " + String(delay_cnt)); // if error than speed is slow animating chart ANIMATED_RELOAD = true; delay(50); delay_cnt++; } #endif // TODO: move osd logic here as a daley ;) // Loop is needed if heltec_delay(1) not used heltec_loop(); // Move joystick #ifdef JOYSTICK_ENABLED int joy_x_pressed = get_joy_x(true); joystickMoveCursor(joy_x_pressed); #endif } w++; if (w > ROW_STATUS_TEXT + 1) { w = WATERFALL_START; } { Event event(r, SCAN_TASK_COMPLETE, millis()); r.fireEvent(event); } // Render display data here #ifdef UPTIME_CLOCK uptime->draw(millis()); #endif display.display(); #ifdef OSD_ENABLED // Sometimes OSD prints entire screen with the digits. // We need clean the screen to fix it. // We can do it every time but to optimise doing every N times if (global_counter != 0 && global_counter % 10 == 0) { #if !defined(BT_SCANNING_ENABLED) && !defined(WIFI_SCANNING_ENABLED) osd.clear(); osd.displayChar(14, 1, 0x10f); global_counter = 0; #endif } ANIMATED_RELOAD = false; global_counter++; #endif } #ifdef PRINT_DEBUG // Serial.println("----"); #endif joy_btn_clicked = false; if (config.print_profile_time) { #ifdef PRINT_PROFILE_TIME loop_time = millis() - loop_start; Serial.printf("LOOP: %lld ms; SCAN: %lld ms;\n ", loop_time, scan_time); #endif } // No WiFi and BT Scan Without OSD #ifdef OSD_ENABLED #ifdef WIFI_SCANNING_ENABLED if ((millis() - wf_start) > WF_SCAN_DELAY) { scanWiFi(); wf_start = millis(); // prevent BT scanning after scanning WF bt_start = millis(); } #endif #ifdef BT_SCANNING_ENABLED if ((millis() - bt_start) > BT_SCAN_DELAY) { scanBT(); bt_start = millis(); } #endif #endif }