Gör denna avancerade digitala amperemätare med Arduino

I det här inlägget ska vi konstruera en digital amperemeter med 16 x 2 LCD-skärm och Arduino. Vi kommer att förstå metoden för att mäta ström med hjälp av ett shuntmotstånd och implementera en design baserad på Arduino. Den föreslagna digitala amperemätaren kan mäta ström från 0 till 2 Ampere (absolut maximalt) med rimlig noggrannhet.

Hur ammetrar fungerar

Det finns två typer av ammetrar: Analoga och digitala, deras funktion skiljer sig mycket från varandra. Men de har båda ett gemensamt koncept: Ett shuntmotstånd.

Ett shuntmotstånd är ett motstånd med mycket litet motstånd placerat mellan källan och belastningen medan strömmen mäts.

Låt oss se hur en analog amperemätare fungerar och då blir det lättare att förstå den digitala.

Ett shuntmotstånd med mycket lågt motstånd R och antar att någon slags analog mätare är ansluten över motståndet, vars avböjning är direkt proportionell mot spänningen genom den analoga mätaren.

Låt oss nu passera en viss mängd ström från vänster sida. i1 är strömmen innan du går in i shuntmotståndet R och i2 kommer att vara strömmen efter att ha passerat shuntmotståndet.

Strömmen i1 kommer att vara större än i2 eftersom den tappade en bråkdel av strömmen genom shuntmotståndet. Strömskillnaden mellan shuntmotståndet utvecklar mycket liten mängd spänning vid V1 och V2.
Mängden spänning kommer att mätas av den analoga mätaren.

Spänningen som utvecklas över shuntmotståndet beror på två faktorer: strömmen som strömmar genom shuntmotståndet och värdet på shuntmotståndet.

Om strömflödet är större genom shunten är den utvecklade spänningen mer. Om shuntens värde är högt är spänningen som utvecklas över shunten mer.

Shuntmotståndet måste ha ett mycket litet värde och det måste ha högre wattvärde.

Ett motstånd med litet värde säkerställer att belastningen får tillräcklig mängd ström och spänning för normal drift.

Shuntmotståndet måste också ha högre wattvärde så att det tål högre temperatur medan strömmen mäts. Ju högre ström genom shunten, genereras mer värme.

Nu skulle du ha fått grundidén, hur en analog mätare fungerar. Nu går vi vidare till digital design.

Nu vet vi att ett motstånd producerar en spänning om det finns ett strömflöde. Från diagrammet V1 och V2 är punkterna där vi tar spänningsproverna till mikrokontrollern.

Beräkning av spänning till strömomvandling

Låt oss nu se den enkla matematiken, hur kan vi konvertera den producerade spänningen till ström.

Ohms lag: I = V / R

Vi vet värdet på shuntmotståndet R och det kommer att matas in i programmet.

Spänningen som produceras över shuntmotståndet är:

V = V1 - V2

Eller

V = V2 - V1 (för att undvika negativ symbol vid mätning och även negativ symbol beror på strömflödets riktning)

Så vi kan förenkla ekvationen,

I = (V1 - V2) / R.
Eller
I = (V2 - V1) / R.

En av ovanstående ekvationer kommer att matas in i koden och vi kan hitta det aktuella flödet och kommer att visas på LCD-skärmen.

Låt oss nu se hur du väljer shuntmotståndsvärdet.

Arduino har inbyggt 10 bitars analog till digital omvandlare (ADC). Den kan detektera från 0 till 5V i 0 till 1024 steg eller spänningsnivåer.

Så upplösningen för denna ADC blir 5/1024 = 0,00488 volt eller 4,88 millivolt per steg.

Så 4,88 millivolt / 2 mA (minsta upplösning av amperemätaren) = 2,44 eller 2,5 ohm motstånd.

Vi kan använda fyra 10 ohm, 2 Watt motstånd parallellt för att få 2,5 ohm som testades i prototypen.

Så, hur kan vi säga det maximala mätbara området för den föreslagna amperemätaren som är 2 Ampere.

ADC kan bara mäta från 0 till 5 V, dvs. Allt ovan kommer att skada ADC i mikrokontrollern.

