Multimeter - Code
10/04/2021 | Views: 8149 | Arduino | by: ELECTRONOOBS      


Solder the HC05 module to the multimeter PCB. Go below and get the new version of the Multimeter code. Make sure you also check my old project of the multimeter. This new code will still print the values on the OLED display but also send the same data with Bluetooth connection. All we have to do is to get the receiver code and upload it to the smart glasses PCB and receive the data. So once you uplaod the multimeter code from below, go and see the receiver code.







/* Arduino multimeter V2 by ELECTRONOOBS (Voltage, resistance, capacitance, inductance adn current)
 *  Scheamtic: https://electronoobs.com/eng_arduino_tut112_sch1.php
 *  Code: https://electronoobs.com/eng_arduino_tut112_code1.php
 *  Video: https://www.youtube.com/watch?v=_M_iC_AAjxo
 *  Part list: https://electronoobs.com/eng_arduino_tut112_parts1.php
 *  PCB Gerber: https://electronoobs.com/eng_arduino_tut112_gerber1.php
 *  3D case: https://electronoobs.com/eng_arduino_tut112_stl1.php
*/

/////////////////////////////Library for ADS1115 ADC//////////////////////////////////
#include <Adafruit_ADS1015.h>       //download here: https://www.electronoobs.com/eng_arduino_Adafruit_ADS1015.php
Adafruit_ADS1115 ads(0x48);
//////////////////////////////////////////////////////////////////////////////////////

////////////////////////OLED 64x124 display with i2c//////////////////////////////////
//OLED screen libraries
#include <Adafruit_GFX.h>           //download here: https://www.electronoobs.com/eng_arduino_Adafruit_GFX.php
#include <Adafruit_SSD1306.h>
#define OLED_RESET 11
Adafruit_SSD1306 display(OLED_RESET);
//////////////////////////////////////////////////////////////////////////////////////


//Define Inputs Outputs
int mode_selector = A3;           //my analog values were: 1023, 675, 405, 285
int Vcc_read = A1;
int current_switch = A7;          //1023 - Left, 0 - Right
int Baterry_read = A7;            //divider: 6.8k and 2.2k = 0.24*Vin
int CapAnalogPin = A0;
int CapAnalogPin2 = A2;
int Buzzer = 2;
int D3 = 3;                       //Pins for resistance mode
int D4 = 4;                       //Pins for resistance mode
int D5 = 5;                       //Pins for resistance mode
int Induct_OUT = 6;               //Pin for pulse for inductance mode
int D7 = 7;                       //For voltage mode, divider for set to GND
int Right_button = 8;
int Induct_IN = 9;
int Left_button = 10;
int dischargePin = 13;
int D12 = 12;                     //For voltage mode, divider for set to GND
int chargePin = 11;         


/////////////////////Variables/////////////////////
int mode = 1;

//Voltage mode
float VoltageReadOffset = 0.0;
float Voltage = 0.0;
float Volt_ref = 0;

//Resistance mode
int R2_1 = 2050;
int R2_2 = 20;      //In K ohms
int R2_3 = 195;     //in K ohms
int Res_Offset = 0;
bool conductivity = true;

//Capacitance mode
unsigned long startTime;
unsigned long elapsedTime;
float microFarads;                
float nanoFarads;
#define resistorValue  10200.00F  //Remember, we've used a 10K resistor to charge the capacitor
bool cap_scale = false;
//Small scale
const float IN_STRAY_CAP_TO_GND = 56.88;
const float IN_CAP_TO_GND  = IN_STRAY_CAP_TO_GND;
const float R_PULLUP = 34.8;  
const int MAX_ADC_VALUE = 1023;

//Inductance mode
double pulse, frequency, Induct_cap, inductance;

//Current mode
float Sensibility = 0.113;                      //Given by the ACS712 datasheet but tweeked a bit


