mirror of
https://github.com/Genaker/LoraSA.git
synced 2026-05-02 03:22:53 +02:00
457 lines
14 KiB
C++
457 lines
14 KiB
C++
/* Heltec Automation Ink screen example
|
|
* NOTE!!!: to upload we neew code you need to press button BOOT and RESET or you will
|
|
* have serial error. After upload you need reset device...
|
|
*
|
|
* Function:
|
|
* 1. Ink screen full brush demonstration
|
|
*
|
|
* Description:
|
|
* 1.Inherited from ssd1306 for drawing points, lines, and functions
|
|
*
|
|
* */
|
|
|
|
#include "HT_DEPG0290BxS800FxX_BW.h"
|
|
#include "global_config.h"
|
|
#include "images.h"
|
|
#include "ui.h"
|
|
#include <Arduino.h>
|
|
|
|
// Disabling default lib display
|
|
#define HELTEC_NO_DISPLAY
|
|
#define DISPLAY_WIDTH 296
|
|
#define DISPLAY_HEIGHT 128
|
|
// Without this line Lora Radio doesn't work
|
|
#define ARDUINO_heltec_wifi_32_lora_V3
|
|
#include "heltec_unofficial.h"
|
|
#include "modules/SX126x/patches/SX126x_patch_scan.h"
|
|
|
|
// <--- Spectrum display Varriables START
|
|
#define SCAN_METHOD
|
|
#define METHOD_SPECTRAL
|
|
// numbers of the spectrum screan lines = width of screan
|
|
#define STEPS 296 // 128
|
|
// Number of samples for each scan. Fewer samples = better temporal resolution.
|
|
#define MAX_POWER_LEVELS 33
|
|
// multiplies STEPS * N to increase scan resolution.
|
|
#define SCAN_RBW_FACTOR 1 // 2
|
|
// Print spectrum values pixels at once or by line
|
|
bool ANIMATED_RELOAD = false;
|
|
// Remove reading without neighbors
|
|
#define FILTER_SPECTRUM_RESULTS true
|
|
#define FILTER_SAMPLES_MIN
|
|
constexpr bool DRAW_DETECTION_TICKS = true;
|
|
// Number of samples for each frequency scan. Fewer samples = better temporal resolution.
|
|
// if more than 100 it can freez
|
|
#define SAMPLES 35 //(scan time = 1294)
|
|
// number of samples for RSSI method
|
|
#define SAMPLES_RSSI 30 // 21 //
|
|
|
|
#define FREQ_BEGIN 750
|
|
|
|
#define RANGE (int)(FREQ_END - FREQ_BEGIN)
|
|
|
|
#define SINGLE_STEP (float)(RANGE / (STEPS * SCAN_RBW_FACTOR))
|
|
|
|
uint64_t range = (int)(FREQ_END - FREQ_BEGIN);
|
|
uint64_t fr_begin = FREQ_BEGIN;
|
|
uint64_t fr_end = FREQ_BEGIN;
|
|
|
|
// Feature to scan diapazones. Other frequency settings will be ignored.
|
|
// int SCAN_RANGES[] = {850890, 920950};
|
|
int SCAN_RANGES[] = {};
|
|
|
|
// MHZ per page
|
|
// to put everething into one page set RANGE_PER_PAGE = FREQ_END - 800
|
|
// uint64_t RANGE_PER_PAGE = FREQ_END - FREQ_BEGIN; // FREQ_END - FREQ_BEGIN
|
|
|
|
// Override or e-ink
|
|
uint64_t RANGE_PER_PAGE = FREQ_BEGIN + DISPLAY_WIDTH;
|
|
|
|
uint64_t iterations = RANGE / RANGE_PER_PAGE;
|
|
|
|
// uint64_t range_frequency = FREQ_END - FREQ_BEGIN;
|
|
uint64_t median_frequency = FREQ_BEGIN + FREQ_END - FREQ_BEGIN / 2;
|
|
|
|
// #define DISABLE_PLOT_CHART false // unused
|
|
|
|
// Array to store the scan results
|
|
uint16_t result[RADIOLIB_SX126X_SPECTRAL_SCAN_RES_SIZE];
|
|
uint16_t result_display_set[RADIOLIB_SX126X_SPECTRAL_SCAN_RES_SIZE];
|
|
uint16_t result_detections[RADIOLIB_SX126X_SPECTRAL_SCAN_RES_SIZE];
|
|
uint16_t filtered_result[RADIOLIB_SX126X_SPECTRAL_SCAN_RES_SIZE];
|
|
|
|
// Waterfall array
|
|
bool waterfall[STEPS], detected_y[STEPS]; // 20 - ??? steps of the waterfall
|
|
|
|
// 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;
|
|
uint64_t drone_detected_frequency_start = 0;
|
|
uint64_t drone_detected_frequency_end = 0;
|
|
uint64_t detection_count = 0;
|
|
bool single_page_scan = false;
|
|
bool SOUND_ON = 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
|
|
|
|
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;
|
|
|
|
float freq = 0;
|
|
int rssi = 0;
|
|
int state = 0;
|
|
|
|
#ifdef METHOD_SPECTRAL
|
|
constexpr int samples = SAMPLES;
|
|
#endif
|
|
#ifdef METHOD_RSSI
|
|
constexpr int samples = SAMPLES_RSSI;
|
|
#endif
|
|
|
|
uint8_t result_index = 0;
|
|
uint8_t button_pressed_counter = 0;
|
|
uint64_t loop_cnt = 0;
|
|
// <--- Spectrum display Varriables END
|
|
|
|
// Initialize the display
|
|
DEPG0290BxS800FxX_BW display(5, 4, 3, 6, 2, 1, -1,
|
|
6000000); // rst,dc,cs,busy,sck,mosi,miso,frequency
|
|
typedef void (*Demo)(void);
|
|
/* screen rotation
|
|
* ANGLE_0_DEGREE
|
|
* ANGLE_90_DEGREE
|
|
* ANGLE_180_DEGREE
|
|
* ANGLE_270_DEGREE
|
|
*/
|
|
#define DIRECTION ANGLE_0_DEGREE
|
|
int demoMode = 0;
|
|
|
|
void init_radio()
|
|
{
|
|
// initialize SX1262 FSK modem at the initial frequency
|
|
Serial.println("Init radio");
|
|
RADIOLIB_OR_HALT(radio.beginFSK(FREQ_BEGIN));
|
|
|
|
// 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
|
|
Serial.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
|
|
|
|
Serial.println("Setting up radio");
|
|
RADIOLIB_OR_HALT(radio.setRxBandwidth(BANDWIDTH));
|
|
|
|
// and disable the data shaping
|
|
RADIOLIB_OR_HALT(radio.setDataShaping(RADIOLIB_SHAPING_NONE));
|
|
Serial.println("Starting scanning...");
|
|
|
|
// calibrate only once ,,, at startup
|
|
// TODO: check documentation (9.2.1) if we must calibrate in certain ranges
|
|
radio.setFrequency(FREQ_BEGIN, true);
|
|
delay(50);
|
|
}
|
|
|
|
#define HEIGHT 4
|
|
DEPG0290BxS800FxX_BW display_instance = display;
|
|
/**
|
|
* @brief Draws ticks on the display at regular whole intervals.
|
|
*
|
|
* @param every The interval between ticks in MHz.
|
|
* @param length The length of each tick in pixels.
|
|
*/
|
|
void drawTicks(float every, int length)
|
|
{
|
|
int first_tick;
|
|
bool correction;
|
|
int pixels_per_step;
|
|
int correction_number;
|
|
int tick;
|
|
int tick_minor;
|
|
int median;
|
|
|
|
first_tick = 0;
|
|
//+ (every - (fr_begin - (int)(fr_begin / every) * every));
|
|
/*if (first_tick < fr_begin)
|
|
{
|
|
first_tick += every;
|
|
}*/
|
|
correction = false;
|
|
pixels_per_step = STEPS / (RANGE_PER_PAGE / every);
|
|
if (STEPS / RANGE_PER_PAGE != 0)
|
|
{
|
|
correction = true;
|
|
}
|
|
correction_number = STEPS - (int)(pixels_per_step * (RANGE_PER_PAGE / every));
|
|
tick = 0;
|
|
tick_minor = 0;
|
|
median = (RANGE_PER_PAGE / every) / 2;
|
|
// TODO: (RANGE_PER_PAGE / every)
|
|
// * 2 has twice extra steps we need to figureout correct logic or minor
|
|
// ticks is not showing to the end
|
|
for (int t = 0; t <= (RANGE_PER_PAGE / every) * 2; t++)
|
|
{
|
|
// fix if pixels per step is not int and we have shift
|
|
if (correction && t % 2 != 0 && correction_number > 1)
|
|
{
|
|
// pixels_per_step++;
|
|
correction_number--;
|
|
}
|
|
tick += pixels_per_step;
|
|
tick_minor = tick / 2;
|
|
if (tick <= 128 - 3)
|
|
{
|
|
display_instance.drawLine(tick, HEIGHT + X_AXIS_WEIGHT, tick,
|
|
HEIGHT + X_AXIS_WEIGHT + length);
|
|
// Central tick
|
|
if (tick > (128 / 2) - 3 && tick < (128 / 2) + 3)
|
|
{
|
|
display_instance.drawLine(tick + 1, HEIGHT + X_AXIS_WEIGHT, tick + 1,
|
|
HEIGHT + X_AXIS_WEIGHT + length);
|
|
}
|
|
}
|
|
#ifdef MINOR_TICKS
|
|
// Fix two ticks together
|
|
if ((tick_minor + 1 != tick) && (tick_minor - 1 != tick) &&
|
|
(tick_minor + 2 != tick) && (tick_minor - 2 != tick))
|
|
{
|
|
display_instance.drawLine(tick_minor, HEIGHT + X_AXIS_WEIGHT, tick_minor,
|
|
HEIGHT + X_AXIS_WEIGHT + MINOR_TICK_LENGTH);
|
|
}
|
|
// Central tick
|
|
if (tick_minor > (128 / 2) - 3 && tick_minor < (128 / 2) + 3)
|
|
{
|
|
display_instance.drawLine(tick_minor + 1, HEIGHT + X_AXIS_WEIGHT,
|
|
tick_minor + 1,
|
|
HEIGHT + X_AXIS_WEIGHT + MINOR_TICK_LENGTH);
|
|
}
|
|
#endif
|
|
}
|
|
}
|
|
|
|
void drawFontFaceDemo()
|
|
{
|
|
// Font Demo1
|
|
// create more fonts at http://oleddisplay.squix.ch/
|
|
display.setTextAlignment(TEXT_ALIGN_LEFT);
|
|
display.setFont(ArialMT_Plain_10);
|
|
display.drawString(0, 0, "Spectrum Analizer Lora SA");
|
|
display.setFont(ArialMT_Plain_16);
|
|
display.drawString(0, 10, "SX 1262");
|
|
display.setFont(ArialMT_Plain_24);
|
|
display.drawString(0, 26, "e-ink display");
|
|
}
|
|
void drawTextFlowDemo()
|
|
{
|
|
display.setFont(ArialMT_Plain_10);
|
|
display.setTextAlignment(TEXT_ALIGN_LEFT);
|
|
display.drawStringMaxWidth(
|
|
0, 0, DISPLAY_HEIGHT,
|
|
"Lorem ipsum\n dolor sit amet, consetetur sadipscing elitr, sed diam nonumy "
|
|
"eirmod tempor invidunt ut labore.");
|
|
}
|
|
void drawTextAlignmentDemo()
|
|
{
|
|
// Text alignment demo
|
|
char str[30];
|
|
int x = 0;
|
|
int y = 0;
|
|
display.setFont(ArialMT_Plain_10);
|
|
// The coordinates define the left starting point of the text
|
|
display.setTextAlignment(TEXT_ALIGN_LEFT);
|
|
display.drawString(x, y, "Left aligned (0,0)");
|
|
// The coordinates define the center of the text
|
|
display.setTextAlignment(TEXT_ALIGN_CENTER);
|
|
x = display.width() / 2;
|
|
y = display.height() / 2 - 5;
|
|
sprintf(str, "Center aligned (%d,%d)", x, y);
|
|
display.drawString(x, y, str);
|
|
// The coordinates define the right end of the text
|
|
display.setTextAlignment(TEXT_ALIGN_RIGHT);
|
|
x = display.width();
|
|
y = display.height() - 12;
|
|
sprintf(str, "Right aligned (%d,%d)", x, y);
|
|
display.drawString(x, y, str);
|
|
}
|
|
void drawRectDemo()
|
|
{
|
|
// Draw a pixel at given position
|
|
for (int i = 0; i < 10; i++)
|
|
{
|
|
display.setPixel(i, i);
|
|
display.setPixel(10 - i, i);
|
|
}
|
|
display.drawRect(12, 12, 20, 20);
|
|
// Fill the rectangle
|
|
display.fillRect(14, 14, 17, 17);
|
|
// Draw a line horizontally
|
|
display.drawHorizontalLine(0, 40, 20);
|
|
// Draw a line horizontally
|
|
display.drawVerticalLine(40, 0, 20);
|
|
}
|
|
void drawCircleDemo()
|
|
{
|
|
int x = display.width() / 4;
|
|
int y = display.height() / 2;
|
|
for (int i = 1; i < 8; i++)
|
|
{
|
|
display.setColor(WHITE);
|
|
display.drawCircle(x, y, i * 3);
|
|
if (i % 2 == 0)
|
|
{
|
|
display.setColor(BLACK);
|
|
}
|
|
int x = display.width() / 4 * 3;
|
|
display.fillCircle(x, y, 32 - i * 3);
|
|
}
|
|
}
|
|
void drawImageDemo()
|
|
{
|
|
// see http://blog.squix.org/2015/05/esp8266-nodemcu-how-to-create-xbm.html
|
|
// on how to create xbm files
|
|
int x = display.width() / 2 - WiFi_Logo_width / 2;
|
|
int y = display.height() / 2 - WiFi_Logo_height / 2;
|
|
display.drawXbm(x, y, WiFi_Logo_width, WiFi_Logo_height, WiFi_Logo_bits);
|
|
}
|
|
void VextON(void)
|
|
{
|
|
pinMode(18, OUTPUT);
|
|
digitalWrite(18, HIGH);
|
|
}
|
|
void VextOFF(void) // Vext default OFF
|
|
{
|
|
pinMode(18, OUTPUT);
|
|
digitalWrite(18, LOW);
|
|
}
|
|
|
|
int lower_level = 108;
|
|
int up_level = 40;
|
|
int rssiToPix(int rssi)
|
|
{
|
|
// Bigger is lower signal
|
|
if (abs(rssi) >= lower_level)
|
|
{
|
|
return lower_level - 1;
|
|
}
|
|
if (abs(rssi) <= up_level)
|
|
{
|
|
return up_level;
|
|
}
|
|
return abs(rssi);
|
|
}
|
|
|
|
Demo demos[] = {drawFontFaceDemo, drawTextFlowDemo, drawTextAlignmentDemo,
|
|
drawRectDemo, drawCircleDemo, drawImageDemo};
|
|
int demoLength = (sizeof(demos) / sizeof(Demo));
|
|
long timeSinceLastModeSwitch = 0;
|
|
|
|
float fr = FREQ_BEGIN;
|
|
int rssi2 = 0;
|
|
int x1 = 0, y2 = 0;
|
|
unsigned int loop_counter = 1;
|
|
void loop()
|
|
{
|
|
radio.setFrequency(fr, false); // false = no calibration need here
|
|
for (int i = 0; i < SAMPLES_RSSI; i++)
|
|
{
|
|
if (i % 2 == 0)
|
|
radio.setFrequency((float)fr + 0.33, false);
|
|
else if (i % 3 == 0)
|
|
radio.setFrequency((float)fr + 0.33, false);
|
|
rssi2 = radio.getRSSI(false);
|
|
if (rssi2 > lower_level)
|
|
continue;
|
|
// Serial.println(String(fr) + ":" + String(rssi2));
|
|
// display.drawString(x1, (int)y2, String(fr) + ":" + String(rssi2));
|
|
display.setPixel(x1, rssiToPix(rssi2));
|
|
}
|
|
|
|
fr++;
|
|
x1++;
|
|
if (x1 >= STEPS)
|
|
{
|
|
if (loop_counter > STEPS * 5)
|
|
{
|
|
loop_counter = 0;
|
|
// Draw a line horizontally
|
|
display.drawHorizontalLine(0, lower_level + 1, DISPLAY_WIDTH);
|
|
for (int x = 0; x < DISPLAY_WIDTH; x++)
|
|
{
|
|
if (x % (DISPLAY_WIDTH / 2) == 0 && x > 5)
|
|
{
|
|
display.drawVerticalLine(x, lower_level + 1, 8);
|
|
display.drawVerticalLine(x - 1, lower_level + 1, 8);
|
|
display.drawVerticalLine(x + 1, lower_level + 1, 8);
|
|
}
|
|
if (x % 10 == 0 || x == 0)
|
|
display.drawVerticalLine(x, lower_level + 1, 6);
|
|
if (x % 5 == 0)
|
|
display.drawVerticalLine(x, lower_level + 1, 3);
|
|
}
|
|
display.setFont(ArialMT_Plain_10);
|
|
|
|
display.drawString(1, DISPLAY_HEIGHT - 10, String(FREQ_BEGIN));
|
|
display.drawString(DISPLAY_WIDTH - 24, DISPLAY_HEIGHT - 10, String(fr));
|
|
display.drawString((DISPLAY_WIDTH / 2) - 10, DISPLAY_HEIGHT - 10,
|
|
String(FREQ_BEGIN + ((fr - FREQ_BEGIN) / 2)));
|
|
|
|
display.display();
|
|
// delay(2000);
|
|
if (loop_counter == 0)
|
|
{
|
|
display.clear();
|
|
}
|
|
}
|
|
fr = FREQ_BEGIN;
|
|
x1 = 0;
|
|
}
|
|
loop_counter++;
|
|
}
|
|
|
|
void setup()
|
|
{
|
|
// Initialising the UI will init the display too.
|
|
display.init();
|
|
display.screenRotate(DIRECTION);
|
|
display.setFont(ArialMT_Plain_10);
|
|
display.clear();
|
|
display.drawXbm((DISPLAY_WIDTH / 3) - 10, DISPLAY_HEIGHT / 4, 128, 60,
|
|
epd_bitmap_ucog);
|
|
display.display();
|
|
delay(2000);
|
|
display.clear();
|
|
Serial.begin(115200);
|
|
w = WATERFALL_START;
|
|
init_radio();
|
|
state = radio.startReceive(RADIOLIB_SX126X_RX_TIMEOUT_NONE);
|
|
if (state != RADIOLIB_ERR_NONE)
|
|
{
|
|
Serial.print(F("Failed to start receive mode, error code: "));
|
|
Serial.println(state);
|
|
}
|
|
heltec_setup();
|
|
Serial.println();
|
|
Serial.println();
|
|
drawFontFaceDemo();
|
|
display.display();
|
|
delay(1000);
|
|
VextON();
|
|
display.clear();
|
|
}
|