లెర్నింగ్ బేసిక్ ఆర్డునో ప్రోగ్రామింగ్ - క్రొత్తవారికి ట్యుటోరియల్

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

పరిచయం

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

మైక్రోకంట్రోలర్ ఒక వినియోగదారుకు చాలా ఉపయోగకరంగా ఉంటుంది, ఎందుకంటే ఇది అంతర్నిర్మిత ప్రాసెసర్, మెమరీ మరియు ఇన్పుట్ / అవుట్పుట్ పోర్టులను (GPIO లేదా జనరల్ పర్పస్ ఇన్పుట్ / అవుట్పుట్ పిన్స్ అని కూడా పిలుస్తారు) అందిస్తుంది, వీటిని వినియోగదారుడు మనకు కావలసిన స్పెసిఫికేషన్ల ప్రకారం నియంత్రించవచ్చు.

ఈ ట్యుటోరియల్‌లో మేము ప్రోగ్రామ్‌లను నేర్చుకోవడం మరియు పరీక్షించడం కోసం ఆర్డునో యునో బోర్డుతో కలిసి పని చేస్తాము. హార్డ్వేర్ అసెంబ్లీని పరీక్షించడానికి మరియు సమగ్రపరచడానికి మేము బ్రెడ్‌బోర్డ్‌ను ఉపయోగిస్తాము.

ఇప్పుడు త్వరగా కదిలి, ఆర్డునో ప్రోగ్రామింగ్‌తో ఎలా ప్రారంభించాలో తెలుసుకుందాం.

1.2 సాఫ్ట్‌వేర్ (విండోస్) ను ఇన్‌స్టాల్ చేస్తోంది

దీని కోసం మీకు ఇంటర్నెట్‌కు ప్రాప్యత అవసరం, ఇది మీరు మీ కంప్యూటర్‌లో కలిగి ఉంటారు. దయచేసి కింది లింక్‌కి వెళ్లి IDE సాఫ్ట్‌వేర్‌ను డౌన్‌లోడ్ చేయండి:

నాన్ అడ్మిన్ ఇన్‌స్టాల్ కోసం విండోస్ జిప్ ఫైల్

డౌన్‌లోడ్ చేసిన తర్వాత మీరు డౌన్‌లోడ్ ఫోల్డర్‌లో ఆర్డునో సెటప్ చిహ్నాన్ని కనుగొంటారు, ఇది ఇలా ఉంటుంది:

మీరు దీన్ని పొందిన తర్వాత, మీరు దానిపై డబుల్ క్లిక్ చేసి, మీ కంప్యూటర్‌లో ఆర్డునో ది ఇంటిగ్రేటెడ్ డెవలప్‌మెంట్ ఎన్విరాన్‌మెంట్ (IDE) ను ఇన్‌స్టాల్ చేయవచ్చు. పూర్తి ప్రక్రియను క్రింది వీడియోలో చూడవచ్చు:

1.4 మా మొదటి సర్క్యూట్‌తో ప్రారంభమవుతుంది

మేము వాస్తవ ప్రోగ్రామింగ్ పద్ధతులను నేర్చుకోవడం ప్రారంభించే ముందు, ఏదైనా క్రొత్తవారికి LED వంటి ప్రాథమిక భాగాలతో ప్రారంభించడం ఉపయోగపడుతుంది మరియు దానిని ఆర్డునోతో ఎలా కనెక్ట్ చేయాలో అర్థం చేసుకోండి.

మనకు తెలిసినట్లుగా, LED అనేది ఒక కాంతి ఉద్గార డయోడ్, ఇది ధ్రువణత కలిగి ఉంటుంది మరియు సరైన సరఫరా స్తంభాలతో అనుసంధానించబడకపోతే అది ప్రకాశించదు.

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

నియమావళి ప్రకారం, ప్రస్తుత ఇన్పుట్‌ను అవసరమైన సురక్షిత స్థాయికి పరిమితం చేయడానికి సరఫరా ఇన్‌పుట్‌లో ప్రతి 5 వి పెరుగుదలకు 330 ఓం 1/4 వాట్ చాలా అనువైనది. అందువల్ల 5 వికి ఇది 330 ఓంలు కావచ్చు, 10 వికి ఇది 680 ఓంలు కావచ్చు.

అసెంబ్లీ కోసం బ్రెడ్‌బోర్డ్‌ను ఉపయోగించడం

దయచేసి a ను ఎలా ఉపయోగించాలో మీకు తెలుసా అని నిర్ధారించుకోండి బ్రెడ్‌బోర్డ్ ఈ అధ్యాయంలో వివరించిన ట్యుటోరియల్‌ను ప్రయత్నించే ముందు, ఇక్కడ ఉన్న అన్ని ప్రయోగాలకు మేము బ్రెడ్‌బోర్డ్‌ను ఉపయోగిస్తాము.

ప్రాథమిక LED కనెక్షన్ సెటప్ క్రింద చూడవచ్చు:

మీరు పైన 3 ప్రాథమిక భాగాలను చూడవచ్చు:

1. 5 ఎంఎం, 20 ఎంఏ ఎల్‌ఈడీ
2. 330 ఓం 1/4 వాట్ రెసిస్టర్
3. ఒక ఆర్డునో బోర్డు

రేఖాచిత్రం ప్రకారం వ్యవస్థను సమీకరించండి.

తరువాత, కంప్యూటర్ USB నుండి Arduino వరకు 5V ని ప్లగ్ చేయండి. మీరు దీన్ని చేసిన వెంటనే మీరు LED లైటింగ్‌ను చూస్తారు.

ఇది చాలా ప్రాథమికమైనదని నాకు తెలుసు, కాని మొదటి నుండి ప్రారంభించడం ఎల్లప్పుడూ మంచిది. మేము ముందుకు వెళ్ళేటప్పుడు మిగిలిన విషయాలు మరింత ఆసక్తికరంగా మారతాయి.

1.5 ఆర్డునోతో LED ని నియంత్రించడం

Arduino ప్రోగ్రాంతో LED ని ఎలా నియంత్రించాలో ఇప్పుడు మనం నేర్చుకుంటాము.

ఒక ప్రోగ్రామ్ రాయడానికి మనకు ప్రతి ప్రోగ్రామ్‌లో కనీసం 2 ఫంక్షన్లు ఉండాలి.

ఒక ఫంక్షన్ క్రింద ఇచ్చిన విధంగా, పేరుతో కేటాయించబడే ప్రోగ్రామింగ్ స్టేట్‌మెంట్ల శ్రేణిగా అర్థం చేసుకోవచ్చు:

1. సెటప్ () ప్రోగ్రామ్ ప్రారంభంలో దీనిని పిలుస్తారు లేదా అమలు చేస్తారు.
2. లూప్ () ఆర్డునో యొక్క మొత్తం కార్యాచరణ కాలంలో దీనిని పదేపదే పిలుస్తారు లేదా అమలు చేస్తారు.

అందువల్ల, దీనికి ఆచరణాత్మక కార్యాచరణ లేకపోయినప్పటికీ, సాంకేతికంగా అతి తక్కువ చట్టబద్ధమైన ఆర్డునో ప్రోగ్రామ్ ఇలా వ్రాయవచ్చు:

సరళమైన ప్రోగ్రామ్

void setup()
{
}
void loop()
{
}

అనేక ప్రోగ్రామింగ్ భాషలలో, 'హలో, వరల్డ్' అనే సాధారణ ముద్రణను ప్రదర్శన తెరపై చూపించడం ద్వారా సిస్టమ్ ప్రారంభమవుతుందని మీరు గమనించి ఉండవచ్చు

మైక్రోకంట్రోలర్ వ్యాఖ్యానంలో ఈ పదబంధానికి ఎలక్ట్రానిక్ సమానమైనది LED ఆన్ మరియు ఆఫ్ చేయడం.

వ్యవస్థ యొక్క సరైన పనితీరును సూచించడానికి ఇది వ్రాయగల మరియు అమలు చేయగల అత్యంత ప్రాథమిక ప్రోగ్రామ్.

మేము ఈ క్రింది కోడ్ ద్వారా విధానాన్ని అమలు చేయడానికి మరియు అర్థం చేసుకోవడానికి ప్రయత్నిస్తాము:

జాబితా 1.2: led1 / led1.pde

const int kPinLed = 13
void setup()
{
pinMode(kPinLed, OUTPUT)
}
void loop()
{
digitalWrite(kPinLed, HIGH)
delay(500)
digitalWrite(kPinLed, LOW)
delay(500)
}

సరే, ఇప్పుడు కోడ్ యొక్క ప్రతి పంక్తి అర్థం మరియు ఫంక్షన్‌ను ఎలా అమలు చేయాలో అర్థం చేసుకుందాం:

const int kPinLed = 13

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

ప్రామాణిక నియమాల ప్రకారం అటువంటి స్థిరాంకాలు ప్రారంభ అక్షరంతో గుర్తించబడతాయి కు . ఇది తప్పనిసరి కానప్పటికీ, కోడ్ వివరాల ద్వారా వెళ్లాలని మీకు అనిపించినప్పుడల్లా ఇది విషయాలు స్పష్టంగా మరియు సులభంగా అర్థమయ్యేలా చేస్తుంది.

void setup()
{
pinMode(kPinLed, OUTPUT)
}

ఈ కోడ్ మా LED ని కట్టిపడేసిన నిర్దిష్ట పిన్ను కాన్ఫిగర్ చేస్తుంది. మరో మాటలో చెప్పాలంటే, ఈ పిన్‌లోని 'రచన' కారకాన్ని 'చదవడానికి' బదులుగా నియంత్రించమని కోడ్ ఆర్డునోకు చెబుతుంది.

void loop()
{
digitalWrite(kPinLed, HIGH)
delay(500)
digitalWrite(kPinLed, LOW)
delay(500)
}

పై పంక్తులు అప్లికేషన్ యొక్క వాస్తవ అమలును సూచిస్తాయి. సంబంధిత LED కనెక్షన్‌పై హైట్ అవుట్ రాయడం మరియు రెండర్ చేయడం ద్వారా కోడ్ ప్రారంభమవుతుంది, LED ని ఆన్ చేస్తుంది.

ఇక్కడ, HIGH అనే పదానికి Arduino యొక్క సంబంధిత పిన్‌పై + 5V పొందడం అని అర్థం. LOW ని పూరించే పదం నియమించబడిన పిన్‌పై సున్నా లేదా 0V ని సూచిస్తుంది.

తరువాత, మేము delay() అని పిలుస్తాము దీని పని మిల్లీసెకన్ల ద్వారా ఆలస్యాన్ని సృష్టించడం (సెకనులో 1/1000 వ వంతు). ఫిగర్ 500 ఎంటర్ అయినందున, అమలు చేయబడిన ఆలస్యం 1/2 సెకన్ల వరకు ఉంటుంది.

ఈ 1/2 సెకన్లు లాప్ అయిన వెంటనే, తదుపరి పంక్తి అమలు అవుతుంది, అదే పిన్‌పై తక్కువ పదంతో LED ఆఫ్ అవుతుంది.

LED లైన్ 1/2 సెకన్ల పాటు ఆఫ్‌లో ఉండటానికి అనుమతించడానికి, తరువాతి పంక్తి 1/2 సెకన్ల ఆలస్యాన్ని మళ్లీ సృష్టిస్తుంది.

ఆర్డునో శక్తితో ఉంచబడినంతవరకు, కోడ్ యొక్క పంక్తుల అమలు ద్వారా ఈ ప్రక్రియ అనంతంగా కొనసాగుతుంది.

తదుపరి స్థాయికి వెళ్ళే ముందు, దయచేసి పై కోడ్‌ను ప్రోగ్రామ్ చేయమని మరియు మీరు LED ఆన్ / ఆఫ్ క్రమాన్ని సరిగ్గా అమలు చేయగలరా లేదా అని తనిఖీ చేయాలని నేను మీకు సిఫార్సు చేస్తున్నాను.

Arduino లోని డిఫాల్ట్ LED పిన్ # 13 తో అనుసంధానించబడి ఉన్నందున, ఇది వెంటనే పై ప్రోగ్రామ్‌కు స్పందించి ఫ్లాషింగ్ ప్రారంభించాలి. అయినప్పటికీ, మీ బాహ్య LED మెరుస్తున్నది కాదని మీరు కనుగొంటే, మీ LED తో కనెక్షన్ లోపం ఉండవచ్చు, మీరు మీ LED యొక్క ధ్రువణతను తిప్పికొట్టడానికి ప్రయత్నించవచ్చు మరియు అది కూడా మెరిసేటట్లు చూడవచ్చు.

'500' ఫిగర్‌ను వేరే విలువకు మార్చడం ద్వారా మీరు ఆలస్యం సమయంతో ఆడవచ్చు మరియు ఆదేశాలకు LED 'లిజనింగ్' ను కనుగొని, పేర్కొన్న ఆలస్యం విలువల ప్రకారం ఫ్లాష్ అయ్యేలా చేస్తుంది.

మీ ఆలస్యం సమయ మార్పుతో సంబంధం లేకుండా, స్థిరమైన 1 సెకను రేటుతో LED మెరుస్తున్నట్లు మీరు చూస్తే, కొంత పొరపాటు కారణంగా కోడ్ పనిచేయడం లేదని ఇది సూచిస్తుంది. ఎందుకంటే అప్రమేయంగా ఆర్డునో 1 సెకను మెరుస్తున్న రేటుతో ప్రోగ్రామ్ చేయబడుతుంది. అందువల్ల ఈ రేటు సరైన పనితీరును నిర్ధారించడానికి మీ కోడ్ ద్వారా వైవిధ్యంగా ఉండాలి.

1.7 వ్యాఖ్యలు

మేము పైన అర్థం చేసుకున్న సంకేతాల పంక్తులు కంప్యూటర్ సాఫ్ట్‌వేర్ కోసం ప్రత్యేకంగా వ్రాయబడ్డాయి.

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

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

ఈ వ్యాఖ్యల భాష రెండు ఫార్మాట్లతో వ్రాయబడింది:

