ESP32 ટ્યુટોરિયલ 55/55 - 12V, 24V અથવા 100V DC વોલ્ટેજ કેવી રીતે માપવું | SunFounder ની ESP32 IoT લર્નિંગ કિટ

ESP32 ટ્યુટોરિયલ 55/55 - 12V, 24V અથવા 100V DC વોલ્ટેજ કેવી રીતે માપવું | SunFounder ની ESP32 IoT લર્નિંગ કિટ

આ ટ્યુટોરિયલમાં, આપણે ESP32 નો ઉપયોગ કરીને વિવિધ DC વોલ્ટેજ માપવાનું શીખીશું, જેમાં 12V, 24V, અને 100V સુધીનો સમાવેશ થાય છે. બે રેઝિસ્ટરથી બનેલા વોલ્ટેજ ડિવાઈડર સર્કિટનો ઉપયોગ કરીને, આપણે ESP32 માઈક્રોકંટ્રોલરને નુકસાન થવાનું જોખમ વિના ઊંચા વોલ્ટેજ સુરક્ષિત રીતે માપી શકીએ છીએ. આ પ્રોજેક્ટ દર્શાવશે કે આ વોલ્ટેજ કેવી રીતે વાંચવા અને તેને સીરિયલ મોનિટર પર પ્રદર્શિત કરવા, જે તમારા પાવર સ્ત્રોતોમાં મૂલ્યવાન આંતરદૃષ્ટિ પ્રદાન કરશે.

વ્યાપક સમજૂતી માટે વિડિઓ જુઓ (વિડિઓમાં 00:00 પર). આપણે આ હાંસલ કરવા માટે એક સરળ વોલ્ટેજ ડિવાઈડર રૂપરેખાંકનનો ઉપયોગ કરીશું, જે સુનિશ્ચિત કરે છે કે આપણે ESP32 ના મહત્તમ ઇનપુટ સ્તર કરતાં વધુ વોલ્ટેજ સુરક્ષિત રીતે માપી શકીએ. આ ટ્યુટોરિયલ તે લોકો માટે યોગ્ય છે જેઓ ESP32 અને તેની ક્ષમતાઓ વિશે તેમનું જ્ઞાન વિસ્તારવા માંગે છે.

વોલ્ટેજ ગણતરી માટેનું સૂત્ર

હાર્ડવેર સમજાવ્યું

આ પ્રોજેક્ટ માટેના મુખ્ય ઘટકોમાં ESP32 માઈક્રોકંટ્રોલર, વોલ્ટેજ ડિવાઈડર બનાવતા બે રેઝિસ્ટર, અને તમે માપવા માંગતા પાવર સ્ત્રોતનો સમાવેશ થાય છે. ESP32 બિલ્ટ-ઇન Wi-Fi અને બ્લૂટૂથ ક્ષમતાઓથી સજ્જ છે, જે તેને IoT પ્રોજેક્ટ્સ માટે બહુમુખી પસંદગી બનાવે છે. બે રેઝિસ્ટરથી બનેલો વોલ્ટેજ ડિવાઈડર, આપણને વોલ્ટેજને સુરક્ષિત સ્તર સુધી ઘટાડવાની મંજૂરી આપે છે જેને ESP32 પ્રોસેસ કરી શકે.

આ સેટઅપમાં, એક રેઝિસ્ટર, R1, 10kΩ પર નિશ્ચિત છે, જ્યારે બીજો રેઝિસ્ટર, R2, તમે માપવા માંગતા મહત્તમ વોલ્ટેજના આધારે બદલાઈ શકે છે. R1 પરનો વોલ્ટેજ એ છે જે આપણે ESP32 ના એનાલોગ ઇનપુટ પિનનો ઉપયોગ કરીને વાંચીશું, જે આપણને પાવર સ્ત્રોતમાંથી મૂળ વોલ્ટેજની ગણતરી કરવાની મંજૂરી આપે છે.

