ESP32 (EP.9) ESP32 กับการใช้เป็น native USB device (HID)

ESP32 S3 (รุ่น S3 นะครับ ไม่ใช่ ESP32 ธรรมดา) มีความสามารถพิเศษอย่างหนึ่งก็คือตัวมันจะมี native USB hardware ใน chip  ก็คือเมื่อเสียบเข้า USB port ของ PC/Notebook  ESP32 S3 สามารถทำตัวเป็นอุปกรณ์ input แบบ USB โดยเป็นได้ทั้ง mouse / keyboard และอื่น ๆ ตามแต่เราจะเขียน code ประยุกต์มันให้เป็นอุปกรณ์ USB

ใน project สาธิตของกระทู้นี้ก็จะเสนอแนวทางการประยุกต์ใช้งานให้ทำงานเป็น USB keyboard และ mouse โดยรับ input ใด ๆ เข้ามาทางขา GPIO และส่งสัญญาณไปที่ PC เหมือนกับเรากดคีย์บอร์ดของคอมพิวเตอร์  ใน project นี้ผมจะสาธิตในรูปแบบของเกมสนุกอันนึงใน google chrome ก็คือเกมไดโน

ท่านที่ใช้ Google Chrome พิมพ์แบบนี้ที่ address bar ได้เลย
chrome://dino

เกมไดโนนี้เวลาเล่นจะต้องกดปุ่มลูกศรขึ้น (ARROW_UP) เพื่อให้ไดโนเสาร์กระโดดข้ามต้นกระบองเพชร โดยผมจะใช้ตัว LDR รับค่าของความสว่างในจอภาพ PC เพื่อนำไปเป็นสัญญาณกระตุ้นที่ขา GPIO ให้ ESP32 S3 สังสัญญาณเสมือนกับกดปุ่ม ARROW_UP เพื่อให้ตัวไดโนเสาร์กระโดดหลบต้นกระบองเพชรครับ

อุปกรณ์ที่ใช้มีเพียงเท่านี้


ขอเริ่มที่ตัว sensor ก่อน ใน project นี้จะใช้ sensor แสงพื้นฐานก็คือตัว LDR รับค่าความสว่างบนจอ PC  ก็คือในเกมนี้จะเป็นพื้นหลังสีดำอยู่แล้วและเมื่อมีสิ่งกีดขวางข้างหน้าไดโนเสาร์เลื่อนมา (ต้นกระบองเพชร) มันจะเป็นสีออกเทา-ขาวซึ่งก็หมายความว่าความสว่างจะเปลี่ยน  LDR ก็จะรับค่านี้ได้และไปสั่งงานให้ ESP32 S3 ส่งสัญญาณผ่าน USB ไปที่คอมพิวเตอร์เหมือนกับการปุ่มลูกศรขึ้น (ARROW_UP) เพื่อให้ไดโนเสาร์กระโดดครับ

ในการใช้งาน LDR เชื่อมต่อกับ ESP32 S3 จะต้องสร้างวงจรเองก็คือใช้ LM393 เป็นตัว comparator  ที่ต้องทำแบบนี้เพื่อจะได้มีสัญญาณ trigger ที่คมมากพอ …. จริง ๆ แล้วสามารถใช้ LDR ต่อกับตัวความต้านทานก็ได้ป้อนเข้า GPIO ก็ได้แต่ค่าแรงดันในการเปลี่ยนจาก logic 0 ไปเป็น logic 1 มันจะไม่ค่อยคมซึ่งมีผลต่อ delay time เป็นอย่างมากทำให้ส่งสัญญาณให้ไดโนเสาร์กระโดดพลาดได้ ดังนั้นจึงต้องใช้ comparator มาช่วยครับวงจรตามภาพล่างนี้

ในการติดตั้งตัว LDR ก็จ่อเข้ากับจอภาพง่าย ๆ อย่างนี้เลย

ผลลัพท์ออกมาแบบนี้


