మానిటరింగ్ స్టేట్ ఆఫ్ ఎ స్విచ్ (డిజిటల్ రీడ్ సీరియల్) - ఆర్డునో బేసిక్స్

ఈ ఆర్డునో బేసిక్స్ ఒక కోడ్‌ను అమలు చేసే పద్ధతిని చర్చిస్తుంది, దీని ద్వారా బాహ్య పుష్-బటన్ యొక్క ఆన్ లేదా ఆఫ్ స్థితిని ఆర్డునోలో చదవవచ్చు లేదా పర్యవేక్షించవచ్చు.

డిజిటల్ రీడ్ సీరియల్

యుఎస్‌బి ద్వారా మీ ఆర్డునో మరియు మీ పిసి అంతటా సీరియల్ కమ్యూనికేషన్ చేయడం ద్వారా స్విచ్ స్థితిని ఎలా పర్యవేక్షించాలో ఇక్కడ మనం తెలుసుకుంటాము.

మీ ఆర్డునో బోర్డ్‌కు మించి, మీకు ఈ క్రింది ప్రాథమిక అంశాలు అవసరం:

హార్డ్వేర్

క్షణిక స్విచ్, బటన్ లేదా పుష్-టు-ఆన్ స్విచ్

10 కె, 1/4 వాట్ ఓం రెసిస్టర్

బ్రెడ్‌బోర్డ్
హుక్-అప్ లేదా జంపర్ వైర్ లింకులు.

సర్క్యూట్ ఆపరేషన్

ఆపరేషన్ క్రింది దశలతో చేయవచ్చు:

జంపర్ వైర్ల యొక్క 3 ముక్కలను తీసుకొని వాటిని మీ ఆర్డునో బోర్డ్‌తో కట్టిపడేశాయి. రెండు వైర్లు, ఎరుపు మరియు నలుపు, బ్రెడ్‌బోర్డ్ వైపున ఉన్న రెండు పొడవైన నిలువు వరుసలకు వెళతాయి, ఇవి తీసుకువెళ్ళడానికి బోర్డు యొక్క సరఫరా తీగలుగా మారుతాయి. బోర్డుకి 5 వి డిసి అవసరం.

మూడవ వైర్ డిజిటల్ పిన్ 2 ను పుష్-టు-ఆన్ స్విచ్ యొక్క లీడ్లలో ఒకదానికి కనెక్ట్ చేయడానికి ఉపయోగించబడుతుంది.

బటన్ యొక్క ఈ ప్రత్యేకమైన సీసం పుల్-డౌన్ 10 కె రెసిస్టర్‌తో ప్రతికూల సరఫరా రైలు లేదా భూమికి అనుసంధానిస్తుంది. స్విచ్ యొక్క ఇతర ఉచిత సీసం 5 వోల్ట్ సరఫరా యొక్క సానుకూలతతో ముడిపడి ఉంది.

పై కనెక్షన్లతో, పుష్ ఇచ్చినప్పుడు స్విచ్ సర్క్యూట్లో టోగుల్ చేస్తుంది లేదా ద్వంద్వ చర్య చేస్తుంది.

సాధారణంగా స్విచ్ డిస్‌కనెక్ట్ చేయబడిన స్థితిలో ఉన్నప్పుడు, దాని రెండు లీడ్‌లు విడిగా ఉంటాయి, పుల్-డౌన్ రెసిస్టర్ ద్వారా భూమితో అనుసంధానించబడిన పిన్ తక్కువ లేదా లాజిక్ 0 స్థాయిని అందిస్తుంది.

నొక్కిన పరిస్థితిలో, స్విచ్ దాని రెండు లీడ్‌ల యొక్క క్షణికమైన వంతెనను అమలు చేస్తుంది, అంటే దాని లీడ్‌లు + 5 వోల్ట్‌లకు లోబడి ఉంటాయి, వాటిలో హై లేదా రెండర్ 1 స్థాయిని అందిస్తాయి.

డిజిటల్ ఐ / ఓ పిన్‌అవుట్‌లను మిగతా వాటి నుండి వేరుచేయడం, ఎల్‌ఈడీని గడ్డివాముకి వెళ్లి బలవంతంగా మెరిసేలా చేస్తుంది. ఇన్పుట్ దేనికీ ఇవ్వబడకపోవడం లేదా 'ఉరి' స్థానంలో ఉంచడం దీనికి కారణం - అంటే ఇది ఏదైనా ఖచ్చితమైన తర్కానికి నియమించబడలేదు, అధిక లేదా తక్కువ కాదు (+ 5 వి లేదా 0 వి), దీనివల్ల మనం ఉద్యోగం చేయడానికి కారణం స్విచ్తో పుల్-డౌన్ రెసిస్టర్.

