Kit to replace the EMM801 Tube – $TBD

I’ve been working on producing this kit for a couple of years now, and I’m finally nearing completion. After a lot of second-guessing whether this was actually a good idea and going through many, many board revisions, I’m now in the final testing phase.

At this point, I’ve stared at it for so many hours that I have no idea if I missed anything so am having a couple of people do test build to give me feedback.

Scroll down to the bottom if you would like to download the White Sheet, Assembly Manual and current Code.

White Sheet

EMM801 Tube Replacement Board V2.2TH

EMM801 magic eye tubes have become increasingly rare and expensive. Almost no NOS stock remains, and equivalents were never reproduced. As a result, many Dynaco FM3 owners are left tuning their beloved radios by ear, without a visual reference. Since I enjoy spending an inordinate amount of time and effort solving problems nobody ever asked to be solved, I made my own.

Schematic:

EMM801 V2.2TH SchematicDownload

Components In the full Kit

Operation

1. Introduction

The EMM801 Replacement Board is a voltage measurement and display system built around an ATmega328P microcontroller. It features an OLED display that mimics the visual style of the original EMM801 magic eye tube by showing voltage readings from two input channels as bar indicators.

Two high-impedance voltage dividers scale the input signals for safe processing by the ATmega328P. Since the FM3 outputs negative voltages, an LM324 operational amplifier is used in the analog front end to condition the signals appropriately. The visual output is further refined using an adjustable alpha smoothing factor, which produces a smooth and natural display response.

This document details the board’s functionality, including its hardware schematic and the Arduino-based firmware.

2. Hardware Description

2.1 Microcontroller (U1 – ATmega328P-PU)

The ATmega328P serves as the central processing unit of the system, handling voltage sampling, signal processing, and display output. It interfaces with various peripheral components including:

  • OLED Display (U3): Connected via I2C (SDA and SCK)
  • Operational Amplifier (U2 – LM324): Used for voltage scaling and buffering
  • Button Input (SW1): Adjusts the alpha smoothing factor for voltage bar movement
  • FTDI Basic (H2): Provides alterative power and programming capabilities
  • ICSP Header (H1): Used for flashing the microcontroller firmware
  • Voltage Divider (R1, R2, etc.): Scales the voltage inputs to acceptable levels before ADC sampling
  • Reset Jumper (JP2): Resets the ATmega328P
  • Function Jumpers (JP3, JP4): Sets the additional display modes.

2.2 Power Supply

When in the FM3 the board is powered by the 6.3V AC on PIN 4 and PIN5 through a bridge rectifier to a 7805 voltage regulator (U4), which provides a stable 5V DC supply. The power section also includes:

  • D9 (1N5819): A Schottky diode providing a low-impedance discharge path, preventing the capacitor from discharging into the regulator’s output.
  • C5, C6, C7, C8: Capacitors for power stability and filtering

Alternatively, for testing and programming, the unit can be powered externally through an FT232RL FTDI by placing a jumper on ACC – JP1. However, ensure this jumper is removed before the EMM801 board is installed in an FM3.

2.3 Voltage Measurement Circuit

The two input voltage channels (PIN 7 and PIN 9) are connected to voltage divider networks consisting of 5MΩ and 100KΩ resistors with 0.1% tolerances. These divider networks scale the 0V to -20V grid signals to 0V to -400mV for the ADC inputs (ADC1 and ADC2) of the ATmega328P. The reference voltage on the ATmega328P is internally set to 1.1V in the code. The comparison voltage input to ADC0 is adjusted via R5, a 10KΩ potentiometer, to the midpoint of AREF at 550mV, allowing a measurement range of -28V to 28V with a resolution of 55mV.

It’s completely unnecessary, but you could achieve greater accuracy by using precisely matched resistors in the voltage dividers and entering their measured values into the code. Additionally, you could measure the actual voltage on AREF to two or three decimal places and use that value in the code. This won’t affect the main bar display function much since it’s 3.2 pixels per -1V, but sometimes we can do things just to be pedantic.

The unit is connected to a circuit with high voltages present, so both input channels are protected from overvoltage using bi-directional diode clamps. These consist of two 1N4148 and two 1N5819 diodes. These arrays clamp the input if the voltage exceeds ±800mV across R5, thereby protecting the ATmega328P inputs.

2.4 OLED Display (U3)