นอกจากนี้แล้วด้วยความที่ ESP32 S3 มันเป็นอุปกรณ์ native USB ดังนั้นจึงสั่งให้ประยุกต์ใช้งานให้สามารถ “พิมพ์” ข้อความไปที่โปรแกรมใด ๆ ก็ได้ใน windows อย่างในคลิปบนนี้เลื่อนไปวินาทีที่ 45 ก็คือพิมพ์ข้อความภาษาอังกฤษ  ซึ่งใน code สามารถเขียน delay time ได้ว่าจะให้พิมพ์ช้าหรือเร็วเท่าไหร่  แต่การประยุกต์ใช้งานลักษณะการพิมพ์เองแบบนี้ผมก็ยังนึกไม่ค่อยออกเท่าไหร่ครับ  ดังนั้นการประยุกต์ใช้งานแบบ sensor ร่วมกับเกมไดโนเสาร์กระโดดแบบข้างบนจะมีประโยชน์มากกว่า

ในการที่จะส่งสัญญาณผ่าน USB กับทำได้ทั้ง Keyboard / Mouse  ซึ่งใน library สามารถสั่งงานได้อย่างง่าย ๆ ว่าให้เลื่อน mouse cursor อย่างไร …. จากในคลิปบน (ที่เวลา 1:02) จะเห็นว่าสามารถวาดเป็นวงกลมได้ซึ่งถ้าเราทำด้วยมือไม่มีทางทำได้กลม perfect แบบนี้แต่ใน code ทำได้ครับ

ก็หวังว่าท่านที่สนใจคงจะได้ไอเดียไปประยุกต์ใช้งานเพื่อให้เป็นเสมือนอุปกรณ์ USB สำหรับคอมพิวเตอร์ได้นะครับ

ESP32 (EP.8) ESP32 ควบคุมอุปกรณ์ไฟฟ้าในห้อง

วันนี้จะขอเสนอเรื่องการใช้งานประยุกต์ใช้ ESP32 กับรีโมทคอนโทรลในการควบคุมอุปกรณ์ไฟฟ้าในห้อง

การใช้งาน ESP32 ในการควบคุมอุปกรณ์ไฟฟ้าต่าง ๆ ในห้องจะมีความสะดวกมาก  เนื่องจาก ESP32 มีขา GPIO จำนวนมาก (สูงสุดถึงประมาณ 15 ขาในการใช้งานแบบ digital ON/OFF)  และรีโมท 1 อันก็จะมีทั้งแป้นตัวเลขและปุ่มอื่นจำนวนมากเช่นกัน  นั่นก็หมายความว่าเราสามารถควบคุมอุปกรณ์ได้นับสิบอย่างที่มีในห้องโดยที่เรานั่งอยู่กับโต๊ะหรือนอนอยู่บนเตียงก็ได้ครับ

project นี้ค่อนข้างจะง่ายมาก …. ขั้นตอนจะมี 2 อย่างเท่านั้น

ขั้นแรกก็คือเราจะต้องหา code ที่ตัวรีโมทคอนโทรลส่งสัญญาณ Infrared ออกมาก่อน  ซึ่งสัญญาณ infrared ที่รีโมทส่งออกมาจะเป็น pulse train แบบภาพนี้

ซึ่งก็แน่นอนว่าทุกปุ่มของรีโมทคอนโทรลจะมี code ต่างกัน  ลักษณะของ code นี้เมื่อรับโดย ESP32 มันจะแปลง pulse train ที่ซับซ้อนออกมาเป็นชุด data ในรูปแบบ HEX (Hexadecimal numbers) จะต้องทำงานร่วมกับ library ครับ …. ซึ่ง library ใหม่สุดที่แนะนำก็คือ “IRremote” library (พัฒนาโดย shirriff / z3t0 / ArminJo)  ตัวล่าสุดนี้ทำงานได้ดีและให้ HEX data สั้นที่สุด  ดูได้จากคลิปด้านล่างนี้เลยครับ