1. వ్యాఖ్య యొక్క బ్లాక్ శైలి, దీనిలో వ్యాఖ్య వివరణ ప్రారంభ చిహ్నం / * మరియు ముగింపు చిహ్నం * /
2. ఇది ఒక పంక్తిలో పరిమితం చేయవలసిన అవసరం లేదు, అయితే ఈ క్రింది ఉదాహరణలో చూపిన విధంగా వ్యాఖ్య యొక్క పొడవు లేదా వివరణను బట్టి తదుపరి తదుపరి పంక్తులకు విస్తరించవచ్చు:

/ * ఇది వ్యాఖ్య * /

/ * కాబట్టి ఇది * /

/ * మరియు
* ఇది
* గా
* బాగా * /

వ్యాఖ్య కోసం శీఘ్ర సింగిల్ లైన్ వివరణ రాయడానికి, ప్రారంభంలో రెండు స్లాష్ // గుర్తు సరిపోతుంది. ఈ పంక్తికి అసలు కోడ్‌తో ఎటువంటి సంబంధం లేదని ఇది కంప్యూటర్‌కు చెబుతుంది మరియు విస్మరించాలి. ఉదాహరణకి:

// ఇది కంప్యూటర్లు విస్మరించే వ్యాఖ్య.

సూచన కోసం ఇక్కడ ఒక ఉదాహరణ:

/*
* Program Name: Blink
* Author: Alan Smith
* Description:
* Turns an LED on for one half second, then off for one half second repeatedly.
*/

/* Pin Definitions */
const int kPinLed = 13
/*
* Function Name: setup
* Purpose: Run once when the system powers up.
*/
void setup()
{
pinMode(kPinLed, OUTPUT)
}
/*
* Function name: loop
* Purpose: Runs over and over again, as long as the Arduino has power
*/
void loop()
{
digitalWrite(kPinLed, HIGH)
delay(500)
digitalWrite(kPinLed, LOW)
delay(500)
}

1.8 ట్రబుల్షూటింగ్

మీ ప్రోగ్రామ్ కంపైల్ చేసేటప్పుడు 'లోపం' లేదా ఇతర సమస్యలను చూపిస్తే, మీ కోడ్‌ను మళ్లీ తనిఖీ చేయడానికి కింది చిట్కాలు మీకు సహాయపడతాయి.

1. మీ ప్రోగ్రామ్ భాష కేస్ సెన్సిటివ్‌గా ఉంటుంది. ఉదాహరణకు వ్యక్తీకరణ myVar అని వ్రాయలేము మైవర్.
2. మీ కీబోర్డ్ టైపింగ్ ద్వారా అమలు చేయబడే అన్ని రకాల తెల్లని ఖాళీలు చివరికి ఒకే స్థలంగా ఇవ్వబడతాయి మరియు ఇది మీకు మాత్రమే కనిపిస్తుంది లేదా అర్థమవుతుంది, కంప్యూటర్ దీన్ని పరిగణనలోకి తీసుకోదు. ఒక్కమాటలో చెప్పాలంటే, ఏ రకమైన ఖాళీ స్థలాలు కోడ్ ఫలితాలపై ఎటువంటి ప్రభావం చూపవు.
3. కోడ్ యొక్క ప్రతి బ్లాక్ తప్పనిసరిగా ఎడమ మరియు కుడి వంకర బ్రాకెట్లతో జతచేయబడాలి, '{' మరియు '}'
4. సంఖ్య అంకెలను కామాలతో వేరు చేయకూడదు. ఉదాహరణకు, 1000 ను 1,000 గా వ్రాయకపోవచ్చు.
5. వంకర బ్రాకెట్ల మధ్య ఉన్న ప్రతి కోడ్ లైన్ సెమికోలన్‌తో పూర్తి చేయాలి

Arduino తో ఆసక్తికరమైన LED లైట్ సీక్వెన్స్ సృష్టించడం

మా మునుపటి అధ్యాయంలో స్థిరమైన ఆలస్యం రేటుతో నిరంతరం LED ఆన్ / ఆఫ్ చేయడం ఎలాగో నేర్చుకున్నాము.

ప్రోగ్రామ్ కోడ్‌ను అప్‌గ్రేడ్ చేయడం ద్వారా ఒకే LED లో వేర్వేరు ఆలస్యం నమూనాలను ఎలా అమలు చేయవచ్చో ఇప్పుడు మనం నేర్చుకుంటాము.

మేము బాహ్య LED ని ఉపయోగించము, బదులుగా పిన్ # 13 వద్ద Arduino బోర్డులో నిర్మించిన డిఫాల్ట్ LED ని ఉపయోగిస్తాము. మీరు ఈ చిన్న SMD LED ని USB కనెక్టర్ వెనుక చూడవచ్చు.

2.2 IF ప్రకటనలను అర్థం చేసుకోవడం

ఈ విభాగంలో నియంత్రణ నిర్మాణాలు వ్యక్తిగత కోడ్‌లను అమలు చేయడానికి మాకు ఎలా సహాయపడతాయో నేర్చుకుంటాము మరియు కొంతకాలం కూడా పునరావృతమవుతుంది.

ప్రకటన ఉంటే 1 వ నియంత్రణ నిర్మాణం అవుతుంది. కింది అమలు ఇది ఎలా ఉపయోగించబడుతుందో చూపిస్తుంది:

const int kPinLed = 13
void setup()
{
pinMode(kPinLed, OUTPUT)
}
int delayTime = 1000
void loop()
{
delayTime = delayTime - 100
if(delayTime <= 0){ // If the delay time is zero or less, reset it.
delayTime = 1000
}
digitalWrite(kPinLed, HIGH)
delay(delayTime)
digitalWrite(kPinLed, LOW)
delay(delayTime)
}

పై కోడ్ దశల వారీగా అర్థం చేసుకోవడానికి మేము ప్రయత్నిస్తాము మరియు ఇలాంటి ఇతర మరణశిక్షలకు ఇది ఎలా ఉపయోగపడుతుందో తెలుసుకుంటాము.

1 వ మరియు 7 వ పంక్తి మధ్య సంకేతాలు మా ప్రారంభ ప్రోగ్రామ్‌కు సమానంగా ఉంటాయి.

మొదటి మార్పు వాస్తవానికి 8 వ పంక్తిలో జరుగుతుంది.

int delayTime = 1000

ఇది 1 వ పంక్తిలోని కోడ్‌తో సమానమైనదిగా మీరు కనుగొనవచ్చు, ఇది ఈ పదాన్ని కోల్పోయిందనే వాస్తవాన్ని మినహాయించి const.

దీనికి కారణం, ఈ కోడ్ స్థిరంగా లేదు. బదులుగా ఇది a గా నిర్వచించబడింది వేరియబుల్ , ఇది ప్రోగ్రామింగ్ సమయంలో వేరియబుల్ విలువ యొక్క ఆస్తిని కలిగి ఉంటుంది.

పై ఉదాహరణలో ఈ వేరియబుల్ 1000 విలువతో ఆపాదించబడిందని మీరు చూడవచ్చు. గుర్తుంచుకోండి, కర్లీ బ్రాకెట్లలో జతచేయబడిన అటువంటి వేరియబుల్స్ ఖచ్చితంగా కర్లీ బ్రాకెట్ల జతలలో మాత్రమే వ్రాయబడాలి మరియు వాటిని 'లోకల్' వేరియబుల్స్ అని సూచిస్తారు.

ప్రత్యామ్నాయంగా, మనం ఇప్పుడు చర్చిస్తున్నట్లుగా వంకర బ్రాకెట్లకు వెలుపల ఉండాల్సిన వేరియబుల్స్ 'గ్లోబల్' గా గుర్తించబడతాయి మరియు ప్రోగ్రామ్ కోడ్‌లో ఎక్కడైనా అమలు చేయబడతాయి.

ముందుకు వెళుతున్నప్పుడు, 9 మరియు 11 వ పంక్తి మధ్య సంకేతాలు కూడా మొదటి ప్రోగ్రామ్‌కు సమానమైనవని మీరు చూడవచ్చు, అయినప్పటికీ 11 వ పంక్తి తర్వాత విషయాలు ఆసక్తికరంగా మారడం ప్రారంభిస్తాయి. ఎలా చూద్దాం!

delayTime = delayTime - 100

ఈ కోడ్‌లో డిఫాల్ట్ విలువ delayTime దాని నుండి 100 ను తీసివేయడం ద్వారా సవరించబడుతుంది.

100 అర్థం దాని ప్రారంభ విలువ 1000 నుండి తీసివేయబడుతుంది, ఇది 900 యొక్క కొత్త విలువను అందిస్తుంది.

కింది చిత్రం ద్వారా మేము ఆర్డునో భాషలో ఉపయోగించిన కొన్ని మఠం ఆపరేటర్లను అర్థం చేసుకోవడానికి ప్రయత్నిస్తాము.

ఇప్పుడు 13 మరియు 15 వ పంక్తి మధ్య సంకేతాలను అంచనా వేద్దాం.

if(delayTime <= 0){ // If the delay time is zero or less, reset it.
delayTime = 1000
}

పైన పేర్కొన్న కోడ్ యొక్క ప్రధాన లక్ష్యం ఏమిటంటే, LED ఎటువంటి అంతరాయం లేకుండా మెరిసేటట్లు చూసుకోవాలి.

అసలు నుండి 100 తీసివేయబడుతోంది delayTime , ఇది LED మెరిసేటట్లు సున్నాకి రాకుండా నిరోధిస్తుంది మరియు మెరిసేటట్లు నిరంతరం కొనసాగడానికి అనుమతిస్తుంది.

కింది చిత్రం మా కోడ్‌లలో ఉపయోగించబోయే కొన్ని పోలిక ఆపరేటర్లను చూపుతుంది:

మా పై కోడ్‌లో, మేము if(delayTime == 0) అని కోడ్‌ను పరీక్షించి ఉండవచ్చు.

అయినప్పటికీ, ప్రతికూల వ్యక్తిగా ఉండటం చాలా చెడ్డది కనుక, మేము దాని కోసం వెళ్ళలేదు మరియు ఇది సిఫార్సు చేయబడిన పద్ధతి.

delayTime నుండి 100 కు బదులుగా 300 ను తీసివేయడానికి ప్రయత్నిస్తే ఫలితం ఎలా ఉంటుందో ఆలోచించండి?

కాబట్టి delayTime ఉంటే ఇప్పుడు మీరు గ్రహించి ఉండవచ్చు తక్కువ లేదా సున్నాకి సమానంగా వ్రాయబడుతుంది, అప్పుడు ఆలస్యం సమయం అసలు సంఖ్య 1000 కు సెట్ చేయబడుతుంది.

digitalWrite(kPinLed, HIGH)
delay(delayTime)
digitalWrite(kPinLed, LOW)
delay(delayTime)

పైన చూపిన విధంగా కోడ్ యొక్క చివరి 4 పంక్తులు LED ని నిరంతరం ఆన్ / ఆఫ్ చేయడానికి, ఆన్ / ఆఫ్ చేయడానికి బాధ్యత వహిస్తాయి.

ఇక్కడ మీరు స్పష్టంగా గమనించవచ్చు, అనేక సంఖ్యలను ఉపయోగించటానికి బదులుగా, ఆలస్యం సమయాన్ని కేటాయించడానికి మేము వేరియబుల్‌ని ఉపయోగించాము, తద్వారా కోడ్ యొక్క కార్యాచరణ వ్యవధిలో మనకు కావలసిన విధంగా దాన్ని సర్దుబాటు చేయవచ్చు. అది బాగుంది, సరియైనదా?

2.3 ELSE ప్రకటనలు

ఇక్కడ మనం ఎందుకు మరియు ఎలా నేర్చుకుంటాము ఉంటే పదానికి ఒక నిబంధన ఉండవచ్చు లేకపోతే తద్వారా అది పరిస్థితిని నిర్ణయిస్తుంది ఉంటే ప్రకటన తప్పు.

అది చాలా గందరగోళంగా అనిపిస్తే క్షమించండి, చింతించకండి, మేము ఈ క్రింది ఉదాహరణతో అర్థం చేసుకోవడానికి ప్రయత్నిస్తాము:

const int kPinLed = 13
void setup()
{
pinMode(kPinLed, OUTPUT)
}
int delayTime = 1000
void loop()
{
if(delayTime <= 100){ // If it is less than or equal to 100, reset it
delayTime = 1000
}
else{
delayTime = delayTime - 100
}
digitalWrite(kPinLed, HIGH)
delay(delayTime)
digitalWrite(kPinLed, LOW)
delay(delayTime)
}

10 వ పంక్తి కోడ్‌లో delayTime ఉన్నప్పుడు మాత్రమే అమలు చేయబడుతుందని పై వాటిలో మీరు బాగా చూడవచ్చు 100 కి తక్కువ లేదా సమానం, కాకపోతే 13 వ పంక్తిలోని కోడ్ అమలు అవుతుంది, కానీ రెండూ కలిసి ఎప్పుడూ జరగవు, 10 వ పంక్తి లేదా 13 వ పంక్తి కోడ్ అమలు చేయబడుతుంది, రెండూ ఎప్పుడూ ఉండవు.

మా మునుపటి విభాగం 2.2 లో చేసినదానికంటే భిన్నంగా, ఇక్కడ మేము 100 తో పోల్చితే 0 తో పోల్చలేదని మీరు గమనించవచ్చు. దీనికి కారణం, ఈ ఉదాహరణలో మనం 100 ను తీసివేసే ముందు, సెక్షన్ 2.2 లో విరుద్ధంగా, మేము పోల్చిన తరువాత తీసివేయబడుతుంది. మేము 100 కి బదులుగా 0 ను పోల్చి చూస్తే ఏమి జరిగిందో మీరు చెప్పగలరా?

2.4 WHILE ప్రకటనలు

TO అయితే ప్రకటన చాలా పోలి ఉంటుంది ఉంటే స్టేట్మెంట్, ఇది కోడ్ యొక్క బ్లాక్కు (ఇది వంకర బ్రాకెట్ల మధ్య ఉండవచ్చు) పదేపదే అమలుకు కారణమవుతుందనే నిజం తప్ప, పరిస్థితులు వర్తిస్తాయి మరియు ఇది లేకుండా పనిచేస్తుంది లేకపోతే ప్రకటన.