A 1.3″ SH1106 based OLED module is used to display graphical bars, real-time voltage readings, and user-adjustable indicators. The SH1106 is a single-chip CMOS driver and controller designed for organic/polymer light-emitting diode (OLED/PLED) dot-matrix graphic displays. The screen measures 1.3” diagonally with a resolution of 128 × 62 pixels. Unlike TFT screens, OLEDs emit their own light, eliminating the need for a backlight. Communication with the display is handled via I2C, using the address 0x3C.

3. Firmware Description

The firmware is written in C++ and is based on the Arduino framework. It processes the ADC readings, signal smoothing and drives the OLED display.

3.1 Initialization

The setup() function:

  • Configures analog reference voltage (AREF) to 1.1V
  • Initializes I2C communication with the OLED
  • Checks jumper configurations to determine the display mode:
  • PD5 LOW, PD6 LOW → Draws voltage bars
  • PD5 HIGH, PD6 LOW → Draws a cross on the display
  • PD6 HIGH, PD5 LOW → Displays numerical voltage values

3.2 ADC Sampling and Voltage Calculation

The system continuously samples voltage values from A0, A1, and A2 with oversampling (100 readings per cycle) for noise reduction. The formula used for voltage conversion is:

defined as:

where:

  • AREF = 1.1V
  • R_LOW = 100KΩ
  • R_HIGH = 5MΩ
  • ADC_RESOLUTION = 1023

3.3 Alpha Smoothing Implementation

The voltage readings are smoothed using an exponential moving average with an adjustable alpha factor (0.1𝜶 – 0.5𝜶). The smoothing formula is:

The alpha factor can be adjusted by pressing SW1 on PD7, cycling through from 0.1𝜶 to 0.5𝜶. When the alpha factor is changed the current value is displayed for 0.5 seconds as a full height rectangle at the center of the screen where the rectangle width is the alpha value * 250 so 0.1𝜶 = 25 pixels wide etc.

The change of the alpha value adjusts how quickly the bars grow and shrink in relation to the input voltage, allowing the user to tune the smoothing effect. The code sets the default alpha value at 0.3𝜶. Try the range of settings with the button then enter your desired level in the code. I thought 0.3𝜶. looked similar the original EMM801 movement so used it as the default.

3.4 Display Functions

The system offers three display modes:

  1. Voltage Bars Display: PIN 7 and PIN 9 voltage levels are represented as 30-pixel tall bars starting at the edges and meeting in the middle of the screen growing at 3.2 pixels per -1V. This is the main display mode and is shown if PD5 and PD6 are LOW at startup.
  2. Crosshair Display: A 1-pixel thick cross is drawn on the screen if PD5 is HIGH at startup. This is used to check the positioning of the module when installed in the FM3. 
  3. Numerical Voltage Display: The raw voltage values of PIN 7 and PIN 9 are shown if PD6 is HIGH at startup. This mode is used for trouble shooting the voltages.

3.5 Main Loop Execution

The loop() function performs the following in each cycle:

  1. Samples voltage values from A0, A1, A2
  2. Applies smoothing to reduce noise
  3. Updates the display with the chosen mode
  4. Checks for user input to adjust smoothing settings

4. Conclusion

This board is designed as a drop-in replacement for the Dynaco FM3, replicating the EMM801’s dual display bars as accurately as possible using readily available components. The kit can be assembled as a simple EMM801 replacement using only the necessary components or can be built with all components to enable reprogramming and experimentation with different functions.

I tried to keep all components through-hole to be easy to solder but ran out of space and had to use an SMD button. Since it’s not a microscopic part it is easy to solder, I made an exception.

I would be interested to hear ideas on how the remaining channel of the LM324 could be utilized. Its functionality is somewhat limited, as measurements must be referenced to COM (Pin 3).

I’m not a professional coder, so if you spot any errors or have suggestions for improvements, I’d appreciate your feedback.

Assembly EMM801 Tube Replacement Board V2.2TH

This document covers the assembly of the kit, which includes all the components needed to replace
an EMM801 magic eye tube and enables full use of all modes and programming functionality.

Parts Check List:

Download Check listDownload

Tools Required:

  • Soldering Iron with a fine tip
  • Solder (60/40 preferable)
  • Flux cleaner or Isopropyl & Soft Brush
  • Wire cutters
  • Scissors
  • Flat File
  • Flat head screwdriver – small
  • Multimeter with pointy probes
  • Alligator Clip (optional)
  • Power Supply (9V Battery, FT232RL FTDI or 6.3V AC)