• ચોક્કસ માપન માટે રેઝિસ્ટર 1% સહિષ્ણુતાના છે તેની ખાતરી કરો.
• ESP32 ના ઇનપુટ વોલ્ટેજ રેટિંગ્સ કરતાં વધુ ન થાય તે માટે વોલ્ટેજ ડિવાઈડરનો ઉપયોગ કરો.
• R1 ને 10kΩ પર રાખો અને વોલ્ટેજ શ્રેણીના આધારે R2 ને સમાયોજિત કરો.
• અચોક્કસ રીડિંગ્સ તરફ દોરી શકે તેવા ફ્લોટિંગ ઇનપુટ્સ ટાળવા માટે જોડાણો તપાસો.
• સતત વોલ્ટેજ માપન માટે સ્થિર પાવર સ્ત્રોતનો ઉપયોગ કરો.

વાયરિંગ સૂચનાઓ

સર્કિટ વાયર કરવા માટે, R1 રેઝિસ્ટર (10kΩ) ના એક છેડાને તમારા વોલ્ટેજ સ્ત્રોત સાથે અને બીજા છેડાને ESP32 ની GPIO પિન 35 સાથે જોડીને શરૂ કરો. આ પિન R1 પરનો વોલ્ટેજ વાંચશે. આગળ, R2 રેઝિસ્ટર (જે 100kΩ અથવા તમારી જરૂરિયાતોના આધારે બીજું મૂલ્ય હોઈ શકે છે) ને R1 ના જંકશન બિંદુ અને ગ્રાઉન્ડ વચ્ચે જોડો. ખાતરી કરો કે પાવર સ્ત્રોતનું ગ્રાઉન્ડ પણ ESP32 ના ગ્રાઉન્ડ સાથે જોડાયેલું છે.

ઉદાહરણ તરીકે, જો 24V માપતા હો, તો પાવર સપ્લાયના પોઝિટિવ ટર્મિનલને R1 સાથે જોડો, પછી R1 ના બીજા છેડાને પિન 35 અને બે રેઝિસ્ટરના જંકશન સાથે જોડો. R2 નો મુક્ત છેડો ગ્રાઉન્ડ પર જવો જોઈએ. આ રૂપરેખાંકન ESP32 ને સ્કેલ-ડાઉન વોલ્ટેજ સુરક્ષિત રીતે વાંચવાની મંજૂરી આપશે.

કોડ ઉદાહરણો અને વોકથ્રુ

const int R1 = 10000; // રેઝિસ્ટર 1 મૂલ્ય
const int R2 = 100000; // રેઝિસ્ટર 2 મૂલ્ય
const int VinPin = 35; // વોલ્ટેજ ઇનપુટ પિન

આ ભાગમાં, આપણે આપણા રેઝિસ્ટર, R1 અને R2 ના મૂલ્યો તેમજ એનાલોગ પિન VinPin ને વ્યાખ્યાયિત કરીએ છીએ જેનો ઉપયોગ આપણે વોલ્ટેજ વાંચવા માટે કરીશું. આ સ્થિરાંકો આપણી વોલ્ટેજ ગણતરીઓ માટે નિર્ણાયક છે.

void readVoltage() {
  uint32_t voltage_mV = analogReadMilliVolts(VinPin); // મિલિવોલ્ટમાં વાંચો
  VB1 = (((float) voltage_mV) / 1000.0) * (1 + (float)R2/(float)R1);
}

આ ફંક્શન નિર્દિષ્ટ પિનમાંથી મિલિવોલ્ટમાં વોલ્ટેજ વાંચે છે અને વોલ્ટેજ ડિવાઈડર સૂત્રનો ઉપયોગ કરીને વાસ્તવિક વોલ્ટેજ VB1 ની ગણતરી કરે છે. સ્કેલ-ડાઉન વોલ્ટેજને મૂળ મૂલ્યમાં પાછું ભાષાંતર કરવા માટે આ મહત્વપૂર્ણ છે.

void maxVoltage() {
  float maxVoltage = (3.1) * (1 + (float)R2/(float)R1);
}

અહીં, આપણે રેઝિસ્ટર મૂલ્યોના આધારે સુરક્ષિત રીતે માપી શકાય તેવા મહત્તમ વોલ્ટેજની ગણતરી અને છાપવા માટે એક ફંક્શન વ્યાખ્યાયિત કરીએ છીએ. આ ફંક્શન ખાતરી કરવા માટે નિર્ણાયક છે કે આપણે ESP32 ની વોલ્ટેજ મર્યાદા કરતાં વધુ ન જઈએ.