void setup() {
  Serial.begin(9600);
  ads.begin();                        //Start the communication with the ADC
  
  analogReference(DEFAULT);
  
  pinMode(mode_selector, INPUT);
  pinMode(Vcc_read, INPUT); 
  pinMode(current_switch, INPUT);       
  pinMode(A6, INPUT);  
  pinMode(CapAnalogPin, INPUT);  
  pinMode(CapAnalogPin2, OUTPUT);  
    
  pinMode(Buzzer, OUTPUT);
  pinMode(D3, INPUT);
  pinMode(D4, INPUT);
  pinMode(D5, INPUT);
  pinMode(Induct_OUT, OUTPUT);
  pinMode(D7, INPUT);
  pinMode(Left_button, INPUT_PULLUP);
  pinMode(Induct_IN, INPUT);
  pinMode(Right_button, INPUT_PULLUP);
  pinMode(dischargePin, INPUT);
  pinMode(D12, INPUT);
  pinMode(chargePin, OUTPUT);


  digitalWrite(Buzzer,LOW);
  digitalWrite(chargePin,LOW);
  digitalWrite(Induct_OUT,LOW);
  
  delay(200);

  //OLED display settings...
  display.begin(SSD1306_SWITCHCAPVCC, 0x3C);  // initialize with the I2C addr 0x3C (for the 128x32 or 64 from eBay)
  delay(50);
  display.clearDisplay();
  
  display.setTextSize(1);
  display.setTextColor(WHITE);    
  display.setCursor(0,20);
  display.println("    ELECTRONOOBS");
  display.println("    MULTIMETER");
  display.display();
  
  delay(500);
  display.clearDisplay();
  display.display();
}