దీన్ని బాగా అర్థం చేసుకోవడానికి క్రింది ఉదాహరణ మీకు సహాయం చేస్తుంది

const int kPinLed = 13
void setup()
{
pinMode(kPinLed, OUTPUT)
}
int delayTime = 1000
void loop()
{
while(delayTime > 0){ // while delayTime is greater than 0
digitalWrite(kPinLed, HIGH)
delay(delayTime)
digitalWrite(kPinLed, LOW)
delay(delayTime)
delayTime = delayTime - 100
}
while(delayTime <1000){ // while delayTime is less than 1000
delayTime = delayTime + 100 // do this first so we don’t have a loop with delayTime = 0
digitalWrite(kPinLed, HIGH)
delay(delayTime)
digitalWrite(kPinLed, LOW)
delay(delayTime)
}
}

పై కోడ్ ఏమి ప్రోగ్రామ్ చేయబడిందో మీరు Can హించగలరా? బాగా, ఇది LED ని వేగంగా మరియు తరువాత నెమ్మదిగా రెప్పపాటు కోసం రూపొందించబడింది.

2.5 ఏది నిజం మరియు తప్పు?

ప్రోగ్రామింగ్ భాషలో, తప్పుడు సున్నా (0) ను సూచిస్తుంది. వాస్తవానికి 'ట్రూ' ఉపయోగించబడదు, బదులుగా ఏమీ తప్పు కానప్పుడు, చేర్చబడినవన్నీ నిజమని భావించబడుతుంది.

ఇది కొద్దిగా వింతగా కనిపిస్తుంది, అయితే ఇది చాలా చక్కగా పని చేస్తుంది.

మేము ఈ క్రింది ఉదాహరణ ద్వారా పరిస్థితిని గ్రహించడానికి ప్రయత్నిస్తాము.

క్రింద ఇచ్చిన విధంగా మీరు కొన్నిసార్లు కోడ్‌ను చూడవచ్చు:

while (1){
digitalWrite(kPinLed, HIGH)
delay(100)
digitalWrite(kPinLed, LOW)
delay(100)
}

సుదీర్ఘ శక్తి అందుబాటులో ఉన్నందున, LED అమలు సైక్లింగ్‌ను ఎప్పటికీ ఉంచుతుంది.

ఏదేమైనా, అనుకోకుండా వినియోగదారు == కు బదులుగా = ను వర్తింపజేసినప్పుడు ఈ రకమైన కోడ్ యొక్క ఒక ఇబ్బంది తలెత్తుతుంది.

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

ఉదాహరణకు, మీరు వరుసగా వేగవంతమైన నమూనాతో మరియు పదేపదే ఫ్లాష్ చేయడానికి మీకు LED అవసరమని అనుకుందాం, కానీ తప్పుగా == బదులుగా = ఉపయోగించారు.

కోడ్ అప్పుడు ఇలా కనిపిస్తుంది:

int delayTime = 1000
void loop()
{
if(delayTime = 0){ // WRONG!!! the = should have been ==
delayTime = 1000
}
digitalWrite(kPinLed, HIGH)
delay(delayTime)
digitalWrite(kPinLed, LOW)
delay(delayTime)
delayTime = delayTime - 100
}

పొరపాటు 0 నుండి delayTime ని కేటాయిస్తుంది మరియు దారితీస్తుంది ఉంటే 0 నిజమో కాదో తనిఖీ చేసే స్టేట్మెంట్. 0 తప్పుడుని సూచిస్తుంది కాబట్టి, ఇది నిజం కాదని అనుకుంటుంది మరియు delayTime = 1000 అమలు చేయడాన్ని ఆపివేస్తుంది, కానీ బదులుగా ఫంక్షన్ delayTime లూప్ () సమయంలో 0 వద్ద జరుగుతుంది.

ఇది చాలా అవాంఛనీయమైనదిగా కనిపిస్తుంది !!

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

2.6 కలయికలు

కొన్నిసార్లు మీరు కలిసి బహుళ విషయాలను పరీక్షించవలసిన అవసరాన్ని అనుభవించవచ్చు. ఇలా, వేరియబుల్ రెండు సంఖ్యల మధ్య ఉందో లేదో మీరు పరిశీలించాలనుకోవచ్చు. If స్టేట్మెంట్‌ను అనేకసార్లు ఉపయోగించి దీన్ని అమలు చేయగలిగినప్పటికీ, మంచి మరియు సులభంగా చదవడానికి తార్కిక కలయికలను ఉపయోగించడం మరింత సౌకర్యవంతంగా ఉంటుంది.

కింది పట్టికలో చూపిన విధంగా, తార్కిక పదాలపై కలయికలను 3 పద్ధతులతో చేయవచ్చు:

NOT ఆపరేటర్ వేరియబుల్ కోసం స్విచ్చర్‌గా పనిచేయగలదని తెలుసుకోవడం ఆసక్తికరంగా ఉంటుంది నిజం లేదా తప్పుడు (లేదా తక్కువ లేదా ఎక్కువ).

కింది ఉదాహరణ పరిస్థితిని వివరిస్తుంది:

int ledState = LOW
void loop()
{
ledState = !ledState // toggle value of ledState
digitalWrite(kPinLed, ledState)
delay(1000)
}

ఇక్కడ ledState తక్కువ అవుతుంది, తదనంతరం ledState = !ledState, అది అధికంగా మారుతుంది. కింది లూప్ కారణం అవుతుంది ledState ledState = !ledState ఉన్నప్పుడు అధికంగా ఉండాలి తక్కువగా వుంది.

2.7 ప్రకటనలకు

ఇప్పుడు మనం మరొక నియంత్రణ నిర్మాణం గురించి అర్థం చేసుకోవడానికి ప్రయత్నిస్తాము కోసం లూప్. మీరు అనేకసార్లు ఏదైనా అమలు చేయాలనుకున్నప్పుడు ఇది చాలా సులభమవుతుంది.

ఈ క్రింది ఉదాహరణతో దీనిని అర్థం చేసుకుందాం:

const int kPinLed = 13
void setup()
{
pinMode(kPinLed, OUTPUT)
}
void loop()
{
for(int i = 0 i <4 i++){
digitalWrite(kPinLed, HIGH)
delay(200)
digitalWrite(kPinLed, LOW)
delay(200)
}
delay(1000) // 1 second
}

మీరు లైన్‌లో ప్రత్యేకమైనదాన్ని కనుగొనవచ్చు కోసం.

ఇది కోడ్ i ++? . సోమరితనం మరియు అనుకూలమైన సత్వరమార్గాల ద్వారా కోడింగ్‌ను అమలు చేయాలనుకునే ప్రోగ్రామర్‌లకు ఇది ఉపయోగపడుతుంది

పై పదాన్ని కాంపౌండ్ ఆపరేటర్లు అని పిలుస్తారు, ఎందుకంటే వారు ఒక అసైన్‌మెంట్ ఆపరేటర్‌ను మరొక అసైన్‌మెంట్ ఆపరేటర్‌తో కలిపే పనిని చేస్తారు. వీటిలో అత్యంత ప్రాచుర్యం పొందినవి ఈ క్రింది పట్టికలో చూడవచ్చు:

ఒక స్టేట్మెంట్లో 3 ఉప స్టేట్మెంట్లు ఉన్నాయని మీరు కనుగొంటారు. ఇది క్రింద చూపిన విధంగా నిర్మించబడింది:

for (statement1conditionstatement2){
// statements
}

# 1 ప్రకటన ప్రారంభంలోనే మరియు ఒక్కసారి మాత్రమే జరుగుతుంది. లూప్ సమయంలో ప్రతిసారీ పరిస్థితి పరీక్షించబడుతుంది. ఎప్పుడు నిజం వంకర బ్రాకెట్లలో, తదుపరి ప్రకటన # 2 అమలు అవుతుంది. ఒక సందర్భంలో తప్పుడు, సిస్టమ్ కోడ్ యొక్క తదుపరి బ్లాక్‌కు దూకుతుంది.

మరిన్ని LED లను కనెక్ట్ చేస్తోంది

సరే, ఇప్పుడు మరింత ఆసక్తికరమైన ప్రభావాలను పొందడానికి ఎక్కువ సంఖ్యలో LEDS ని ఎలా కనెక్ట్ చేయవచ్చో చూద్దాం.

క్రింద చూపిన విధంగా దయచేసి LED లు మరియు Arduino ని కనెక్ట్ చేయండి. ఎరుపు తీగ వాస్తవానికి అవసరం లేదు, కానీ బ్రెడ్‌బోర్డులో సరఫరా పట్టాలు రెండింటినీ కలిగి ఉండటం ఎల్లప్పుడూ మంచిది.

ఇప్పుడు మన హార్డ్వేర్ సరిగ్గా కాన్ఫిగర్ చేయబడిందా లేదా అని తనిఖీ చేయడానికి ఒక ప్రోగ్రామ్ను పరిష్కరించుకుందాం.

సంబంధిత హార్డ్‌వేర్‌లు సరిగ్గా వైర్ చేయబడిందా లేదా అని తనిఖీ చేయడానికి చిన్న బిట్స్ ప్రోగ్రామ్‌లను దశలవారీగా కోడ్ చేసి అమలు చేయడానికి ఎల్లప్పుడూ సిఫార్సు చేయబడింది.

ఇది సాధ్యమయ్యే లోపాన్ని త్వరగా పరిష్కరించడానికి సహాయపడుతుంది.

దిగువ కోడ్ ఉదాహరణ LED 2 నుండి 5 వరకు ఒక నిర్దిష్ట నమూనాను ఒకదాని తరువాత ఒకటి చక్రీయ పద్ధతిలో తిప్పడం ద్వారా అందిస్తుంది.

const int kPinLed1 = 2
const int kPinLed2 = 3
const int kPinLed3 = 4
const int kPinLed4 = 5
void setup()
{
pinMode(kPinLed1, OUTPUT)
pinMode(kPinLed2, OUTPUT)
pinMode(kPinLed3, OUTPUT)
pinMode(kPinLed4, OUTPUT)
}
void loop()
{
// turn on each of the LEDs in order
digitalWrite(kPinLed1, HIGH)
delay(100)
digitalWrite(kPinLed2, HIGH)
delay(100)
digitalWrite(kPinLed3, HIGH)
delay(100)
digitalWrite(kPinLed4, HIGH)
delay(100)
// turn off each of the LEDs in order
digitalWrite(kPinLed1, LOW)
delay(100)
digitalWrite(kPinLed2, LOW)
delay(100)
digitalWrite(kPinLed3, LOW)
delay(100)
digitalWrite(kPinLed4, LOW)
}

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

పై కోడ్ రాయడానికి మంచి మార్గాలు ఉన్నాయి, కింది విభాగం దానిని వెల్లడిస్తుంది.

2.9 శ్రేణులను పరిచయం చేస్తోంది

శ్రేణులు వేరియబుల్స్ యొక్క సమూహం కావచ్చు, ఇవి ఇండెక్స్ సంఖ్యలతో సూచించబడతాయి. దీన్ని బాగా అర్థం చేసుకోవడానికి ఈ క్రింది ఉదాహరణ మాకు సహాయపడుతుంది.

const int k_numLEDs = 4
const int kPinLeds[k_numLEDs] = {2,3,4,5} // LEDs connected to pins 2-5
void setup()
{
for(int i = 0 i pinMode(kPinLeds[i], OUTPUT)
}
}
void loop()
{
for(int i = 0 i digitalWrite(kPinLeds[i], HIGH)
delay(100)
}
for(int i = k_numLEDs - 1 i >= 0 i--){
digitalWrite(kPinLeds[i], LOW)
delay(100)
}
}

సరే, ఇప్పుడు ప్రతి విభాగం గుండా వెళ్లి అవి వాస్తవంగా ఎలా పని చేస్తాయో అర్థం చేసుకుందాం.

const int k_numLEDs = 4

శ్రేణిలో మనం ఎన్ని గరిష్ట అంశాలను కలిగి ఉండాలో పై కోడ్ నిర్వచిస్తుంది. ప్రతిదీ శ్రేణిలో వ్రాయబడిందని మరియు శ్రేణి ముగిసిన తర్వాత ఏమీ లేదని నిర్ధారించడానికి ఈ కోడ్ తరువాతి విభాగాలలో మాకు సహాయపడుతుంది.

const int kPinLeds[k_numLEDs] = {2,3,4,5} // LEDs connected to pins 2-5

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

మీరు సంఖ్య 0 తో సూచించబడిన శ్రేణిని కనుగొన్నప్పుడు, ఇది code: k_LEDPins is k_LEDPins[0] లో చూపిన విధంగా శ్రేణిలోని మొదటి మూలకాన్ని సూచిస్తుంది.

అదేవిధంగా చివరి మూలకం k_LEDPins[3] గా చూపబడుతుంది, ఎందుకంటే 0 నుండి 3 వరకు లెక్కింపు 4.

void setup()
{
for(int i = 0 i pinMode(kPinLeds[i], OUTPUT)
}
}

పై కోడ్ ప్రతి శ్రేణి మూలకాల ద్వారా కొనసాగడానికి మరియు వాటిని OUTPUTS గా సెట్ చేయడానికి లూప్ వాడకాన్ని చూపుతుంది. శ్రేణిలోని ప్రతి మూలకాలను చేరుకోవడానికి మేము సూచికతో పాటు చదరపు బ్రాకెట్లను అమలు చేస్తాము.

శ్రేణులు లేకుండా # 5 ను పిన్ చేయడానికి పిన్ # 2 ను ఉపయోగించడం సాధ్యమేనా అని మీరు ఆలోచిస్తున్నట్లయితే, సమాధానం అవును, అది సాధ్యమే. కానీ ఈ ఉదాహరణలో అది చేయలేదు ఎందుకంటే మేము ఆ విధంగా చేయలేదు. ఎంచుకున్న అవుట్పుట్ పిన్స్ వరుసలో లేకపోతే కింది విభాగాలలో మీరు శ్రేణి విధానాన్ని తొలగించవచ్చు.

ముందుకు వెళుతున్నప్పుడు, కోడ్ యొక్క తదుపరి బ్లాక్ ఏమి చేస్తుందో చూద్దాం:

