Arduino ఉపయోగించి ఈ అధునాతన డిజిటల్ అమ్మీటర్ చేయండి

ఈ పోస్ట్‌లో మేము 16 x 2 ఎల్‌సిడి డిస్‌ప్లే మరియు ఆర్డునో ఉపయోగించి డిజిటల్ అమ్మీటర్‌ను నిర్మించబోతున్నాం. షంట్ రెసిస్టర్‌ను ఉపయోగించి కరెంట్‌ను కొలిచే పద్దతిని మేము అర్థం చేసుకుంటాము మరియు ఆర్డునో ఆధారంగా ఒక డిజైన్‌ను అమలు చేస్తాము. ప్రతిపాదిత డిజిటల్ అమ్మీటర్ 0 నుండి 2 ఆంపియర్ (సంపూర్ణ గరిష్ట) వరకు ప్రస్తుతమును సహేతుకమైన ఖచ్చితత్వంతో కొలవగలదు.

అమ్మీటర్లు ఎలా పనిచేస్తాయి

రెండు రకాల అమ్మీటర్లు ఉన్నాయి: అనలాగ్ మరియు డిజిటల్, వాటి పనితీరు ఒకదానికొకటి భిన్నంగా ఉంటాయి. కానీ, వారిద్దరికీ ఒక భావన ఉమ్మడిగా ఉంది: ఒక షంట్ రెసిస్టర్.

షంట్ రెసిస్టర్ అనేది కరెంట్‌ను కొలిచేటప్పుడు మూలం మరియు లోడ్ మధ్య చాలా చిన్న నిరోధకత కలిగిన రెసిస్టర్.

అనలాగ్ అమ్మీటర్ ఎలా పనిచేస్తుందో చూద్దాం, ఆపై డిజిటల్‌ను అర్థం చేసుకోవడం సులభం అవుతుంది.

చాలా తక్కువ నిరోధకత కలిగిన షంట్ రెసిస్టర్ మరియు ఒక రకమైన అనలాగ్ మీటర్ రెసిస్టర్ అంతటా అనుసంధానించబడిందని అనుకోండి, అతని విక్షేపం అనలాగ్ మీటర్ ద్వారా వోల్టేజ్‌కు నేరుగా అనులోమానుపాతంలో ఉంటుంది.

ఇప్పుడు ఎడమ చేతి వైపు నుండి కొంత కరెంట్ పాస్ చేద్దాం. షంట్ రెసిస్టర్ R లోకి ప్రవేశించే ముందు i1 కరెంట్ మరియు షంట్ రెసిస్టర్ గుండా వెళ్ళిన తరువాత i2 కరెంట్ అవుతుంది.

ప్రస్తుత i1 i2 కన్నా ఎక్కువగా ఉంటుంది, ఎందుకంటే ఇది షంట్ రెసిస్టర్ ద్వారా కరెంట్ యొక్క కొంత భాగాన్ని వదిలివేసింది. షంట్ రెసిస్టర్ మధ్య ప్రస్తుత వ్యత్యాసం V1 మరియు V2 వద్ద చాలా తక్కువ మొత్తంలో వోల్టేజ్‌ను అభివృద్ధి చేస్తుంది.
వోల్టేజ్ మొత్తాన్ని ఆ అనలాగ్ మీటర్ ద్వారా కొలుస్తారు.

షంట్ రెసిస్టర్ అంతటా అభివృద్ధి చేయబడిన వోల్టేజ్ రెండు అంశాలపై ఆధారపడి ఉంటుంది: షంట్ రెసిస్టర్ ద్వారా ప్రవహించే ప్రస్తుత మరియు షంట్ రెసిస్టర్ యొక్క విలువ.

షంట్ ద్వారా ప్రస్తుత ప్రవాహం ఎక్కువగా ఉంటే అభివృద్ధి చెందిన వోల్టేజ్ ఎక్కువ. షంట్ విలువ ఎక్కువగా ఉంటే షంట్ అంతటా అభివృద్ధి చేయబడిన వోల్టేజ్ ఎక్కువ.

