Project tutorial
Praduino Arduino-Based Multimeter

Praduino Arduino-Based Multimeter © GPL3+

The Praduino multimeter is based on Arduino Nano. This multimeter can work on normal power supply or with 3.7V LiPo battery.

  • 2,740 views
  • 16 comments
  • 13 respects

Components and supplies

Ard nano
Arduino Nano R3
×1
Pcbway qeheggiidg
PCBWay Custom PCB
this is the backbone of this project as i could order 10 multimeter pcbs for just 5$. to get free pcb excluding shipping charges go to the link below https://www.pcbway.com/setinvite.aspx?inviteid=113421praddy.
×1
Oled lcd 128x64 1
ElectroPeak 0.96" OLED 64x128 Display Module
×1
4415447 jg5sklyzsj
Resistor 220 ohm
×1
ADS1115
×1

Necessary tools and machines

09507 01
Soldering iron (generic)
3drag
3D Printer (generic)

Apps and online services

About this project

This is a portable digital arduino nano based PRADUINO MULTIMETER.

THE IDEA HAS BEEN GOT FROM ELECTRONOOBS. YOU CAN SEE ITS TUTORIAL FROM THE BELOW LINK :

I have used the idea to make a simple pcb.

The main feature of this multimeter is that it can indicate:

1)resistance

2)potential difference

3)inductance

4)capacitance

5)current

This multimeter can be operated with 3.7v lipo battery. this multimeter works with arduino nano and ADC module. other component list is menioned in item list.

I decided to make this project because it is arranged and easy to carry.

I have seen that engineers try to make multimeter but when wiring components the multimeter gets messed up hence in failure to the project.

hence I tried to make a cheap and arranged multimeter for use.

the working of the mutimeter is very simple:

1)when you have soldered all the components to pcb.

2)switch on the sliding button.

3)use male bullet connectors connencted to the type of reading you want to measure.

4)the value will be displayed in the oled display.

some of the images of the project are as follows:

that's all for this project if you like this project please respect in to motivate me for more special pcb boards.

order your first pcbs from the link given below excluding shipping charges,

use china post for cheap shipping method.

https://www.pcbway.com/setinvite.aspx?inviteid=113421

thanks to pcbway for their cooperation and support.

get the pcb from here:

https://www.pcbway.com/project/shareproject/PRADUINO_arduino_based_multimeter.html.

I recommend everyone to use pcbway new feature, the links are mentioned below kindly check it:

PCBWay online gerber view function:https://www.pcbway.com/project/OnlineGerberViewer.html

PCBWay gift shop:https://www.pcbway.com/project/gifts.html

ALL THE LINKS MENTIONED ABOVE ARE IMPORTANT SO KINDLY USE AND TRY THEM.

COMMENT BELOW FOR MOTIVATING US FOR MORE PROJECTS.

Code

arduino nano codeArduino
just upload it to arduino nano
#include <Adafruit_GFX.h>             
#include <Adafruit_SSD1306.h>         
#define OLED_RESET 10
Adafruit_SSD1306 display(OLED_RESET);
#include <Adafruit_ADS1015.h>        
Adafruit_ADS1115 ads(0x48);


//inputs/outputs PUT THE PINS AS IN THE SCHEMATIC
int res_2k = 6;
int res_20k = 7;
int res_470k = 8;
#define cap_in_analogPin     0          
#define chargePin           13        
#define dischargePin        11
int pulse_induct_out = 5;
int oscillate_in = 9;
const int OUT_PIN = A1;
//const int IN_PIN = A0;
int top_but = 2;
int mid_but = 3;
int bot_but = 4;


//Modes variables
int mode = 0;
int res_scale = 0;
int cap_scale = 0;
bool mid_but_state = true;
bool top_but_state = true;


//Variables for voltage mode
float Voltage = 0.0;
float resistance_voltage = 0.0;
float battery_voltage = 0.0;
float measured_resistance = 0.0;


//Variables for resistance mode
float Res_2k_value = 1998;         //2K resistor          //CHANGE THIS VALUES. MEASURE YOUT 2k, 20k and 470K and put the real values here
float Res_20k_value = 1.962;      //20K resistor
float Res_470k_value = 0.4655;    //470K resistor