for(int i = 0 i digitalWrite(kPinLeds[i], HIGH)
delay(100)
}

ఇక్కడ కోడ్ ప్రతి LED ద్వారా 100 మిల్లీసెకన్ల గ్యాప్ లేదా ఆలస్యం తో వరుసగా వాటిని ఆన్ చేస్తుంది.

for(int i = k_numLEDs - 1 i >= 0 i--){
digitalWrite(kPinLeds[i], LOW)
delay(100)
}

పై కోడ్‌ను ఉపయోగించడం వల్ల అప్లికేషన్ ఎలా ఉంటుందో ప్రదర్శిస్తుంది లూప్ కోసం రివర్స్ క్రమంలో కూడా లూప్ ద్వారా తరలించడానికి ఉపయోగించవచ్చు.

ఇది k_numLEDs - 1 నుండి ప్రారంభమవుతుంది ఎందుకంటే శ్రేణులు సున్నా సూచిక. మేము k_LEDPins[4] నుండి ప్రారంభించము ఎందుకంటే అది శ్రేణి ముగింపును దాటుతుంది.

కోడ్ తనిఖీ చేయడానికి> = 0 ను ఉపయోగిస్తుంది, తద్వారా సూచిక 0 లోని మొదటి మూలకం తప్పిపోదు లేదా విస్మరించబడదు.

అధ్యాయం 3

ఇన్పుట్ అంటే ఏమిటి

Arduino ఉపయోగించి పనులను ఎలా ఆపరేట్ చేయాలో నేర్చుకున్నాము. ఈ అధ్యాయంలో బాహ్య పారామితుల నుండి ఇన్పుట్లను ఇంటర్ఫేస్ చేయడం ద్వారా వాస్తవ ప్రపంచాన్ని ఎలా గ్రహించాలో చర్చించాము.

3.1 పుష్బటన్లను ఉపయోగించడం

పుష్-బటన్ అంటే ఏమిటి మరియు అది ఎలా పనిచేస్తుందో మనందరికీ తెలుసు. ఇది ఒక రకమైన స్విచ్ లేదా బటన్, ఇది ఒక సర్క్యూట్ దశ నుండి మరొక సిగ్నల్‌ను అణగారిన స్థితిలో ఉన్నప్పుడు క్షణికంగా కలుపుతుంది మరియు విడుదల చేసినప్పుడు సిగ్నల్‌ను విచ్ఛిన్నం చేస్తుంది.

3.1.1 ఒక బటన్ మరియు ఒక LED

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

సూచించిన పుష్ బటన్‌ను మైక్రో స్విచ్ పుష్ బటన్ అని కూడా పిలుస్తారు, మొత్తం 4 పిన్‌లు (ప్రతి వైపు 2 జతలు) ఉంటాయి. నెట్టివేసినప్పుడు, ప్రతి జత పిన్‌లు అంతర్గతంగా కలుస్తాయి మరియు వాటి అంతటా కనెక్షన్ లేదా ప్రసరణను ప్రారంభిస్తాయి.

ఈ ఉదాహరణలో మేము ఈ పిన్స్ లేదా పరిచయాలలో కేవలం ఒక జతని ఉపయోగిస్తున్నాము, మరొక జత అసంబద్ధం మరియు అందువల్ల విస్మరించబడుతుంది.

కింది కోడ్‌ను వర్తింపజేస్తున్నాం మరియు అది పని చేస్తుందో లేదో చూద్దాం!

const int kPinButton1 = 2
const int kPinLed = 9
void setup()
{
pinMode(kPinButton1, INPUT)
digitalWrite(kPinButton1, HIGH) // turn on pull-up resistor
pinMode(kPinLed, OUTPUT)
}
void loop()
{
if(digitalRead(kPinButton1) == LOW){
digitalWrite(kPinLed, HIGH)
}
else{
digitalWrite(kPinLed, LOW)
}
}

మీరు ఇక్కడ అసాధారణంగా కనిపించే కొన్ని విషయాలు కనుగొనవచ్చు. వాటిని దశల వారీగా గుర్తించండి.

void setup()
{
pinMode(kPinButton1, INPUT)
digitalWrite(kPinButton1, HIGH) // turn on pull-up resistor
pinMode(kPinLed, OUTPUT)
}

మేము చేసే మొదటి పని దాన్ని పరిష్కరించడం బటన్పిన్ గా INPUT. అది చాలా ప్రాథమికమైనది, నాకు తెలుసు.

తరువాత, మేము కేటాయిస్తాము అధిక కు INPUT పిన్. మీరు ఆశ్చర్యపోతున్నారా, ఇన్పుట్ వద్ద ఏదైనా రాయడం ఎలా సాధ్యమవుతుంది? ఖచ్చితంగా, ఇది ఆసక్తికరంగా ఉండవచ్చు.

వాస్తవానికి, ఒక ఆర్డునో ఇన్‌పుట్‌కు అధికంగా కేటాయించడం అంతర్గత 20 కే ఓం పుల్-అప్ రెసిస్టర్‌ను టోగుల్ చేస్తుంది (ఈ పిన్‌పై తక్కువ దాన్ని ఆఫ్ చేస్తుంది).

మీరు అడిగే మరో ప్రశ్న ఏమిటంటే పుల్-అప్ రెసిస్టర్. మీరు పుల్-అప్ రెసిస్టర్‌లపై సమగ్రమైన పోస్ట్‌ను కవర్ చేసాను ఇక్కడ నేర్చుకోండి .

సరే, ముందుకు సాగడం, ఇప్పుడు ప్రధాన లూప్ కోడ్‌ను చూద్దాం:

void loop()
{
if(digitalRead(kPinButton1) == LOW){
digitalWrite(kPinLed, HIGH)
}
else{
digitalWrite(kPinLed, LOW)
}
}

మీరు పుష్ బటన్‌ను నొక్కినప్పుడు, వైర్డు పిన్ భూమికి అనుసంధానించబడుతుంది, ఇది a తక్కువ ఆ పిన్‌కు. మరియు నొక్కిచెప్పని స్థితిలో ఉన్నప్పుడు అదే పిన్ వద్ద ఉంచబడుతుంది అధిక లేదా 20K అంతర్గత పుల్-అప్ రెసిస్టర్ ద్వారా + 5 వి.

పుష్ బటన్ నొక్కినప్పుడు (తక్కువ) ఆర్డునో ఎల్‌ఈడీని వెలిగించాలని ఇక్కడ మేము కోరుకుంటున్నాము, అందువల్ల పుష్ బటన్ నుండి తక్కువ ప్రతి స్పందన కోసం అవుట్పుట్ కోసం మేము హై వ్రాస్తాము, అది నొక్కినప్పుడు.

3.1.2 రెండు బటన్లు మరియు ఒక LED

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

ఈ సమయం వరకు, మేము స్విచ్ ఆన్ (హై) లేదా ఎల్‌ఈడీ ఆఫ్ (తక్కువ) మారడం కోసం వ్రాసే కోడ్‌లను అధ్యయనం చేసాము.

ఇప్పుడు ఆర్డునోతో LED యొక్క ప్రకాశాన్ని ఎలా నియంత్రించవచ్చో చూద్దాం.

ఇది రెండు పద్ధతులను ఉపయోగించి చేయవచ్చు:

1. కరెంట్ మొత్తాన్ని LED కి పరిమితం చేయడం ద్వారా
2. ఉపయోగించడం ద్వార పిడబ్ల్యుఎం లేదా పల్స్ వెడల్పు మాడ్యులేషన్, దీనిలో LED కి సరఫరా చాలా వేగంగా కావలసిన రేటుకు ఆన్ / ఆఫ్ చేయబడుతుంది, ఇది సగటు ప్రకాశాన్ని ఉత్పత్తి చేస్తుంది, దీని తీవ్రత PWM పై ఆధారపడి ఉంటుంది.

ఒక ఆర్డునో బోర్డ్‌లో పిడబ్ల్యుఎం మద్దతు టిల్డే (~) తో గుర్తించబడిన పిన్‌లపై లభిస్తుంది, అవి పిన్స్ 3, 4,5,9,10 మరియు 11) 500 హెర్ట్జ్ (సెకనుకు 500 సార్లు) వద్ద ఉంటాయి. వినియోగదారు 0 మరియు 255 మధ్య ఏదైనా విలువను అందించగలుగుతారు, ఇక్కడ 0 HIGH లేదా + 5V లేదు అని సూచిస్తుంది, మరియు 255 Arduino కి HIGH లేదా + 5V ని ఎప్పటికప్పుడు పొందమని చెబుతుంది. ఈ ఆదేశాలను ప్రారంభించడానికి మీరు కావలసిన విలువతో అనలాగ్‌రైట్ () ను యాక్సెస్ చేయాలి.

మీరు PWM ను x / 255 అని అనుకోవచ్చు, ఇక్కడ x మీరు analogWrite() ద్వారా పంపించదలిచిన విలువ.

పైన చూపిన విధంగా Arduino మరియు ఇతర పారామితులను సెటప్ చేయండి.

const int kPinButton1 = 2
const int kPinButton2 = 3
const int kPinLed = 9
void setup()
{
pinMode(kPinButton1, INPUT)
pinMode(kPinButton2, INPUT)
pinMode(kPinLed, OUTPUT)
digitalWrite(kPinButton1, HIGH) // turn on pullup resistor
digitalWrite(kPinButton2, HIGH) // turn on pullup resistor
}
int ledBrightness = 128
void loop()
{
if(digitalRead(kPinButton1) == LOW){
ledBrightness--
}
else if(digitalRead(kPinButton2) == LOW){
ledBrightness++
}
ledBrightness = constrain(ledBrightness, 0, 255)
analogWrite(kPinLed, ledBrightness)
delay(20)
}

మీకు ఇక్కడ 3 పంక్తులు కొంత వివరణ అవసరం.

ledBrightness = constrain(ledBrightness, 0, 255)
25 analogWrite(kPinLed, ledBrightness)
26 delay(20)

పంక్తి: ledBrightness = constrain(ledBrightness, 0, 255) ఆర్డ్యునో లోపల ఒక ప్రత్యేకమైన ఫంక్షన్‌ను నిర్బంధ () అని పిలుస్తారు.

ఈ అంతర్గత ఫంక్షన్ కింది వాటికి సమానమైన కోడ్‌ను కలిగి ఉంటుంది:

పూర్ణాంకం (పూర్ణాంక విలువ, పూర్ణాంక నిమిషం, పూర్ణాంకం)
{
if(value > max){
value = max
}
if(value value = min
}
return value
}

దీనికి ముందు చర్చించిన అన్ని సంకేతాలు ప్రారంభమయ్యాయి శూన్యమైనది , అంటే దేనినీ తిరిగి ఇవ్వకూడదు (శూన్యమైనది). పై కోడ్ ప్రారంభమవుతుంది పూర్ణాంకానికి , ఇది పూర్ణాంకాన్ని తిరిగి ఇస్తుందని సూచిస్తుంది. మేము తరువాతి విభాగాలలో మరింత చర్చిస్తాము, ప్రస్తుతానికి ఒక పూర్ణాంకానికి భిన్నమైన భాగాలు లేవని గుర్తుంచుకోండి.

కుడి, కాబట్టి ఇది సూచిస్తుంది: కోడ్: ledBrightness = constrain(ledBrightness, 0, 255) ledBrightness to be within the range of 0 and 255 ని కేటాయిస్తుంది.

తదుపరి పంక్తి analogWrite ఎంచుకున్న పిన్‌పై PWM ను కావలసిన విలువతో వర్తింపజేయడానికి Arduino ని ఆదేశించడానికి.

తరువాతి పంక్తి 20 మిల్లీసెకన్ల ఆలస్యాన్ని సృష్టిస్తుంది, ఇది మేము 50 హెర్ట్జ్ కంటే వేగంగా లేదా సెకనుకు 50 సార్లు తిన్నట్లు సర్దుబాటు చేయకుండా చూసుకోవాలి. ఎందుకంటే మానవులు ఆర్డునో కంటే చాలా నెమ్మదిగా ఉంటారు. అందువల్ల ఆలస్యం చేయకపోతే ప్రోగ్రామ్ మొదటి బటన్‌ను నొక్కడం LED ఆఫ్ చేసి, రెండవ బటన్‌ను నొక్కితే దాన్ని ఆన్ చేసిందని మాకు అనిపించవచ్చు (నిర్ధారించడానికి మీరే ప్రయత్నించండి).

3.2 పొటెన్టోమీటర్లు

ముందుకు సాగండి మరియు ఎలా ఉపయోగించాలో నేర్చుకుందాం Arduino తో పొటెన్టోమీటర్లు.

పొటెన్షియోమీటర్ లేదా కుండ ఎలా పనిచేస్తుందో తెలుసుకోవడానికి, మీరు దీన్ని చదువుకోవచ్చు వ్యాసం .

పైన చూపిన విధంగా చూపిన పారామితులను మీ ఆర్డునోతో కనెక్ట్ చేయండి.

ఒక కుండలో 3 టెర్మినల్స్ ఉంటాయి. మిడిల్ టెర్మినస్ల్ ఆర్డునోలోని ANALOG IN 0 తో కనెక్ట్ అవుతుంది. మిగిలిన రెండు బాహ్య టెర్మినల్స్ + 5 వి మరియు 0 వి సరఫరా పట్టాలకు అనుసంధానించబడి ఉండవచ్చు.

ప్రోగ్రామ్ చేద్దాం మరియు ఫలితాలను చూద్దాం:

const int kPinPot = A0
const int kPinLed = 9
void setup()
{
pinMode(kPinPot, INPUT)
pinMode(kPinLed, OUTPUT)
}
void loop()
{
int ledBrightness
int sensorValue = 0
sensorValue = analogRead(kPinPot)
ledBrightness = map(sensorValue, 0, 1023, 0, 255)
analogWrite(kPinLed, ledBrightness)
}

మీరు పూర్తిగా క్రొత్తగా కనిపించే మరియు మా మునుపటి కోడ్‌లలో చేర్చని కొన్ని విషయాలను మీరు కనుగొంటారు.