จากคลิปนี้จะเห็นว่าเมื่อเรากดปุ่มตัวเลข 1 2 3 และอื่น ๆ มันจะให้ HEX data ที่สั้นมาก  เราก็เอา HEX data นี้ไปใส่ใน code ของ ESP32 เพื่อที่จะสั่งงาน GPIO ให้ ON / OFF ตามปุ่มของรีโมทที่เรากดได้

Code ทั้งหมด

#include <Arduino.h>
#include <IRremote.hpp>

// Hardware Pin Definitions
const int IR_RECEIVE_PIN = 15;
const int PIN_BTN1 = 21;
const int PIN_BTN2 = 38;
const int PIN_BTN3 = 39;
const int PIN_BTN4 = 47;
const int PIN_BUZZER = 4;

// Captured IR Raw Data Constants
const uint32_t IR_BTN_1 = 0x7308CF;
const uint32_t IR_BTN_2 = 0xB304CF;
const uint32_t IR_BTN_3 = 0x330CCF;
const uint32_t IR_BTN_4 = 0xD302CF;

// Variables to track output states
bool statePin21 = LOW;
bool statePin38 = LOW;
bool statePin39 = LOW;
bool statePin47 = LOW;

// Non-blocking Buzzer Timing Variables
bool buzzerActive = false;
unsigned long buzzerStartTime = 0;
const unsigned long BUZZER_DURATION = 200; // 0.5 second beep duration

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

  // Initialize GPIO outputs
  pinMode(PIN_BTN1, OUTPUT);
  pinMode(PIN_BTN2, OUTPUT);
  pinMode(PIN_BTN3, OUTPUT);
  pinMode(PIN_BTN4, OUTPUT);
  pinMode(PIN_BUZZER, OUTPUT);

  digitalWrite(PIN_BTN1, LOW);
  digitalWrite(PIN_BTN2, LOW);
  digitalWrite(PIN_BTN3, LOW);
  digitalWrite(PIN_BTN4, LOW);
  digitalWrite(PIN_BUZZER, LOW);

  // Initialize IR Receiver
  IrReceiver.begin(IR_RECEIVE_PIN, ENABLE_LED_FEEDBACK);
  Serial.println("ESP32-S3 IR Control System Ready.");
}

void loop() {
  // 1. Process Incoming IR Commands
  if (IrReceiver.decode()) {
    // Ignore repeat hold signals to prevent accidental fast toggling
    if (!(IrReceiver.decodedIRData.flags & IRDATA_FLAGS_IS_REPEAT)) {
      uint32_t rawData = IrReceiver.decodedIRData.decodedRawData;

      // Trigger Buzzer for 0.5 sec upon receiving any IR command
      digitalWrite(PIN_BUZZER, HIGH);
      buzzerActive = true;
      buzzerStartTime = millis();

      switch (rawData) {
        case IR_BTN_1:
          statePin21 = !statePin21;
          digitalWrite(PIN_BTN1, statePin21);
          Serial.print("Button 1 pressed -> GPIO 21 state: ");
          Serial.println(statePin21 ? "ON" : "OFF");
          break;

        case IR_BTN_2:
          statePin38 = !statePin38;
          digitalWrite(PIN_BTN2, statePin38);
          Serial.print("Button 2 pressed -> GPIO 38 state: ");
          Serial.println(statePin38 ? "ON" : "OFF");
          break;

        case IR_BTN_3:
          statePin39 = !statePin39;
          digitalWrite(PIN_BTN3, statePin39);
          Serial.print("Button 3 pressed -> GPIO 39 state: ");
          Serial.println(statePin39 ? "ON" : "OFF");
          break;

        case IR_BTN_4:
          statePin47 = !statePin47;
          digitalWrite(PIN_BTN4, statePin47);
          Serial.print("Button 4 pressed -> GPIO 47 state: ");
          Serial.println(statePin47 ? "ON" : "OFF");
          break;

        default:
          // Unmapped IR codes
          break;
      }
    }

    IrReceiver.resume(); // Enable receiving the next signal
  }

  // 2. Non-blocking Buzzer Timer (turns OFF active buzzer after 500ms)
  if (buzzerActive && (millis() - buzzerStartTime >= BUZZER_DURATION)) {
    digitalWrite(PIN_BUZZER, LOW);
    buzzerActive = false;
  }
}

