Oscilloscope Circuit

Channel 1 Input Circuit:
┌─────────────┐
│ Signal In   │
└──────┬──────┘
       │
      ┌┴┐ 1kΩ (current limiting)
      └┬┘
       ├─────────→ GPIO 34 (ADC1_CH6)
       │
      ═╪═ 100nF (noise filtering, optional)
       │
      GND

Channel 2 Input Circuit:
┌─────────────┐
│ Signal In   │
└──────┬──────┘
       │
      ┌┴┐ 1kΩ (current limiting)
      └┬┘
       ├─────────→ GPIO 35 (ADC1_CH7)
       │
      ═╪═ 100nF (noise filtering, optional)
       │
      GND

ESP32 Power:
├── VIN → 5V USB
├── GND → Common ground (shared with signal grounds)
└── 3.3V → Reference (do not draw current)

Signal In (up to 15V)
       │
      ┌┴┐ R1 = 10kΩ
      └┬┘
       ├─────────→ GPIO 34/35
      ┌┴┐ R2 = 3.3kΩ
      └┬┘
       │
      GND

Attenuation Factor = (R1 + R2) / R2 = 4.03:1
Max Safe Input = 3.3V × 4.03 = 13.3V

#include <Arduino.h>

#define ADC1_PIN 34
#define ADC2_PIN 35
#define ADC_READ_INTERVAL_US (1000000 / 200)  // 200 samples per second

volatile bool adcStreaming = false;
unsigned long lastAdcMicros = 0;

void setup() {
  Serial.begin(115200);
  delay(1000);

  // Configure ADC resolution and attenuation
  analogReadResolution(12);       // 12-bit resolution (0-4095)
  analogSetAttenuation(ADC_11db); // 0-3.3V range

  Serial.println("Oscilloscope Ready");
  Serial.println("Commands: ADC START, ADC STOP");
}

void loop() {
  // Command processing
  if (Serial.available()) {
    String cmd = Serial.readStringUntil('\n');
    cmd.trim();

    if (cmd == "ADC START") {
      adcStreaming = true;
      Serial.println("ADC STREAMING STARTED");
    } 
    else if (cmd == "ADC STOP") {
      adcStreaming = false;
      Serial.println("ADC STREAMING STOPPED");
    }
  }

  // ADC streaming loop
  if (adcStreaming) {
    unsigned long now = micros();
    if (now - lastAdcMicros >= ADC_READ_INTERVAL_US) {
      lastAdcMicros = now;

      int adc1 = analogRead(ADC1_PIN);
      int adc2 = analogRead(ADC2_PIN);

      // Output format: S,channel1,channel2
      Serial.print("S,");
      Serial.print(adc1);
      Serial.print(",");
      Serial.println(adc2);
    }
  }
}

#include <Arduino.h>
#include <WiFi.h>

#define ADC_CH1_PIN 34   // GPIO34 = ADC1_CH6
#define ADC_CH2_PIN 35   // GPIO35 = ADC1_CH7

#define ADC_SAMPLE_RATE 100
#define ADC_TIMER_INTERVAL_US (1000000 / ADC_SAMPLE_RATE)
#define ADC_BUFFER_SIZE 512

// Circular buffer structure for each ADC channel
typedef struct {
  uint8_t  pin;
  uint16_t buffer[ADC_BUFFER_SIZE];
  volatile uint16_t writeIdx;
  volatile uint16_t readIdx;
  volatile uint16_t count;
} AdcChannel;

AdcChannel adc1 = {ADC_CH1_PIN, {}, 0, 0, 0};
AdcChannel adc2 = {ADC_CH2_PIN, {}, 0, 0, 0};

hw_timer_t* adcTimer = nullptr;
volatile bool adcSampleReady = false;
volatile bool adcEnabled = false;

portMUX_TYPE timerMux = portMUX_INITIALIZER_UNLOCKED;

// Timer ISR - triggers ADC sampling
void IRAM_ATTR onAdcTimer() {
  adcSampleReady = true;
}

// Push sample to circular buffer
inline void pushSample(AdcChannel* ch, uint16_t val) {
  ch->buffer[ch->writeIdx] = val;
  ch->writeIdx = (ch->writeIdx + 1) % ADC_BUFFER_SIZE;
  if (ch->count < ADC_BUFFER_SIZE) {
    ch->count++;
  } else {
    // Buffer full: advance readIdx (circular overwrite)
    ch->readIdx = (ch->readIdx + 1) % ADC_BUFFER_SIZE;
  }
}

// Pop sample from circular buffer
inline bool popSample(AdcChannel* ch, uint16_t* out) {
  if (ch->count == 0) return false;
  *out = ch->buffer[ch->readIdx];
  ch->readIdx = (ch->readIdx + 1) % ADC_BUFFER_SIZE;
  ch->count--;
  return true;
}

void initAdcTimer() {
  analogReadResolution(12);       // 12 bits → 0..4095
  analogSetAttenuation(ADC_11db); // range 0..3.3V

  // Timer 3 to avoid collision with DAC timers (0 and 2)
  adcTimer = timerBegin(3, 80, true);  // 80 MHz / 80 = 1 MHz
  timerAttachInterrupt(adcTimer, &onAdcTimer, true);
  timerAlarmWrite(adcTimer, ADC_TIMER_INTERVAL_US, true);
  timerAlarmEnable(adcTimer);
}

void setup() {
  Serial.begin(115200);
  delay(1000);

  initAdcTimer();

  // WiFi setup (configure your credentials)
  WiFi.begin("your_ssid", "your_password");
  while (WiFi.status() != WL_CONNECTED) {
    delay(500);
    Serial.print(".");
  }
  Serial.println("\nWiFi connected");
  Serial.println(WiFi.localIP());
}

void loop() {
  // ADC sampling triggered by timer ISR
  if (adcSampleReady) {
    adcSampleReady = false;

    if (adcEnabled) {
      // Read ADC values (safe to do outside ISR)
      uint16_t v1 = analogRead(ADC_CH1_PIN);
      uint16_t v2 = analogRead(ADC_CH2_PIN);

      pushSample(&adc1, v1);
      pushSample(&adc2, v2);
    }
  }

  // Send buffered samples to client
  // (WiFi client handling code omitted for brevity)
}

analogReadResolution(12);  // 12-bit ADC: values 0-4095

analogSetAttenuation(ADC_11db);  // 0-3.3V input range

// Convert ADC reading to voltage
float voltage = (adcValue / 4095.0) * 3.3;  // 0-3.3V

// For AC signals centered at 1.65V
float acVoltage = voltage - 1.65;  // -1.65V to +1.65V

// Simple calibration example
float calibratedVoltage = (rawADC * gain) + offset;