స్కీమాటిక్

కోడ్ అర్థం చేసుకోవడం

దిగువ కింది ప్రోగ్రామ్‌లో, సెకనుకు 9600 బిట్స్ డేటా చొప్పున సెటప్ ఫంక్షన్‌లో సీరియల్ కమ్యూనికేషన్‌తో ప్రారంభిస్తాము, ఇది ఆర్డునో బోర్డు మరియు అటాచ్ చేసిన కంప్యూటర్ మధ్య ప్రారంభించబడుతుంది: సీరియల్.బెగిన్ (9600)

తదుపరి దశలో, పుష్ స్విచ్‌తో ఇన్‌పుట్‌గా అవుట్‌పుట్‌కు బాధ్యత వహించే పిన్: పిన్‌మోడ్ (2, ఇన్‌పుట్) ఇది మా 'సెటప్'ను పూర్తి చేస్తుంది, ఇప్పుడు మేము మా కోడ్ యొక్క ప్రధాన లూప్‌లోకి వెళ్తాము .

ఇక్కడ పుష్బటన్ నొక్కినప్పుడు, 5 వోల్ట్లు మా సర్క్యూట్ ద్వారా వెళ్ళడానికి అనుమతించబడతాయి, అయితే ఇన్పుట్ పిన్ 10-కిలోహోమ్ రెసిస్టర్ ద్వారా భూమితో అనుసంధానించబడి ఉంటుంది.

పైన పేర్కొన్నది మనం డిజిటల్ ఇన్పుట్ అని పిలుస్తాము, ఇది స్విచ్ ఒక నిర్దిష్ట స్థితిలో మాత్రమే ఉండగల పరిస్థితిని సూచిస్తుంది (ఆర్డునో చేత '1', లేదా లాజిక్ హైగా అంగీకరించబడింది) లేదా ఆఫ్ స్టేట్ (విజువలైజ్డ్ ఆర్డునో చేత '0', లేదా లాజిక్ తక్కువ), వాటి మధ్య ఇతర నిర్వచించబడని సైట్లు లేవు.

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

సిగ్నల్స్ '1' లేదా '0' రూపంలో ఉండటంతో పైన చర్చించినట్లుగా, మేము ఇక్కడ ఒక పూర్ణాంక డేటాటైప్‌ను ఉపయోగిస్తాము. మేము ఈ వేరియబుల్‌ను సెన్సార్‌వాల్యూ అని పేరు పెట్టవచ్చు మరియు డిజిటల్ పిన్ 2 లో చదవబడుతున్న ప్రతిదానికీ అనుగుణంగా దాన్ని పరిష్కరించవచ్చు. ఇవన్నీ ఒక లైన్ కోడ్ ద్వారా సాధించగలవు:

int sensValue = DigitalRead (2) Arduino ఇన్పుట్ చదివిన తర్వాత, దానిని దశాంశ విలువ రూపంలో కంప్యూటర్కు తిరిగి ముద్రించండి.

కోడ్ యొక్క ముగింపు పంక్తిలో Serial.println () కమాండ్ సహాయంతో దీనిని అమలు చేయవచ్చు: Serial.println (sensValue)

దీని తరువాత, ఆర్డునో డొమైన్‌లో సీరియల్ మానిటర్ ప్రారంభించినప్పుడల్లా, పుష్ బటన్ ఓపెన్ పొజిషన్ సమయంలో '0 యొక్క గొలుసును మేము చూస్తాము, మరియు గొలుసులు 1 యొక్క సందర్భాలలో బటన్ క్లోజ్డ్ కండిషన్‌లో ఉంచబడుతుంది.

/*
DigitalReadSerial
Reads a digital input on pin 2, prints the result to the serial monitor
This example code is in the public domain.
*/
// digital pin 2 has a pushbutton attached to it. Give it a name:
int pushButton = 2

// the setup routine runs once when you press reset:
void setup() {
// initialize serial communication at 9600 bits per second:
Serial.begin(9600)
// make the pushbutton's pin an input:
pinMode(pushButton, INPUT)
}
// the loop routine runs over and over again forever:
void loop() {
// read the input pin:
int buttonState = digitalRead(pushButton)
// print out the state of the button:
Serial.println(buttonState)
delay(1) // delay in between reads for stability
}