อุปกรณ์ที่ใช้มีเพียงเท่านี้  

LED 4 ดวงในภาพต่ออยู่กับ GPIO ของ ESP32 …. ซึ่งในการประยุกต์ใช้งานจริงเราจะต้องต่อวงจรจาก GPIO ต่าง ๆ เพื่อไปควบคุมอุปกรณ์ซึ่งใช้ไฟ 220 โวลต์  วิธีการต่อที่ง่ายที่สุดก็คือใช้ครับรายละเอียดตามภาพด้านล่าง

ในการหา HEX data ของแต่ละปุ่มในการกดรีโมท  อุปกรณ์ที่ใช้มีเพียงเท่านี้

Code ทั้งหมด

#include <Arduino.h>
#include <IRremote.hpp>

// Define the GPIO pin where your IR receiver module (e.g., VS1838B) OUT pin is connected
const int IR_RECEIVE_PIN = 15; 

void setup() {
  // Initialize Serial communication at 115200 baud
  Serial.begin(115200);
  while (!Serial) delay(10); // Wait for Serial to open

  Serial.println("\n--- ESP32 IR Code Scanner ---");
  Serial.println("Point your remote at the receiver and press any button...\n");

  // Start the IR receiver
  // ENABLE_LED_FEEDBACK blinks the ESP32's built-in LED whenever an IR signal is detected
  IrReceiver.begin(IR_RECEIVE_PIN, ENABLE_LED_FEEDBACK);
}

void loop() {
  // Check if an IR signal has been received and decoded
  if (IrReceiver.decode()) {
    
    // Ignore repeat signals (when you hold down a button)
    if (!(IrReceiver.decodedIRData.flags & IRDATA_FLAGS_IS_REPEAT)) {
      
      Serial.print("Protocol: ");
      Serial.print(getProtocolString(IrReceiver.decodedIRData.protocol));
      
      // Print the 8-bit Command in HEX format (Most common for button mapping)
      Serial.print(" | Command (HEX): 0x");
      if (IrReceiver.decodedIRData.command < 0x10) Serial.print("0"); // Leading zero formatting
      Serial.print(IrReceiver.decodedIRData.command, HEX);

      // Print the full Raw Data/Address frame in HEX format for reference
      Serial.print(" | Raw Data: 0x");
      Serial.println(IrReceiver.decodedIRData.decodedRawData, HEX);
    } 
    else {
      Serial.println("[Button Held Down - Repeat Signal]");
    }

    // Prepare the receiver to accept the next IR signal
    IrReceiver.resume(); 
  }
}

ให้ท่านเปลี่ยน HEX data ตามของรีโมทท่าน

ESP32 (EP.7) ESP32 ทำเป็น RC meter

การใช้ ESP32 ทำเป็น RC meter …. ขอเริ่มที่การวัดค่าความต้านทานก่อน  

พื้นฐานที่ง่ายที่สุดและได้ผลดีมากพอสมควรก็คือการต่อตัวความต้านทานเป็นวงจรแบ่งแรงดัน (Voltage divider)  วงจรแบ่งแรงดันนั้นรายละเอียดของวงจรและสมการที่ใช้เป็นไปตามภาพด้านล่างนี้  