1. స్థిరమైన kPinPot A0 గా కేటాయించబడుతుంది, దీనిలో A అనలాగ్ పిన్‌లలో ఒకదాన్ని వివరించడానికి సత్వరమార్గం. అయినప్పటికీ A0 పిన్ # 14, A1 ను పిన్ చేయడానికి # 15 మరియు మొదలగునవి సూచిస్తుంది, మరియు మీరు ఒక ప్రయోగం కోసం పిన్స్ అయిపోయినప్పుడు ఇవి డిజిటల్ ఇన్‌పుట్‌లు / అవుట్‌పుట్‌లుగా ఉపయోగించడానికి మిమ్మల్ని అనుమతిస్తాయి. కానీ మీరు డిజిటల్ పిన్‌లను అనలాగ్ పిన్‌లుగా ఉపయోగించలేరని గుర్తుంచుకోండి.
2. పంక్తి: ledBrightness = map(sensorValue, 0, 1023, 0, 255) Arduino లో కొత్త లోపలి ఫంక్షన్‌ను అందిస్తుంది మ్యాప్ (). ఈ లక్షణం ఇచ్చిన పరిధి నుండి మరొకదానికి తిరిగి క్రమాంకనం చేస్తుంది, దీనిని పిలుస్తారు మ్యాప్ (విలువ, నుండి, తక్కువ నుండి, తక్కువ, నుండి ఎత్తు వరకు). analogueRead నుండి ఇది కీలకం కావచ్చు 0-1023 పరిధిలో విలువను ఇస్తుంది, కాని అనలాగ్‌రైట్ 0-255 నుండి విలువను అంగీకరించగలదు.

మారుతున్న ప్రతిఘటన ద్వారా LED యొక్క ప్రకాశాన్ని నియంత్రించడం సాధ్యమే కాబట్టి, ఒక కుండ ప్రయోజనం కోసం సరిపోయేది, ఎందుకు ఆర్డునో వాడకం అని మీరు అనుకోవచ్చు. ఒక కుండను ఆర్డునోతో ఎలా కాన్ఫిగర్ చేయవచ్చో చూపించడానికి, మళ్ళీ అది పునాది మాత్రమే.

సమస్యలు లేవు, ఇప్పుడు మేము ఆర్డునో లేకుండా చేయలేని పనిని చేస్తాము.

ఈ ప్రయోగంలో, LED యొక్క మెరిసే వేగం లేదా రేటును నియంత్రించడానికి కుండ యొక్క విభిన్న నిరోధకత ఎలా ఉపయోగించబడుతుందో చూద్దాం.

కార్యక్రమం ఇక్కడ ఉంది:

const int kPinPot = A0
const int kPinLed = 9
void setup()
{
pinMode(kPinLed, OUTPUT)
}
void loop()
{
int sensorValue
sensorValue = analogRead(kPinPot)
digitalWrite(kPinLed, HIGH)
delay(sensorValue)
digitalWrite(kPinLed, LOW)
delay(sensorValue)
}

3.2.3 ఆలస్యాన్ని నివారించడం ()

పై కోడ్ బాగుంది, కాని ప్రతి పూర్తి చక్రం గుండా వెళ్ళే వరకు LED కుండ విలువను తనిఖీ చేయలేకపోతుంది. ఎక్కువ ఆలస్యం కోసం ఈ ప్రక్రియ ఎక్కువ అవుతుంది వినియోగదారుడు అతను కుండ ప్రతిస్పందనను కదిలేటప్పుడు చూడటానికి వేచి ఉండాలి. ఈ ఆలస్యాన్ని కొన్ని ఇంటెలిజెంట్ ప్రోగ్రామింగ్‌తో నివారించవచ్చు, తద్వారా వినియోగదారుడు కనీస ఆలస్యం లేకుండా విలువను తనిఖీ చేయడానికి అనుమతిస్తుంది. ఇక్కడ కోడ్ ఉంది.

const int kPinPot = A0
const int kPinLed = 9
void setup()
{
pinMode(kPinLed, OUTPUT)
}
long lastTime = 0
int ledValue = LOW
void loop()
{
int sensorValue
sensorValue = analogRead(kPinPot)
if(millis() > lastTime + sensorValue){
if(ledValue == LOW){
ledValue = HIGH
}
else{
ledValue = LOW
}
lastTime = millis()
digitalWrite(kPinLed, ledValue)
}
}

కాబట్టి పై కోడ్‌లో భిన్నమైనది ఏమిటి? ఇది క్రింది పంక్తిలో తేడా చేస్తుంది.

long lastTime = 0

ఈ విభాగం వరకు, మేము వేరియబుల్ పూర్ణాంకం గురించి చర్చించాము. అయితే, మీరు యాక్సెస్ చేయగల అనేక రకాల వేరియబుల్స్ ఉండవచ్చు. జాబితా క్రింద చదవవచ్చు:

ప్రస్తుతం, సాపేక్షంగా పెద్ద సంఖ్యలో నిల్వ చేయడానికి తెలుసుకోవడం మాత్రమే కీలకం పూర్ణాంకానికి వేరియబుల్, మీరు ఈ పదాన్ని ఉపయోగించవచ్చు పొడవు లేదా a పొడవైన పూర్ణాంకానికి.

ఇక్కడ మీరు మరొక ఆసక్తికరమైన ఫంక్షన్ చూడవచ్చు మిల్లీస్ ().

ఇది ఆర్డునో మొదటి నుండి దాని ఆపరేషన్ సమయంలో పనిచేసిన మిల్లీసెకన్లలో సమయ వ్యవధిని ఉత్పత్తి చేస్తుంది (ఇది ప్రతి 50 రోజుల తరువాత 0 కి రీసెట్ అవుతుంది). ఇక్కడ అది చాలా కాలం తిరిగి వస్తుంది ఎందుకంటే అది తిరిగి వస్తే పూర్ణాంకానికి , ఎక్కువ కాలం లెక్కించడం సాధ్యం కాకపోవచ్చు. మీరు ఎంతకాలం సమాధానం చెప్పగలరా? సమాధానం 32.767 సెకన్లు.

అందువల్ల ఆలస్యం () ను ఉపయోగించకుండా, మేము మిల్లీస్ () కోసం తనిఖీ చేస్తాము మరియు నిర్దిష్ట సంఖ్యలో మిల్లీసెకన్ల లోపాలు వచ్చిన వెంటనే మేము LED ని మారుస్తాము. పర్యవసానంగా మేము దానిని మార్చిన సమయాన్ని చివరిగా నిల్వ చేస్తాము చివరిసారి వేరియబుల్, తద్వారా ఇది కావలసినప్పుడు మళ్ళీ తనిఖీ చేయడానికి అనుమతిస్తుంది.

3.3 RGB LED లు

ఇప్పటివరకు మేము ఒకే రంగు LED తో ఆడాము. LED ని మరొక రంగుతో మార్చడం ద్వారా LED రంగును మార్చగలిగినప్పటికీ, RGB LED లను ఎలా ఉపయోగించాలి LED రంగులను మార్చడానికి LED లను మార్చకుండా?

ఒక RGB LED అనేది ప్రాథమికంగా ఎరుపు, ఆకుపచ్చ మరియు నీలం రంగు LED ని కలిగి ఉంటుంది మరియు ఒకే LED లో విలీనం చేయబడుతుంది. ఇది ఒక సాధారణ సీసం కలిగి ఉంది, ఇది భూమికి లేదా 0 వి సరఫరా రైలుకు వెళుతుంది, మిగిలిన 3 లీడ్లు ఉద్దేశించిన అమలు కోసం వైవిధ్యభరితమైన పిడబ్ల్యుఎం పాజిటివ్ సిగ్నల్స్ తో ఇవ్వబడతాయి కలర్ మిక్సింగ్ .

క్రింద చూపిన విధంగా మీరు సెటప్‌ను వైర్ చేయవచ్చు:

ఇది కొంచెం క్లిష్టంగా అనిపించవచ్చు, కాని వాస్తవానికి ఇది PWM ని ఉపయోగించి మా మునుపటి LED నియంత్రణ రూపకల్పనకు ప్రతిరూపం.

ప్రాక్టీస్ ప్రోగ్రామ్ కోడ్ ఇక్కడ ఉంది:

const int kPinPot1 = A0
const int kPinPot2 = A1
const int kPinPot3 = A2
const int kPinLed_R = 6
const int kPinLed_G = 10
const int kPinLed_B = 11
void setup()
{
pinMode(kPinLed_R, OUTPUT)
pinMode(kPinLed_G, OUTPUT)
pinMode(kPinLed_B, OUTPUT)
}
void loop()
{
int potValue
int ledValue
potValue = analogRead(kPinPot1)
ledValue = map(potValue, 0, 1023, 0, 255)
analogWrite(kPinLed_R, ledValue)
potValue = analogRead(kPinPot2)
ledValue = map(potValue, 0, 1023, 0, 255)
analogWrite(kPinLed_G, ledValue)
potValue = analogRead(kPinPot3)
ledValue = map(potValue, 0, 1023, 0, 255)
analogWrite(kPinLed_B, ledValue)
}

ఈ కోడ్‌ను అప్‌లోడ్ చేసిన తర్వాత, కుండ సర్దుబాట్లు RGB పై ఆసక్తికరమైన కాంతి ప్రభావాన్ని ఎలా సృష్టిస్తాయో చూడండి, ఇది నిజమైన ఆహ్లాదకరంగా ఉంటుంది.

అన్ని 3 కుండలను గరిష్ట స్థానాలకు తరలించినప్పుడు, తెలుపు రంగుకు బదులుగా మీరు ఎరుపు రంగును చూస్తారు. ఎందుకంటే 3 రంగులలో ఎరుపు రంగు చాలా ప్రముఖమైనది మరియు అందువల్ల ఈ పరిస్థితిలో ఆధిపత్యం చెలాయిస్తుంది. అయితే మీరు ఫంక్షన్‌తో ప్రయోగాలు చేయవచ్చు మ్యాప్ () , మరింత సున్నితమైన సమతుల్యతను సృష్టించడానికి, LED యొక్క ఎరుపు భాగానికి అమలు చేయడానికి ముందు.

Arduino తో ఆడియో

ఈ విభాగంలో ఆర్డునో సెటప్‌కు ప్రాథమిక ధ్వని మరియు సంగీతాన్ని ఎలా జోడించాలో నేర్చుకుంటాము.

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

మరింత ఖచ్చితంగా చెప్పాలంటే, మధ్య నోట్ ప్రయత్నించబడుతుంది, ఇది 440 హెర్ట్జ్ ఫ్రీక్వెన్సీ నోట్.

దీన్ని చేయడానికి మేము మిడిల్ ఎ నోట్‌ను ప్లే చేస్తాము మరియు స్క్వేర్ వేవ్‌తో సైన్ వేవ్ సిగ్నల్‌ను ఆప్టిమైజ్ చేస్తాము.

అలాగే, ఫార్ములాపై దావా వేయడం ద్వారా లౌడ్‌స్పీకర్ ఆన్‌లో ఉండగల సమయాన్ని మేము లెక్కిస్తాము:

timeDelay = 1 సెకను / 2 x టోన్ఫ్రీక్వెన్సీ.

timeDelay = 1 సెకను / 2 x 440

timeDelay = 1136 మైక్రోసెకన్లు

4.1 ఆర్డునో బోర్డును హుక్ అప్ చేద్దాం

4.2 సాధారణ గమనికను కలుపుతోంది

మేము ఇప్పటికే ఫంక్షన్ గురించి చర్చించాము ఆలస్యం () ఇక్కడ యూనిట్ మిల్లీసెకన్లలో (రెండవ / 1000) ఉంటుంది, అయితే మీరు మరో ఫంక్షన్‌ను కనుగొంటారు delayMicroseconds() ఇక్కడ యూనిట్ మైక్రోసెకన్లలో ఉంటుంది, (మిల్లీసెకండ్ / 1000).

ప్రస్తుత సెటప్ కోసం, సెకనుకు 440 పప్పుల చొప్పున, స్పీకర్‌తో అనుసంధానించబడిన ఎంచుకున్న పిన్‌పై + 5 వి ఆన్ / ఆఫ్ చేయడానికి కోడ్‌ను ప్రోగ్రామ్ చేస్తాము.

గుర్తుంచుకోండి, చివరి చర్చలో మేము ఉద్దేశించిన ఆడియో నోట్ కోసం 1136 మైక్రోసెకండ్ విలువను నిర్ణయించాము.

కాబట్టి దీని కోసం ఇక్కడ ప్రోగ్రామ్ ఉంది, ఇది మీరు స్పీకర్ కనెక్ట్ చేయబడిన ఆర్డునోను ప్రోగ్రామ్ చేసిన వెంటనే 440 హెర్ట్జ్ యొక్క ఆడియో నోట్‌ను వినడానికి అనుమతిస్తుంది.

const int kPinSpeaker = 9
const int k_timeDelay = 1136
void setup()
{
pinMode(kPinSpeaker, OUTPUT)
}
void loop()
{
digitalWrite(kPinSpeaker, HIGH)
delayMicroseconds(k_timeDelay)
digitalWrite(kPinSpeaker, LOW)
delayMicroseconds(k_timeDelay)
}

పై అనువర్తనంతో ఆడియో గమనికను తయారు చేయడం సాధ్యపడుతుంది, అంటే మన స్వంత ఎంపిక ప్రకారం సంగీతాన్ని సృష్టించవచ్చు.

ఆర్డునోలో కొన్ని ఇంటిగ్రేటెడ్ ఫంక్షన్లు ఉన్నాయని కోడ్ నుండి మేము గ్రహించాము, ఇది సంగీతం యొక్క సృష్టికి అదనంగా దోహదం చేస్తుంది.

మొదటిది స్వరం () ఇది 3 వ ఐచ్ఛిక మూలకంతో పాటు 2 అంశాలతో పనిచేస్తుంది టోన్ (పిన్, ఫ్రీక్వెన్సీ, వ్యవధి). లేదా టోన్ (పిన్, ఫ్రీక్వెన్సీ)

మీరు కేటాయించిన కాల వ్యవధిని అమలు చేయడానికి రెండూ నియమించబడ్డాయి.

సమయ వ్యవధి లేనప్పుడు, కాల్ వరకు సంగీతం ఆడుతూనే ఉంటుంది స్వరం () మళ్ళీ అమలు చేయబడుతుంది లేదా మీరు అమలు చేసే వరకు ఒకటి కాదు ().