void loop() {
  analogReference(DEFAULT);
  ////////////////////////////MODE DETECTOR//////////////////////////////
  if(analogRead(current_switch) > 512)
  {
    mode = 5;
  }
  else
  {
    int val = analogRead(mode_selector);
    if(val > 750)
    {
      //Serial.println("MODE 1");
      mode = 1;
    }
    else if(val > 480)
    {
      //Serial.println("MODE 2"); 
      mode = 2;
    }
    else if(val > 360)
    {
      //Serial.println("MODE 3");
      mode = 3;
    }
    else
    {
      //Serial.println("MODE 4");
      mode = 4;
    }
  }
  /////////////////////////END MODE DETECTOR//////////////////////////////






  ////////////////////////////////MODE 1//////////////////////////////////  
  if( mode == 1 )
  {  
    pinMode(D12,OUTPUT);
    pinMode(D7,OUTPUT);
    digitalWrite(D12,LOW);
    digitalWrite(D7,LOW);
    float adc; // Leemos el ADC, con 16 bits 
    adc = ads.readADC_Differential_0_1();
    //adc = ads.readADC_SingleEnded(0);
    Voltage = 11 * (adc * 0.1875)/1000 + VoltageReadOffset;           
    //I've used a 1K adn 10K divider so outpout is 1/11 that's why
    //we multiply voltage by  11
    //Serial.print(Voltage, 2);  
    //Serial.println(" Volts"); 

    Serial.print("V");
    Serial.print(Voltage,3);
    
    display.clearDisplay();  
    display.setTextSize(2);
    display.setTextColor(WHITE);    
    display.setCursor(12,0);    
    display.print(" VOLTAGE");
      
    display.setTextSize(2);
    display.setTextColor(WHITE);    
    display.setCursor(0,20);
    display.println(Voltage);
    display.println("V");
    display.display();

    
    delay(10); 
  }
  /////////////////////////////END MODE 1/////////////////////////////////






  ////////////////////////////////MODE 2//////////////////////////////////  
  if( mode == 2 )
  {               
    pinMode(D4,INPUT);
    pinMode(D5,INPUT);
    pinMode(D3,OUTPUT);
    digitalWrite(D3,LOW);   
    delay(10); 
    
    float adc2;     
    float res;
    
    /*int res_loop = 0;
    while(res_loop < 10)
    {
      adc2 = ads.readADC_SingleEnded(2);
      Voltage = Voltage + (adc2 * 0.1875)/1000;
      res_loop = res_loop + 1;
    }
    Voltage = Voltage/10;    */  

    adc2 = ads.readADC_SingleEnded(2);
    Voltage = (adc2 * 0.1875)/1000;
      
    
    res = ((R2_1*5.04 )/Voltage) - R2_1 - Res_Offset;          //3.422V(AMS1117 3.3V) -0.616V (diode)
        
    if(res < 2000)
    {      
      Serial.print("R");
      Serial.print(res); 
    
      display.clearDisplay();  
      display.setTextSize(2);
      display.setTextColor(WHITE);    
      display.setCursor(4,0);
      display.print("RESISTANCE");
      
      display.setTextSize(2);
      display.setTextColor(WHITE);    
      display.setCursor(0,20);
      display.println(res);
      display.println("Ohms");
      display.display();
    }
    else if(res < 20000)
    {      
      pinMode(D3,INPUT);
      pinMode(D4,OUTPUT);
      pinMode(D5,INPUT);
      digitalWrite(D4,LOW);   
      delay(10);           
     
      adc2 = ads.readADC_SingleEnded(2);
      Voltage = (adc2 * 0.1875)/1000;      
      res = ((R2_2*5)/Voltage) - R2_2;          //3.422V(AMS1117 3.3V) -0.616V (diode)
      
      Serial.print("k");
      Serial.print(res);
      
      display.clearDisplay();  
      display.setTextSize(2);
      display.setTextColor(WHITE);    
      display.setCursor(4,0);
      display.print("RESISTANCE");
      
      display.setTextSize(2);
      display.setTextColor(WHITE);    
      display.setCursor(0,20);
      display.println(res);
      display.println("KOhms");
      display.display();
    }
    else if(res > 20000) 
    {
      pinMode(D5,OUTPUT);
      digitalWrite(D5,LOW); 
      pinMode(D3,INPUT);
      pinMode(D4,INPUT);       
      delay(10);         
      adc2 = ads.readADC_SingleEnded(2);
      Voltage = (adc2 * 0.1875)/1000;      
      res = ((R2_3*5)/Voltage) - R2_3;          //3.422V(AMS1117 3.3V) -0.616V (diode)
      if(res < 2000)
      {
        Serial.print("k");
        Serial.print(res);
      
        display.clearDisplay();  
        display.setTextSize(2);
        display.setTextColor(WHITE);    
        display.setCursor(4,0);
        display.print("RESISTANCE");
        
        display.setTextSize(2);
        display.setTextColor(WHITE);    
        display.setCursor(0,20);
        display.println(res);
        display.println("KOhms");
        display.display();        
      }
      else
      {
        Serial.print("R");
        Serial.print(0);
        display.clearDisplay();  
        display.setTextSize(2);
        display.setTextColor(WHITE);    
        display.setCursor(4,0);
        display.print("RESISTANCE");
        
        display.setTextSize(2);
        display.setTextColor(WHITE);    
        display.setCursor(0,20);
        display.println("INSERT");
        display.println("RESISTOR");
        display.display();
      }
      
    }    
    delay(50);   
  }//end mode 2
  /////////////////////////////END MODE 2/////////////////////////////////







  ////////////////////////////////MODE 3//////////////////////////////////  
  if( mode == 3 )
  {       
    //This is the scale for 1uF to max value
    if(!cap_scale)
    {       
      pinMode(CapAnalogPin,INPUT);
      pinMode(CapAnalogPin2, OUTPUT);  
      pinMode(chargePin, OUTPUT); 
      
      digitalWrite(CapAnalogPin2, LOW); 
      digitalWrite(chargePin, HIGH);  
      startTime = micros();
      while(analogRead(CapAnalogPin) < 648){}    //end while
      
      elapsedTime= micros() - startTime;
      microFarads = ((float)elapsedTime / resistorValue) - 0.01097;
        
      if (microFarads > 1)
      {
        Serial.print("u");
        Serial.print(microFarads);
       
        delay(500);    
        display.clearDisplay();  
        display.setTextSize(2);
        display.setTextColor(WHITE);    
        display.setCursor(10,0);
        display.print("CAPACITOR");
        
        display.setTextSize(2);
        display.setTextColor(WHITE);    
        display.setCursor(0,20);
        display.println(microFarads);
        display.println("uF");
        display.display();
      }
      
      else
      {
        /*nanoFarads = microFarads * 1000.0; 
        Serial.print(nanoFarads);
        Serial.println(" nF");  
        delay(500);  */
        cap_scale = true;       //We change the scale to MIN - 1uF
      }
      
      digitalWrite(chargePin, LOW);            
      pinMode(dischargePin, OUTPUT);            
      digitalWrite(dischargePin, LOW);        //discharging the capacitor     
      while(analogRead(CapAnalogPin) > 0){}   //This while waits till the capaccitor is discharged    
      pinMode(dischargePin, INPUT);           //this sets the pin to high impedance      
      //Serial.println("Discharging"); 
    }//end of upper scale


    if(cap_scale)
    {      
      pinMode(dischargePin,INPUT);
      pinMode(chargePin,INPUT);
      pinMode(CapAnalogPin2,OUTPUT);
      pinMode(CapAnalogPin, INPUT);
      
      digitalWrite(CapAnalogPin2, HIGH);
      int val = analogRead(CapAnalogPin);
      digitalWrite(CapAnalogPin2, LOW);
  
      if (val < 1000)
      {
        pinMode(CapAnalogPin, OUTPUT);  
        float capacitance = (float)val * IN_CAP_TO_GND / (float)(MAX_ADC_VALUE - val);
        
        Serial.print("p");
        Serial.print(capacitance);
        
        display.clearDisplay();  
        display.setTextSize(2);
        display.setTextColor(WHITE);    
        display.setCursor(10,0);
        display.print("CAPACITOR");
        
        display.setTextSize(2);
        display.setTextColor(WHITE);    
        display.setCursor(0,20);
        display.println(capacitance);
        display.println("pF");
        display.display();
        delay(400);
      }
      
      else
      {
        pinMode(CapAnalogPin, OUTPUT);
        delay(1);
        pinMode(CapAnalogPin2, INPUT_PULLUP);
        unsigned long u1 = micros();
        unsigned long t;
        int digVal;  
        do
        {
          digVal = digitalRead(CapAnalogPin2);
          unsigned long u2 = micros();
          t = u2 > u1 ? u2 - u1 : u1 - u2;
        }         
        while ((digVal < 1) && (t < 400000L));
  
        pinMode(CapAnalogPin2, INPUT);  
        val = analogRead(CapAnalogPin2);
        digitalWrite(CapAnalogPin, HIGH);
        int dischargeTime = (int)(t / 1000L) * 5;
        delay(dischargeTime);   
        pinMode(CapAnalogPin2, OUTPUT);  
        digitalWrite(CapAnalogPin2, LOW);
        digitalWrite(CapAnalogPin, LOW);
        float capacitance = -(float)t / R_PULLUP / log(1.0 - (float)val / (float)MAX_ADC_VALUE);
                                
        if (capacitance > 1000.0)
        {          
          /*Serial.print(capacitance / 1000.0, 2);
          Serial.println(" uF");*/
          cap_scale = false;          //We change the scale to 1uF - max        
        }          
        else
        {          
          Serial.print("n");
          Serial.print(capacitance);
        
          display.clearDisplay();  
          display.setTextSize(2);
          display.setTextColor(WHITE);    
          display.setCursor(10,0);
          display.print("CAPACITOR");
          
          display.setTextSize(2);
          display.setTextColor(WHITE);    
          display.setCursor(0,20);
          display.println(capacitance);
          display.println("nF");
          display.display(); 
                  
        }
      }
      while (micros() % 1000 != 0);
    }////end of lower scalee       
  }//end mode 3
  /////////////////////////////END MODE 3/////////////////////////////////




  ////////////////////////////////MODE 4//////////////////////////////////
  if( mode == 4 )
  {
    display.clearDisplay();  
    display.setTextSize(2);
    display.setTextColor(WHITE);    
    display.setCursor(3,0);
    display.print("INDUCTANCE");
    display.display();
    
    digitalWrite(Induct_OUT, HIGH);
    delay(5);                               //give some time to charge inductor.
    digitalWrite(Induct_OUT,LOW);
    delayMicroseconds(100);                 //make sure resination is measured
    pulse = pulseIn(Induct_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
      Induct_cap = 2.E-6;                                                   // - insert value here
          
      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
    
      //Serial print    
      Serial.print("H");
      Serial.print(inductance); 
      
          
      display.setTextSize(2);
      display.setTextColor(WHITE);    
      display.setCursor(0,20);
      display.println(inductance);
      display.println("uH");
      display.display();
      delay(100);  
    }
  }//end mode 4
  /////////////////////////////END MODE 4/////////////////////////////////



  ////////////////////////////////MODE 5//////////////////////////////////
  if( mode == 5 )
  {
    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;
    } 
    //133 233
    Sens_volt = Sens_volt/100;
    //Serial.println(Sens_volt); 
    float I =  -0.004 + ((Sens_volt - 2.5075)/Sensibility); //EcuaciĆ³n  para obtener la corriente
    //Serial.print(I,3); 
    //Serial.println(" A"); 

    Serial.print("A");
    Serial.print(I,3); 
      
    display.clearDisplay();  
    display.setTextSize(2);
    display.setTextColor(WHITE);    
    display.setCursor(10,0);
    display.print(" CURRENT");
          
    display.setTextSize(2);
    display.setTextColor(WHITE);    
    display.setCursor(0,20);
    display.println(I,3);
    display.println("A");
    display.display();  
    delay(50);  
  }
  /////////////////////////////END MODE 5/////////////////////////////////
  
 
}//End of void Loop













Last tutorials

Halloween 3D Printed Skull with Smoke Machine
TL431 Current Limiter Circuit - Fixed Value
TL431 Variable Zener + Examples
Shocking Game - Lie detector | 3D printed
Wireless but STEREO homemade Bluetooth Speaker

ADVERTISERS



ADVERTISERS

PCBWAY PCB service

PCBWAY PCB service





Curso Arduino Online nivel bajo