klaute/ESP32_Scope
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity

Compare commits

base: klaute:1a54d4bc59eb0bd38bba0f9fc673129e9a97d299
Branches Tags
klaute:develop
..
compare: klaute:100650edb21f2788f03ce85b8644dc14462f6280
Branches Tags
klaute:develop

No commits in common. "1a54d4bc59eb0bd38bba0f9fc673129e9a97d299" and "100650edb21f2788f03ce85b8644dc14462f6280" have entirely different histories.
1a54d4bc59 ... 100650edb2

6 changed files with 263 additions and 361 deletions
Show stats Expand all files Collapse all files

98
ESP32_Oscilloscope/ESP32_Oscilloscope.ino
View file

@ -1,38 +1,35 @@
/* Add https://dl.espressif.com/dl/package_esp32_index.json to your arduino IDE to get ESP32 support
*/
#include <Arduino.h> #include <Arduino.h>
#include <driver/i2s.h> #include <driver/i2s.h>
#include <driver/adc.h> #include <driver/adc.h>
#include <soc/syscon_reg.h> #include <soc/syscon_reg.h>
#include <TFT_eSPI.h> #include <TFT_eSPI.h>
#include <SPI.h> #include <SPI.h>
#include "esp_adc_cal.h" #include "esp_adc_cal.h"
#include "filters.h" #include "filters.h"
//#define DEBUG_SERIAL //#define DEBUG_SERIAL
#define DEBUG_BUFF //#define DEBUG_BUFF
#define DEBUG_DELAY 250 #define DELAY 1000
// Width and height of sprite // Width and height of sprite
#define DISPLAY_HEIGHT 240 #define WIDTH 240
#define DISPLAY_WIDTH 320 #define HEIGHT 280
#define ADC_CHANNEL ADC1_CHANNEL_5 // GPIO33 #define ADC_CHANNEL ADC1_CHANNEL_5 // GPIO33
#define NUM_SAMPLES 1000 // number of samples #define NUM_SAMPLES 1000 // number of samples
#define I2S_NUM (0) #define I2S_NUM (0)
#define BUFF_SIZE 50000 #define BUFF_SIZE 50000
#define B_MULT BUFF_SIZE/NUM_SAMPLES #define B_MULT BUFF_SIZE/NUM_SAMPLES
#define BUTTON_Ok 32
#define BUTTON_Plus 15
#define BUTTON_Minus 35
#define BUTTON_Back 34
TFT_eSPI tft = TFT_eSPI(); // Declare object "tft"
TFT_eSprite spr = TFT_eSprite(&tft); // Declare Sprite object "spr" with pointer to "tft" object
#define BUTTON_Ok 32
#define BUTTON_Plus 15
#define BUTTON_Minus 35
#define BUTTON_Back 34
TFT_eSPI tft = TFT_eSPI(); // Declare object "tft"
TFT_eSprite spr = TFT_eSprite(&tft); // Declare Sprite object "spr" with pointer to "tft" object
esp_adc_cal_characteristics_t adc_chars; esp_adc_cal_characteristics_t adc_chars;
@ -167,7 +164,7 @@ void core0_task( void * pvParameters ) {
update_screen(i2s_buff, RATE); update_screen(i2s_buff, RATE);
updating_screen = false; updating_screen = false;
vTaskDelay(pdMS_TO_TICKS(10)); vTaskDelay(pdMS_TO_TICKS(10));
//Serial.println("CORE0"); Serial.println("CORE0");
} }
vTaskDelay(pdMS_TO_TICKS(10)); vTaskDelay(pdMS_TO_TICKS(10));
@ -175,90 +172,75 @@ void core0_task( void * pvParameters ) {
} }
void core1_task(void *pvParameters) void core1_task( void * pvParameters ) {
{
(void)pvParameters; (void) pvParameters;
for (;;) for (;;) {
{ if (!single_trigger) {
if (!single_trigger) while (updating_screen) {
{
while (updating_screen)
{
vTaskDelay(pdMS_TO_TICKS(1)); vTaskDelay(pdMS_TO_TICKS(1));
} }
if (!stop) if (!stop) {
{ if (stop_change) {
if (stop_change)
{
i2s_adc_enable(I2S_NUM_0); i2s_adc_enable(I2S_NUM_0);
stop_change = false; stop_change = false;
} }
ADC_Sampling(i2s_buff); ADC_Sampling(i2s_buff);
new_data = true; new_data = true;
} }
else else {
{ if (!stop_change) {
if (!stop_change)
{
i2s_adc_disable(I2S_NUM_0); i2s_adc_disable(I2S_NUM_0);
i2s_zero_dma_buffer(I2S_NUM_0); i2s_zero_dma_buffer(I2S_NUM_0);
stop_change = true; stop_change = true;
} }
} }
// Serial.println("CORE1"); Serial.println("CORE1");
vTaskDelay(pdMS_TO_TICKS(300)); vTaskDelay(pdMS_TO_TICKS(300));
} }
else else {
{
float old_mean = 0; float old_mean = 0;
while (single_trigger) while (single_trigger) {
{
stop = true; stop = true;
ADC_Sampling(i2s_buff); ADC_Sampling(i2s_buff);
float mean = 0; float mean = 0;
float max_v, min_v; float max_v, min_v;
peak_mean(i2s_buff, BUFF_SIZE, &max_v, &min_v, &mean); peak_mean(i2s_buff, BUFF_SIZE, &max_v, &min_v, &mean);
// signal captured (pp > 0.4V || changing mean > 0.2V) -> DATA ANALYSIS //signal captured (pp > 0.4V || changing mean > 0.2V) -> DATA ANALYSIS
if ((old_mean != 0 && fabs(mean - old_mean) > 0.2) || to_voltage(max_v) - to_voltage(min_v) > 0.05) if ((old_mean != 0 && fabs(mean - old_mean) > 0.2) || to_voltage(max_v) - to_voltage(min_v) > 0.05) {
{
float freq = 0; float freq = 0;
float period = 0; float period = 0;
uint32_t trigger0 = 0; uint32_t trigger0 = 0;
uint32_t trigger1 = 0; uint32_t trigger1 = 0;
// if analog mode OR auto mode and wave recognized as analog //if analog mode OR auto mode and wave recognized as analog
bool digital_data = !false; bool digital_data = !false;
if (digital_wave_option == 1) if (digital_wave_option == 1) {
{
trigger_freq_analog(i2s_buff, RATE, mean, max_v, min_v, &freq, &period, &trigger0, &trigger1); trigger_freq_analog(i2s_buff, RATE, mean, max_v, min_v, &freq, &period, &trigger0, &trigger1);
} }
else if (digital_wave_option == 0) else if (digital_wave_option == 0) {
{
digital_data = digital_analog(i2s_buff, max_v, min_v); digital_data = digital_analog(i2s_buff, max_v, min_v);
if (!digital_data) if (!digital_data) {
{
trigger_freq_analog(i2s_buff, RATE, mean, max_v, min_v, &freq, &period, &trigger0, &trigger1); trigger_freq_analog(i2s_buff, RATE, mean, max_v, min_v, &freq, &period, &trigger0, &trigger1);
} }
else else {
{
trigger_freq_digital(i2s_buff, RATE, mean, max_v, min_v, &freq, &period, &trigger0); trigger_freq_digital(i2s_buff, RATE, mean, max_v, min_v, &freq, &period, &trigger0);
} }
} }
else else {
{
trigger_freq_digital(i2s_buff, RATE, mean, max_v, min_v, &freq, &period, &trigger0); trigger_freq_digital(i2s_buff, RATE, mean, max_v, min_v, &freq, &period, &trigger0);
} }
single_trigger = false; single_trigger = false;
new_data = true; new_data = true;
Serial.println("Single GOT"); Serial.println("Single GOT");
// return to normal execution in stop mode //return to normal execution in stop mode
} }
vTaskDelay(pdMS_TO_TICKS(1)); // time for the other task to start (low priorit) vTaskDelay(pdMS_TO_TICKS(1)); //time for the other task to start (low priorit)
} }
vTaskDelay(pdMS_TO_TICKS(300)); vTaskDelay(pdMS_TO_TICKS(300));
} }

150
ESP32_Oscilloscope/data_analysis.ino
View file

@ -1,14 +1,11 @@
void peak_mean(uint16_t *i2s_buffer, uint32_t len, float * max_value, float * min_value, float *pt_mean) {
void peak_mean(uint16_t *i2s_buffer, uint32_t len, float *max_value, float *min_value, float *pt_mean)
{
max_value[0] = i2s_buffer[0]; max_value[0] = i2s_buffer[0];
min_value[0] = i2s_buffer[0]; min_value[0] = i2s_buffer[0];
mean_filter filter(5); mean_filter filter(5);
filter.init(i2s_buffer[0]); filter.init(i2s_buffer[0]);
float mean = 0; float mean = 0;
for (uint32_t i = 1; i < len; i++) for (uint32_t i = 1; i < len; i++) {
{
float value = filter.filter((float)i2s_buffer[i]); float value = filter.filter((float)i2s_buffer[i]);
if (value > max_value[0]) if (value > max_value[0])
@ -23,36 +20,31 @@ void peak_mean(uint16_t *i2s_buffer, uint32_t len, float *max_value, float *min_
pt_mean[0] = mean; pt_mean[0] = mean;
} }
// true if digital/ false if analog
bool digital_analog(uint16_t *i2s_buffer, uint32_t max_v, uint32_t min_v) //true if digital/ false if analog
{ bool digital_analog(uint16_t *i2s_buffer, uint32_t max_v, uint32_t min_v) {
uint32_t upper_threshold = max_v - 0.05 * (max_v - min_v); uint32_t upper_threshold = max_v - 0.05 * (max_v - min_v);
uint32_t lower_threshold = min_v + 0.05 * (max_v - min_v); uint32_t lower_threshold = min_v + 0.05 * (max_v - min_v);
uint32_t digital_data = 0; uint32_t digital_data = 0;
uint32_t analog_data = 0; uint32_t analog_data = 0;
for (uint32_t i = 0; i < BUFF_SIZE; i++) for (uint32_t i = 0; i < BUFF_SIZE; i++) {
{ if (i2s_buffer[i] > lower_threshold) {
if (i2s_buffer[i] > lower_threshold) if (i2s_buffer[i] > upper_threshold) {
{ //HIGH DIGITAL
if (i2s_buffer[i] > upper_threshold)
{
// HIGH DIGITAL
digital_data++; digital_data++;
} }
else else {
{ //ANALOG/TRANSITION
// ANALOG/TRANSITION
analog_data++; analog_data++;
} }
} }
else else {
{ //LOW DIGITAL
// LOW DIGITAL
digital_data++; digital_data++;
} }
} }
// more than 50% of data is analog //more than 50% of data is analog
if (analog_data < digital_data) if (analog_data < digital_data)
return true; return true;
@ -67,8 +59,7 @@ void trigger_freq_analog(uint16_t *i2s_buffer,
float *pt_freq, float *pt_freq,
float *pt_period, float *pt_period,
uint32_t *pt_trigger0, uint32_t *pt_trigger0,
uint32_t *pt_trigger1) uint32_t *pt_trigger1) {
{
float freq = 0; float freq = 0;
float period = 0; float period = 0;
bool signal_side = false; bool signal_side = false;
@ -77,25 +68,21 @@ void trigger_freq_analog(uint16_t *i2s_buffer,
uint32_t trigger_temp[trigger_num] = {0}; uint32_t trigger_temp[trigger_num] = {0};
uint32_t trigger_index = 0; uint32_t trigger_index = 0;
// get initial signal relative to the mean //get initial signal relative to the mean
if (to_voltage(i2s_buffer[0]) > mean) if (to_voltage(i2s_buffer[0]) > mean) {
{
signal_side = true; signal_side = true;
} }
// waveform repetitions calculation + get triggers time
//waveform repetitions calculation + get triggers time
uint32_t wave_center = (max_v + min_v) / 2; uint32_t wave_center = (max_v + min_v) / 2;
for (uint32_t i = 1; i < BUFF_SIZE; i++) for (uint32_t i = 1 ; i < BUFF_SIZE; i++) {
{ if (signal_side && i2s_buffer[i] < wave_center - (wave_center - min_v) * 0.2) {
if (signal_side && i2s_buffer[i] < wave_center - (wave_center - min_v) * 0.2)
{
signal_side = false; signal_side = false;
} }
else if (!signal_side && i2s_buffer[i] > wave_center + (max_v - wave_center) * 0.2) else if (!signal_side && i2s_buffer[i] > wave_center + (max_v - wave_center) * 0.2) {
{
freq++; freq++;
if (trigger_count < trigger_num) if (trigger_count < trigger_num) {
{
trigger_temp[trigger_count] = i; trigger_temp[trigger_count] = i;
trigger_count++; trigger_count++;
} }
@ -103,66 +90,62 @@ void trigger_freq_analog(uint16_t *i2s_buffer,
} }
} }
// frequency calculation //frequency calculation
if (trigger_count < 2) if (trigger_count < 2) {
{
trigger_temp[0] = 0; trigger_temp[0] = 0;
trigger_index = 0; trigger_index = 0;
freq = 0; freq = 0;
period = 0; period = 0;
} }
else else {
{
// simple frequency calculation fair enough for frequencies over 2khz (20hz resolution) //simple frequency calculation fair enough for frequencies over 2khz (20hz resolution)
freq = freq * 1000 / 50; freq = freq * 1000 / 50;
period = (float)(sample_rate * 1000.0) / freq; // us period = (float)(sample_rate * 1000.0) / freq; //us
// from 2000 to 80 hz -> uses mean of the periods for precision //from 2000 to 80 hz -> uses mean of the periods for precision
if (freq < 2000 && freq > 80) if (freq < 2000 && freq > 80) {
{
period = 0; period = 0;
for (uint32_t i = 1; i < trigger_count; i++) for (uint32_t i = 1; i < trigger_count; i++) {
{
period += trigger_temp[i] - trigger_temp[i - 1]; period += trigger_temp[i] - trigger_temp[i - 1];
} }
period /= (trigger_count - 1); period /= (trigger_count - 1);
freq = sample_rate * 1000 / period; freq = sample_rate * 1000 / period;
} }
// under 80hz, single period for frequency calculation //under 80hz, single period for frequency calculation
else if (trigger_count > 1 && freq <= 80) else if (trigger_count > 1 && freq <= 80) {
{
period = trigger_temp[1] - trigger_temp[0]; period = trigger_temp[1] - trigger_temp[0];
freq = sample_rate * 1000 / period; freq = sample_rate * 1000 / period;
} }
} }
// setting triggers offset and getting second trigger for debug cursor on drawn_channel1 //setting triggers offset and getting second trigger for debug cursor on drawn_channel1
/* /*
The trigger function uses a rise porcentage (5%) obove the mean, thus, The trigger function uses a rise porcentage (5%) obove the mean, thus,
the real waveform starting point is some datapoints back. the real waveform starting point is some datapoints back.
The resulting trigger gets a negative offset of 5% of the calculated period The resulting trigger gets a negative offset of 5% of the calculated period
*/ */
uint32_t trigger2 = 0; uint32_t trigger2 = 0;
if (trigger_temp[0] - period * 0.05 > 0 && trigger_count > 1) if (trigger_temp[0] - period * 0.05 > 0 && trigger_count > 1) {
{
trigger_index = trigger_temp[0] - period * 0.05; trigger_index = trigger_temp[0] - period * 0.05;
trigger2 = trigger_temp[1] - period * 0.05; trigger2 = trigger_temp[1] - period * 0.05;
} }
else if (trigger_count > 2) else if (trigger_count > 2) {
{
trigger_index = trigger_temp[1] - period * 0.05; trigger_index = trigger_temp[1] - period * 0.05;
if (trigger_count > 2) if (trigger_count > 2)
trigger2 = trigger_temp[2] - period * 0.05; trigger2 = trigger_temp[2] - period * 0.05;
} }
pt_trigger0[0] = trigger_index; pt_trigger0[0] = trigger_index;
pt_trigger1[0] = trigger2; pt_trigger1[0] = trigger2;
pt_freq[0] = freq; pt_freq[0] = freq;
pt_period[0] = period; pt_period[0] = period;
} }
void trigger_freq_digital(uint16_t *i2s_buffer, void trigger_freq_digital(uint16_t *i2s_buffer,
float sample_rate, float sample_rate,
float mean, float mean,
@ -170,8 +153,7 @@ void trigger_freq_digital(uint16_t *i2s_buffer,
uint32_t min_v, uint32_t min_v,
float *pt_freq, float *pt_freq,
float *pt_period, float *pt_period,
uint32_t *pt_trigger0) uint32_t *pt_trigger0) {
{
float freq = 0; float freq = 0;
float period = 0; float period = 0;
@ -181,38 +163,32 @@ void trigger_freq_digital(uint16_t *i2s_buffer,
uint32_t trigger_temp[trigger_num] = {0}; uint32_t trigger_temp[trigger_num] = {0};
uint32_t trigger_index = 0; uint32_t trigger_index = 0;
// get initial signal relative to the mean //get initial signal relative to the mean
if (to_voltage(i2s_buffer[0]) > mean) if (to_voltage(i2s_buffer[0]) > mean) {
{
signal_side = true; signal_side = true;
} }
// waveform repetitions calculation + get triggers time //waveform repetitions calculation + get triggers time
uint32_t wave_center = (max_v + min_v) / 2; uint32_t wave_center = (max_v + min_v) / 2;
bool normal_high = (mean > to_voltage(wave_center)) ? true : false; bool normal_high = (mean > to_voltage(wave_center)) ? true : false;
if (max_v - min_v > 4095 * (0.4 / 3.3)) if (max_v - min_v > 4095 * (0.4 / 3.3)) {
{ for (uint32_t i = 1 ; i < BUFF_SIZE; i++) {
for (uint32_t i = 1; i < BUFF_SIZE; i++) if (signal_side && i2s_buffer[i] < wave_center - (wave_center - min_v) * 0.2) {
{
if (signal_side && i2s_buffer[i] < wave_center - (wave_center - min_v) * 0.2)
{
// signal was high, fell -> trigger if normal high //signal was high, fell -> trigger if normal high
if (trigger_count < trigger_num && normal_high) if (trigger_count < trigger_num && normal_high) {
{
trigger_temp[trigger_count] = i; trigger_temp[trigger_count] = i;
trigger_count++; trigger_count++;
} }
signal_side = false; signal_side = false;
} }
else if (!signal_side && i2s_buffer[i] > wave_center + (max_v - wave_center) * 0.2) else if (!signal_side && i2s_buffer[i] > wave_center + (max_v - wave_center) * 0.2) {
{
freq++; freq++;
// signal was low, rose -> trigger if normal low //signal was low, rose -> trigger if normal low
if (trigger_count < trigger_num && !normal_high) if (trigger_count < trigger_num && !normal_high) {
{
trigger_temp[trigger_count] = i; trigger_temp[trigger_count] = i;
trigger_count++; trigger_count++;
} }
@ -222,25 +198,21 @@ void trigger_freq_digital(uint16_t *i2s_buffer,
} }
freq = freq * 1000 / 50; freq = freq * 1000 / 50;
period = (float)(sample_rate * 1000.0) / freq; // us period = (float)(sample_rate * 1000.0) / freq; //us
if (trigger_count > 1) if (trigger_count > 1) {
{ //from 2000 to 80 hz -> uses mean of the periods for precision
// from 2000 to 80 hz -> uses mean of the periods for precision if (freq < 2000 && freq > 80) {
if (freq < 2000 && freq > 80)
{
period = 0; period = 0;
for (uint32_t i = 1; i < trigger_count; i++) for (uint32_t i = 1; i < trigger_count; i++) {
{
period += trigger_temp[i] - trigger_temp[i - 1]; period += trigger_temp[i] - trigger_temp[i - 1];
} }
period /= (trigger_count - 1); period /= (trigger_count - 1);
freq = sample_rate * 1000 / period; freq = sample_rate * 1000 / period;
} }
// under 80hz, single period for frequency calculation //under 80hz, single period for frequency calculation
else if (trigger_count > 1 && freq <= 80) else if (trigger_count > 1 && freq <= 80) {
{
period = trigger_temp[1] - trigger_temp[0]; period = trigger_temp[1] - trigger_temp[0];
freq = sample_rate * 1000 / period; freq = sample_rate * 1000 / period;
} }
@ -254,7 +226,11 @@ void trigger_freq_digital(uint16_t *i2s_buffer,
trigger_index = 0; trigger_index = 0;
} }
pt_trigger0[0] = trigger_index; pt_trigger0[0] = trigger_index;
pt_freq[0] = freq; pt_freq[0] = freq;
pt_period[0] = period; pt_period[0] = period;
} }

2
ESP32_Oscilloscope/debug_routines.ino
View file

@ -2,7 +2,7 @@
void debug_buffer() { void debug_buffer() {
ADC_Sampling(); ADC_Sampling();
i2s_adc_disable(I2S_NUM_0); i2s_adc_disable(I2S_NUM_0);
delay(DEBUG_DELAY); delay(1000);
for (uint32_t i = 0; i < B_MULT * NUM_SAMPLES; i++) { for (uint32_t i = 0; i < B_MULT * NUM_SAMPLES; i++) {
for (int j = 0; j < 1; j++) { for (int j = 0; j < 1; j++) {
Serial.println(i2s_buff[i]); Serial.println(i2s_buff[i]);

8
ESP32_Oscilloscope/i2s.ino
View file

@ -23,20 +23,12 @@ void configure_i2s(int rate) {
i2s_adc_enable(I2S_NUM_0); i2s_adc_enable(I2S_NUM_0);
} }
/*
void ADC_Sampling(uint16_t *i2s_buff){ void ADC_Sampling(uint16_t *i2s_buff){
for (int i = 0; i < B_MULT; i++) { for (int i = 0; i < B_MULT; i++) {
//TODO i2s_read_bytes is deprecated, replace with new function //TODO i2s_read_bytes is deprecated, replace with new function
i2s_read_bytes(I2S_NUM_0, (char*)&i2s_buff[i * NUM_SAMPLES], NUM_SAMPLES * sizeof(uint16_t), portMAX_DELAY); i2s_read_bytes(I2S_NUM_0, (char*)&i2s_buff[i * NUM_SAMPLES], NUM_SAMPLES * sizeof(uint16_t), portMAX_DELAY);
} }
} }
*/
void ADC_Sampling(uint16_t *i2s_buff){
size_t bytes_read; for (int i = 0; i < B_MULT; i++) {
i2s_read(I2S_NUM_0, (void*)&i2s_buff[i * NUM_SAMPLES], NUM_SAMPLES * sizeof(uint16_t), &bytes_read, portMAX_DELAY);
for(size_t ix = 0; ix < bytes_read/2; ix++) i2s_buff[(i * NUM_SAMPLES) + ix] &= 0x0FFF; // 16bit to 12bit conversion 
}
}
void set_sample_rate(uint32_t rate) { void set_sample_rate(uint32_t rate) {
i2s_driver_uninstall(I2S_NUM_0); i2s_driver_uninstall(I2S_NUM_0);

290
ESP32_Oscilloscope/options_handler.ino
View file

@ -12,7 +12,7 @@ int voltage_division[6] = { //screen has 4 divisions, 31 pixels each (125 pixels
thus, the time division is the number thus, the time division is the number
of samples per screen division of samples per screen division
*/ */
float time_division[9] = { //screen has 4 divisions, 60 pixel each (WIDTH pixel of width) float time_division[9] = { //screen has 4 divisions, 60 pixel each (240 pixel of width)
10, 10,
25, 25,
50, 50,
@ -34,99 +34,87 @@ void menu_handler() {
button(); button();
} }
void button() void button() {
{ if ( btnok == 1 || btnbk == 1 || btnpl == 1 || btnmn == 1)
if (btnok == 1 || btnbk == 1 || btnpl == 1 || btnmn == 1)
{ {
menu_action = true; menu_action = true;
} }
if (menu == true) if (menu == true)
{ {
if (set_value) if (set_value) {
{ switch (opt) {
switch (opt) case Vdiv:
{ if (btnpl == 1) {
case Vdiv: volts_index++;
if (btnpl == 1) if (volts_index >= sizeof(voltage_division) / sizeof(*voltage_division)) {
{ volts_index = 0;
volts_index++; }
if (volts_index >= sizeof(voltage_division) / sizeof(*voltage_division)) btnpl = 0;
{
volts_index = 0;
} }
btnpl = 0; else if (btnmn == 1) {
} volts_index--;
else if (btnmn == 1) if (volts_index < 0) {
{ volts_index = sizeof(voltage_division) / sizeof(*voltage_division) - 1;
volts_index--; }
if (volts_index < 0) btnmn = 0;
{
volts_index = sizeof(voltage_division) / sizeof(*voltage_division) - 1;
} }
btnmn = 0;
}
v_div = voltage_division[volts_index]; v_div = voltage_division[volts_index];
break; break;
case Sdiv: case Sdiv:
if (btnmn == 1) if (btnmn == 1) {
{ tscale_index++;
tscale_index++; if (tscale_index >= sizeof(time_division) / sizeof(*time_division)) {
if (tscale_index >= sizeof(time_division) / sizeof(*time_division)) tscale_index = 0;
{ }
tscale_index = 0; btnmn = 0;
} }
btnmn = 0; else if (btnpl == 1) {
} tscale_index--;
else if (btnpl == 1) if (tscale_index < 0) {
{ tscale_index = sizeof(time_division) / sizeof(*time_division) - 1;
tscale_index--; }
if (tscale_index < 0) btnpl = 0;
{
tscale_index = sizeof(time_division) / sizeof(*time_division) - 1;
} }
btnpl = 0;
}
s_div = time_division[tscale_index]; s_div = time_division[tscale_index];
break; break;
case Offset: case Offset:
if (btnmn == 1) if (btnmn == 1) {
{ offset += 0.1 * (v_div * 4) / 3300;
offset += 0.1 * (v_div * 4) / 3300; btnmn = 0;
btnmn = 0; }
} else if (btnpl == 1) {
else if (btnpl == 1) offset -= 0.1 * (v_div * 4) / 3300;
{ btnpl = 0;
offset -= 0.1 * (v_div * 4) / 3300; }
btnpl = 0;
}
if (offset > 3.3) if (offset > 3.3)
offset = 3.3; offset = 3.3;
if (offset < -3.3) if (offset < -3.3)
offset = -3.3; offset = -3.3;
break; break;
case TOffset: case TOffset:
if (btnpl == 1) if (btnpl == 1)
{ {
toffset += 0.1 * s_div; toffset += 0.1 * s_div;
btnpl = 0; btnpl = 0;
} }
else if (btnmn == 1) else if (btnmn == 1)
{ {
toffset -= 0.1 * s_div; toffset -= 0.1 * s_div;
btnmn = 0; btnmn = 0;
} }
break; break;
default:
break;
default:
break;
} }
if (btnbk == 1) if (btnbk == 1)
{ {
@ -163,68 +151,67 @@ void button()
hide_menu(); hide_menu();
btnbk = 0; btnbk = 0;
} }
if (btnok == 1) if (btnok == 1) {
{ switch (opt) {
switch (opt) case Autoscale:
{ auto_scale = !auto_scale;
case Autoscale: break;
auto_scale = !auto_scale;
break;
case Vdiv: case Vdiv:
set_value = true; set_value = true;
break; break;
case Sdiv: case Sdiv:
set_value = true; set_value = true;
break; break;
case Offset: case Offset:
set_value = true; set_value = true;
break; break;
case Stop: case Stop:
stop = !stop; stop = !stop;
Serial.print("Stop : "); //Serial.print("Stop : ");
Serial.println(stop); //Serial.println(stop);
set_value = false; set_value = false;
break; break;
case TOffset: case TOffset:
set_value = true; set_value = true;
// set_value = false; //set_value = false;
break; break;
case Single: case Single:
single_trigger = true; single_trigger = true;
set_value = false; set_value = false;
break; break;
case Reset: case Reset:
offset = 0; offset = 0;
v_div = 550; v_div = 550;
s_div = 10; s_div = 10;
tscale_index = 0; tscale_index = 0;
volts_index = 0; volts_index = 0;
break; break;
case Probe: case Probe:
break; break;
case Mode: case Mode:
digital_wave_option++; digital_wave_option++;
if (digital_wave_option > 2) if (digital_wave_option > 2)
digital_wave_option = 0; digital_wave_option = 0;
break; break;
case Filter: case Filter:
current_filter++; current_filter++;
if (current_filter > 3) if (current_filter > 3)
current_filter = 0; current_filter = 0;
break; break;
default:
break;
default:
break;
} }
btnok = 0; btnok = 0;
@ -251,86 +238,71 @@ void button()
} }
btnbk = 0; btnbk = 0;
} }
if (btnpl == 1) if (btnpl == 1) {
{
volts_index++; volts_index++;
if (volts_index >= sizeof(voltage_division) / sizeof(*voltage_division)) if (volts_index >= sizeof(voltage_division) / sizeof(*voltage_division)) {
{
volts_index = 0; volts_index = 0;
} }
btnpl = 0; btnpl = 0;
v_div = voltage_division[volts_index]; v_div = voltage_division[volts_index];
} }
if (btnmn == 1) if (btnmn == 1) {
{
tscale_index++; tscale_index++;
if (tscale_index >= sizeof(time_division) / sizeof(*time_division)) if (tscale_index >= sizeof(time_division) / sizeof(*time_division)) {
{
tscale_index = 0; tscale_index = 0;
} }
btnmn = 0; btnmn = 0;
s_div = time_division[tscale_index]; s_div = time_division[tscale_index];
} }
} }
} }
void hide_menu() void hide_menu() {
{
menu = false; menu = false;
} }
void hide_all() void hide_all() {
{
menu = false; menu = false;
info = false; info = false;
} }
void show_menu() void show_menu() {
{
menu = true; menu = true;
} }
String strings_vdiv() String strings_vdiv() {
{
return ""; return "";
} }
String strings_sdiv() String strings_sdiv() {
{
return ""; return "";
} }
String strings_offset() String strings_offset() {
{
return ""; return "";
} }
String strings_toffset() String strings_toffset() {
{
return ""; return "";
} }
String strings_freq() String strings_freq() {
{
return ""; return "";
} }
String strings_peak() String strings_peak() {
{
return ""; return "";
} }
String strings_vmax() String strings_vmax() {
{
return ""; return "";
} }
String strings_vmin() String strings_vmin() {
{
return ""; return "";
} }
String strings_filter() String strings_filter() {
{
return ""; return "";
} }

74
ESP32_Oscilloscope/screen.ino
View file

@ -1,22 +1,21 @@
void setup_screen() { void setup_screen() {
// Initialise the TFT registers // Initialise the TFT registers
tft.init(); tft.init();
tft.setRotation(3); tft.setRotation(1);
// Optionally set colour depth to 8 or 16 bits, default is 16 if not spedified // Optionally set colour depth to 8 or 16 bits, default is 16 if not spedified
spr.setColorDepth(8); spr.setColorDepth(8);
// Create a sprite of defined size // Create a sprite of defined size
spr.createSprite(DISPLAY_WIDTH, DISPLAY_HEIGHT); spr.createSprite(HEIGHT, WIDTH);
// Clear the TFT screen to blue // Clear the TFT screen to blue
tft.fillScreen(TFT_BLACK); tft.fillScreen(TFT_BLACK);
} }
int data[DISPLAY_WIDTH] = {0}; int data[280] = {0};
/*
float to_scale(float reading) { float to_scale(float reading) {
float temp = DISPLAY_HEIGHT - float temp = WIDTH -
( (
( (
( (
@ -27,33 +26,18 @@ float to_scale(float reading) {
(v_div * 6) (v_div * 6)
) )
) )
* (DISPLAY_HEIGHT - 1) * (WIDTH - 1)
- 1; - 1;
return temp; return temp;
} }
*/
float to_scale(float reading) {
float temp = DISPLAY_HEIGHT - (((reading / 4095.0) + (offset / 3.3)) * 3300 / (v_div * 6)) * (DISPLAY_HEIGHT - 1) - 1;
return temp;
}
/*
float to_voltage(float reading) { float to_voltage(float reading) {
return (reading - 20480.0) / 4095.0 * 3.3; return (reading - 20480.0) / 4095.0 * 3.3;
} }
*/
float to_voltage(float reading) {
return reading / 4095.0 * 3.3;
}
/*
uint32_t from_voltage(float voltage) { uint32_t from_voltage(float voltage) {
return uint32_t(voltage / 3.3 * 4095 + 20480.0); return uint32_t(voltage / 3.3 * 4095 + 20480.0);
} }
*/
uint32_t from_voltage(float voltage) {
return ((uint32_t)(voltage / 3.3 * 4095));
}
void update_screen(uint16_t *i2s_buff, float sample_rate) { void update_screen(uint16_t *i2s_buff, float sample_rate) {
@ -165,11 +149,11 @@ void draw_sprite(float freq,
draw_channel1(trigger, 0, i2s_buff, sample_rate); draw_channel1(trigger, 0, i2s_buff, sample_rate);
} }
int shift = DISPLAY_WIDTH - 110; int shift = 150;
if (menu) { if (menu) {
spr.drawLine( 0, DISPLAY_HEIGHT/2, DISPLAY_WIDTH, DISPLAY_HEIGHT/2, TFT_WHITE); //center line spr.drawLine( 0, 120, 280, 120, TFT_WHITE); //center line
spr.fillRect(shift, 0, (DISPLAY_HEIGHT/2)-18, (DISPLAY_HEIGHT/2)+15, TFT_BLACK); spr.fillRect(shift, 0, 102, 135, TFT_BLACK);
spr.drawRect(shift, 0, (DISPLAY_HEIGHT/2)-18, (DISPLAY_HEIGHT/2)+15, TFT_WHITE); spr.drawRect(shift, 0, 102, 135, TFT_WHITE);
spr.fillRect(shift + 1, 3 + 10 * (opt - 1), 100, 11, TFT_RED); spr.fillRect(shift + 1, 3 + 10 * (opt - 1), 100, 11, TFT_RED);
spr.drawString("AUTOSCALE", shift + 5, 5); spr.drawString("AUTOSCALE", shift + 5, 5);
@ -194,34 +178,30 @@ void draw_sprite(float freq,
spr.drawRect(shift, 0, 70, 30, TFT_WHITE); spr.drawRect(shift, 0, 70, 30, TFT_WHITE);
spr.drawString("P-P: " + String(max_v - min_v) + "V", shift + 5, 5); spr.drawString("P-P: " + String(max_v - min_v) + "V", shift + 5, 5);
spr.drawString(frequency, shift + 5, 15); spr.drawString(frequency, shift + 5, 15);
//String offset_line = String((2.0 * v_div) / 1000.0 - offset) + "V"; String offset_line = String((2.0 * v_div) / 1000.0 - offset) + "V";
String offset_line = String((3.0 * v_div) / 1000.0 - offset) + "V"; spr.drawString(offset_line, shift + 40, 59);
spr.drawString(offset_line, shift + 25, (DISPLAY_HEIGHT/2)-8);
if (set_value) { if (set_value) {
uint16_t t_left = shift+161; spr.fillRect(229, 0, 11, 11, TFT_BLUE);
// Plus symbols while setting a value spr.drawRect(229, 0, 11, 11, TFT_WHITE);
spr.fillRect(t_left, 0, 11, 11, TFT_BLUE); spr.drawLine(231, 5, 238 , 5, TFT_WHITE);
spr.drawRect(t_left, 0, 11, 11, TFT_WHITE); spr.drawLine(234, 2, 234, 8, TFT_WHITE);
spr.drawLine(t_left+2, 5, t_left+9, 5, TFT_WHITE);
spr.drawLine(t_left+5, 2, t_left+5, 8, TFT_WHITE);
// Minus symbols while setting a value
spr.fillRect(t_left, 124, 11, 11, TFT_BLUE); spr.fillRect(229, 124, 11, 11, TFT_BLUE);
spr.drawRect(t_left, 124, 11, 11, TFT_WHITE); spr.drawRect(229, 124, 11, 11, TFT_WHITE);
spr.drawLine(t_left+2, 129, t_left+9, 129, TFT_WHITE); spr.drawLine(231, 129, 238, 129, TFT_WHITE);
} }
} }
else if (info) { else if (info) {
spr.drawLine( 0, 120, DISPLAY_WIDTH, 120, TFT_WHITE); //center line spr.drawLine( 0, 120, 280, 120, TFT_WHITE); //center line
//spr.drawRect(shift + 10, 0, DISPLAY_WIDTH - shift - 20, 30, TFT_WHITE); //spr.drawRect(shift + 10, 0, 280 - shift - 20, 30, TFT_WHITE);
spr.drawString("P-P: " + String(max_v - min_v) + "V", shift + 15, 5); spr.drawString("P-P: " + String(max_v - min_v) + "V", shift + 15, 5);
spr.drawString(frequency, shift + 15, 15); spr.drawString(frequency, shift + 15, 15);
spr.drawString(String(int(v_div)) + "mV/div", shift - 100, 5); spr.drawString(String(int(v_div)) + "mV/div", shift - 100, 5);
spr.drawString(String(int(s_div)) + "uS/div", shift - 100, 15); spr.drawString(String(int(s_div)) + "uS/div", shift - 100, 15);
//String offset_line = String((2.0 * v_div) / 1000.0 - offset) + "V"; String offset_line = String((2.0 * v_div) / 1000.0 - offset) + "V";
String offset_line = String((3.0 * v_div) / 1000.0 - offset) + "V"; spr.drawString(offset_line, shift + 100, 112);
spr.drawString(offset_line, shift + 75, (DISPLAY_HEIGHT/2)-8);
} }
@ -233,15 +213,15 @@ void draw_sprite(float freq,
void draw_grid() { void draw_grid() {
for (int i = 0; i < (DISPLAY_WIDTH/10); i++) { for (int i = 0; i < 28; i++) {
spr.drawPixel(i * 10, 40, TFT_WHITE); spr.drawPixel(i * 10, 40, TFT_WHITE);
spr.drawPixel(i * 10, 80, TFT_WHITE); spr.drawPixel(i * 10, 80, TFT_WHITE);
spr.drawPixel(i * 10, 120, TFT_WHITE); spr.drawPixel(i * 10, 120, TFT_WHITE);
spr.drawPixel(i * 10, 160, TFT_WHITE); spr.drawPixel(i * 10, 160, TFT_WHITE);
spr.drawPixel(i * 10, 200, TFT_WHITE); spr.drawPixel(i * 10, 200, TFT_WHITE);
} }
for (int i = 0; i < DISPLAY_HEIGHT; i += 10) { for (int i = 0; i < 240; i += 10) {
for (int j = 0; j < DISPLAY_WIDTH; j += 40) { for (int j = 0; j < 280; j += 40) {
spr.drawPixel(j, i, TFT_WHITE); spr.drawPixel(j, i, TFT_WHITE);
} }
} }
@ -263,7 +243,7 @@ void draw_channel1(uint32_t trigger0, uint32_t trigger1, uint16_t *i2s_buff, flo
trigger0 += index_offset; trigger0 += index_offset;
uint32_t old_index = trigger0; uint32_t old_index = trigger0;
float n_data = 0, o_data = to_scale(i2s_buff[trigger0]); float n_data = 0, o_data = to_scale(i2s_buff[trigger0]);
for (uint32_t i = 1; i < DISPLAY_WIDTH; i++) { for (uint32_t i = 1; i < 280; i++) {
uint32_t index = trigger0 + (uint32_t)((i + 1) * data_per_pixel); uint32_t index = trigger0 + (uint32_t)((i + 1) * data_per_pixel);
if (index < BUFF_SIZE) { if (index < BUFF_SIZE) {
if (full_pix && s_div > 40 && current_filter == 0) { if (full_pix && s_div > 40 && current_filter == 0) {