Från den testade prototypen har vi observerat att vid de två analoga ingångarna från punkt V1 och V2 när det nuvarande uppmätta värdet X mA, läser den analoga spänningen X / 2 (i seriell bildskärm).

Säg till exempel, om amperemätaren läser 500 mA läser de analoga värdena på seriell bildskärm 250 steg eller spänningsnivåer. ADC kan tåla upp till 1024 steg eller maximalt 5 V, så när amperemätaren läser 2000 mA läser den seriella monitorn cirka 1000 steg. vilket är nära 1024.

Allt över 1024 spänningsnivå kommer att skada ADC i Arduino. För att undvika detta strax före 2000 mA uppmanas ett varningsmeddelande på LCD-skärmen som säger att koppla bort kretsen.

Nu skulle du ha förstått hur den föreslagna amperemätaren fungerar.

Nu går vi vidare till konstruktionsdetaljer.

Schematiskt diagram:

Den föreslagna kretsen är mycket enkel och nybörjarvänlig. Konstruera enligt kretsschemat. Justera 10K potentiometern för att justera skärmens kontrast.

Du kan driva Arduino från USB eller via DC-uttag med 9 V-batterier. Fyra motstånd på 2 watt sprider värmen jämnt än att använda ett 2,5 ohm motstånd med 8- 10 watt motstånd.

När ingen ström passerar kan skärmen läsa något litet slumpmässigt värde som du kan ignorera det, detta kan bero på avvikande spänning över mätterminalerna.

ANMÄRKNING: Vänd inte inmatningspolaritetens inmatning.

Programkod:

//------------------Program Developed by R.GIRISH------------------//
#include
#define input_1 A0
#define input_2 A1
LiquidCrystal lcd(12, 11, 5, 4, 3, 2)
int AnalogValue = 0
int PeakVoltage = 0
float AverageVoltage = 0
float input_A0 = 0
float input_A1 = 0
float output = 0
float Resolution = 0.00488
unsigned long sample = 0
int threshold = 1000
void setup()
{
lcd.begin(16,2)
Serial.begin(9600)
}
void loop()
{
PeakVoltage = 0
for(sample = 0 sample <5000 sample ++)
{
AnalogValue = analogRead(input_1)
if(PeakVoltage {
PeakVoltage = AnalogValue
}
else
{
delayMicroseconds(10)
}
}
input_A0 = PeakVoltage * Resolution
PeakVoltage = 0
for(sample = 0 sample <5000 sample ++)
{
AnalogValue = analogRead(input_2)
if(PeakVoltage {
PeakVoltage = AnalogValue
}
else
{
delayMicroseconds(10)
}
}
input_A1 = PeakVoltage * Resolution
output = (input_A0 - input_A1) * 100
output = output * 4
while(analogRead(input_A0) >= threshold)
{
lcd.clear()
lcd.setCursor(0,0)
lcd.print('Reached Maximum')
lcd.setCursor(0,1)
lcd.print('Limit!!!')
delay(1000)
lcd.clear()
lcd.setCursor(0,0)
lcd.print('Disconnect now!!')
delay(1000)
}
while(analogRead(input_A0) >= threshold)
{
lcd.clear()
lcd.setCursor(0,0)
lcd.print('Reached Maximum')
lcd.setCursor(0,1)
lcd.print('Limit!!!')
delay(1000)
lcd.clear()
lcd.setCursor(0,0)
lcd.print('Disconnect now!!')
delay(1000)
}
lcd.clear()
lcd.setCursor(0,0)
lcd.print('DIGITAL AMMETER')
lcd.setCursor(0,1)
lcd.print(output)
lcd.print(' mA')
Serial.print('Volatge Level at A0 = ')
Serial.println(analogRead(input_A0))
Serial.print('Volatge Level at A1 = ')
Serial.println(analogRead(input_A1))
Serial.println('------------------------------')
delay(1000)
}
//------------------Program Developed by R.GIRISH------------------//

Om du har några specifika frågor angående detta Arduino-baserade digitala ammeterkretsprojekt, vänligen uttryck i kommentarsektionen, du kan få ett snabbt svar.