షంట్ రెసిస్టర్ చాలా చిన్న విలువగా ఉండాలి మరియు ఇది అధిక వాటేజ్ రేటింగ్ కలిగి ఉండాలి.

ఒక చిన్న విలువ నిరోధకం సాధారణ ఆపరేషన్ కోసం లోడ్ తగినంత కరెంట్ మరియు వోల్టేజ్ పొందుతున్నట్లు నిర్ధారిస్తుంది.

షంట్ రెసిస్టర్‌లో అధిక వాటేజ్ రేటింగ్ ఉండాలి, తద్వారా ఇది కరెంట్‌ను కొలిచేటప్పుడు అధిక ఉష్ణోగ్రతను తట్టుకోగలదు. షంట్ ద్వారా ఎక్కువ కరెంట్ ఎక్కువ వేడి ఉత్పత్తి అవుతుంది.

అనలాగ్ మీటర్ ఎలా పనిచేస్తుందో ఇప్పుడు మీకు ప్రాథమిక ఆలోచన వచ్చింది. ఇప్పుడు డిజిటల్ డిజైన్‌కు వెళ్దాం.

ప్రస్తుత ప్రవాహం ఉంటే రెసిస్టర్ వోల్టేజ్‌ను ఉత్పత్తి చేస్తుందని ఇప్పుడు మనకు తెలుసు. రేఖాచిత్రం నుండి V1 మరియు V2 పాయింట్లు, ఇక్కడ మేము వోల్టేజ్ నమూనాలను మైక్రోకంట్రోలర్‌కు తీసుకువెళతాము.

ప్రస్తుత మార్పిడికి వోల్టేజ్‌ను లెక్కిస్తోంది

ఇప్పుడు సాధారణ గణితాన్ని చూద్దాం, ఉత్పత్తి చేసిన వోల్టేజ్‌ను కరెంట్‌గా ఎలా మార్చగలం.

ఓం యొక్క చట్టం: I = V / R.

షంట్ రెసిస్టర్ R యొక్క విలువ మాకు తెలుసు మరియు అది ప్రోగ్రామ్‌లో నమోదు చేయబడుతుంది.

షంట్ రెసిస్టర్ అంతటా ఉత్పత్తి అయ్యే వోల్టేజ్:

వి = వి 1 - వి 2

లేదా

V = V2 - V1 (కొలిచేటప్పుడు ప్రతికూల చిహ్నాన్ని నివారించడానికి మరియు ప్రతికూల గుర్తు ప్రస్తుత ప్రవాహం యొక్క దిశపై ఆధారపడి ఉంటుంది)

కాబట్టి మనం సమీకరణాన్ని సరళీకృతం చేయవచ్చు,

I = (V1 - V2) / R.
లేదా
I = (V2 - V1) / R.

పై సమీకరణాలలో ఒకటి కోడ్‌లో నమోదు చేయబడుతుంది మరియు మేము ప్రస్తుత ప్రవాహాన్ని కనుగొనవచ్చు మరియు LCD లో ప్రదర్శించబడుతుంది.

ఇప్పుడు షంట్ రెసిస్టర్ విలువను ఎలా ఎంచుకోవాలో చూద్దాం.

ఆర్డునో 10 బిట్ అనలాగ్ టు డిజిటల్ కన్వర్టర్ (ఎడిసి) లో నిర్మించింది. ఇది 0 నుండి 1024 దశల్లో లేదా వోల్టేజ్ స్థాయిలలో 0 నుండి 5V వరకు గుర్తించగలదు.

కాబట్టి ఈ ADC యొక్క రిజల్యూషన్ 5/1024 = 0.00488 వోల్ట్ లేదా ప్రతి దశకు 4.88 మిల్లీవోల్ట్ అవుతుంది.

కాబట్టి 4.88 మిల్లివోల్ట్ / 2 ఎమ్ఏ (అమ్మీటర్ యొక్క కనీస రిజల్యూషన్) = 2.44 లేదా 2.5 ఓం రెసిస్టర్.

ప్రోటోటైప్‌లో పరీక్షించిన 2.5 ఓంలను పొందడానికి సమాంతరంగా నాలుగు 10 ఓం, 2 వాట్ రెసిస్టర్‌లను ఉపయోగించవచ్చు.