మ్యూజిక్ ప్లేయింగ్ మాత్రమే మీరు అమలు చేస్తున్న ప్రాథమిక విషయం అయితే ఇది ఆలస్యం ఫంక్షన్‌ను ఉపయోగించి చేయవలసి ఉంటుంది.

సమయం ఎంత కీలకం కావచ్చు, ఎందుకంటే ఇది ఎంతకాలం సంగీతాన్ని ప్లే చేయాలో సమయాన్ని అందిస్తుంది, కాబట్టి మీరు ఇతర పనులను స్వేచ్ఛగా చేయవచ్చు. వ్యవధి ముగిసిన వెంటనే, సంగీతం ఆగిపోతుంది.

తదుపరి ఫంక్షన్ ఒకటి కాదు () ఒకే పరామితిని నిర్వహిస్తుంది మరియు ఎంచుకున్న టోన్‌ను నిర్దిష్ట కేటాయించిన పిన్‌పై ఆపివేస్తుంది.

విచిత్రమైన హెచ్చరిక: ఎప్పుడైనా స్వరం () ఫంక్షన్ అమలు చేయబడింది, పిన్ 3 మరియు 11 పై పిడబ్ల్యుఎం ఫంక్షన్ పనిచేయడం ఆగిపోతుంది.

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

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

#define NOTE_C4 262
#define NOTE_D4 294
#define NOTE_E4 330
#define NOTE_F4 349
#define NOTE_G4 392
#define NOTE_A4 440
#define NOTE_B4 494
#define NOTE_C5 523
const int kPinSpeaker = 9
void setup()
{
pinMode(kPinSpeaker, OUTPUT)
}
void loop()
{
tone(kPinSpeaker, NOTE_C4, 500)
delay(500)
tone(kPinSpeaker, NOTE_D4, 500)
delay(500)
tone(kPinSpeaker, NOTE_E4, 500)
delay(500)
tone(kPinSpeaker, NOTE_F4, 500)
delay(500)
tone(kPinSpeaker, NOTE_G4, 500)
delay(500)
tone(kPinSpeaker, NOTE_A4, 500)
delay(500)
tone(kPinSpeaker, NOTE_B4, 500)
delay(500)
tone(kPinSpeaker, NOTE_C5, 500)
delay(500)
noTone(kPinSpeaker)
delay(2000)
}

పై కోడ్‌లో మీరు క్రొత్తదాన్ని గమనించి ఉండవచ్చు # నిర్వచించండి .

కంపైల్ చేస్తున్నప్పుడు ఈ పదం కంప్యూటర్ కోసం సెర్చ్ అండ్ రీప్లేస్ కమాండ్ లాగా పనిచేస్తుంది.

ఇది స్థలం ముందు మొదటిదాన్ని కనుగొన్నప్పుడల్లా, దాన్ని లైన్ యొక్క మిగిలిన భాగంతో భర్తీ చేస్తుంది (మాక్రోస్ అని పిలుస్తారు).

కాబట్టి కంప్యూటర్ చూసినప్పుడు ఈ ఉదాహరణలో NOTE_E4 ఇది త్వరగా 330 పరిమాణంతో భర్తీ చేస్తుంది.

మరిన్ని గమనికలు మరియు అనుకూలీకరణ కోసం మీరు మీ USB స్టిక్‌లోని ఫైల్‌ను సూచించవచ్చు pitches.h , మీ ప్రాధాన్యత కోసం చాలా పౌన encies పున్యాలు కనుగొనబడతాయి.

4.4 ఫంక్షన్లతో సంగీతం

పై కోడ్ బాగుంది, కానీ చాలా పునరావృత్తులు ఉన్నట్లు అనిపిస్తుంది, ఈ పునరావృత్తులు తగ్గించడానికి కొన్ని పద్ధతులు ఉండాలి, సరియైనదా?

ఇప్పటివరకు మేము ఆర్డునోతో సహా రెండు ముఖ్యమైన ఫంక్షన్లతో పనిచేశాము. ఇప్పుడు మన స్వంత విధులను సృష్టించిన సమయం కావచ్చు.

ప్రతి ఫంక్షన్ దానితో సంబంధం ఉన్న వేరియబుల్ రకంతో ప్రారంభం కావాలి. ఉదాహరణకు ఫంక్షన్ శూన్యమైనది ఏమీ ఇవ్వని రకాన్ని సూచిస్తుంది కాబట్టి పేరు శూన్యమైనది. గమనిక, మేము ఇప్పటికే మా మునుపటి విభాగాలలో వేరియబుల్ జాబితాను చర్చించాము, మీరు వాటిని సూచించాలనుకోవచ్చు.

పర్యవసానంగా, నిర్దిష్ట ఫంక్షన్ పేరు ఓపెన్ కుండలీకరణాన్ని పొందుతుంది '(' కామాతో వేరు చేయబడిన పారామితుల జాబితా తరువాత.

ప్రతి పరామితి దాని రకాన్ని ఒక పేరుతో పాటు, చివరకు మూసివేస్తుంది ')' కుండలీకరణాలు.

ఈ పారామితులను ఫంక్షన్ లోపల వేరియబుల్స్ రూపంలో అన్వయించవచ్చు.

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

మేము ఈ ఫంక్షన్లను మా మునుపటి కోడ్‌లో అమలు చేస్తాము మరియు ఈ క్రింది ప్రోగ్రామ్‌ను పొందండి, చివరి పంక్తులను చూడండి:

#define NOTE_C4 262
#define NOTE_D4 294
#define NOTE_E4 330
#define NOTE_F4 349
#define NOTE_G4 392
#define NOTE_A4 440
#define NOTE_B4 494
#define NOTE_C5 523
const int kPinSpeaker = 9
void setup()
{
pinMode(kPinSpeaker, OUTPUT)
}
void loop()
{
tone(kPinSpeaker, NOTE_C4, 500)
delay(500)
tone(kPinSpeaker, NOTE_D4, 500)
delay(500)
tone(kPinSpeaker, NOTE_E4, 500)
delay(500)
tone(kPinSpeaker, NOTE_F4, 500)
delay(500)
tone(kPinSpeaker, NOTE_G4, 500)
delay(500)
tone(kPinSpeaker, NOTE_A4, 500)
delay(500)
tone(kPinSpeaker, NOTE_B4, 500)
delay(500)
tone(kPinSpeaker, NOTE_C5, 500)
delay(500)
noTone(kPinSpeaker)
delay(2000)
}
void ourTone(int freq, int duration)
{
tone(kPinSpeaker, freq, duration)
delay(duration)
}

ప్రోగ్రామ్‌ను సులభంగా అర్థం చేసుకోవడానికి విధులు చాలా సులభమవుతాయి.

కిందిది మేము రెండు శ్రేణులను ఉపయోగించి ఆడాలనుకుంటున్న స్వరం యొక్క ఎంపికను పేర్కొనగలిగే ఉదాహరణ. గమనికలను నిలుపుకోవటానికి ఒక శ్రేణి, మరొకటి బీట్లను నిలుపుకోవటానికి.

#include 'pitches.h'
int kPinSpeaker = 9
#define NUM_NOTES 15
const int notes[NUM_NOTES] = // a 0 represents a rest
{
NOTE_C4, NOTE_C4, NOTE_G4, NOTE_G4,
NOTE_A4, NOTE_A4, NOTE_G4, NOTE_F4,
NOTE_F4, NOTE_E4, NOTE_E4, NOTE_D4,
NOTE_D4, NOTE_C4, 0
}
const int beats[NUM_NOTES] = {
1, 1, 1, 1, 1, 1, 2, 1, 1, 1, 1, 1, 1, 2, 4 }
const int beat_length = 300
void setup()
{
pinMode(kPinSpeaker, OUTPUT)
}
void loop()
{
for (int i = 0 i if (notes[i] == 0) {
delay(beats[i] * beat_length) // rest
}
else {
ourTone(notes[i], beats[i] * beat_length)
}
// pause between notes
noTone(kPinSpeaker)
delay(beat_length / 2)
}
}
void ourTone(int freq, int duration)
{
tone(kPinSpeaker, freq, duration)
delay(duration)
}

పరిచయం మొదటి పంక్తిలో మీరు స్పష్టంగా చూడవచ్చు # చేర్చండి ప్రకటన. ఈ స్టేట్మెంట్ యొక్క పని కోట్స్ మధ్య మొత్తం ఫైల్ను ఎంచుకొని దానిని స్థానంలో ఉంచడం # చేర్చండి ప్రకటన. ప్రామాణిక నిబంధనల ప్రకారం ఇవి ప్రోగ్రామ్ ప్రారంభంలో ఖచ్చితంగా ఉంచబడతాయి.

అధ్యాయం 5

ఉష్ణోగ్రతను కొలవడం

గుర్తుకు తెచ్చుకోవటానికి, పెద్ద ప్రోగ్రామ్‌లను పూర్తిగా వ్రాయడానికి బదులుగా గుర్తుంచుకోండి, సంకేతాల యొక్క చిన్న భాగాలను వ్రాయడం మరియు విశ్లేషించడం ఎల్లప్పుడూ తెలివైనది, ఇది తప్పులను త్వరగా గుర్తించడంలో సహాయపడుతుంది.

5.1 సీరియల్ మానిటర్

ఇప్పటి వరకు, శీఘ్ర ట్రబుల్షూటింగ్‌ను ప్రారంభించడానికి మేము చర్చించిన సంకేతాలు అంత తేలికగా కనిపించవు. ఇక్కడ మేము పర్యవేక్షణ కోసం విషయాలను సులభతరం చేయడానికి మరియు సాధ్యమయ్యే సమస్యను సులభంగా పరిష్కరించడానికి ప్రయత్నిస్తాము.

ఆర్డునోకు ఒక లక్షణం ఉంది, ఇది కంప్యూటర్‌తో 'తిరిగి మాట్లాడటానికి' వీలు కల్పిస్తుంది. పిన్ 0 మరియు పిన్ 1 ఒకదానికొకటి పక్కన RX ఒక TX గా గుర్తించబడటం మీరు గమనించవచ్చు. ఈ పిన్‌లను వాస్తవానికి ఆర్డునోలోని ప్రత్యేక ఐసి ట్రాక్ చేస్తుంది, ఇది పిసికి ప్లగ్ చేయబడినప్పుడు యుఎస్‌బి కేబుల్ అంతటా చదవడానికి వాటిని అప్‌గ్రేడ్ చేస్తుంది.

దిగువ విభాగం పూర్తి స్థాయి ప్రోగ్రామ్‌ను చూపిస్తుంది, దయచేసి వెళ్ళండి, ఆ తర్వాత కోడ్‌లోని క్రొత్త ఎంట్రీలకు సంబంధించి మేము నేర్చుకుంటాము. ఈ కోడ్ వ్యక్తీకరించబడిన విభాగం 2.2 వలె ఉంటుంది, ఇది కోడ్ చేయబడిన వాటిని గుర్తించడానికి మాకు అనుమతించడానికి కొన్ని అదనపు డేటాను కలిగి ఉంది.

const int kPinLed = 13
void setup()
{
pinMode(kPinLed, OUTPUT)
Serial.begin(9600)
}
int delayTime = 1000
void loop()
{
delayTime = delayTime - 100
if(delayTime <= 0){ // If it would have been zero or less, reset it.
delayTime = 1000
}
Serial.print('delayTime = ')
Serial.println(delayTime)
digitalWrite(kPinLed, HIGH)
delay(delayTime)
digitalWrite(kPinLed, LOW)
delay(delayTime)
}

మీరు ఇక్కడ రెండు కొత్త విషయాలను గుర్తించవచ్చు, లో కొత్త పంక్తి సెటప్ () ఫంక్షన్.

Serial.begin(9600)

ఈ పంక్తిని ఉపయోగించాల్సిన అవసరాన్ని వ్యక్తపరుస్తుంది సీరియల్ 1 9600 బాడ్‌తో అమలు చేయడానికి కోడ్. (ఇక్కడ సీరియల్ సూచిస్తుంది బిట్స్ ఒకదాని తరువాత ఒకటి పంపబడింది మరియు బాడ్ అంటే అది పంపిన రేటు). ఈ బాడ్ విలువ మరియు సీరియల్ మానిటర్ లోపల ఉన్నది (మేము దీనిని తరువాత నేర్చుకుంటాము) సమానంగా ఉండాలి, లేకపోతే సీరియల్ మానిటర్‌లోని డేటా చెత్తను చూపుతుంది. 9600 ప్రామాణికంగా ఉండటం మరింత సౌకర్యవంతంగా మారుతుంది.

రెండవ కొత్త ఎంట్రీ ఈ క్రింది విధంగా ఉన్నాయి

Serial.print('delayTime = ')
Serial.println(delayTime)

ఇక్కడ రెండవ పంక్తి సీరియల్ పోర్ట్ నుండి వచ్చే తదుపరి విషయం తదుపరి పంక్తిలో ప్రారంభమవుతుందని సూచిస్తుంది. రెండవ పంక్తి పిడికిలి రేఖకు భిన్నంగా ఉంటుంది.