สมการที่ใช้จะไม่ยากเลยเนื่องจากมันก็เป็นกฎของโอห์มธรรมดานี่เองครับ  การประยุกต์ใช้วงจรแบ่งแรงดันเพื่อทำให้วัดค่าความต้านทานได้ก็คือ  ต่อ Vout ของวงจรแบ่งแรงดันกับ GPIO เพื่อวัดค่าแรงดัน  โดยมีแรงดัน Vin นำมาจากไฟ 3.3 โวลต์ของ ESP32 เอง  และ Vout ก็ต่อตรงกับ GPIO ของ ESP32 ใน ADC mode

  ในสมการล่างนี้  ตัวความต้านทานที่เราต้องการจะวัดค่าก็คือตัว R1 ….. ส่วนตัว R2 จะใช้ R ค่าคงที่  ซึ่งจากค่าแรงดัน input อ้างอิง 3.3 โวลต์ค่าของ R2 ที่เหมาะสมก็คือ 22kΩ …. ดังนั้นการหาสมการสุดท้ายที่จะใส่ใน code เราก็จะต้องย้ายข้างสมการ โดยในสมการให้แทนค่าแรงดัน Vin = 3.3 โวลต์และค่าเท่ากับ 22kΩ  สุดท้ายแล้วจะได้สมการที่จะนำไปใส่ใน code ตามภาพด้านล่างนี้


ส่วนการวัดค่า Capacitor วิธีที่ง่ายที่สุดก็คือจะต้องต่อวงจรเพิ่มโดยใช้ IC 555 timer ครับ
จะขออธิบายถึงวงจรสำหรับ IC 555 timer ตัวนี้ก่อน (ภาพล่าง) การต่อ IC 555 ในลักษณะนี้จะเรียกว่า Astable multivibrator  สูตรเพื่อหาความถี่จะมาจากค่าความสัมพันธ์ระหว่างอุปกรณ์ 3 ตัวก็คือ R1 , R2 และ C  ซึ่งสูตรก็ง่ายมากรายละเอียดตามภาพล่าง

concept การทำงานก็คือ  เมื่อเราจิ้ม capacito rที่ต้องการวัดลงไป  ตัว IC 555 ก็จะกำเนิดความถี่ป้อนเข้า GPIO (digital mode) ของ ESP32 และวัดความถี่ + แปลงไปเป็นค่า Capacitor ที่เราจะวัด  ในการ code ให้วัดค่า capacitor วิธีการที่ดีที่สุดก็คือใช้คุณสมบัติอันแม่นยำอย่างหนึ่งของ MCPWM โดยมันจะวัดคาบเวลาระหว่างของขาขึ้น (Rising edge) ของคลื่นความถี่ที่กำเนิดจาก IC 555 เข้ามาและคำนวณออกมาเป็นค่าของ capacitor เป็นไปตามสมการด้านล่างนี้


อุปกรณ์ทั้งหมดมีเพียงเท่านี้
จากภาพนี้ ในวงจรส่วนบนก็คือวงจรกำเนิดความถี่ของ IC 555 และสังเกตในจอภาพก็จะแสดงค่า Resistor , Capacitor

ในภาพล่างนี้ เอา capacitor ขนานกัน 2 ตัว (100 µF + 10 µF) ก็จะอ่านได้ค่า capacitance ที่ถูกต้องก็คือ 111.5 µF …. และใช้สาย jumper จิ้มวัด R 5.6kΩ ในจอภาพก็แสดงค่า 5.59 kΩ

Code ทั้งหมด

#include <Arduino.h>
#include <SPI.h>
#include <Wire.h>
#include <Adafruit_GFX.h>
#include <Adafruit_SH110X.h>
#include "driver/mcpwm_cap.h"

// Hardware Pin Definitions
#define CAP_INPUT_PIN   11   // Capacitance input (MCPWM)
#define RES_ANALOG_PIN  1    // Resistance input (ADC1_CH0 / GPIO 1)
#define I2C_SDA         40   // Shared OLED SDA
#define I2C_SCL         42   // Shared OLED SCL
#define SCREEN_ADDRESS  0x3C

// OLED Display Setup
#define SCREEN_WIDTH 128
#define SCREEN_HEIGHT 64
Adafruit_SH1106G display(SCREEN_WIDTH, SCREEN_HEIGHT, &Wire, -1);

// --- Capacitance Meter Constants & Variables ---
const double TIMER_CONSTANT = 1.44 / 3000.0; // 555 Timer Astable Mode (R1=1000, R2=1000)
const uint32_t APB_CLOCK = 80000000;         // 80 MHz MCPWM clock source