//Variables for big capacitance mode
#define resistorValue  9900.0F  //Remember, we've used a 10K resistor to charge the capacitor MEASURE YOUR VALUE!!!
unsigned long startTime;
unsigned long elapsedTime;
float microFarads;                
float nanoFarads;
const float IN_STRAY_CAP_TO_GND = 47.48;
const float IN_CAP_TO_GND  = IN_STRAY_CAP_TO_GND;
const float R_PULLUP = 34.8;  
const int MAX_ADC_VALUE = 1023;


//Variables for inductance mode
//D5 is the input to the circuit (connects to 150ohm resistor), 11 is the comparator/op-amp output.
double pulse, frequency, capacit, inductance;
float C_cap_value = 1E6;                    //The capacitor value used for the LC tank. See schematic. For me that is 2uF

//Variables for current mode with the ACS712 of 5A range
float Current_sensor_Resolution = 0.185;



void setup(void)
{  
  pinMode(top_but,INPUT_PULLUP);
  pinMode(mid_but,INPUT_PULLUP);
  pinMode(bot_but,INPUT_PULLUP);
  pinMode(res_2k,OUTPUT);
  pinMode(res_20k,INPUT);
  pinMode(res_470k,INPUT);
  pinMode(OUT_PIN, OUTPUT);
  pinMode(cap_in_analogPin, OUTPUT); 
  pinMode(pulse_induct_out,OUTPUT);
  pinMode(oscillate_in,INPUT);
  
  digitalWrite(res_2k,LOW);

  pinMode(chargePin, OUTPUT);     
  digitalWrite(chargePin, LOW); 
  
  display.begin(SSD1306_SWITCHCAPVCC, 0x3C);  // initialize with the I2C addr 0x3C (for the 128x32)
  delay(100);  
  display.clearDisplay();

  
  display.setTextSize(1);
  display.setTextColor(WHITE); 
  display.setCursor(25,0);
  display.print("ELECTRONOOBS");  
  display.setCursor(30,20);    
  display.print("MULTIMETER"); 
 

    
  display.display();
  delay(1000);
  Serial.begin(9600);
  ads.begin();
}