Assembly of PCB-1:

  1. Solder in 1N418 Diodes – D1, D2, D5, D6.

The line on the end of the diode should align with the line marked on the board. The diode’s cathode lead goes into the hole with the square pad

  1. Solder in 1N5819 Diodes – D3, D4, D7, D8, D9.

The line on the end of the diode should align with the line marked on the board. The diode’s cathode lead goes into the hole with the square pad

  1. Solder in 5M Resistors – R1, R3.
  1. Solder in 100K Resistors – R2, R4.
  1. Solder in 10K Resistors – R6, R7, R8, R9.
  1. Solder in Diode Bridge DF01M – D10.

Ensure the wiggly lines go towards the edge of the board and the + and – pins go to the left.

  1. Solder in 16 MHz Crystal – X1.

Orientation of the crystal does not matter just solder it in. I forgot to take a picture of this step. Just pretend the Dip Sockets are not there.

  1. Solder in DIP Sockets – U1-S, U2-S.

Note the orientation of the half-moon notches on the ends of the DIP sockets and the corresponding markings on the silkscreen. Start by soldering one pin at the end of the socket. Check there is no gap between the socket and the board. If a gap exists, reheat the soldered pin while gently pressing the socket down. Once properly seated, solder the remaining pins.

  1. Solder in Voltage Regulator L78L05 – U4.

Note that the flat side should face toward the edge of the board. Insert the leads into the holes and push down while gently rocking the component back and forth to get to the desired height. The top of the voltage regulator should not protrude excessively above the board. If it does not stick out any further than the picture below, you’re fine. When installed in the FM3, there is a nearby coil that the regulator could potentially contact if its too tall.  

  1. Solder in 100nF Capacitors – C1, C8.

These capacitors are non-polarized, so their orientation does not matter.

  1. Solder in 22pF Capacitors – C3, C4.

These capacitors are also non-polarized, so their orientation does not matter.

  1.  Solder in 10uF Capacitor – C2, .33uF Capacitor – C6, .1uF Capacitor – C7.

Note the orientation of the positive and negative leads. The long lead goes into the + hole with the square pad.

  1. Solder in 470uF Capacitor – C5.

Note the orientation of the positive and negative leads. The long lead goes into the + hole with the square pad.

  1. Solder in 10K Potentiometer – R5.

Note the orientation of the adjustment screw.

  1. Solder in the Jumper Pins VCC – JP1, RST – JP2, PD5 – JP3, PD6 – JP4 & Header Pins ICSP – H1, ICSP – H2.

These can be a bit tricky to align properly, as they are small and finicky. I use an alligator clip to hold them flush against the board, then solder a pin. After that, I check for any gaps and ensure the part is straight. If it’s slightly misaligned, I reheat the soldered pin and adjust the position before soldering the remaining pins. It also helps to place a jumper on the header to avoid burning your fingers during alignment.

  1. Solder on Button – SW1

I didn’t want to use an SMD button, but given the limited space, it was my only option. If you’d prefer not to attempt it yourself, let me know and I can solder it on before shipping the kit.

That said, it’s not too difficult as far as surface-mount soldering goes. Start by placing a small amount of solder on the tip of your iron and touch one of the pads on the board. Then, align the button over the pads and use the iron to press the leg down onto the pre-soldered pad. Once the first leg is secured, add a small amount of solder to your tip and solder the remaining legs one by one.

  1. Dip Chips ATMEGA328P-PU – U1 & LM324 – U2

 You can install U1 and U2 in their sockets now or wait until the rest of the assembly is complete. You may need to straighten the pins slightly to get them to fit properly into the sockets. To do this, place a stiff, flat object like a ruler across all the pins and gently press them against a hard, flat surface (such as a countertop). The goal is to ensure all the pins are aligned at the same angle for easy socket insertion.

At this point, take the time to trim all component leads as close to the board as possible. If any are longer than 2 mm, they may interfere with the mounting height of the OLED. Give the board a thorough cleaning with isopropyl alcohol and a soft brush to remove any residual flux.


Assembly of PCB-2, PCB-3, SP-1 and PINS