volatile uint32_t last_capture_ticks = 0;
volatile uint32_t current_prescaler = 1;
volatile bool new_data_available = false;
volatile uint32_t last_interrupt_time = 0;

mcpwm_cap_channel_handle_t cap_chan = NULL;
mcpwm_cap_timer_handle_t cap_timer = NULL;

// Global variables to store latest measurements
double global_frequency = 0.0;
bool cap_connected = false;

// --- Resistance Meter Constants & Variables ---
unsigned long last_resistor_measure = 0;
const unsigned long resistor_interval = 500; // Measure resistance every 500ms
float global_resistance = -1.0;              // -1.0 indicates "OPEN" or disconnected

// Forward Declarations
String formatWithDigits(long value);
void set_capture_prescaler(uint32_t prescale_val);

// --- Capacitance MCPWM ISR Callback ---
static bool IRAM_ATTR on_capture_callback(mcpwm_cap_channel_handle_t cap_chan, const mcpwm_capture_event_data_t *edata, void *user_data) {
    static uint32_t last_trigger_count = 0;
    static uint32_t pulse_counter = 0;
   
    uint32_t current_count = edata->cap_value;
    pulse_counter++;
   
    if (pulse_counter >= current_prescaler) {
        last_capture_ticks = current_count - last_trigger_count;
        last_trigger_count = current_count;
        pulse_counter = 0;
        
        last_interrupt_time = millis();
        new_data_available = true;
    }
    return false;
}

void set_capture_prescaler(uint32_t prescale_val) {
    current_prescaler = prescale_val;
}

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

    // 1. Initialize shared I2C bus for the OLED display
    Wire.begin(I2C_SDA, I2C_SCL);
    if(!display.begin(SCREEN_ADDRESS, true)) {
        Serial.println(F("SH1106 allocation failed"));
        for(;;);
    }
   
    display.clearDisplay();
    display.setTextColor(SH110X_WHITE);
    display.setTextSize(1);
    display.setCursor(0, 0);
    display.println("Initializing Combo...");
    display.display();

    // 2. Configure Resistance ADC Input
    analogReadResolution(12); // 0-4095
    analogSetPinAttenuation(RES_ANALOG_PIN, ADC_11db); // ~0V to 3.1V - 3.3V

    // 3. Initialize Capacitance MCPWM Capture Timer
    mcpwm_capture_timer_config_t timer_config = {};
    timer_config.group_id = 0;
    timer_config.clk_src = MCPWM_CAPTURE_CLK_SRC_DEFAULT;
    ESP_ERROR_CHECK(mcpwm_new_capture_timer(&timer_config, &cap_timer));

    // 4. Initialize Capacitance MCPWM Capture Channel
    mcpwm_capture_channel_config_t cap_chan_config = {};
    cap_chan_config.gpio_num = CAP_INPUT_PIN;
    cap_chan_config.prescale = 1;
    cap_chan_config.flags.neg_edge = 0;
    cap_chan_config.flags.pos_edge = 1;
    cap_chan_config.flags.pull_up = 0;
    cap_chan_config.flags.pull_down = 0;
    ESP_ERROR_CHECK(mcpwm_new_capture_channel(cap_timer, &cap_chan_config, &cap_chan));

    // 5. Register Capacitance ISR Callback
    mcpwm_capture_event_callbacks_t cbs = {};
    cbs.on_cap = on_capture_callback;
    ESP_ERROR_CHECK(mcpwm_capture_channel_register_event_callbacks(cap_chan, &cbs, NULL));

    // 6. Enable and Start Capacitance Hardware Peripherals
    ESP_ERROR_CHECK(mcpwm_capture_channel_enable(cap_chan));
    ESP_ERROR_CHECK(mcpwm_capture_timer_enable(cap_timer));
    ESP_ERROR_CHECK(mcpwm_capture_timer_start(cap_timer));

    last_interrupt_time = millis();
}

