How to display a frequency counter on a 0.96 inch I2C OLED?
Hardware Setup and Wiring
The 0.96 inch 128x64 i2c oled display requires four connections: VCC (power), GND (ground), SDA (data line), and SCL (clock line). For most microcontrollers, the I2C pins are fixed. On an Arduino Uno, SDA is A4 and SCL is A5. On an ESP32, you can use GPIO21 for SDA and GPIO22 for SCL by default, but you can reassign them in software. The display module typically has pull-up resistors on the I2C lines, so you don’t need external ones for short cable runs (under 20 cm). The signal input for frequency counting should be connected to a digital pin that supports interrupts. On an Arduino Uno, pins 2 and 3 are interrupt-capable. On an ESP32, almost all GPIO pins can be used for interrupts, but GPIO2, GPIO4, GPIO5, GPIO12, GPIO13, GPIO14, GPIO15, GPIO16, GPIO17, GPIO18, GPIO19, GPIO21, GPIO22, GPIO23, GPIO25, GPIO26, GPIO27, GPIO32, GPIO33, GPIO34, GPIO35, GPIO36, GPIO39 are available. The input signal should be a clean square wave with a voltage level matching the microcontroller’s logic level (3.3V or 5V). If your signal is higher, use a voltage divider or a level shifter. For example, a 5V signal can be divided down to 3.3V using two resistors: 1k ohm from signal to pin, and 2k ohm from pin to ground. The maximum frequency you can measure depends on the microcontroller’s clock speed and the interrupt latency. For an Arduino Uno running at 16 MHz, you can reliably count up to about 4 MHz with a simple interrupt routine. For an ESP32 at 240 MHz, you can go up to 40 MHz with careful coding. The OLED display itself does not affect the frequency measurement, but the I2C communication overhead can introduce delays if you update the display too frequently. To avoid this, update the display only when the frequency value changes by more than 1% or at a fixed interval like every 100 milliseconds.
Frequency Measurement Techniques
There are three common methods to measure frequency with a microcontroller: pulse counting over a fixed gate time, period measurement, and frequency-to-voltage conversion. The pulse counting method is the most straightforward for digital signals. You set a timer to generate an interrupt every 1 second (or 0.1 second for faster updates), and during that interval, you count the number of rising edges on the input pin using an external interrupt. The frequency is then the count divided by the gate time. For example, if you count 10,000 pulses in 1 second, the frequency is 10,000 Hz (10 kHz). The accuracy depends on the gate time precision. Using a crystal oscillator-based timer (like the 16 MHz crystal on an Arduino) gives you a timing accuracy of about 50 ppm (parts per million), which translates to a frequency error of 0.005% for a 1-second gate. For higher frequencies, you can use a shorter gate time to get faster updates, but the resolution decreases. For instance, a 0.1-second gate gives a resolution of 10 Hz (since you can only count integer pulses). The period measurement method is better for low frequencies (below 1 kHz). You measure the time between two consecutive rising edges using a timer with microsecond resolution. The frequency is 1 divided by the period. For example, if the period is 1000 microseconds, the frequency is 1000 Hz. This method gives high resolution for low frequencies but becomes inaccurate for high frequencies because the period is too short to measure precisely. The third method, frequency-to-voltage conversion, uses an external circuit like an LM331 or a PLL (phase-locked loop) and then reads the voltage with an ADC. This is less common with microcontrollers because it adds components and calibration steps. For most practical applications, the pulse counting method is the best trade-off between accuracy, complexity, and update rate. Below is a comparison table of the three methods:
| Method | Best Frequency Range | Accuracy | Update Rate | Hardware Required |
|---|---|---|---|---|
| Pulse counting (gate time) | 1 Hz to 10 MHz | ±1 count per gate time | 0.1 to 1 second | Microcontroller only |
| Period measurement | 0.01 Hz to 1 kHz | ±1 timer tick | Per period (variable) | Microcontroller only |
| Frequency-to-voltage | 0.1 Hz to 100 kHz | ±1% typical | Continuous (analog) | External circuit + ADC |
For a 0.96 inch 128x64 i2c oled display, the pulse counting method is the most practical because you can display the frequency in a clear numeric format. The OLED has a 128x64 pixel resolution, which allows you to show up to 6 digits in a large font (like 16x32 pixels) or 10 digits in a smaller font (like 8x16 pixels). You can also add a unit label like "Hz" or "kHz" and a decimal point for readability. The display driver (SSD1306) supports both horizontal and vertical scrolling, but for a frequency counter, static text is usually sufficient. The I2C bus speed is typically 100 kHz (standard mode) or 400 kHz (fast mode). At 400 kHz, sending a full screen buffer (1024 bytes) takes about 20 milliseconds, but you only need to update the area where the frequency number is displayed, which reduces the transfer time to under 5 milliseconds. This is important because you don’t want the display update to block the interrupt routine that counts pulses. To avoid this, use a non-blocking I2C library like the Adafruit SSD1306 library with the Adafruit GFX library, which allows you to set a buffer and then send it in the main loop without waiting for the I2C transaction to complete. Alternatively, you can use the U8g2 library, which provides more font options and faster rendering for monochrome displays.
Code Implementation for Arduino and ESP32
Let’s walk through a complete code example for an Arduino Uno that counts frequency on pin 2 and displays it on the 0.96 inch 128x64 i2c oled display. First, you need to install the Adafruit SSD1306 and Adafruit GFX libraries via the Arduino Library Manager. The wiring is: OLED VCC to 5V, GND to GND, SDA to A4, SCL to A5. Signal input to pin 2. The code uses a volatile variable to store the pulse count, which is incremented in the interrupt service routine (ISR). The ISR should be as short as possible—just increment the counter. In the main loop, a timer (using the millis() function) checks if 1 second has passed. If yes, it calculates the frequency, resets the counter, and updates the display. Here is a simplified version of the code logic:
```cpp
#include
#include
#include
#define SCREEN_WIDTH 128
#define SCREEN_HEIGHT 64
#define OLED_RESET -1
Adafruit_SSD1306 display(SCREEN_WIDTH, SCREEN_HEIGHT, &Wire, OLED_RESET);
volatile unsigned long pulseCount = 0;
unsigned long lastTime = 0;
float frequency = 0.0;
const int gateTime = 1; // seconds
void countPulse() {
pulseCount++;
}
void setup() {
pinMode(2, INPUT_PULLUP);
attachInterrupt(digitalPinToInterrupt(2), countPulse, RISING);
if(!display.begin(SSD1306_SWITCHCAPVCC, 0x3C)) {
while(1);
}
display.clearDisplay();
display.setTextSize(2);
display.setTextColor(SSD1306_WHITE);
display.setCursor(0, 0);
display.println("Freq:");
display.display();
}
void loop() {
unsigned long currentTime = millis();
if (currentTime - lastTime >= gateTime * 1000) {
noInterrupts();
unsigned long count = pulseCount;
pulseCount = 0;
interrupts();
frequency = (float)count / gateTime;
lastTime = currentTime;
display.clearDisplay();
display.setCursor(0, 0);
display.print("Freq:");
display.setCursor(0, 32);
if (frequency >= 1000) {
display.print(frequency / 1000, 2);
display.print(" kHz");
} else {
display.print(frequency, 0);
display.print(" Hz");
}
display.display();
}
}
```
This code works for frequencies up to about 4 MHz on an Arduino Uno. For higher frequencies, you need to use an ESP32 because it has a faster clock and hardware counters. On an ESP32, you can use the pulse counter (PCNT) peripheral, which counts pulses in hardware without CPU intervention. This allows you to measure frequencies up to 40 MHz with high accuracy. The PCNT module has 8 independent counters, each with a 16-bit counter that can be configured to count rising or falling edges. You can set a threshold to generate an interrupt when the counter overflows, and then read the counter value in the main loop. The display connection for an ESP32 is the same, but you need to specify the I2C pins in the code. For example, using Wire.begin(21, 22) for SDA and SCL. The display update logic is similar, but you can use a higher update rate (like 10 Hz) because the ESP32 can handle the I2C communication faster. Here is a code snippet for ESP32 using the PCNT module:
```cpp
#include
#include
#include
#include "driver/pcnt.h"
#define SCREEN_WIDTH 128
#define SCREEN_HEIGHT 64
#define OLED_RESET -1
Adafruit_SSD1306 display(SCREEN_WIDTH, SCREEN_HEIGHT, &Wire, OLED_RESET);
#define PCNT_INPUT_PIN 4
#define PCNT_H_LIM 10000
pcnt_config_t pcnt_config = {
.pulse_gpio_num = PCNT_INPUT_PIN,
.ctrl_gpio_num = PCNT_PIN_NOT_USED,
.lctrl_mode = PCNT_MODE_KEEP,
.hctrl_mode = PCNT_MODE_KEEP,
.pos_mode = PCNT_COUNT_INC,
.neg_mode = PCNT_COUNT_DIS,
.counter_h_lim = PCNT_H_LIM,
.counter_l_lim = 0,
.unit = PCNT_UNIT_0,
.channel = PCNT_CHANNEL_0,
};
void setup() {
pcnt_unit_config(&pcnt_config);
pcnt_counter_pause(PCNT_UNIT_0);
pcnt_counter_clear(PCNT_UNIT_0);
pcnt_counter_resume(PCNT_UNIT_0);
if(!display.begin(SSD1306_SWITCHCAPVCC, 0x3C)) {
while(1);
}
display.clearDisplay();
display.setTextSize(2);
display.setTextColor(SSD1306_WHITE);
}
void loop() {
int16_t count = 0;
pcnt_get_counter_value(PCNT_UNIT_0, &count);
float frequency = (float)count * 100; // assuming 10 ms gate time
pcnt_counter_clear(PCNT_UNIT_0);
display.clearDisplay();
display.setCursor(0, 0);
display.print("Freq:");
display.setCursor(0, 32);
if (frequency >= 1000) {
display.print(frequency / 1000, 2);
display.print(" kHz");
} else {
display.print(frequency, 0);
display.print(" Hz");
}
display.display();
delay(10);
}
```
Note that the gate time in this ESP32 example is 10 milliseconds (set by the delay(10) in the loop), so the frequency is calculated as count * 100. This gives a resolution of 100 Hz for the displayed value. You can adjust the gate time by changing the delay value and the multiplier accordingly. For example, a 100 ms delay gives a resolution of 10 Hz, and a 1-second delay gives 1 Hz resolution. The PCNT module has a hardware limit of 16-bit (65535 counts), so for a 10 ms gate, the maximum frequency you can measure without overflow is 6.5535 MHz. If you need higher frequencies, you can use a longer gate time or configure the PCNT to generate an interrupt on overflow and extend the counter in software. The 0.96 inch 128x64 i2c oled display can handle the update rate of 100 Hz (10 ms) without flickering because the OLED’s response time is much faster than the LCD’s. However, the I2C bus speed limits the data transfer. At 400 kHz, sending a full screen buffer takes about 20 ms, so updating at 100 Hz would cause the display to be constantly busy. To avoid this, only update the text area (e.g., the frequency number) instead of the entire screen. You can do this by using the display.fillRect() and display.setCursor() methods to redraw only the digits that change. This reduces the I2C transfer to about 2-3 ms per update, which is well within the 10 ms interval.
Accuracy and Calibration Considerations
The accuracy of your frequency counter depends on three factors: the time base (gate time), the interrupt latency, and the signal conditioning. The time base is generated by the microcontroller’s internal timer, which is driven by a crystal oscillator. On an Arduino Uno, the 16 MHz crystal has a tolerance of about 50 ppm (parts per million), which means the actual frequency could be off by 0.005% from the nominal value. For a 1-second gate, this translates to a maximum error of 0.05 milliseconds, which is negligible for most applications. However, if you use the internal RC oscillator (like on some Arduino clones), the tolerance can be as high as 1% to 5%, which is unacceptable for precision measurements. For the ESP32, the crystal oscillator is typically 40 MHz with a tolerance of 10 ppm, giving even better accuracy. The interrupt latency is the time between the signal edge and the microcontroller’s response. On an Arduino, the interrupt latency is about 4 to 8 clock cycles (0.25 to 0.5 microseconds at 16 MHz). This latency is deterministic for a given interrupt priority, but if other interrupts are active, the latency can vary. To minimize this, disable other interrupts during the frequency measurement, or use a dedicated timer that captures the input signal directly (like the input capture unit