This assembly plugs into the tube socket and connects to PCB-1

  1. Place PCB-2 on a hard, flat surface with the numbers and pads facing down. Position Spacer SP-1 on top of PCB-2, ensuring that all the holes are properly aligned. Then place PCB-3 on top of the spacer with the “TOP” label facing down as seen below. Once all three layers are aligned, insert the bronze pins through the stacked assembly.
  1. Make sure everything is properly aligned, and that all pins pass through each layer and contact the surface. Touch your soldering iron tip to both the pin and the pad, then feed a small amount of solder onto the pad so it flows into the hole. Start with Pin 1 and Pin 5, then check that everything is still straight and properly aligned. If needed, reheat the solder joint and adjust the alignment. Once everything is square, proceed to solder the remaining pins using the same method.  
  1. Flip the unit over, apply light pressure, and solder the pins through the top holes. The tops of the pins should be flush with the surface of PCB-2. If they protrude or the solder forms excessive bulges, carefully trim or file them down until the surface is nearly flat.
  1. Use a flat file to round the tips of the pins and ensure they are all the same height. If any solder has built up on the pin shafts above the board level, file it off to ensure a smooth, reliable fit.
  1. If you have a 9-pin tube socket available, test the fit by gently inserting it onto the socket. It should require some pressure but should not need to be forced. If the fit is too tight or misaligned, use needle-nose pliers to carefully straighten any bent pins for a smooth insertion. Give the assembly a thorough cleaning with isopropyl alcohol and a soft brush to remove any residual flux.

Mating of PCB-1 and PCB-2,3 Assemblies

  1. Slot the PCB-2/3 assembly into the cutout at the end of PCB-1, making sure that Pad 9 on PCB-1 aligns with Pad 9 on the PCB-2/3 assembly. The tolerances are tight, so if the assembly doesn’t fit, lightly file the notches on PCB-2 until it seats properly. Solder Pad 4 and Pad 9 on each end to tack the assembly in place. Apply some solder to your tip, touch the pad, and drag the solder to the perpendicular pad to form a solid bridge. If the solder doesn’t form a proper connection, add a bit more and try again. Make sure the assembly is square to the board. Repeat the process on the opposite side to secure it fully.
  1.  Next, solder the 3 center pads. Avoid using excessive solder to prevent bridging between the neighbouring pads.

Once all pads are soldered, it’s a good idea to test for conductivity between the bronze pins and the pads on PCB-1. You only need to test pins 3, 4, 5, 7, and 9, as they are the only active connections.

Mounting of 1.3 OLED – U3 & 3D Printed Spacer – SP-2

The last component to be soldered to PCB-1 is the 1.3” SH1106 OLED U3 

  1. Take the 2mm foam SP-3 and cut four pieces approximately the same size as the rectangular outlines on the front of PCB-1. The shapes don’t need to be exact, just make sure they’re close enough to fit within the outlines without touching any pins. Remove the backing from each piece and stick them to the board in the indicated areas.
  1. Take the 1.3” OLED U3 and the 3D Printed Spacer SP-2 and clip them together. They should snap into place easily; if they don’t, lightly file the tops of the spacer’s posts to help them fit through the holes on the OLED. The OLED should sit level and flush on the spacer once properly attached.
  1. This step is very important, as it sets the clearance of the OLED to the FM3. Insert the four pins of the OLED assembly into PCB-1, allowing the spacer to rest on the foam pads. Then, place PCB-1 face down on the edge of something so the OLED assembly sits flat and the PCB-2/3 assembly hangs over the edge. Ensure the assembly is level and that the spacer is fully supported by all the foam pads. Once you are confident everything is properly aligned and level, solder the four OLED pins to PCB-1.

Setting the comparison voltage with 10K Trimmer Pot – R5

To ensure accurate operation, you must set the comparison voltage using the 10K trimmer potentiometer R5. This procedure requires the board to be powered on.

Powering the board on the bench

You have several options to power the board during setup:

  1. Via FTDI Programmer:
  • Place the jumper on ACC – JP1.
  • Connect an FTDI programmer to the FTDI – H2 header.
  1. Using a 9V Battery:
  • Connect the positive terminal to Pin 4.
  • Connect the negative terminal to Pin 5.
  1. Using 6.3V AC:
  • Connect one AC leg to Pin 4 and the other to Pin 5.