void loop() {
    unsigned long currentMillis = millis();

    // ==========================================
    // 1. RESISTANCE MEASUREMENT LOGIC (Every 500ms)
    // ==========================================
    if (currentMillis - last_resistor_measure >= resistor_interval) {
        last_resistor_measure = currentMillis;
        
        int rawADC = analogRead(RES_ANALOG_PIN);
        if (rawADC <= 10) {
            global_resistance = -1.0; // Mark as OPEN circuit
        } else {
            float vGpio1 = (rawADC * 3.3f) / 4095.0f;
            float resistance = (73480.0f / vGpio1) - 22000.0f;
            if (resistance < 0.0f) resistance = 0.0f;
            global_resistance = resistance;
        }
    }

    // ==========================================
    // 2. CAPACITANCE MEASUREMENT LOGIC (Asynchronous)
    // ==========================================
    // Check if pulse stream stopped (Timeout after 2.5 seconds)
    if (millis() - last_interrupt_time > 2500) {
        cap_connected = false;
        global_frequency = 0.0;
        set_capture_prescaler(1);
    }
    // New pulse batch caught by ISR
    else if (new_data_available) {
        new_data_available = false;

        noInterrupts();
        uint32_t ticks = last_capture_ticks;
        uint32_t active_prescaler = current_prescaler;
        interrupts();

        if (ticks > 0) {
            global_frequency = ((double)APB_CLOCK * (double)active_prescaler) / (double)ticks;
            
            if (global_frequency > 600000.0) {
                cap_connected = false;
            } else {
                cap_connected = true;
            }

            // Auto-Ranging Software Engine
            if (ticks < 250 && active_prescaler == 1) {
                set_capture_prescaler(16);
            } else if (ticks > 50000 && active_prescaler == 16) {
                set_capture_prescaler(1);
            }
        }
    }

    // ==========================================
    // 3. UNIFIED OLED DISPLAY UPDATE (Every 300ms)
    // ==========================================
    static uint32_t last_display_update = 0;
    if (millis() - last_display_update > 300) {
        last_display_update = millis();
        
        display.clearDisplay();
        display.setTextColor(SH110X_WHITE);

        // --- TOP HALF: RESISTANCE METER ---
        display.setTextSize(1);
        display.setCursor(0, 0);
        display.print("RESISTANCE:");
        
        display.setCursor(0, 10);
        display.setTextSize(2);
        if (global_resistance < 0.0f) {
            display.print("OPEN");
        } else if (global_resistance < 1000.0f) {
            display.print(formatWithDigits((long)global_resistance));
            display.print(" ");
            display.print(" Ohm"); // If you just want it to say "Ohm" cleanly
        } else {
            float kOhm = global_resistance / 1000.0f;
            display.print(kOhm, 2);
            display.print(" K");
            display.print("Ohm"); // If you just want it to say "Ohm" cleanly
        }

        // Dividers visually separates the two regions
        display.drawLine(0, 30, 128, 30, SH110X_WHITE);

        // --- BOTTOM HALF: CAPACITANCE METER ---
        display.setTextSize(1);
        display.setCursor(0, 34);
        display.print("CAPACITANCE:");
        
        if (!cap_connected) {
            display.setCursor(0, 46);
            display.setTextSize(2);
            display.print("OPEN");
        } else {
            double capacitance_F = TIMER_CONSTANT / global_frequency;
            double capacitance_uF = capacitance_F * 1000000.0;

            display.setCursor(0, 46);
            display.setTextSize(2);
            if (capacitance_uF < 0.1) {
                display.print(capacitance_uF, 4);
            } else if (capacitance_uF < 10.0) {
                display.print(capacitance_uF, 3);
            } else {
                display.print(capacitance_uF, 1);
            }
            display.setTextSize(1);
            display.print(" uF");
        }

        display.display();
    }
}

// Helper function to handle digit grouping (e.g., 22,000 instead of 22000)
String formatWithDigits(long value) {
    String valStr = String(value);
    String result = "";
    int len = valStr.length();
   
    for (int i = 0; i < len; i++) {
        if (i > 0 && (len - i) % 3 == 0) {
            result += ",";
        }
        result += valStr[i];
    }
    return result;
}