પ્રદર્શન / શું અપેક્ષા રાખવી

જ્યારે તમે કોડ ચલાવો છો, ત્યારે તમારે સીરિયલ મોનિટર પર માપેલ વોલ્ટેજ પ્રદર્શિત થતું જોવું જોઈએ. જેમ તમે ઇનપુટ વોલ્ટેજને સમાયોજિત કરો છો, તેમ રીડિંગ્સ આ ફેરફારોને રીઅલ-ટાઇમમાં પ્રતિબિંબિત કરવા જોઈએ, જે ESP32 ની વિવિધ DC વોલ્ટેજને ચોક્કસ રીતે માપવાની ક્ષમતા દર્શાવે છે. જો તમને રીડિંગ્સમાં વધઘટ જોવા મળે, તો વધુ સ્થિર પરિણામ પ્રાપ્ત કરવા માટે બહુવિધ નમૂનાઓનું સરેરાશીકરણ કરવાનું વિચારો (વિડિઓમાં 12:30 પર).

વિડિઓ સમયસ્ટેમ્પ્સ

• 00:00 શરૂઆત
• 1:59 પ્રોજેક્ટનો પરિચય
• 5:45 વોલ્ટેજ ડિવાઈડર
• 7:33 વાયરિંગ સમજાવ્યું
• 9:14 Arduino કોડ સમજાવ્યો
• 14:45 Arduino IDE પર ESP32 બોર્ડ અને COM પોર્ટ પસંદ કરવું
• 16:27 ESP32 નો ઉપયોગ કરીને 30V માપવાનું પ્રદર્શન
• 21:36 R2 ને 330k ઓહ્મમાં બદલ્યું
• 22:33 લઘુત્તમ વોલ્ટેજ માપન

Images

ESP32-55_any-voltrage-formula

ESP32-55-any-voltage-main

ESP32-55_any-voltrage-formula

ESP32-55-any-voltage-main

/*
Arduino code for ESP32 to measure any DC voltage
📚⬇️ Download and resource page https://robojax.com/RJT674
written by Ahmad Shamshiri
watch full video explanation https://youtu.be/znBiVlgV9JI
www.robojax.com
Feb 19, 2024
*/
bool debug = false;
const int R1 = 10000;//we read the voltage acrosst this resistor ()
const int R2 = 100000;

const int VinPin = 35; // Potentiometer connected to GPIO14


// PWM settings
const int freq = 5000; // PWM frequency
const int resolution = 12; // PWM resolution (bits)
const int channel = 0; // PWM channel

float VB1;
int mV;

void setup() {
  Serial.begin(115200);
  // Configure PWM
  ledcSetup(channel, freq, resolution);
  //calculatResistor(R1, 24);//10000 ohm and 35.0V

}



void loop() {
   readVoltage();

  Serial.print("VB1 Voltage: ");
  Serial.print(VB1); // Convert millivolts to volts
  Serial.println("V ");


  delay(500);
}

void readVoltage()
{
  uint32_t voltage_mV = analogReadMilliVolts(VinPin); // Read the voltage in millivolts
  if(debug)
  {
    maxVoltage();
    Serial.print("PinVoltage: ");
    Serial.print(voltage_mV);
    Serial.println("mV");
    Serial.println();//this adds a new line
  }
  mV = voltage_mV;
  VB1 = (((float) voltage_mV) / 1000.0)  * (1 + (float)R2/(float)R1);
}

/*
prints maximum volage
*/
void maxVoltage()
{
  float maxVoltage = ( 3.1)  * (1 + (float)R2/(float)R1);
    Serial.print("****Maximum Voltage: ");
    Serial.print(maxVoltage);
    Serial.println("V");

}//maxVoltage() end

void calculatResistor(int r1, float voltage)
{
    Serial.print("Calculating R2 when R1 is :");
    Serial.print(r1);
    Serial.print(" Ohms and Maximum Input Voltage is ");  
    Serial.print(voltage);  
    Serial.println("V");  
    Serial.print("***** R2 Should Be ");  
    float r2 = (voltage - 3.1)/ (3.1/ (float)r1);
    Serial.print(r2 / 1000.0);  
    Serial.println(" kilo Ohms");  
    while(1);
}