మీరు చూడగలిగే మరో విషయం కోట్స్ ('). దీనిని స్ట్రింగ్ అని పిలుస్తారు, ఇది ఇక్కడ స్థిరాంకాల వలె మాత్రమే ఉపయోగించబడుతుంది, ఎందుకంటే ఈ అంశంపై మరింత చర్చ చాలా విస్తృతంగా మరియు పరిధికి మించినది.

సరే, మనం ఇప్పుడు పై కోడ్‌ను ఆర్డునోలో అప్‌లోడ్ చేసి ఏమి జరుగుతుందో చూడవచ్చు.

ఏమిటి, అయ్యో ఏమీ జరగలేదు, ఆర్డునో పిన్ # 13 LED మెరిసిపోయింది మరియు ఆగిపోయింది, Tx LED మెరిసేటట్లు ఉండిపోయింది.

బాగా, ఎందుకంటే సీరియల్ మానిటర్ విండో ఇంకా పరిష్కరించబడలేదు.

పైన చూపిన విధంగా మీరు మీ IDE లోని సీరియల్ మానిటర్ బాక్స్‌పై క్లిక్ చేయాలి. దిగువ కుడి వైపున ఉన్న బాడ్ రేటును తనిఖీ చేయడం మర్చిపోవద్దు, అప్రమేయంగా ఇది 9600 ఉండాలి మరియు కోడ్‌తో సరిపోతుంది. లేకపోతే 9600 ఎంచుకోండి.

కింది వీడియో క్లిప్ అది ఎలా జరిగిందో వివరిస్తుంది.

ఇప్పుడు ముందుకు సాగండి మరియు ప్రాసెస్ చేయడానికి పై సీరియల్ మానిటర్ ఫీచర్ ఎలా సహాయపడుతుందో తెలుసుకుందాం Arduino ఉపయోగించి ఉష్ణోగ్రత యొక్క కొలత

-40 నుండి 150 డిగ్రీల సెల్సియస్ పరిధిని కలిగి ఉన్న IC TMP36 ను ఉష్ణోగ్రత సెన్సార్‌గా ఉపయోగిస్తాము.

సెటప్ క్రింద చూడవచ్చు:

కింది కోడ్ TMP36 సెన్సార్ నుండి అవుట్‌పుట్‌ను చదవడం ద్వారా మరియు వాటిని ID యొక్క సీరియల్ మానిటర్‌కు పంపడం ద్వారా ఉష్ణోగ్రత కొలతను ప్రారంభిస్తుంది.

const int kPinTemp = A0
void setup()
{
Serial.begin(9600)
}
void loop()
{
float temperatureC = getTemperatureC()
Serial.print(temperatureC)
Serial.println(' degrees C')
// now convert to Fahrenheit
float temperatureF = convertToF(temperatureC)
Serial.print(temperatureF)
Serial.println(' degrees F')
delay(500)
}
float getTemperatureC()
{
int reading = analogRead(kPinTemp)
float voltage = (reading * 5.0) / 1024
// convert from 10 mv per degree with 500mV offset
// to degrees ((voltage - 500mV) * 100)
return (voltage - 0.5) * 100
}
float convertToF(float temperatureC)
{
return (temperatureC * 9.0 / 5.0) + 32.0
}

ఎగువ నుండి కోడ్ అర్థం చేసుకుందాం.

float temperatureC = getTemperatureC()

మేము వేరియబుల్ రకాన్ని చేర్చినట్లు ఇక్కడ మీరు చూడవచ్చు ఫ్లోట్.

పూర్ణాంక సంఖ్యలు (దశాంశ లేదా పాక్షిక భాగాలు లేని సంఖ్యలు) మినహా ప్రతిదీ నిల్వ చేసే ఏకైక వేరియబుల్ రకం ఇది.

ఫ్లోట్ వేరియబుల్ నుండి ఖచ్చితత్వం 6 నుండి 7 అంకెలు వరకు ఉంటుంది.

ప్రక్కనే ఉన్న కోడ్ getTemperatureC() మా స్వంత ఫంక్షన్, ఇది TMP36 సెన్సార్ నుండి గ్రహించిన వోల్టేజ్ వ్యత్యాసాన్ని గణితశాస్త్రంలో లెక్కిస్తుంది మరియు డిగ్రీల సెల్సియస్‌గా మారుస్తుంది.

float getTemperatureC()
{
int reading = analogRead(kPinTemp)
float voltage = (reading * 5.0) / 1024
// convert from 10 mv per degree with 500mV offset
// to degrees ((voltage - 500mV) * 100)
return (voltage - 0.5) * 100
}

analogIn() అనే పదం నుండి సంకేతాల తదుపరి విభాగంలో 1 నుండి 1023 మధ్య ఒక సంఖ్యను తిరిగి ఇవ్వడానికి కేటాయించబడింది, మన పఠనాన్ని 5 గుణించి, 1024 ద్వారా విభజించడం ద్వారా సెన్సార్ నుండి వోల్టేజ్‌ను అంచనా వేయడం సాధ్యమవుతుంది.

సెన్సార్ TMP36 0 డిగ్రీల సెల్సియస్ వద్ద 0.5V ను ఉత్పత్తి చేయడానికి పేర్కొనబడింది మరియు తరువాత డిగ్రీ సెల్సియస్ యొక్క ప్రతి పెరుగుదలకు 10mV ను ఉత్పత్తి చేస్తుంది.

లెక్కల ద్వారా మనం ఉత్పత్తి చేయగలిగే ఉజ్జాయింపు ఇక్కడ ఉంది:

మీరు మీ మొదటి ఫంక్షన్‌గా పరిగణించవచ్చు, ఇది కొంత విలువను ఇస్తుంది (మిగిలిన అన్ని ఫంక్షన్‌లు ఈ రకానికి చెందినవి కాబట్టి ఇప్పటివరకు ఏ విలువను ఇవ్వలేదు. శూన్యమైనది ).

ఒక ఫంక్షన్ నుండి విలువను పొందడానికి, మీరు జోడించాల్సిన అవసరం ఉందని మీరు అర్థం చేసుకోవచ్చు తిరిగి మీరు తిరిగి ఇవ్వాలనుకున్న కావలసిన సంఖ్య తరువాత.

మేము చెప్పినప్పుడు తిరిగి దీని అర్థం ఫంక్షన్ ఒక స్పందన లేదా ప్రత్యుత్తరాన్ని పిలిచినప్పుడల్లా తిరిగి ఇస్తుంది, ఇది వేరియబుల్‌కు వర్తించవచ్చు.

ఇది సీరియల్ మానిటర్‌కు పంపినప్పుడు, పఠనం ఫారెన్‌హీట్‌గా మార్చబడుతుంది convertToF ().

float convertToF(float temperatureC)
{
return (temperatureC * 9.0 / 5.0) + 32.0
}

ఈ ఫంక్షన్ సెల్సియస్ పరిధిని ఎంచుకొని దానిని ఫారెన్‌హీట్‌గా మారుస్తుంది.

ఫారెన్‌హీట్‌ను సెల్సియస్‌గా మార్చడానికి మేము సూత్రాన్ని అమలు చేస్తాము ఫారెన్‌హీట్ = 9 / 5 (సెల్సియస్) + 32.

5.3 ఒక ఎల్‌సిడిని ఇంటర్‌ఫేసింగ్

ఇప్పుడు ఇంటర్ఫేస్ లేదా కనెక్ట్ ఎలా చేయాలో అధ్యయనం చేద్దాం LCD డిస్ప్లే అవసరమైన అవుట్‌పుట్‌ల కోసం దృశ్య ప్రదర్శన పొందడానికి ఆర్డునోతో.

మా అనువర్తనంలో మేము 84x48 గ్రాఫికల్ LCD ని ఉపయోగించబోతున్నాము, 84 పిక్సెల్ లేదా చుక్కలు అడ్డంగా, మరియు 48 పిక్సెల్స్ నిలువు రిజల్యూషన్ కలిగి ఉంటాయి. అన్ని LCD లకు అంకితమైన నియంత్రిక అత్యవసరం అవుతుంది కాబట్టి, ప్రస్తుత పరికరం PCD8544 నియంత్రిక రూపంలో ఒకదాన్ని కలిగి ఉంటుంది.

ఈ ట్యుటోరియల్‌లో మేము పైన పేర్కొన్న ఎల్‌సిడి మాడ్యూల్‌ను ఆర్డునోతో కనెక్ట్ చేస్తాము మరియు ప్రదర్శనలో వచన సందేశాలను సృష్టించడానికి కొన్ని నిత్యకృత్యాలను వర్తింపజేస్తాము.

కింది చిత్రంలో మీరు చిన్నదానితో పాటు ఎల్‌సిడి ఇంటర్‌ఫేసింగ్‌కు సంబంధించిన వివరాలను కనుగొనవచ్చు 3.3 వి వోల్టేజ్ రెగ్యులేటర్ . 3.3V సరఫరాతో పనిచేయడానికి LCD పేర్కొనబడినందున ఈ నియంత్రకం అవసరం.

మీరు LCD మాడ్యూల్ నుండి 8 పిన్‌అవుట్‌లను కూడా చూడవచ్చు, ఈ క్రింది పట్టిక నుండి పిన్‌అవుట్ స్పెసిఫికేషన్లను అధ్యయనం చేయవచ్చు:

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

5.4 LCD కి కమ్యూనికేట్ చేయడం

ఆర్డునో నుండి ఎల్‌సిడితో సంభాషించడానికి విస్తృతమైన కోడ్‌లను వ్రాయడం సాధ్యమే అయినప్పటికీ, లైబ్రరీలను ఉపయోగించి ఎలా చేయాలో నేర్చుకుంటాము.

ఎంచుకున్న ఆర్డునో ప్రోగ్రామ్ కోసం త్వరగా వర్తించే సంకేతాల కలగలుపు లైబ్రరీలలో ఉంటుంది.

ఇది సంక్లిష్టమైన కోడింగ్ పని ద్వారా వెళ్లకుండా ఒక ఫంక్షన్‌ను అప్రయత్నంగా కాల్ చేయడానికి వినియోగదారుని అనుమతిస్తుంది.

5.4.1 లైబ్రరీని ఎలా ఇన్‌స్టాల్ చేయాలి

దీని కోసం మీరు వివరించిన విధంగా మీ కంప్యూటర్ ఆర్డునో ఐడిఇలో లైబ్రరీస్ అనే డైరెక్టరీని సృష్టించాలి ఇక్కడ

5.4.2 LCD ఆపరేషన్లను అమలు చేయడం

మా మునుపటి విధానం వలె, మేము మొదట మొత్తం కోడ్‌ను చెక్అవుట్ చేసి, ఆపై వ్యక్తిగత పంక్తుల వివరాలను అర్థం చేసుకోవడానికి ప్రయత్నిస్తాము.

#include
const int kPin_CLK = 5
const int kPin_DIN = 6
const int kPin_DC = 7
const int kPin_RESET = 8
PCD8544 lcd(kPin_CLK, kPin_DIN, kPin_DC, kPin_RESET)
void setup()
{
lcd.init()
lcd.setCursor(0,0)
lcd.print('Hello, World!')
}
void loop()
{
lcd.setCursor(0,1)
lcd.print(millis())
}

పంక్తిలో కోడ్ #include

ప్రోగ్రామ్ కంపైల్ చేసేటప్పుడు పేర్కొన్న ఫైల్‌ను పికప్ చేయమని మరియు # చేర్చండి మూలకాన్ని ఫైల్ విషయాలతో భర్తీ చేయమని కోడ్ # చేర్చండి.

# చేర్చండి మూలకం కోణం బ్రాకెట్లను కలిగి ఉంటుంది, ఇది లైబ్రరీ డైరెక్టరీలో శోధించడాన్ని సూచిస్తుంది, ప్రత్యామ్నాయంగా ఇది కోట్స్ కలిగి ఉండవచ్చు, ఇది ప్రోగ్రామ్ ఉన్న అదే డైరెక్టరీలో శోధించడాన్ని సూచిస్తుంది.

కోడ్ యొక్క తరువాతి పంక్తులు LCD పిన్‌అవుట్‌లను వ్యక్తపరుస్తాయి, ఆపై మేము వేరియబుల్ యొక్క కొత్త రూపాన్ని వ్రాస్తాము:

PCD8544 lcd(kPin_CLK, kPin_DIN, kPin_DC, kPin_RESET)

ఇక్కడ మనం పిసిడి 8544 రకాన్ని కలిగి ఉన్న ఎల్‌సిడి పేరుతో వేరియబుల్‌ను వ్యక్తీకరిస్తున్నాము మరియు ఆర్డునోతో అనుబంధించబడిన పిన్‌అవుట్‌లను రీగ్రేడ్ చేయమని పిసికి ఆదేశిస్తున్నాము.

ఈ ప్రక్రియలో పిన్ క్లాక్, దిన్, డిసి మరియు రీసెట్ ఆర్డునోతో ఎలా అనుసంధానించబడిందో సూచించడం ద్వారా పిసికి వేరియబుల్ గురించి వివరిస్తాము.

void setup()
{
lcd.init()
lcd.setCursor(0,0)
lcd.print('Hello, World!')
}

పంక్తి lcd.init() LCD ఆపరేషన్‌ను ప్రారంభిస్తుంది. ఇది అమలు అయిన తర్వాత, తదుపరి పంక్తి ప్రదర్శన యొక్క ఎడమ ఎగువ భాగంలో కర్సర్‌ను అమలు చేస్తుంది. మరియు తరువాతి తదుపరి పంక్తి 'హలో, వరల్డ్' సందేశాన్ని ముద్రించడానికి ప్రయత్నం చేస్తుంది.

సీరియల్ మానిటర్ ద్వారా మేము సందేశాలను పంపిన సాంకేతికతకు ఇది చాలా పోలి ఉంటుంది. lcd.print కోడ్ ఉపయోగించడం మాత్రమే తేడా serial.print బదులుగా.

కోడ్ యొక్క తదుపరి బ్లాక్ వాస్తవానికి పునరావృతమవుతుంది.

void loop()
{
lcd.setCursor(0,1)
lcd.print(millis())
}

ఈ పంక్తిని ఉపయోగించడం lcd.setCursor(0,1) మేము కర్సర్‌ను ఎల్‌సిడి డిస్‌ప్లే ద్వారా 1 వ వరుసకు ఎడమవైపున 0 వ కాలమ్‌కు పరిష్కరించాము.

తదుపరి పంక్తి సత్వరమార్గాన్ని ఉపయోగిస్తుంది: | _ + + |

మీరు గుర్తుచేసుకుంటే మేము lcd.print(millis()) తో పనిచేశాము మా మునుపటి కోడ్‌లలో, కోడ్‌ల ద్వారా కూడా ఇక్కడే వర్తింపజేయవచ్చు:

millis()

అయినప్పటికీ ఇక్కడ మిల్లీసెకన్లో ఎటువంటి కాల వ్యవధులు పాల్గొనలేవు కాబట్టి, మేము long numMillis = millis()
lcd.print(numMillis) నేరుగా millis() .

5.5 హోల్ థింగ్ కలపడం

సరే, ఇప్పుడు LCD ఉష్ణోగ్రత సర్క్యూట్ చేయడానికి మేము పైన నేర్చుకున్న అన్ని కోడ్‌లను మిళితం చేద్దాం మరియు ఇది ఎలా ఉందో చూద్దాం:

lcd.print()

ఫంక్షన్ యొక్క ఉపయోగం తప్ప, పై ప్రోగ్రామ్‌లో ప్రతిదీ ప్రామాణికంగా కనిపిస్తుంది setCursor () . ప్రదర్శన మధ్యలో చుట్టూ సాధ్యమైనంతవరకు వచనాన్ని సమలేఖనం చేయడానికి ఇది ఉపయోగించబడుతుంది.

గొప్పది! మరియు అభినందనలు, మీరు Arduino ని ఉపయోగించి మీ స్వంత చిన్న LCD ఉష్ణోగ్రత సూచికను ప్రోగ్రామ్ చేసారు.

ప్రాక్టికల్ ఆర్డునో అప్లికేషన్స్

ఈ సమయంలో, మేము వివిధ ప్రోగ్రామింగ్ పద్ధతులను సమగ్రంగా కవర్ చేసాము కాబట్టి, కొన్ని ఉపయోగకరమైన ఆచరణాత్మక అమలుల కోసం వాటిని వర్తింపజేయడం ద్వారా వాటిని ఎట్స్ట్ చేయడానికి సమయం ఆసన్నమైంది.

మేము సెన్సార్‌లతో ప్రారంభిస్తాము మరియు కొన్ని నమూనా కోడ్‌లను అమలు చేయడం ద్వారా ఆర్డునోతో సెన్సార్ పరికరాలను ఎలా ఉపయోగించవచ్చో చూస్తాము.

7.1 సెన్సార్ల పరిచయం

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

మేము ఇంటర్‌ఫేసింగ్‌తో ప్రారంభిస్తాము లైట్ సెన్సార్ LDR Arduino తో, నేను ఈ క్రింది రేఖాచిత్రాన్ని చూపించాను:

మనందరికీ తెలిసినట్లుగా, LDR అనేది కాంతి ఆధారిత నిరోధక పరికరం, దీని నిరోధకత దాని ఉపరితలంపై పరిసర సంఘటన యొక్క తీవ్రతపై ఆధారపడి ఉంటుంది.

కాంతి యొక్క తీవ్రత LDR యొక్క నిరోధక పఠనానికి విలోమానుపాతంలో ఉంటుంది.

ఉపయోగకరమైన అనువర్తనాన్ని అమలు చేయడానికి ఈ ఆస్తిని ఆర్డునోతో ఎలా విలీనం చేయవచ్చో ఇక్కడ నేర్చుకుంటాము:

క్రింద ఇచ్చిన విధంగా పూర్తి ప్రోగ్రామ్ కోడ్‌ను చూడవచ్చు:

#include
const int kPin_CLK = 5
const int kPin_DIN = 6
const int kPin_DC = 7
const int kPin_RESET = 8
const int kPin_Temp = A0
PCD8544 lcd(kPin_CLK, kPin_DIN, kPin_DC, kPin_RESET)
void setup()
{
lcd.init()
lcd.setCursor(10,0)
lcd.print('Temperature:')
}
void loop()
{
float temperatureC = getTemperatureC()
// now convert to Fahrenheit
float temperatureF = convertToF(temperatureC)
lcd.setCursor(21,1)
lcd.print(temperatureC)
lcd.print(' C')
lcd.setCursor(21,2)
lcd.print(temperatureF)
lcd.print(' F')
delay(100)
}
float getTemperatureC()
{
int reading = analogRead(kPin_Temp)
float voltage = (reading * 5.0) / 1024
// convert from 10 mv per degree with 500mV offset
// to degrees ((voltage - 500mV) * 100)
return (voltage - 0.5) * 100
}
float convertToF(float temperatureC)
{
return (temperatureC * 9.0 / 5.0) + 32.0
}

కోడ్‌లో ఉపయోగించిన అన్ని పారామితులు మేము ఇప్పటివరకు నేర్చుకున్న మా కోర్సులో ఇప్పటికే చర్చించబడ్డాయి. సంబంధిత విభాగాలను సూచించడం ద్వారా మీరు పంక్తులను తనిఖీ చేయవచ్చు.

విలువలు యాదృచ్ఛికంగా ఎంపిక చేయబడ్డాయి, మీరు మీ స్వంత ప్రాధాన్యతల ప్రకారం సులభంగా మార్చవచ్చు.

టిల్ట్ సెన్సార్

టిల్ట్ సెన్సార్ అనేది ఒక సాధారణ పరికరం, ఇది ఇన్‌స్టాల్ చేయబడిన ఏదైనా వస్తువుపై వంపు చర్యను గుర్తించడానికి ఉపయోగపడుతుంది. పరికరం ప్రాథమికంగా లోపల ఒక లోహ బంతిని కలిగి ఉంటుంది, ఇది ఒక జత పరిచయాలపై టిల్టింగ్ రోల్స్ మీద ఆ పరిచయాలలో ఒక ప్రసరణకు కారణమవుతుంది. ఈ పరిచయాలు వంపు స్విచ్ యొక్క లీడ్లుగా ముగించబడతాయి, టిల్టింగ్ చర్య కారణంగా ప్రసరణను గుర్తించడానికి మరియు కావలసిన అవుట్పుట్ అనువర్తనాన్ని సక్రియం చేయడానికి బాహ్య సర్క్యూట్‌తో ఉపయోగించబడుతుంది.

ఇప్పుడు ఎలా చూద్దాం a టిల్ట్ సెన్సార్ పరికరం వైర్ అప్ చేయవచ్చు. దిగువ చిత్రం పూర్తి కాన్ఫిగరేషన్ గురించి మాకు ఒక ఆలోచన ఇస్తుంది:

const int kPin_Photocell = A0
void setup()
{
Serial.begin(9600)
}
void loop()
{
int value = analogRead(kPin_Photocell)
Serial.print('Analog Reading = ')
Serial.print(value)
if(value <200){
Serial.println(' - Dark')
}else if(value <400){
Serial.println(' - Dim')
}
else if(value <600){
Serial.println(' - Light')
}
else if(value <800){
Serial.println(' - Bright')
}
else{
Serial.println(' - Very Bright')
}
delay(1000)
}

ఈ ఉదాహరణలో డిఫాల్ట్ పిన్ # 13 LED వంపు సూచికగా ఉపయోగించబడుతుంది.

పుల్-అప్ రెసిస్టర్‌ను ఇక్కడ చేర్చడాన్ని మీరు స్పష్టంగా చూడవచ్చు, సెక్షన్ 3.1 లో మేము చేసినదానితో సమానంగా ఉంటుంది. అందువల్ల LOW అనే పదం వంపు ఫంక్షన్ ప్రేరేపించబడదని సూచిస్తుంది.

7.4 రీడ్ స్విచ్ రిలే (సూక్ష్మ మాగ్నెట్ యాక్టివేటెడ్ రిలే)

ఇప్పుడు ఆర్డునోతో రిలే స్విచ్ లేదా మాగ్నెటిక్ ఫీల్డ్ సెన్సార్‌ను ఎలా హుక్ చేయాలో చూద్దాం. రీడ్ రిలే అనేది ఒక రకమైన స్విచ్, ఇది అయస్కాంత క్షేత్రం లేదా అయస్కాంతం దాని దగ్గరకు తీసుకువచ్చినప్పుడు సక్రియం చేస్తుంది లేదా నిర్వహిస్తుంది. ప్రాథమికంగా ఇది ఒక చిన్న గాజు ఎన్‌క్లోజర్ లోపల ఒక జత ఫెర్రో అయస్కాంత పరిచయాలను కలిగి ఉంటుంది, ఇది ఒక అయస్కాంతం దానికి దగ్గరగా ఉన్నప్పుడు అయస్కాంత పుల్ కారణంగా కలుస్తుంది లేదా పరిచయం చేస్తుంది. ఇది జరిగినప్పుడు పరిచయాల టెర్మినల్స్ పరిచయాలను మూసివేయడం వలన ప్రసరణను చూపుతాయి.

ఇక్కడ కూడా ప్రతిస్పందనను సూచించడానికి పిన్ # 13 LED ని ఉపయోగిస్తాము. మా మునుపటి వివరణల ప్రకారం అవసరమైతే మీరు ఈ పిన్ నుండి బాహ్య LED ని కనెక్ట్ చేయవచ్చు.

const int kPin_Tilt = 3
const int kPin_LED = 13
void setup()
{
pinMode(kPin_Tilt, INPUT)
digitalWrite(kPin_Tilt, HIGH) // turn on built-in pull-up resistor
pinMode(kPin_LED, OUTPUT)
}
void loop()
{
if(digitalRead(kPin_Tilt) == HIGH){
digitalWrite(kPin_LED, LOW)
}
else{
digitalWrite(kPin_LED, HIGH)
}
}

కోడ్ నిబంధనలు సుపరిచితం మరియు స్వీయ వివరణాత్మకంగా ఉండాలి.

7.5 పైజో ట్రాన్స్‌డ్యూసర్‌ని ఉపయోగించి వైబ్రేషన్ సెన్సార్

తదుపరి నమూనా ప్రోగ్రామ్‌లో మనం ఎలా చూస్తాము పైజో ట్రాన్స్డ్యూసెర్ Arduino ద్వారా LED ని ప్రకాశవంతం చేయడానికి వైబ్రేషన్ సెన్సార్‌గా ఉపయోగించవచ్చు.

పైజో మూలకం వాస్తవానికి దాని టెర్మినల్స్ అంతటా ఫ్రీక్వెన్సీ వర్తించినప్పుడు కంపనం లేదా డోలనాన్ని ఉత్పత్తి చేసే పరికరం. అయితే అదే పిజోను రివర్స్ ప్రాసెస్‌లో ఉపయోగించవచ్చు విద్యుత్ పప్పులను ఉత్పత్తి చేస్తుంది దాని శరీరంపై వర్తించే కంపనానికి ప్రతిస్పందనగా. ఈ కంపనం పైజో యొక్క ఉపరితలంపై నాక్ లేదా హిట్ రూపంలో ఉంటుంది.

కింది చిత్రంలో ఇచ్చిన విధంగా ఆర్డునో మరియు పిజో మూలకాన్ని సెటప్ చేయండి

const int kPinReedSwitch = 2
const int kPinLed = 13
void setup()
pinMode(kPinReedSwitch, INPUT)
digitalWrite(kPinReedSwitch, HIGH) // turn on pullup resistor
pinMode(kPinLed, OUTPUT)
}
void loop()
{
if(digitalRead(kPinReedSwitch) == LOW){
digitalWrite(kPinLed, HIGH)
}
else{
digitalWrite(kPinLed, LOW)
}
}

