Using this board you could learn how to make each part of my Arduino based multimeter from previous episodes. You have a step for each block for measuring voltage, resistance, inductance, capacitance and current.
by: ELECTRONOOBS on 2026-06-30
Obviouslly, you could make a prototype on a homemade PCB if you want. But is better to use my PCB made to be very easy to assemble. So get the GERBER files and order the PCBs at PCBWAY.com. for example. Once you have the PCBs, all you need are the modules for the ADC, current and the display.
Transmitter
- Dev Board PCB: Download GEBRERs
- 1 x Arduino NANO: LINK Aliexpress
- 1 x OLED display 32x128: LINK Aliexpress
- 2 x ADS1115: LINK Aliexpress
- 1 x ACS712 5A module: LINK Aliexpress
- 1 x LM2903P OPAMP: LINK Aliexpress
- 1 x CD74HC4051E MUX: LINK Aliexpress
- 1 x G3VM-41DY1 SSR: LINK Aliexpress
- 2 x AQW210SZ SSR: LINK Aliexpress
- TH Resistors (120R - 470K): LINK Aliexpress
- Film Capacitors 1uF: LINK Aliexpress
- 2 x DIODE1N914: LINK Aliexpress
So, different from my previous multimeter circuit, this PCB has two external ADCs and you will see why. It still has the ACS712 current meter so we will also need a module like this one. To display values, we have an OLED screen with i2c communication.
Compared with the previous schematic, the different parts are the two blocks on the schematic with the SSRs and MUX. You see, for previous multimeters, to change modes, we were using a rotary switch which is very big or some sliding switches that have to move at the same time, and that’s not working that good. If you want to implement automatic mode switch, we need solid state relays, in this case the G3VM41D for current mode and the AQW210 for the rest of the modes. Since the Arduino doesn't have enough pins, to control each of these relays, we use this multiplexor, the 74HC4051. For the rest of the modes, we only need resistors, capacitors, a small operational amplifier and a full bridge rectifier. Ok, so let’s assemble everything and try some different modes.
Assembling the PCB is very easy. I've made it to use through hole components so it would be easier to solder. Only the SSRs are SMD but they are easy to solder as well. The rest are using modules and male-female pins so is easy to connect them. So get the PCB from PCBWAY.com. and solder all the DIP components and the female pins for the mdoules. Then just add the mdoules and we are ready to go. We can supply the PCB from the USB connectro with 5V for these tests. Check the next chapters for each example.
First example is the OLED control. Download the example code from below and upload it to the Arduino. Make sure you also download and install the library for the OLED screen. This code will teach you how to use the OLED screen and print text of different sizes and in different positions. So select the Arduino NANO board on the Arduino IDE, connect the Arduino to the USB cable and upload the code. As you can see, we can use the OLED screen. So check the code on electronoobs.com and learn how to use it.
#include <SPI.h>
#include <Wire.h>
#include <Adafruit_GFX.h> //Download: https://www.electronoobs.com/eng_arduino_Adafruit_GFX.php
#include <Adafruit_SSD1306.h> //Downlaod: https://www.electronoobs.com/eng_arduino_Adafruit_SSD1306.php
Adafruit_SSD1306 display(4); //Create screen variable
void setup() {
#if (SSD1306_LCDHEIGHT != 32)
#error("Height incorrect, please fix Adafruit_SSD1306.h!");
#endif
display.begin(SSD1306_SWITCHCAPVCC, 0x3C); //Start i2c communication
//display.setRotation(2); //Rotate screen 180 degree
display.clearDisplay(); //Clear the display data
display.display(); //Send data to the display
delay(10);
}
void loop() {
display.clearDisplay();
display.setTextSize(1); //Set text size to 1
display.setTextColor(WHITE); //White text over black screen
display.setCursor(0,0); //Start on pixel 0,0
display.println("ELECTRONOOBS"); //Print text
display.setTextColor(BLACK, WHITE); //Black text over white screen
display.println(3.141592); //Print text
display.setTextSize(2); //Set text size to 2
display.setTextColor(WHITE); //White text over black screen
display.print("0x");
display.println(0xDEADBEEF, HEX); //Print text
display.display(); //Send all data to the screen
delay(2000); //Small delay on each loop
//Now let's print a counter
for (int i=0; i<10; i++){
display.clearDisplay();
display.setTextSize(4);
display.setCursor(0,0);
display.println(i);
display.display();
delay(1000);
}
}
The next example is to read voltage. As you can see on the schematic above, the voltage block has two resistors of 0 ohms. Basically, if you short circuit those pads on the PCB, we jump over the rectifier and that’s because we first only measure DC voltage. This rectifier might introduce some voltage drop and we don’t want that for now. So I short circuit those pads with solder. As you can see, the connections for the voltage mode are controlled with the multiplexor so we need to activate the MUX 3 pin. In the code I set all MUX pins to low and the MUX3 to high using the multiplexor. This multiplexor is controlled with 3 pins from the Arduino, pins A3, D2 and D3.
So download the voltage read code from below. In this code, remember to add the OLED library from before but also the library for the ADS1115 external ADC, since we will use that to measure voltage with precision. Since we have two ADC modules, to have different i2c addresses, on the schematic, one module has the ADDR pin connected to ground and the other one the ADDR pin connected to VCC so one will have different i2c address. In this code we use the ADC functions and read the voltage between ADC0 and ADC1. Since the input has a voltage divider of 11, we multiply the voltage value by 11 and we get the real voltage. We have to set all the unused pins as inputs in order to have high impedance and not affect the rest of the circuit. Upload this code and we test it out. I connect the power supply at the input and apply 5V for example. Then, I try different values and as you can see in the video, the voltage value is the same as on the supply, so the voltage mode works. The ADS1115 is capable of measuring negative voltage as well so if we invert the probes, we can still measure the voltage and it will appear negative on the screen. Since the divider is of 11 and the ADC could take up to 5V, the maximum voltage we can measure is around 50V DC.
#include <SPI.h>
#include <Wire.h>
#include <Adafruit_GFX.h> //Download: https://www.electronoobs.com/eng_arduino_Adafruit_GFX.php
#include <Adafruit_SSD1306.h> //Download: https://www.electronoobs.com/eng_arduino_Adafruit_SSD1306.php
Adafruit_SSD1306 display(4); //Create screen variable
#include <Wire.h>
#include <Adafruit_ADS1015.h> //Download: https://electronoobs.com/eng_arduino_Adafruit_ADS1015.php
Adafruit_ADS1115 ads;
const float multiplier = 0.1875F; //From datasheet
//Define all the Input/output pins of the board
int D2 = 2; //MUX 1
int D3 = 3; //MUX 2
int D4 = 4; //Resistance 20K
int D5 = 5; //Resistance 470K
int D6 = 6; //Inductance pulse
int D7 = 7; //Voltage divider R
int D8 = 8; //Resistance 2K
int D9 = 9; //Inductance out
int D10 = 10; //Push button
int D11 = 11; //Capacitance 10K
int D12 = 12; //Voltage divider L
int D13 = 13; //Capacitance 220K
int a0 = A0; //Capacitance Read
int a1 = A1; //Resistance diode
int a2 = A2; //Capacitance RC
int a3 = A3; //MUX 0
int a6 = A6; //NC
int a7 = A7; //NC
void setup() {
//Define all pins as inputs but not the pins that we will use
pinMode(a0, INPUT);
pinMode(a1, INPUT);
pinMode(a2, INPUT);
//pinMode(a3, INPUT);
pinMode(a6, INPUT);
pinMode(a7, INPUT);
//pinMode(D2, INPUT);
//pinMode(D3, INPUT);
pinMode(D4, INPUT);
pinMode(D5, INPUT);
pinMode(D6, INPUT);
//pinMode(D7, INPUT);
pinMode(D8, INPUT);
pinMode(D9, INPUT);
pinMode(D10, INPUT);
pinMode(D11, INPUT);
//pinMode(D12, INPUT);
pinMode(D13, INPUT);
ads.begin(); //Start i2c communication with the first ADS1115
display.begin(SSD1306_SWITCHCAPVCC, 0x3C); //Start i2c communication
//display.setRotation(2); //Rotate screen 180 degree
display.clearDisplay(); //Clear the display data
display.display(); //Send data to the display
delay(10);
}
void loop() {
//MUX setup
pinMode(a3, OUTPUT); //S0 of mux
pinMode(D2, OUTPUT); //S1 of mux
pinMode(D3, OUTPUT); //S2 of mux
//We set "010" so we activate MUX3 for voltage mode (V)
digitalWrite(a3, LOW); //S0 to 0
digitalWrite(D2, HIGH); //S1 to 1
digitalWrite(D3, LOW); //S2 to 0
//Set pins D7 and D12 to simulate GND
pinMode(D7, OUTPUT);
pinMode(D12, OUTPUT);
digitalWrite(D7, LOW);
digitalWrite(D12, LOW);
//Read voltage
float adc; // Leemos el ADC, con 16 bits
adc = ads.readADC_Differential_0_1();
/*I've used a 1K and 10K divider
*So we multiply voltage by 11
*In my case 10.76 because the resistors are not perfect*/
float Voltage = 10.76 * (adc * 0.1875)/1000;
//Print voltage on the display
display.clearDisplay();
display.setTextSize(2);
display.setTextColor(WHITE);
display.setCursor(12,0);
display.print(" VOLTAGE");
display.setTextSize(2);
display.setTextColor(WHITE);
display.setCursor(0,18);
display.print(Voltage);
display.println(" V");
display.display();
delay(50);
}
The next example is for measuring resistance. For that we use the block with 3 resistors and a diode. So we need to activate the relay for the RC pin by setting MUX2 to high. Then, in the code we decide the range and according to that, we set to low one of these pins, D8, D4 or D5 in order to change the scale. At the same time we also read the battery voltage of the multimeter with a separate block on the scheamtic. That’s why we need two external ADCs, because only 4 inputs was not enough. We need to know the VCC voltage in order to calculate resistance. So in the code we use the ADC and measure the VCC voltage. Then the voltage over the resistance divider. Using ohm law, we get the resistance value. We print the value on the OLED display.
#include <SPI.h>
#include <Wire.h>
#include <Adafruit_GFX.h> //Download: https://www.electronoobs.com/eng_arduino_Adafruit_GFX.php
#include <Adafruit_SSD1306.h> //Downlaod: https://www.electronoobs.com/eng_arduino_Adafruit_SSD1306.php
Adafruit_SSD1306 display(4); //Create screen variable
#include <Wire.h>
#include <Adafruit_ADS1015.h> //Download: https://electronoobs.com/eng_arduino_Adafruit_ADS1015.php
Adafruit_ADS1115 ads(0x48);
Adafruit_ADS1115 ads2(0x49);
const float multiplier = 0.1875F; //From datasheet
//Define all the Input/output pins of the board
int D2 = 2; //MUX 1
int D3 = 3; //MUX 2
int D4 = 4; //Resistance 20K
int D5 = 5; //Resistance 470K
int D6 = 6; //Inductance pulse
int D7 = 7; //Voltage divider R
int D8 = 8; //Resistance 2K
int D9 = 9; //Inductance out
int D10 = 10; //Push button
int D11 = 11; //Capacitance 10K
int D12 = 12; //Voltage divider L
int D13 = 13; //Capacitance 220K
int a0 = A0; //Capacitance Read
int a1 = A1; //Resistance diode
int a2 = A2; //Capacitance RC
int a3 = A3; //MUX 0
int a6 = A6;
int a7 = A7;
//Resistance mode variables
float R2K = 1997;
float R20K = 19.89; //In K ohms
float R470K = 441; //in K ohms
int Res_Offset = 0;
bool conductivity = true;
float DividerVoltage = 0.0;
void setup() {
Serial.begin(9600);
//Define all pins as inputs but not the pins that we will use
pinMode(a0, INPUT);
//pinMode(a1, INPUT);
pinMode(a2, INPUT);
pinMode(a3, INPUT);
pinMode(a6, INPUT);
pinMode(a7, INPUT);
pinMode(D2, INPUT);
pinMode(D3, INPUT);
pinMode(D4, INPUT);
pinMode(D5, INPUT);
pinMode(D6, INPUT);
pinMode(D7, INPUT);
pinMode(D8, INPUT);
pinMode(D9, INPUT);
pinMode(D10, INPUT);
pinMode(D11, INPUT);
pinMode(D12, INPUT);
pinMode(D13, INPUT);
ads.begin(); //Start i2c communication with the first ADS1115
ads2.begin(); //Start i2c communication with the second ADS1115
display.begin(SSD1306_SWITCHCAPVCC, 0x3C); //Start i2c communication
//display.setRotation(2); //Rotate screen 180 degree
display.clearDisplay(); //Clear the display data
display.display(); //Send data to the display
delay(10);
}
void loop() {
//MUX setup
pinMode(a3, OUTPUT); //S0 of mux
pinMode(D2, OUTPUT); //S1 of mux
pinMode(D3, OUTPUT); //S2 of mux
//We set "001" so we activate MUX2 for Resistance mode (RC)
digitalWrite(a3, HIGH); //S0 to 1
digitalWrite(D2, LOW); //S1 to 0
digitalWrite(D3, LOW); //S2 to 0
pinMode(A1,OUTPUT);
digitalWrite(A1,HIGH);
pinMode(D4,INPUT);
pinMode(D5,INPUT);
pinMode(D8,OUTPUT);
digitalWrite(D8,LOW);
delay(10);
//We read the VCC voltage
float adc4;
adc4 = ads2.readADC_SingleEnded(0);
float VccVoltage = (adc4 * 0.1875)/1000;
VccVoltage = VccVoltage * 4.09;
Serial.println(VccVoltage);
float adc2;
float res;
adc2 = ads.readADC_SingleEnded(2);
DividerVoltage = (adc2 * 0.1875)/1000;
res = ((R2K*VccVoltage)/DividerVoltage) - R2K - Res_Offset;
if(res < 2000)
{
display.clearDisplay();
display.setTextSize(2);
display.setTextColor(WHITE);
display.setCursor(4,0);
display.print("RESISTANCE");
display.setTextSize(2);
display.setTextColor(WHITE);
display.setCursor(0,18);
display.print(res,0);
display.println(" Ohms");
display.display();
}
else if(res < 20000)
{
pinMode(D8,INPUT);
pinMode(D5,INPUT);
pinMode(D4,OUTPUT);
digitalWrite(D4,LOW);
delay(10);
adc2 = ads.readADC_SingleEnded(2);
DividerVoltage = (adc2 * 0.1875)/1000;
res = ((R20K*VccVoltage)/DividerVoltage) - R20K;
display.clearDisplay();
display.setTextSize(2);
display.setTextColor(WHITE);
display.setCursor(4,0);
display.print("RESISTANCE");
display.setTextSize(2);
display.setTextColor(WHITE);
display.setCursor(0,18);
display.print(res,2);
display.println(" K");
display.display();
}
else if(res > 20000)
{
pinMode(D8,INPUT);
pinMode(D4,INPUT);
pinMode(D5,OUTPUT);
digitalWrite(D5,LOW);
delay(10);
adc2 = ads.readADC_SingleEnded(2);
DividerVoltage = (adc2 * 0.1875)/1000;
res = ((R470K*DividerVoltage)/DividerVoltage) - R470K; //3.422V(AMS1117 3.3V) -0.616V (diode)
if(res < 2000)
{
display.clearDisplay();
display.setTextSize(2);
display.setTextColor(WHITE);
display.setCursor(4,0);
display.print("RESISTANCE");
display.setTextSize(2);
display.setTextColor(WHITE);
display.setCursor(0,18);
display.print(res,1);
display.println(" K");
display.display();
}
else
{
display.clearDisplay();
display.setTextSize(2);
display.setTextColor(WHITE);
display.setCursor(4,0);
display.print("RESISTANCE");
display.setTextSize(2);
display.setTextColor(WHITE);
display.setCursor(0,18);
display.println("NONE");
display.display();
}
}
delay(50);
}
The inductance mode was the one that faced problems for the previous PCB. You see, the inductance mode uses two capacitors of 1uF to create a resonating oscillation. One side of the capacitor is connected to the negative probe and the other side to the coil that we want to measure. The problem with the previous board without the relays, is that the same pin of the inductance mode was shared with the rest of the resistance and capacitance measurement. As you can see on the previous schematic, that pin was called RLC. But now, using the relays, we can separate the RC from the L. Otherwise, the capacitors would be connected to the other measuring blocks and would change their values and we couldn’t read correctly.
Anyway, for the code, we apply a pulse to the LC tank and create oscillations. We read the frequency of those oscillations with the pulse in function and using a simple formula and knowing that the capacitance is of 2uF, we can get the inductance value. We print that on the OLED display and test it out. I connect a 100uH inductor and once again, it works great and we can also measure inductance with this development board.
#include <SPI.h>
#include <Wire.h>
#include <Adafruit_GFX.h> //Download: https://www.electronoobs.com/eng_arduino_Adafruit_GFX.php
#include <Adafruit_SSD1306.h> //Downlaod: https://www.electronoobs.com/eng_arduino_Adafruit_SSD1306.php
Adafruit_SSD1306 display(4); //Create screen variable
#include <Wire.h>
#include <Adafruit_ADS1015.h> //Download: https://electronoobs.com/eng_arduino_Adafruit_ADS1015.php
Adafruit_ADS1115 ads(0x48);
Adafruit_ADS1115 ads2(0x49);
const float multiplier = 0.1875F; //From datasheet
//Define all the Input/output pins of the board
int D2 = 2; //MUX 1
int D3 = 3; //MUX 2
int D4 = 4; //Resistance 20K
int D5 = 5; //Resistance 470K
int D6 = 6; //Inductance pulse
int D7 = 7; //Voltage divider R
int D8 = 8; //Resistance 2K
int D9 = 9; //Inductance out
int D10 = 10; //Push button
int D11 = 11; //Capacitance 10K
int D12 = 12; //Voltage divider L
int D13 = 13; //Capacitance 220K
int a0 = A0; //Capacitance Read
int a1 = A1; //Resistance diode
int a2 = A2; //Capacitance RC
int a3 = A3; //MUX 0
int a6 = A6;
int a7 = A7;
//Inductance mode variables
double pulse, frequency, Induct_cap, inductance;
void setup() {
//Define all pins as inputs but not the pins that we will use
//pinMode(a0, INPUT);
pinMode(a1, INPUT);
pinMode(a2, INPUT);
pinMode(a3, INPUT);
pinMode(a6, INPUT);
pinMode(a7, INPUT);
//pinMode(D2, INPUT);
//pinMode(D3, INPUT);
pinMode(D4, INPUT);
pinMode(D5, INPUT);
//pinMode(D6, INPUT);
pinMode(D7, INPUT);
pinMode(D8, INPUT);
pinMode(D9, INPUT);
pinMode(D10, INPUT);
pinMode(D11, INPUT);
pinMode(D12, INPUT);
pinMode(D13, INPUT);
ads.begin(); //Start i2c communication with the first ADS1115
ads2.begin(); //Start i2c communication with the second ADS1115
display.begin(SSD1306_SWITCHCAPVCC, 0x3C); //Start i2c communication
//display.setRotation(2); //Rotate screen 180 degree
display.clearDisplay(); //Clear the display data
display.display(); //Send data to the display
delay(10);
}
void loop() {
display.clearDisplay();
display.setTextSize(2);
display.setTextColor(WHITE);
display.setCursor(4,0);
display.print("INDUCTANCE");
display.display();
//MUX setup
pinMode(a3, OUTPUT); //S0 of mux
pinMode(D2, OUTPUT); //S1 of mux
pinMode(D3, OUTPUT); //S2 of mux
//We set "011" so we activate MUX4 for Resistance mode (L)
digitalWrite(a3, HIGH); //S0 to 1
digitalWrite(D2, HIGH); //S1 to 1
digitalWrite(D3, LOW); //S2 to 0
pinMode(A0, OUTPUT);
digitalWrite(A0, LOW);
pinMode(D6, OUTPUT);
digitalWrite(D6, HIGH);
delay(4);//give some time to charge inductor.
digitalWrite(D6,LOW);
delayMicroseconds(100); //Make sure resonation is measured
pulse = pulseIn(D9,HIGH,5000); //returns 0 if timeout
if(pulse > 0.1) //if a timeout did not occur and it took a reading:
{
//#error insert your used capacitance value here. Currently using 2uF. Delete this line after that
Induct_cap = 2.E-6; // - insert value here (in my cse 2x1uF)
frequency = 1.E6/(2*pulse);
inductance = 1./(Induct_cap*frequency*frequency*4.*3.14159*3.14159); //one of my profs told me just do squares like this
inductance *= 1E6; //note that this is the same as saying inductance = inductance*1E6
display.clearDisplay();
display.setTextSize(2);
display.setTextColor(WHITE);
display.setCursor(4,0);
display.print("INDUCTANCE");
display.setTextSize(2);
display.setTextColor(WHITE);
display.setCursor(0,18);
display.print(inductance,2);
display.println(" uH");
display.display();
delay(100);
}
}//End of void lop
To measure capacitance is very easy. We use two resistors to charge and discharge the capacitor. In the code, we count the time it takes the capacitor to get to 63%. Then we calculate the capacitance value. You have more details about this 63% value on the tutorial on here. Run the code and test it out. Here is a 100nF capacitor. How here is one of just 1nF and finally a 47uF capacitor which takes a bit longer to charge and discharge. But it works.
Finally, the current measurement is very easy. We disable the two relays and we activate the other one. That model could handle more current for the current mode. Then, in the code, we measure the voltage from the ACS712 current meter. We apply the formula for the 5A model and we get the current value. Print that on the screen and test it out. I connect it to my power supply and start applying different current values. We have a small positive offset but now, all the main parts are working.
#include <SPI.h>
#include <Wire.h>
#include <Adafruit_GFX.h> //Download: https://www.electronoobs.com/eng_arduino_Adafruit_GFX.php
#include <Adafruit_SSD1306.h> //Downlaod: https://www.electronoobs.com/eng_arduino_Adafruit_SSD1306.php
Adafruit_SSD1306 display(4); //Create screen variable
#include <Wire.h>
#include <Adafruit_ADS1015.h> //Download: https://electronoobs.com/eng_arduino_Adafruit_ADS1015.php
Adafruit_ADS1115 ads(0x48);
Adafruit_ADS1115 ads2(0x49);
const float multiplier = 0.1875F; //From datasheet
//Define all the Input/output pins of the board
int D2 = 2; //MUX 1
int D3 = 3; //MUX 2
int D4 = 4; //Resistance 20K
int D5 = 5; //Resistance 470K
int D6 = 6; //Inductance pulse
int D7 = 7; //Voltage divider R
int D8 = 8; //Resistance 2K
int D9 = 9; //Inductance out
int D10 = 10; //Push button
int D11 = 11; //Capacitance 10K
int D12 = 12; //Voltage divider L
int D13 = 13; //Capacitance 220K
int a0 = A0; //Capacitance Read
int a1 = A1; //Resistance diode
int a2 = A2; //Capacitance RC
int a3 = A3; //MUX 0
int a6 = A6;
int a7 = A7;
//Current mode variables
float Sensibility = 0.185; //Given by the ACS712 datasheet
void setup() {
Serial.begin(9600);
//Define all pins as inputs but not the pins that we will use
pinMode(a0, INPUT);
pinMode(a1, INPUT);
pinMode(a2, INPUT);
pinMode(a3, INPUT);
pinMode(a6, INPUT);
pinMode(a7, INPUT);
pinMode(D2, INPUT);
pinMode(D3, INPUT);
pinMode(D4, INPUT);
pinMode(D5, INPUT);
pinMode(D6, INPUT);
pinMode(D7, INPUT);
pinMode(D8, INPUT);
pinMode(D9, INPUT);
pinMode(D10, INPUT);
pinMode(D11, INPUT);
pinMode(D12, INPUT);
pinMode(D13, INPUT);
ads.begin(); //Start i2c communication with the first ADS1115
ads2.begin(); //Start i2c communication with the second ADS1115
display.begin(SSD1306_SWITCHCAPVCC, 0x3C); //Start i2c communication
display.setRotation(2); //Rotate screen 180 degree
display.clearDisplay(); //Clear the display data
display.display(); //Send data to the display
delay(10);
}
void loop() {
//MUX setup
pinMode(a3, OUTPUT); //S0 of mux
pinMode(D2, OUTPUT); //S1 of mux
pinMode(D3, OUTPUT); //S2 of mux
//We set "000" so we activate MUX1 for Current mode (A)
digitalWrite(a3, LOW); //S0 to 1
digitalWrite(D2, LOW); //S1 to 0
digitalWrite(D3, LOW); //S2 to 0
int read_loop = 0;
float Sens_volt = 0;
while(read_loop < 100)
{
float adc3; // Leemos el ADC, con 16 bits
adc3 = ads.readADC_SingleEnded(3);
Sens_volt = Sens_volt + ( (adc3 * 0.1875)/1000 );
read_loop = read_loop + 1;
}
//We read the VCC voltage
float adc4;
adc4 = ads2.readADC_SingleEnded(0);
float VccVoltage = (adc4 * 0.1875)/1000;
VccVoltage = VccVoltage * 4.09;
Serial.println(VccVoltage);
float VccVoltageHalf = (VccVoltage/2.0)-0.0155;
Sens_volt = Sens_volt/100;
Serial.println(Sens_volt);
float I = 1000*((Sens_volt - VccVoltageHalf)/Sensibility); //Ecuación para obtener la corriente
Serial.print(I,3);
Serial.println(" mA");
display.clearDisplay();
display.setTextSize(2);
display.setTextColor(WHITE);
display.setCursor(10,0);
display.print(" CURRENT");
display.setTextSize(2);
display.setTextColor(WHITE);
display.setCursor(0,18);
display.print(I,0);
display.println(" mA");
display.display();
delay(50);
}
We could also measure frequency, diode mode, continuity, but that would be extra. Now I could make the final version of my two-hand multimeter and I think that would be an amazing project. A multimeter based on Arduino capable of measuring so many values. So guys, get the PCB files and order it at PCBWAY.com and start learning all these parts with help from my tutorials on this website. I hope this will help you understand more how Arduino works.
If my videos help you, consider supporting my work on my PATREON or a donation on my PayPal. Thanks again and see you later guys.
Comments
Leave a comment
Please login in order to comment.