void loop(void)
{

   
      
  if(!digitalRead(mid_but) && mid_but_state)
  {
    mode = mode + 1;
    res_scale = 0;
    cap_scale = 0;
    mid_but_state = false;
    if(mode > 4)
    {
      mode=0;
    }
    delay(100);
  }

  if(digitalRead(mid_but) && !mid_but_state)
  {
    mid_but_state = true;
  }


  if(!digitalRead(top_but) && top_but_state)
  {
    res_scale = res_scale + 1;
    cap_scale = cap_scale + 1;
    top_but_state = false;
    if(res_scale > 2)
    {
      res_scale=0;
    }
    if(cap_scale > 1)
    {
      cap_scale=0;
    }
     startTime = micros();           //Reset the counters      
     elapsedTime= micros() - startTime;
    delay(100);
  }

  if(digitalRead(top_but) && !top_but_state)
  {
    top_but_state = true;
  }

  


////////////////////////////VOLTAGE/////////////////////////////
  if(mode == 0)
  {
    int16_t adc0; // Leemos el ADC, con 16 bits 
    adc0 = ads.readADC_SingleEnded(0);
    Voltage = (adc0 * 0.1875)/1000;    
    Voltage = (Voltage / 0.245108); //R1 = 6.674    R2 = 2,167
    if(Voltage > 0.3)
    {
      Voltage = Voltage +  0.27; //We sum 0.27? (voltage drop on the diode only if voltage is applied)
    }
    int16_t adc2; // Leemos el ADC, con 16 bits   
    adc2 = ads.readADC_SingleEnded(2);
    battery_voltage = ((adc2 * 0.1875)/1000);
      
    display.clearDisplay();
    display.setTextSize(2);
    display.setTextColor(WHITE); 
    display.setCursor(0,0);
    display.print("Volts"); 
    display.setTextSize(1);
    display.setTextColor(BLACK,WHITE); 
    display.setCursor(95,0);    
    display.print(battery_voltage,1); 
    display.print("V");

    if(Voltage > 0)
    {    
      display.setTextSize(3);
      display.setTextColor(BLACK,WHITE); 
      display.setCursor(0,22);
      display.print(Voltage,4);        
      display.display();
      delay(100);
    }
    else
    {    
      display.setTextSize(3);
      display.setTextColor(BLACK,WHITE); 
      display.setCursor(0,22);
      display.print("0.0000");         
      display.display();
      delay(100);
    }
  }






////////////////////////////RESISTANCE/////////////////////////////
  if(mode == 1)
  {
    if(res_scale == 0)
    {
      pinMode(res_2k,OUTPUT);
      pinMode(res_20k,INPUT);
      pinMode(res_470k,INPUT);     
      digitalWrite(res_2k,LOW);
  
      int16_t adc1; // Leemos el ADC, con 16 bits   
      adc1 = ads.readADC_SingleEnded(1);
      resistance_voltage = (adc1 * 0.1875)/1000;
      int16_t adc2; // Leemos el ADC, con 16 bits   
      adc2 = ads.readADC_SingleEnded(2);
      battery_voltage = ((adc2 * 0.1875)/1000);
      measured_resistance = (Res_2k_value - 149) * (  (battery_voltage/resistance_voltage)-1  );
      if(measured_resistance < 4000)
      {
        display.clearDisplay();
        display.setTextSize(2);
        display.setTextColor(WHITE); 
        display.setCursor(0,0);
        display.print("Ohms");
        display.setTextSize(1);
        display.setTextColor(BLACK,WHITE); 
        display.setCursor(95,0);    
        display.print(battery_voltage,1); 
        display.print("V");
        
        display.setTextSize(3);
        display.setTextColor(BLACK,WHITE); 
        display.setCursor(0,22);
        display.print(measured_resistance,5);  
        display.display();
        delay(100);        
      }
      else
      {
        display.clearDisplay();
        display.setTextSize(2);
        display.setTextColor(WHITE); 
        display.setCursor(0,0);
        display.print("Ohms");
        display.setTextSize(1);
        display.setTextColor(BLACK,WHITE); 
        display.setCursor(95,0);    
        display.print(battery_voltage,1); 
        display.print("V");
        
        display.setTextSize(3);
        display.setTextColor(BLACK,WHITE); 
        display.setCursor(0,22);
        display.print(">4000");  
        display.display();          
        delay(100);
      }
    }
    if(res_scale == 1)
    {
      pinMode(res_2k,INPUT);
      pinMode(res_20k,OUTPUT);
      pinMode(res_470k,INPUT);     
      digitalWrite(res_20k,LOW);
      int16_t adc1; // Leemos el ADC, con 16 bits   
      adc1 = ads.readADC_SingleEnded(1);
      resistance_voltage = (adc1 * 0.1875)/1000;
      int16_t adc2; // Leemos el ADC, con 16 bits   
      adc2 = ads.readADC_SingleEnded(2);
      battery_voltage = ((adc2 * 0.1875)/1000);      
      measured_resistance = (Res_20k_value - 0.149) * (  (battery_voltage/resistance_voltage)-1  );
      if(measured_resistance < 200)
      {
        display.clearDisplay();
        display.setTextSize(2);
        display.setTextColor(WHITE); 
        display.setCursor(0,0);
        display.print("Kohms");
        display.setTextSize(1);
        display.setTextColor(BLACK,WHITE); 
        display.setCursor(95,0);    
        display.print(battery_voltage,1); 
        display.print("V");
        
        display.setTextSize(3);
        display.setTextColor(BLACK,WHITE); 
        display.setCursor(0,22);
        display.print(measured_resistance,2);  
        display.display();          
        delay(100);        
      }
      else
      {
        display.clearDisplay();
        display.setTextSize(2);
        display.setTextColor(WHITE); 
        display.setCursor(0,0);
        display.print("Kohms");
        display.setTextSize(1);
        display.setTextColor(BLACK,WHITE); 
        display.setCursor(95,0);    
        display.print(battery_voltage,1); 
        display.print("V"); 
        
        display.setTextSize(3);
        display.setTextColor(BLACK,WHITE); 
        display.setCursor(0,22);
        display.print(">200K");  
        display.display();          
        delay(100);
      }
    }
    if(res_scale == 2)
    {
      pinMode(res_2k,INPUT);
      pinMode(res_20k,INPUT);
      pinMode(res_470k,OUTPUT);     
      digitalWrite(res_470k,LOW);
      int16_t adc1; // Leemos el ADC, con 16 bits   
      adc1 = ads.readADC_SingleEnded(1);
      resistance_voltage = (adc1 * 0.1875)/1000;
      int16_t adc2; // Leemos el ADC, con 16 bits   
      adc2 = ads.readADC_SingleEnded(2);
      battery_voltage = ((adc2 * 0.1875)/1000);
      measured_resistance = (Res_470k_value - 0.000149) * (  (battery_voltage/resistance_voltage)-1  );
      if(measured_resistance < 4 && measured_resistance > 0)
      {
        display.clearDisplay();
        display.setTextSize(2);
        display.setTextColor(WHITE); 
        display.setCursor(0,0);
        display.print("Mohms");
        display.setTextSize(1);
        display.setTextColor(BLACK,WHITE); 
        display.setCursor(95,0);    
        display.print(battery_voltage,1); 
        display.print("V"); 
        
        display.setTextSize(3);
        display.setTextColor(BLACK,WHITE); 
        display.setCursor(0,22);
        display.print(measured_resistance,2);  
        display.display();          
        delay(200);
      }
      else
      {
        display.clearDisplay();
        display.setTextSize(2);
        display.setTextColor(WHITE); 
        display.setCursor(0,0);
        display.print("Mohms"); 
        display.setTextSize(1);
        display.setTextColor(BLACK,WHITE); 
        display.setCursor(95,0);    
        display.print(battery_voltage,1); 
        display.print("V");
        
        display.setTextSize(3);
        display.setTextColor(BLACK,WHITE); 
        display.setCursor(0,22);
        display.print(">4M");  
        display.display();          
        delay(200);
      }
    }
  }//end of mode 1 = resistance mode


  if(mode == 2)
  {
    int16_t adc2; // Leemos el ADC, con 16 bits   
    adc2 = ads.readADC_SingleEnded(2);
    battery_voltage = ((adc2 * 0.1875)/1000);
    if(cap_scale == 0)    
    {   
      pinMode(cap_in_analogPin, INPUT);  
      pinMode(OUT_PIN,OUTPUT);
      digitalWrite(OUT_PIN, LOW); 
      pinMode(chargePin, OUTPUT);   
       
      digitalWrite(chargePin, HIGH);  //apply 5 Volts
      startTime = micros();           //Start the counter
      while(analogRead(cap_in_analogPin) < 648){       //While the value is lower than 648, just wait
      }
    
      elapsedTime= micros() - startTime;
      microFarads = ((float)elapsedTime / resistorValue) ; //calculate the capacitance value
  
  
      if (microFarads > 1)
      {
        display.clearDisplay();
        display.setTextSize(2);
        display.setTextColor(WHITE); 
        display.setCursor(0,0);
        display.print("uF");
        display.setTextSize(1);
        display.setTextColor(BLACK,WHITE); 
        display.setCursor(95,0);    
        display.print(battery_voltage,1); 
        display.print("V");
        
        display.setTextSize(3);
        display.setTextColor(BLACK,WHITE); 
        display.setCursor(0,22);
        display.print(microFarads);  
        display.display();          
        delay(100);   
      }
    
      else{
        nanoFarads = microFarads * 1000.0; 
        display.clearDisplay();
        display.setTextSize(2);
        display.setTextColor(WHITE); 
        display.setCursor(0,0);
        display.print("nF");
        display.setTextSize(1);
        display.setTextColor(BLACK,WHITE); 
        display.setCursor(95,0);    
        display.print(battery_voltage,1); 
        display.print("V"); 
        
        display.setTextSize(3);
        display.setTextColor(BLACK,WHITE); 
        display.setCursor(0,22);
        display.print(nanoFarads);  
        display.display();
        delay(100);
      }
  
      digitalWrite(chargePin, LOW);            
      pinMode(dischargePin, OUTPUT);            
      digitalWrite(dischargePin, LOW);     //discharging the capacitor     
      while(analogRead(cap_in_analogPin) > 0){         
      }//This while waits till the capaccitor is discharged
    
      pinMode(dischargePin, INPUT);      //this sets the pin to high impedance
      
              
      display.setTextSize(1);
      display.setTextColor(BLACK,WHITE); 
      display.setCursor(0,54);
      display.print("Discharging...");  
      display.display();       
    }



    if(cap_scale == 1)    
    {
      pinMode(chargePin, INPUT);     
      pinMode(dischargePin, INPUT);  
      pinMode(cap_in_analogPin, INPUT);
      digitalWrite(OUT_PIN, HIGH);
      int val = analogRead(cap_in_analogPin);
      digitalWrite(OUT_PIN, LOW);
  
      if (val < 1000)
      {
        pinMode(cap_in_analogPin, OUTPUT);  
        float capacitance = (float)val * IN_CAP_TO_GND / (float)(MAX_ADC_VALUE - val);
        display.clearDisplay();
        display.setTextSize(2);
        display.setTextColor(WHITE); 
        display.setCursor(0,0);
        display.print("pF");
        display.setTextSize(1);
        display.setTextColor(BLACK,WHITE); 
        display.setCursor(95,0);    
        display.print(battery_voltage,1); 
        display.print("V");
        
        display.setTextSize(3);
        display.setTextColor(BLACK,WHITE); 
        display.setCursor(0,22);
        display.print(capacitance);  
        display.display();
        delay(200);
      }
      
      else
      {
        pinMode(cap_in_analogPin, OUTPUT);
        delay(1);
        pinMode(OUT_PIN, INPUT_PULLUP);
        unsigned long u1 = micros();
        unsigned long t;
        int digVal;
  
        do
        {
          digVal = digitalRead(OUT_PIN);
          unsigned long u2 = micros();
          t = u2 > u1 ? u2 - u1 : u1 - u2;
        } 
        
        while ((digVal < 1) && (t < 400000L));
  
        pinMode(OUT_PIN, INPUT);  
        val = analogRead(OUT_PIN);
        digitalWrite(cap_in_analogPin, HIGH);
        int dischargeTime = (int)(t / 1000L) * 5;
        delay(dischargeTime);   
        pinMode(OUT_PIN, OUTPUT);  
        digitalWrite(OUT_PIN, LOW);
        digitalWrite(cap_in_analogPin, LOW);
  
        float capacitance = -(float)t / R_PULLUP / log(1.0 - (float)val / (float)MAX_ADC_VALUE);
  
               
        if (capacitance > 1000.0)
        {
          display.clearDisplay();
          display.setTextSize(2);
          display.setTextColor(WHITE); 
          display.setCursor(0,0);
          display.print("uF");
          display.setTextSize(1);
          display.setTextColor(BLACK,WHITE); 
          display.setCursor(95,0);    
          display.print(battery_voltage,1); 
          display.print("V"); 
          
          display.setTextSize(3);
          display.setTextColor(BLACK,WHITE); 
          display.setCursor(0,22);
          display.print(capacitance/1000);  
          display.display();
          delay(200);        
        }
          
        else
        {
          display.clearDisplay();
          display.setTextSize(2);
          display.setTextColor(WHITE); 
          display.setCursor(0,0);
          display.print("nF");
          display.setTextSize(1);
          display.setTextColor(BLACK,WHITE); 
          display.setCursor(95,0);    
          display.print(battery_voltage,1); 
          display.print("V"); 
          
          display.setTextSize(3);
          display.setTextColor(BLACK,WHITE); 
          display.setCursor(0,22);
          display.print(capacitance);  
          display.display();
          delay(200);
        }
    }
      //while (micros() % 1000 != 0);
    }
    
  }//end of mode 2  = capacitance




  if(mode == 3)
  {
    
    digitalWrite(pulse_induct_out, HIGH);
    delay(4);//give some time to charge inductor.
    digitalWrite(pulse_induct_out,LOW);
    delayMicroseconds(100); //make sure resonation is measured
    pulse = pulseIn(oscillate_in,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
      capacit = 16.E-7; // - insert value here
      
      int16_t adc2; // Leemos el ADC, con 16 bits   
      adc2 = ads.readADC_SingleEnded(2);
      battery_voltage = ((adc2 * 0.1875)/1000);
      
      frequency = C_cap_value/(2*pulse);
      inductance = 1./(capacit*frequency*frequency*4.*3.14159*3.14159);//one of my profs told me just do squares like this
      inductance *= C_cap_value; //note that this is the same as saying inductance = inductance*1E6

      display.clearDisplay();
      display.setTextSize(2);
      display.setTextColor(WHITE); 
      display.setCursor(0,0);
      display.print("uH");
      display.setTextSize(1);
      display.setTextColor(BLACK,WHITE); 
      display.setCursor(95,0);    
      display.print(battery_voltage,1); 
      display.print("V");    
          
      display.setTextSize(3);
      display.setTextColor(BLACK,WHITE); 
      display.setCursor(0,22);
      display.print(inductance);  
      display.display();
      delay(100);      
    }
    else
    {
      int16_t adc2; // Leemos el ADC, con 16 bits   
      adc2 = ads.readADC_SingleEnded(2);
      battery_voltage = ((adc2 * 0.1875)/1000);
      display.clearDisplay();
      display.setTextSize(2);
      display.setTextColor(WHITE); 
      display.setCursor(0,0);
      display.print("uH");
      display.setTextSize(1);
      display.setTextColor(BLACK,WHITE); 
      display.setCursor(95,0);    
      display.print(battery_voltage,1); 
      display.print("V");  
          
      display.setTextSize(3);
      display.setTextColor(BLACK,WHITE); 
      display.setCursor(0,22);
      display.print("NONE");  
      display.display();
      delay(100); 
    }
    
  }//end of mode 3 = inductance
  








   //Current mode
   if(mode == 4)
   {  
      int16_t adc3;                                 // Create the ADC of 16 bits
      adc3 = ads.readADC_SingleEnded(3);            //The Current is connected on teh ADC 3
      float SensorVoltage = ((adc3 * 0.1875)/1000); //Pass from digital to voltage values  
      float I = (SensorVoltage-2.5)/Current_sensor_Resolution;       //Get current value using the formula
      
      display.clearDisplay();
      display.setTextSize(2);
      display.setTextColor(WHITE); 
      display.setCursor(0,0);
      display.print("Amps");
      display.setTextSize(1);
      display.setTextColor(BLACK,WHITE); 
      display.setCursor(95,0);    
      display.print(battery_voltage,1); 
      display.print("V");  
          
      display.setTextSize(3);
      display.setTextColor(BLACK,WHITE); 
      display.setCursor(0,22);
      display.print(I,3);  
      display.display();
      delay(100);  
    
   }//end of mode 4 = current


  


  
}

Comments

Similar projects you might like

Arduino-Based Bitcoin Candy Vending Machine

Project tutorial by Team Elkrem

  • 4,965 views
  • 19 comments
  • 45 respects

Arduino Data Glasses for My Multimeter

Project tutorial by Alain Mauer

  • 12,320 views
  • 12 comments
  • 118 respects

Arduino-Based Shower Cabin FM Radio

Project tutorial by Saulius Bandzevičius

  • 8,047 views
  • 2 comments
  • 31 respects

Walabot and Mobile App Controlled 3D-Printed Cars

Project tutorial by Jonathan Mendenhall

  • 6,620 views
  • 2 comments
  • 49 respects

Arduino-Based Universal AC Motor Speed Controller

Project tutorial by Saulius Bandzevičius

  • 1,391 views
  • 11 comments
  • 11 respects

Smart Soft Switch

Project tutorial by Vishwas Navada

  • 443 views
  • 0 comments
  • 3 respects
Add projectSign up / Login