Setting the Voltage

  1. Verify Board Power:
  • Press the onboard button SW1. A rectangle should appear on the OLED screen, indicating the board is powered correctly.
  1. With the board powered on, place your multimeter probes on the test points at the top right on the back of PCB-1.
  2. Check TP2 Voltage:
  • Measure the voltage between TP2 and GND. It should read 1.1V.
  • If it does not, verify your power source and connections.
  1. Adjust TP1 Voltage:
  • Measure the voltage between TP1 and GND.
  • Use a small screwdriver to turn the adjustment screw on the 10K Trimmer Pot R5 until the multimeter reads 550 mV.

You’re all done

That’s it! You’re now ready for the satisfying peel of the protective film from the OLED. Remove any jumpers and install the board into your FM3. I recommend reading the included white sheet to familiarize yourself with the operation and available display modes.

Here is the White Sheet to download

EMM801-White-sheet-V2.2THDownload

Here is the Assembly Manual to download

EMM801-Full-Kit-Assembly-V2.2THDownload

Here is the code

// Filename: EMM801_V2.0TH.ino
// For EMM801 Board Version 2.2TH
// Author: Shane Aune
// Date: March 17, 2025

#include <Wire.h> // Library for I2C communication
#include <Adafruit_GFX.h> // Graphics library
#include <Adafruit_SH110X.h> // OLED display driver library

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

// Voltage Measurement Constants
#define R_LOW 100.0     // 100K Resistor, this value can be adjusted to match actual measurement to increase precision.      
#define R_HIGH 5000.0   // 5M  Resistor, this value can be adjusted to match actual measurement to increase precision.      
#define AREF 1.1	// Sets the internal voltage reference to 1.1V, Measure actual and adjust to increase precision. 
#define ADC_RESOLUTION 1023 // Defines the 10bit resolution of the DAC

// Input Pin Definitions
#define JUMPER_CROSS 5  // PD5 - Draw cross if HIGH
#define JUMPER_TEXT 6   // PD6 - Display V1 & V2 as text if HIGH
#define BUTTON_PIN 7    // PD7 - Button to adjust alpha smoothing value

// Global Variables for voltage measurement and smoothing
long half_Aref = 0;
long ch_1 = 0, ch_2 = 0;
float V1 = 0.0, V2 = 0.0;
float smoothV1 = 0.0, smoothV2 = 0.0;
float alpha = 0.3; // You can change this value to set the default alpha between 0.1 & 0.5
bool buttonPressed = false;
unsigned long lastDebounceTime = 0;
const unsigned long debounceDelay = 50;

// Function to draw an indicator when Alpha Value changes
void drawAlphaIndicator() {
    display.clearDisplay();
    int rectWidth = (int)(alpha * 250); // Sets the size of the rectangle shown when you change the alpha value
    display.fillRect((SCREEN_WIDTH - rectWidth) / 2, 0, rectWidth, SCREEN_HEIGHT, SH110X_WHITE);
    display.display();
    delay(500);
    display.clearDisplay();
}

// Function to check button press and adjust alpha
void checkButtonPress() {
    int buttonState = digitalRead(BUTTON_PIN);
    if (buttonState == HIGH && !buttonPressed && (millis() - lastDebounceTime > debounceDelay)) {
        buttonPressed = true;
        lastDebounceTime = millis();
        alpha += 0.1;
        if (alpha > 0.5) alpha = 0.1;
        if (alpha < 0.1) alpha = 0.1;
        drawAlphaIndicator();
    } else if (buttonState == LOW) {
        buttonPressed = false;
    }
}

// Function to draw voltage bars on OLED
void drawVoltageBars() {
    display.clearDisplay();
    int barWidthV1 = smoothV1 * -3.2; //pixels per volt use -3.2 for -20V to fill screen to center
    int barWidthV2 = smoothV2 * -3.2; //pixels per volt use -3.2 for -20V to fill screen to center
    display.fillRect(0, 0, barWidthV1, 30, SH110X_WHITE);
    display.fillRect(SCREEN_WIDTH - barWidthV1, 0, barWidthV1, 30, SH110X_WHITE);
    display.fillRect(0, 34, barWidthV2, 30, SH110X_WHITE);
    display.fillRect(SCREEN_WIDTH - barWidthV2, 34, barWidthV2, 30, SH110X_WHITE);
    display.display();
}