త్రెషోల్డ్ 100 ప్రవేశపెట్టబడింది, ఆర్డునో నాక్స్ ద్వారా నిజమైన ప్రకంపనలకు మాత్రమే స్పందిస్తుందని నిర్ధారించుకోవడానికి, మరియు పెద్ద శబ్దాలు లేదా కొమ్ముల నుండి ఇతర చిన్న కంపనాలు కాదు.

A5 పిన్ ఎంపిక తప్పనిసరి కాదు, మీరు మీ ప్రాధాన్యత ప్రకారం మరియు ప్రోగ్రామ్ కోడ్‌లో సరిపోల్చడం ద్వారా ఏదైనా ఇతర అనలాగ్ ఇన్‌పుట్‌లను ఎంచుకోవచ్చు.

ఆర్డునోతో సర్వో మోటారును ఉపయోగించడం

సర్వో మోటారు అనేది ఒక రకమైన DC మోటారు, ఇది ఒక నిర్దిష్ట అనువర్తనం యొక్క డిమాండ్ ప్రకారం ఖచ్చితమైన కోణాలకు తిప్పబడుతుంది. మోటారుపై 180 డిగ్రీల పరిధిలో ఖచ్చితమైన భ్రమణ లేదా మలుపు కోణాన్ని ఉత్పత్తి చేయడానికి మోటారు యొక్క సంబంధిత ఇన్‌పుట్‌లకు లెక్కించిన ఆదేశాన్ని వర్తింపజేయడం ద్వారా ఇది చేయవచ్చు.

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

ఆర్డునో సర్వో మోటారు నియంత్రణను సపోర్ట్ లాంగ్వేజ్‌లో నిర్మించడం ద్వారా సులభతరం చేస్తుంది, ఇది సర్వో మోటారులకు చాలా సౌకర్యవంతంగా మరియు ఆదర్శంగా ఉంటుంది.

ఆర్డునో ద్వారా సర్వో మోటార్ నియంత్రణను అమలు చేయడానికి ప్రాథమిక సెటప్ ప్రోగ్రామ్‌ను ఈ క్రింది ఉదాహరణ చూపిస్తుంది:

కోడ్ క్రింద ఇవ్వబడింది:

const int kPinSensor = A5
const int kPinLed = 13
const int k_threshold = 100
int ledState = LOW // variable used to store the last LED status, to toggle the light
void setup()
{
pinMode(kPinLed, OUTPUT) // declare the ledPin as as OUTPUT
}
void loop()
{
int val = analogRead(kPinSensor)
if (val >= k_threshold) {
ledState = !ledState // toggle the value of ledState
digitalWrite(kPinLed, ledState)
delay(20) // for debouncing
}
}

మేము ఇక్కడ కొన్ని కొత్త ఎంట్రీలను చూడవచ్చు. సర్వో యొక్క జతచేయబడిన తీగను ఏ పిన్‌కు కేటాయించాలో చెప్పే ఒకటి. మరొకటి సర్వోపై భ్రమణ కోణాన్ని నిర్ణయించడానికి పిన్‌కు 0 మరియు 180 మధ్య విలువను అందించే కోడ్.

ముగింపు

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

అందుబాటులో ఉన్నప్పుడల్లా ఇక్కడ ఎప్పటికప్పుడు మరింత సమాచారం నవీకరించబడవచ్చని ఆశిద్దాం.

ఈ సమయంలో మీ ప్రోగ్రామింగ్ కోర్సును ఆస్వాదించండి, మీకు శుభాకాంక్షలు !!