Code formatted

ESP32_Oscilloscope/ESP32_Oscilloscope.ino

@@ -1,35 +1,38 @@
+/* Add https://dl.espressif.com/dl/package_esp32_index.json to your arduino IDE to get ESP32 support
+*/
+
 #include <Arduino.h>
 #include <driver/i2s.h>
 #include <driver/adc.h>
 #include <soc/syscon_reg.h>
+
 #include <TFT_eSPI.h>
+
 #include <SPI.h>
 #include "esp_adc_cal.h"
 #include "filters.h"
 
 //#define DEBUG_SERIAL
-//#define DEBUG_BUFF
-#define DELAY 1000
+#define DEBUG_BUFF
+#define DEBUG_DELAY 250
 
 // Width and height of sprite
-#define WIDTH  240
-#define HEIGHT 280
+#define DISPLAY_HEIGHT 240
+#define DISPLAY_WIDTH  320
 
-#define ADC_CHANNEL   ADC1_CHANNEL_5  // GPIO33
-#define NUM_SAMPLES   1000            // number of samples
-#define I2S_NUM         (0)
-#define BUFF_SIZE 50000
+#define ADC_CHANNEL   ADC1_CHANNEL_5 // GPIO33
+#define NUM_SAMPLES             1000 // number of samples
+#define I2S_NUM                  (0)
+#define BUFF_SIZE              50000
 #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;
 
@@ -164,7 +167,7 @@ void core0_task( void * pvParameters ) {
       update_screen(i2s_buff, RATE);
       updating_screen = false;
       vTaskDelay(pdMS_TO_TICKS(10));
-      Serial.println("CORE0");
+      //Serial.println("CORE0");
     }
 
     vTaskDelay(pdMS_TO_TICKS(10));
@@ -172,75 +175,90 @@ void core0_task( void * pvParameters ) {
 
 }
 
-void core1_task( void * pvParameters ) {
+void core1_task(void *pvParameters)
+{
 
-  (void) pvParameters;
+  (void)pvParameters;
 
-  for (;;) {
-    if (!single_trigger) {
-      while (updating_screen) {
+  for (;;)
+  {
+    if (!single_trigger)
+    {
+      while (updating_screen)
+      {
         vTaskDelay(pdMS_TO_TICKS(1));
       }
-      if (!stop) {
-        if (stop_change) {
+      if (!stop)
+      {
+        if (stop_change)
+        {
           i2s_adc_enable(I2S_NUM_0);
           stop_change = false;
         }
         ADC_Sampling(i2s_buff);
         new_data = true;
       }
-      else {
-        if (!stop_change) {
+      else
+      {
+        if (!stop_change)
+        {
           i2s_adc_disable(I2S_NUM_0);
           i2s_zero_dma_buffer(I2S_NUM_0);
           stop_change = true;
         }
       }
-      Serial.println("CORE1");
+      // Serial.println("CORE1");
       vTaskDelay(pdMS_TO_TICKS(300));
     }
-    else {
+    else
+    {
       float old_mean = 0;
-      while (single_trigger) {
+      while (single_trigger)
+      {
         stop = true;
         ADC_Sampling(i2s_buff);
         float mean = 0;
         float max_v, min_v;
         peak_mean(i2s_buff, BUFF_SIZE, &max_v, &min_v, &mean);
 
-        //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) {
+        // 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)
+        {
           float freq = 0;
           float period = 0;
           uint32_t trigger0 = 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;
-          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);
           }
-          else if (digital_wave_option == 0) {
+          else if (digital_wave_option == 0)
+          {
             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);
             }
-            else {
+            else
+            {
               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);
           }
 
           single_trigger = false;
           new_data = true;
           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));
     }

ESP32_Oscilloscope/data_analysis.ino

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

ESP32_Oscilloscope/debug_routines.ino

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

ESP32_Oscilloscope/i2s.ino

@@ -23,12 +23,20 @@ void configure_i2s(int rate) {
   i2s_adc_enable(I2S_NUM_0);
 }
 
+/*
 void ADC_Sampling(uint16_t *i2s_buff){
   for (int i = 0; i < B_MULT; i++) {
     //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);    
   }
 }
+*/
+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) {
   i2s_driver_uninstall(I2S_NUM_0);

ESP32_Oscilloscope/options_handler.ino

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

ESP32_Oscilloscope/screen.ino

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