// Draws a cross on the screen when PD5 is high at startup
void drawCross() {
    display.clearDisplay();
    int centerX = SCREEN_WIDTH / 2;
    int centerY = SCREEN_HEIGHT / 2;
    for (int i = 0; i < SCREEN_WIDTH / 2; i++) {
        display.drawPixel(centerX + i, centerY, SH110X_WHITE);
        display.drawPixel(centerX - i, centerY, SH110X_WHITE);
    }
    for (int i = 0; i < SCREEN_HEIGHT / 2; i++) {
        display.drawPixel(centerX, centerY + i, SH110X_WHITE);
        display.drawPixel(centerX, centerY - i, SH110X_WHITE);
    }
    display.display();
}

// Displays the voltages present on Pin 9 and Pin 7 on the screen when PD6 is high at startup
void drawVoltageText() {
    while (1) {
        display.clearDisplay();
        display.setTextSize(1);
        display.setTextColor(SH110X_WHITE);
        display.setCursor(0, 6);
                display.print("Pin-9     Pin-7");
        
        display.setTextSize(2);
        display.setCursor(0, 20);
        display.print(V1, 1);
        display.setCursor(64, 20);
        display.print(V2, 1);
        
        display.setTextSize(1);
        display.setCursor(0, 40);
        display.print("Volts     Volts");
        
        display.display();
        
        // Update voltage readings dynamically
        half_Aref = 0;
        ch_1 = 0;
        ch_2 = 0;
        
        analogRead(A0);
        for (int i = 0; i < 100; i++) half_Aref += analogRead(A0);
        half_Aref /= 100;
        
        analogRead(A1);
        for (int i = 0; i < 100; i++) ch_1 += analogRead(A1);
        ch_1 = (ch_1 / 100) - half_Aref;
        V1 = ch_1 * ((R_LOW + R_HIGH) / R_LOW) * AREF / ADC_RESOLUTION;
        
        analogRead(A2);
        for (int i = 0; i < 100; i++) ch_2 += analogRead(A2);
        ch_2 = (ch_2 / 100) - half_Aref;
        V2 = ch_2 * ((R_LOW + R_HIGH) / R_LOW) * AREF / ADC_RESOLUTION;
        
        delay(500);
    }
}

// Setup function
void setup() {
    delay(500);
    #if defined(__AVR__) || defined(ARDUINO_ARCH_AVR)
        analogReference(INTERNAL);
    #endif
    delay(500);
    pinMode(JUMPER_CROSS, INPUT);
    pinMode(JUMPER_TEXT, INPUT);
    pinMode(BUTTON_PIN, INPUT);
    display.begin(0x3C, true); // This is the address of the display
    //display.display();       // Commented out to disable splash screen
    //delay(2000);             // Commented out to disable splash screen
    display.clearDisplay();
    
    if (digitalRead(JUMPER_CROSS) == HIGH && digitalRead(JUMPER_TEXT) == LOW) {
        while (1) {
        drawVoltageText();
    }
    }
    if (digitalRead(JUMPER_CROSS) == LOW && digitalRead(JUMPER_TEXT) == HIGH) {
        drawCross();
        while (1);
    }
}

// Main loop
void loop() {
    checkButtonPress();
    
    half_Aref = 0;
    ch_1 = 0;
    ch_2 = 0;
    
// Read and average 100 samples for better accuracy
    analogRead(A0);
    for (int i = 0; i < 100; i++) half_Aref += analogRead(A0);
    half_Aref /= 100;
    
    analogRead(A1);
    for (int i = 0; i < 100; i++) ch_1 += analogRead(A1);
    ch_1 = (ch_1 / 100) - half_Aref;
    V1 = ch_1 * ((R_LOW + R_HIGH) / R_LOW) * AREF / ADC_RESOLUTION;
    smoothV1 = (alpha * V1) + ((1 - alpha) * smoothV1);
    
    analogRead(A2);
    for (int i = 0; i < 100; i++) ch_2 += analogRead(A2);
    ch_2 = (ch_2 / 100) - half_Aref;
    V2 = ch_2 * ((R_LOW + R_HIGH) / R_LOW) * AREF / ADC_RESOLUTION;
    smoothV2 = (alpha * V2) + ((1 - alpha) * smoothV2);
    
    drawVoltageBars();
    checkButtonPress();
}

//Duh end ;-)