కాబట్టి, ప్రతిపాదిత అమ్మీటర్ యొక్క గరిష్ట కొలత పరిధిని 2 ఆంపియర్ ఎలా చెప్పగలను.

ADC 0 నుండి 5 V వరకు మాత్రమే కొలవగలదు, అనగా. పైన ఏదైనా మైక్రోకంట్రోలర్‌లోని ADC ని పాడు చేస్తుంది.

పరీక్షించిన ప్రోటోటైప్ నుండి, ప్రస్తుత కొలిచిన విలువ X mA ఉన్నప్పుడు పాయింట్ V1 మరియు V2 నుండి రెండు అనలాగ్ ఇన్పుట్ల వద్ద, అనలాగ్ వోల్టేజ్ X / 2 (సీరియల్ మానిటర్‌లో) చదువుతుంది.

ఉదాహరణకు చెప్పండి, అమ్మీటర్ 500 mA చదివితే సీరియల్ మానిటర్‌లోని అనలాగ్ విలువలు 250 దశలు లేదా వోల్టేజ్ స్థాయిలను చదువుతాయి. ADC 1024 దశలు లేదా 5 V గరిష్టంగా తట్టుకోగలదు, కాబట్టి అమ్మీటర్ 2000 mA చదివినప్పుడు, సీరియల్ మానిటర్ సుమారు 1000 దశలను చదువుతుంది. ఇది 1024 కి దగ్గరగా ఉంది.

1024 వోల్టేజ్ స్థాయి కంటే ఎక్కువ ఏదైనా ఆర్డునోలోని ADC ని దెబ్బతీస్తుంది. 2000 mA కి ముందు దీనిని నివారించడానికి, సర్క్యూట్‌ను డిస్‌కనెక్ట్ చేయమని ఎల్‌సిడిలో హెచ్చరిక సందేశం అడుగుతుంది.

ప్రతిపాదిత అమ్మీటర్ ఎలా పనిచేస్తుందో ఇప్పుడు మీరు అర్థం చేసుకున్నారు.

ఇప్పుడు నిర్మాణ వివరాలకు వెళ్దాం.

బొమ్మ నమునా:

ప్రతిపాదిత సర్క్యూట్ చాలా సులభం మరియు బిగినర్స్ ఫ్రెండ్లీ. సర్క్యూట్ రేఖాచిత్రం ప్రకారం నిర్మించండి. డిస్ప్లే కాంట్రాస్ట్‌ను సర్దుబాటు చేయడానికి 10 కె పొటెన్షియోమీటర్‌ను సర్దుబాటు చేయండి.

మీరు ఆర్డినోను యుఎస్‌బి నుండి లేదా డిసి జాక్ ద్వారా 9 వి బ్యాటరీలతో శక్తివంతం చేయవచ్చు. నాలుగు 2 వాట్ల రెసిస్టర్లు 8- 10 వాట్ల రెసిస్టర్‌తో ఒక 2.5 ఓం రెసిస్టర్‌ను ఉపయోగించడం కంటే వేడిని సమానంగా వెదజల్లుతాయి.

కరెంట్ దాటినప్పుడు డిస్ప్లే కొన్ని చిన్న యాదృచ్ఛిక విలువను మీరు విస్మరించవచ్చు, ఇది కొలిచే టెర్మినల్స్ అంతటా విచ్చలవిడి వోల్టేజ్ వల్ల కావచ్చు.

గమనిక: ఇన్‌పుట్ లోడ్ సరఫరా ధ్రువణతను రివర్స్ చేయవద్దు.

ప్రోగ్రామ్ కోడ్:

//------------------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------------------//

ఈ ఆర్డునో ఆధారిత డిజిటల్ అమ్మీటర్ సర్క్యూట్ ప్రాజెక్టుకు సంబంధించి మీకు ఏదైనా నిర్దిష్ట ప్రశ్న ఉంటే, దయచేసి వ్యాఖ్య విభాగంలో వ్యక్తీకరించండి, మీకు శీఘ్ర సమాధానం లభిస్తుంది.