Arduino లో i2c ని ఎలా ఉపయోగించాలి: రెండు arduino బోర్డుల మధ్య కమ్యూనికేషన్

మా మునుపటి ట్యుటోరియల్‌లో ఆర్డునోలో SPI కమ్యూనికేషన్ గురించి తెలుసుకున్నారు. ఈ రోజు మనం మరొక సీరియల్ కమ్యూనికేషన్ ప్రోటోకాల్ గురించి నేర్చుకుంటాము: I2C (ఇంటర్ ఇంటిగ్రేటెడ్ సర్క్యూట్స్). I2C ని SPI తో పోల్చినప్పుడు, I2C కి రెండు వైర్లు మాత్రమే ఉండగా, SPI నాలుగు ఉపయోగిస్తుంది మరియు I2C మల్టిపుల్ మాస్టర్ మరియు స్లేవ్ కలిగి ఉంటుంది, SPI కి ఒక మాస్టర్ మరియు బహుళ బానిసలు మాత్రమే ఉండగలరు. కాబట్టి మాస్టర్స్ కావాల్సిన ప్రాజెక్ట్‌లో ఒకటి కంటే ఎక్కువ మైక్రోకంట్రోలర్లు ఉన్నాయి, అప్పుడు I2C ఉపయోగించబడుతుంది. I2C కమ్యూనికేషన్ సాధారణంగా గైరోస్కోప్, యాక్సిలెరోమీటర్, బారోమెట్రిక్ ప్రెజర్ సెన్సార్లు, LED డిస్ప్లేలు మొదలైన వాటితో కమ్యూనికేట్ చేయడానికి ఉపయోగిస్తారు.

ఈ Arduino I2C ట్యుటోరియల్‌లో మేము రెండు arduino బోర్డుల మధ్య I2C కమ్యూనికేషన్‌ను ఉపయోగిస్తాము మరియు పొటెన్షియోమీటర్ ఉపయోగించి ఒకదానికొకటి (0 నుండి 127) విలువలను పంపుతాము. ప్రతి Arduino కి కనెక్ట్ చేయబడిన 16x2 LCD లో విలువలు ప్రదర్శించబడతాయి. ఇక్కడ ఒక ఆర్డునో మాస్టర్‌గా, మరొకరు స్లేవ్‌గా వ్యవహరిస్తారు. కాబట్టి I2C కమ్యూనికేషన్ గురించి పరిచయంతో ప్రారంభిద్దాం.

I2C కమ్యూనికేషన్ ప్రోటోకాల్ అంటే ఏమిటి?

IIC అనే పదం “ ఇంటర్ ఇంటిగ్రేటెడ్ సర్క్యూట్స్ ”. ఇది సాధారణంగా I2C లేదా I స్క్వేర్డ్ సి లేదా కొన్ని ప్రదేశాలలో 2-వైర్ ఇంటర్ఫేస్ ప్రోటోకాల్ (TWI) గా సూచించబడుతుంది, అయితే ఇవన్నీ ఒకే విధంగా ఉంటాయి. I2C అనేది సింక్రోనస్ కమ్యూనికేషన్ ప్రోటోకాల్ అర్థం, సమాచారాన్ని పంచుకునే రెండు పరికరాలు తప్పనిసరిగా సాధారణ గడియార సంకేతాన్ని పంచుకోవాలి. సమాచారాన్ని పంచుకోవడానికి దీనికి రెండు వైర్లు మాత్రమే ఉన్నాయి, వీటిలో ఒకటి కాక్ సిగ్నల్ కోసం ఉపయోగించబడుతుంది మరియు మరొకటి డేటాను పంపడానికి మరియు స్వీకరించడానికి ఉపయోగించబడుతుంది.

I2C కమ్యూనికేషన్ ఎలా పనిచేస్తుంది?

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

సీరియల్ క్లాక్ (ఎస్సీఎల్) మరియు సీరియల్ డేటా (ఎస్డీఏ) అనే ఈ రెండు వైర్ల ద్వారా పూర్తి కమ్యూనికేషన్ జరుగుతుంది.

సీరియల్ క్లాక్ (ఎస్సీఎల్): మాస్టర్ సృష్టించిన క్లాక్ సిగ్నల్‌ను బానిసతో పంచుకుంటుంది

సీరియల్ డేటా (SDA): మాస్టర్ మరియు బానిస మధ్య మరియు నుండి డేటాను పంపుతుంది.

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

I2C యొక్క వోల్టేజ్ స్థాయిలు ముందే నిర్వచించబడలేదు. I2C కమ్యూనికేషన్ సరళమైనది, అంటే 5v వోల్ట్‌తో నడిచే పరికరం, I2C కోసం 5v ని ఉపయోగించవచ్చు మరియు 3.3v పరికరాలు I2C కమ్యూనికేషన్ కోసం 3v ని ఉపయోగించవచ్చు. వేర్వేరు వోల్టేజ్‌లలో నడుస్తున్న రెండు పరికరాలు, I2C ఉపయోగించి కమ్యూనికేట్ చేయవలసి వస్తే? 5 వి ఐ 2 సి బస్సును 3.3 వి పరికరంతో కనెక్ట్ చేయలేము. ఈ సందర్భంలో వోల్టేజ్ షిఫ్టర్లు రెండు I2C బస్సుల మధ్య వోల్టేజ్ స్థాయిలను సరిపోల్చడానికి ఉపయోగిస్తారు.

లావాదేవీని రూపొందించే కొన్ని షరతులు ఉన్నాయి. ట్రాన్స్మిషన్ ప్రారంభించడం SDA యొక్క పడిపోయే అంచుతో ప్రారంభమవుతుంది, ఇది క్రింద ఉన్న రేఖాచిత్రంలో 'START' కండిషన్ అని నిర్వచించబడింది, ఇక్కడ మాస్టర్ SDA ని తక్కువ సెట్ చేసేటప్పుడు SCL ను వదిలివేస్తుంది.

క్రింద ఉన్న రేఖాచిత్రంలో చూపిన విధంగా, SDA యొక్క పడిపోయే అంచు START పరిస్థితికి హార్డ్‌వేర్ ట్రిగ్గర్. దీని తరువాత ఒకే బస్సులోని అన్ని పరికరాలు లిజనింగ్ మోడ్‌లోకి వెళ్తాయి.

అదే పద్ధతిలో, SDA యొక్క పెరుగుతున్న అంచు పైన ఉన్న రేఖాచిత్రంలో 'STOP' కండిషన్‌గా చూపబడిన ప్రసారాన్ని ఆపివేస్తుంది, ఇక్కడ మాస్టర్ SCL ను అధికంగా వదిలివేస్తుంది మరియు SDA ను అధికంగా వెళ్ళడానికి విడుదల చేస్తుంది. కాబట్టి SDA యొక్క పెరుగుతున్న అంచు ప్రసారాన్ని ఆపివేస్తుంది.

R / W బిట్ క్రింది బైట్ల ప్రసార దిశను సూచిస్తుంది, అది HIGH అయితే బానిస ప్రసారం చేస్తుంది మరియు అది తక్కువగా ఉంటే మాస్టర్ ప్రసారం చేస్తుంది.

ప్రతి గడియార చక్రంలో ప్రతి బిట్ ప్రసారం చేయబడుతుంది, కాబట్టి బైట్‌ను ప్రసారం చేయడానికి 8 గడియార చక్రాలు పడుతుంది. ప్రతి బైట్ పంపిన లేదా స్వీకరించిన తరువాత, ACK / NACK కోసం తొమ్మిదవ గడియార చక్రం జరుగుతుంది (గుర్తించబడింది / గుర్తించబడలేదు). ఈ ACK బిట్ పరిస్థితిని బట్టి బానిస లేదా మాస్టర్ చేత ఉత్పత్తి అవుతుంది. ACK బిట్ కోసం, SDA 9 ^వ గడియార చక్రంలో మాస్టర్ లేదా బానిస చేత తక్కువగా సెట్ చేయబడింది. కనుక ఇది ACK లేకపోతే NACK గా పరిగణించబడుతుంది.

I2C కమ్యూనికేషన్‌ను ఎక్కడ ఉపయోగించాలి?

I2C కమ్యూనికేషన్ స్వల్ప దూర కమ్యూనికేషన్ కోసం మాత్రమే ఉపయోగించబడుతుంది. ఇది స్మార్ట్‌గా చేయడానికి సమకాలీకరించబడిన గడియారపు పల్స్ ఉన్నందున ఇది ఖచ్చితంగా కొంతవరకు నమ్మదగినది. ఈ ప్రోటోకాల్ ప్రధానంగా సెన్సార్ లేదా ఇతర పరికరాలతో కమ్యూనికేట్ చేయడానికి ఉపయోగించబడుతుంది, ఇది మాస్టర్‌కు సమాచారాన్ని పంపాలి. మైక్రోకంట్రోలర్ కనీసం అనేక వైర్లను ఉపయోగించి అనేక ఇతర బానిస మాడ్యూళ్ళతో కమ్యూనికేట్ చేయవలసి వచ్చినప్పుడు ఇది చాలా సులభమైంది. మీరు సుదూర కమ్యూనికేషన్ కోసం చూస్తున్నట్లయితే మీరు RS232 ను ప్రయత్నించాలి మరియు మీరు మరింత నమ్మదగిన కమ్యూనికేషన్ కోసం చూస్తున్నట్లయితే మీరు SPI ప్రోటోకాల్‌ను ప్రయత్నించాలి.

Arduino లో I2C

క్రింద ఉన్న చిత్రం Arduino UNO లో ఉన్న I2C పిన్‌లను చూపిస్తుంది.

I2C లైన్	Arduino లో పిన్ చేయండి
SDA	ఎ 4
ఎస్సీఎల్	A5

మేము రెండు ఆర్డునో ఉపయోగించి ప్రోగ్రామింగ్ I2C లోకి ప్రవేశించే ముందు. Arduino IDE లో ఉపయోగించిన వైర్ లైబ్రరీ గురించి మనం నేర్చుకోవాలి.

లైబ్రరీ I2C కమ్యూనికేషన్ కోసం కింది విధులను ఉపయోగించడం కోసం ప్రోగ్రామ్‌లో చేర్చబడింది.

1. వైర్.బెగిన్ (చిరునామా):

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

చిరునామా: 7-బిట్ బానిస చిరునామా ఐచ్ఛికం మరియు చిరునామా పేర్కొనకపోతే, ఇది బస్సులో ఈ విధమైన మాస్టర్‌గా కలుస్తుంది.

2. వైర్.రెడ్ ():

ఉపయోగం: ఈ ఫంక్షన్ మాస్టర్ లేదా బానిస పరికరం నుండి స్వీకరించబడిన బైట్‌ను చదవడానికి ఉపయోగించబడుతుంది, ఇది బానిస పరికరం నుండి మాస్టర్ పరికరానికి అభ్యర్థన నుండి () నుండి కాల్ చేసిన తర్వాత ప్రసారం చేయబడింది లేదా మాస్టర్ నుండి బానిసకు ప్రసారం చేయబడింది.

3. వైర్.రైట్ ():

ఉపయోగం: బానిస లేదా మాస్టర్ పరికరానికి డేటాను వ్రాయడానికి ఈ ఫంక్షన్ ఉపయోగించబడుతుంది.

మాస్టర్‌కు స్లేవ్ : వైర్.రేక్వెస్ట్ఫ్రమ్ () ను మాస్టర్‌లో ఉపయోగించినప్పుడు స్లేవ్ మాస్టర్‌కు డేటాను వ్రాస్తాడు.

మాస్టర్ టు స్లేవ్: మాస్టర్ నుండి బానిస పరికరానికి ప్రసారం కోసం వైర్.రైట్ () వైర్.బెగిన్ ట్రాన్స్మిషన్ () మరియు వైర్.ఎండ్ ట్రాన్స్మిషన్ () కు కాల్స్ మధ్య ఉపయోగించబడుతుంది .

Wire.write () ను ఇలా వ్రాయవచ్చు:

• వైర్.రైట్ (విలువ)

విలువ: ఒకే బైట్‌గా పంపే విలువ.

• వైర్.రైట్ (స్ట్రింగ్):

స్ట్రింగ్: బైట్‌ల శ్రేణిగా పంపే స్ట్రింగ్.

• వైర్.రైట్ (డేటా, పొడవు):

డేటా: బైట్‌లుగా పంపే డేటా శ్రేణి

పొడవు: ప్రసారం చేయడానికి బైట్ల సంఖ్య.

4. వైర్.బెగిన్ ట్రాన్స్మిషన్ (చిరునామా):

ఉపయోగం: ఇచ్చిన బానిస చిరునామాతో I2C పరికరానికి ప్రసారాన్ని ప్రారంభించడానికి ఈ ఫంక్షన్ ఉపయోగించబడుతుంది. తదనంతరం, రైట్ () ఫంక్షన్‌తో ప్రసారం కోసం బైట్‌ల క్యూను నిర్మించి, ఎండ్‌ట్రాన్స్‌మిషన్ () ఫంక్షన్‌కు కాల్ చేయడం ద్వారా వాటిని ప్రసారం చేయండి. పరికరం యొక్క 7-బిట్ చిరునామా ప్రసారం చేయబడుతుంది.

5. వైర్.ఎండ్ ట్రాన్స్మిషన్ ();

ఉపయోగం: ప్రారంభ ట్రాన్స్మిషన్ () చేత ప్రారంభించబడిన బానిస పరికరానికి ప్రసారాన్ని ముగించడానికి ఈ ఫంక్షన్ ఉపయోగించబడుతుంది మరియు వైర్.రైట్ () చేత క్యూ చేయబడిన బైట్‌లను ప్రసారం చేస్తుంది .

6. వైర్.ఆన్ రిక్వెస్ట్ ();

ఉపయోగం: బానిస పరికరం నుండి Wire.requestFrom () ను ఉపయోగించి మాస్టర్ డేటాను అభ్యర్థించినప్పుడు ఈ ఫంక్షన్ పిలువబడుతుంది. ఇక్కడ మేము మాస్టర్‌కు డేటాను పంపడానికి వైర్.రైట్ () ఫంక్షన్‌ను చేర్చవచ్చు .

7. వైర్.ఆన్ రిసీవ్ ();

ఉపయోగం: బానిస పరికరం మాస్టర్ నుండి డేటాను అందుకున్నప్పుడు ఈ ఫంక్షన్ పిలువబడుతుంది. ఇక్కడ మనం వైర్.రెడ్ () ను చేర్చవచ్చు; మాస్టర్ నుండి పంపిన డేటాను చదవడానికి ఫంక్షన్.

8. వైర్.రెక్వెస్ట్ (చిరునామా, పరిమాణం);

ఉపయోగం: బానిస పరికరం నుండి బైట్‌లను అభ్యర్థించడానికి ఈ ఫంక్షన్ మాస్టర్‌లో ఉపయోగించబడుతుంది. Wire.read () ఫంక్షన్ బానిస పరికరం నుండి పంపిన డేటాను చదవడానికి ఉపయోగించబడుతుంది.

చిరునామా: బైట్‌లను అభ్యర్థించడానికి పరికరం యొక్క 7-బిట్ చిరునామా

పరిమాణం: అభ్యర్థించడానికి బైట్ల సంఖ్య

భాగాలు అవసరం

• ఆర్డునో యునో (2-సంఖ్యలు)
• 16X2 LCD డిస్ప్లే మాడ్యూల్
• 10 కె పొటెన్టోమీటర్ (4-సంఖ్యలు)
• బ్రెడ్‌బోర్డ్
• వైర్లను కనెక్ట్ చేస్తోంది

సర్క్యూట్ రేఖాచిత్రం

పని వివరణ

Arduino లో I2C కమ్యూనికేషన్‌ను ప్రదర్శించడానికి, మేము ఒకదానికొకటి జతచేయబడిన రెండు 16X2 LCD డిస్ప్లేతో రెండు Arduino UNO ని ఉపయోగిస్తాము మరియు పంపే విలువలను (0 నుండి 127 వరకు) మాస్టర్ నుండి బానిసకు మరియు బానిస నుండి మాస్టర్‌కు పంపే విలువలను నిర్ణయించడానికి రెండు arduino వద్ద రెండు పొటెన్షియోమీటర్లను ఉపయోగిస్తాము. పొటెన్షియోమీటర్.

మేము పొటెన్షియోమీటర్ ఉపయోగించి arduino పిన్ A0 వద్ద (0 నుండి 5V వరకు) ఇన్పుట్ అనలాగ్ విలువను తీసుకుంటాము మరియు వాటిని అనలాగ్ నుండి డిజిటల్ విలువకు (0 నుండి 1023 వరకు) మారుస్తాము. I2C కమ్యూనికేషన్ ద్వారా 7-బిట్ డేటాను మాత్రమే పంపగలము కాబట్టి ఈ ADC విలువలు మరింత (0 నుండి 127 వరకు) మార్చబడతాయి. I2C కమ్యూనికేషన్ రెండు ఆర్డునో యొక్క పిన్ A4 & A5 వద్ద రెండు వైర్ల ద్వారా జరుగుతుంది.

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

Arduino లో I2C ప్రోగ్రామింగ్

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

మాస్టర్ ఆర్డునో ప్రోగ్రామింగ్ వివరణ

1. మొదట మనం ఐ 2 సి కమ్యూనికేషన్ ఫంక్షన్లను ఉపయోగించటానికి వైర్ లైబ్రరీని మరియు ఎల్సిడి ఫంక్షన్లను ఉపయోగించటానికి ఎల్సిడి లైబ్రరీని చేర్చాలి. 16x2 LCD కోసం LCD పిన్‌లను కూడా నిర్వచించండి. ఆర్డునోతో ఎల్‌సిడిని ఇంటర్‌ఫేస్ చేయడం గురించి ఇక్కడ మరింత తెలుసుకోండి.

# చేర్చండి # చేర్చండి లిక్విడ్ క్రిస్టల్ ఎల్సిడి (2, 7, 8, 9, 10, 11);

2. శూన్య సెటప్‌లో ()

• మేము బాడ్ రేట్ 9600 వద్ద సీరియల్ కమ్యూనికేషన్‌ను ప్రారంభిస్తాము.

సీరియల్.బెగిన్ (9600);

• తరువాత మనం పిన్ (A4, A5) వద్ద I2C కమ్యూనికేషన్‌ను ప్రారంభిస్తాము

వైర్.బెగిన్ (); // పిన్ (A4, A5) వద్ద I2C కమ్యూనికేషన్ ప్రారంభమవుతుంది

• తరువాత మేము 16X2 మోడ్‌లో LCD డిస్ప్లే మాడ్యూల్‌ను ప్రారంభిస్తాము మరియు స్వాగత సందేశాన్ని ప్రదర్శిస్తాము మరియు ఐదు సెకన్ల తర్వాత క్లియర్ చేస్తాము.

lcd.begin (16,2); // ఎల్‌సిడి డిస్‌ప్లేను ప్రారంభించండి lcd.setCursor (0,0); // డిస్ప్లే lcd.print ("సర్క్యూట్ డైజెస్ట్") యొక్క మొదటి వరుసలో కర్సర్‌ను సెట్ చేస్తుంది ; // LCD lcd.setCursor (0,1) లో CIRCUIT DIGEST ను ముద్రిస్తుంది; // డిస్ప్లే lcd.print ("I2C 2 ARDUINO") యొక్క రెండవ వరుసలో కర్సర్‌ను సెట్ చేస్తుంది ; // LCD ఆలస్యం (5000) లో I2C ARDUINO ను ప్రింట్ చేస్తుంది ; // 5 సెకన్ల ఆలస్యం lcd.clear (); // ఎల్‌సిడి డిస్‌ప్లేను క్లియర్ చేస్తుంది

3. శూన్య లూప్‌లో ()

• మొదట మనం స్లేవ్ నుండి డేటాను పొందాలి కాబట్టి బానిస చిరునామా 8 తో రిక్వెస్ట్ ఫ్రం () ను ఉపయోగిస్తాము మరియు మేము ఒక బైట్ ను అభ్యర్థిస్తాము

వైర్.రెక్వెస్ట్ (8,1);

అందుకున్న విలువ Wire.read () ఉపయోగించి చదవబడుతుంది

బైట్ మాస్టర్ రిసీవ్ = వైర్.రెడ్ ();

• తరువాత మనం పిన్ A0 కి జతచేయబడిన మాస్టర్ ఆర్డునో POT నుండి అనలాగ్ విలువను చదవాలి

int potvalue = అనలాగ్ రీడ్ (A0);

మేము ఆ విలువను ఒక బైట్ పరంగా 0 నుండి 127 గా మారుస్తాము.

బైట్ మాస్టర్‌సెండ్ = మ్యాప్ (పోట్‌వాల్యూ, 0,1023,0,127);

• తరువాత మనం మార్చబడిన విలువలను పంపాలి, కాబట్టి మేము 8 చిరునామాతో బానిస ఆర్డునోతో ప్రసారాన్ని ప్రారంభిస్తాము

వైర్.బెగిన్ ట్రాన్స్మిషన్ (8); వైర్.రైట్ (మాస్టర్‌సెండ్); వైర్.ఎండ్ ట్రాన్స్మిషన్ ();

• తరువాత మేము స్లేవ్ ఆర్డునో నుండి అందుకున్న విలువలను 500 మైక్రో సెకన్ల ఆలస్యంతో ప్రదర్శిస్తాము మరియు మేము ఆ విలువను నిరంతరం స్వీకరిస్తాము మరియు ప్రదర్శిస్తాము.

lcd.setCursor (0,0); // LCD lcd.print (">> మాస్టర్ <<") యొక్క మొదటి వరుసలో కర్సర్‌ను సెట్ చేస్తుంది ; // ప్రింట్లు >> మాస్టర్ << LCD lcd.setCursor వద్ద (0,1); // LCD lcd.print యొక్క రెండవ వరుసలో కర్సర్‌ను సెట్ చేస్తుంది ("స్లేవ్‌వాల్:"); // ప్రింట్స్ స్లేవ్‌వాల్: ఎల్‌సిడి ఎల్‌సిడి.ప్రింట్‌లో (మాస్టర్ రిసీవ్); // ప్రింట్లు స్లేవ్ సీరియల్.ప్రింట్ల్న్ (" బానిస నుండి పొందిన మాస్టర్") నుండి ఎల్‌సిడిలో మాస్టర్ రిసీవ్ ; // సీరియల్ మానిటర్‌లో ప్రింట్లు Serial.println (MasterReceive); ఆలస్యం (500); lcd.clear ();

స్లేవ్ ఆర్డునో ప్రోగ్రామింగ్ వివరణ

1. మాస్టర్ మాదిరిగానే, మొదట మనం I2C కమ్యూనికేషన్ ఫంక్షన్లను ఉపయోగించటానికి వైర్ లైబ్రరీని మరియు LCD ఫంక్షన్లను ఉపయోగించటానికి LCD లైబ్రరీని చేర్చాలి. 16x2 LCD కోసం LCD పిన్‌లను కూడా నిర్వచించండి.

# చేర్చండి # చేర్చండి లిక్విడ్ క్రిస్టల్ ఎల్సిడి (2, 7, 8, 9, 10, 11);

2. శూన్య సెటప్‌లో ()

• మేము బాడ్ రేట్ 9600 వద్ద సీరియల్ కమ్యూనికేషన్‌ను ప్రారంభిస్తాము.

సీరియల్.బెగిన్ (9600);

• తరువాత మనం బానిస చిరునామా 8 తో పిన్ (A4, A5) వద్ద I2C కమ్యూనికేషన్‌ను ప్రారంభిస్తాము. ఇక్కడ బానిస చిరునామాను పేర్కొనడం చాలా ముఖ్యం.

వైర్.బెగిన్ (8);

తరువాత మనం స్లేవ్ మాస్టర్ నుండి విలువను పొందినప్పుడు మరియు స్లేవ్ నుండి మాస్టర్ రిక్వెస్ట్ విలువను పొందినప్పుడు ఫంక్షన్‌కు కాల్ చేయాలి

Wire.onReceive (receEvent); Wire.onRequest (requestEvent);

• తరువాత మేము 16X2 మోడ్‌లో LCD డిస్ప్లే మాడ్యూల్‌ను ప్రారంభిస్తాము మరియు స్వాగత సందేశాన్ని ప్రదర్శిస్తాము మరియు ఐదు సెకన్ల తర్వాత క్లియర్ చేస్తాము.

lcd.begin (16,2); // ఎల్‌సిడి డిస్‌ప్లేను ప్రారంభించండి lcd.setCursor (0,0); // డిస్ప్లే lcd.print ("సర్క్యూట్ డైజెస్ట్") యొక్క మొదటి వరుసలో కర్సర్‌ను సెట్ చేస్తుంది ; // LCD lcd.setCursor (0,1) లో CIRCUIT DIGEST ను ముద్రిస్తుంది; // డిస్ప్లే lcd.print ("I2C 2 ARDUINO") యొక్క రెండవ వరుసలో కర్సర్‌ను సెట్ చేస్తుంది ; // LCD ఆలస్యం (5000) లో I2C ARDUINO ను ప్రింట్ చేస్తుంది ; // 5 సెకన్ల ఆలస్యం lcd.clear (); // ఎల్‌సిడి డిస్‌ప్లేను క్లియర్ చేస్తుంది

3. తరువాత మనకు రెండు ఫంక్షన్లు ఒకటి రిక్వెస్ట్ ఈవెంట్ మరియు మరొకటి రిసీవ్ ఈవెంట్

అభ్యర్థన ఈవెంట్ కోసం

బానిస నుండి మాస్టర్ అభ్యర్థన విలువ ఈ ఫంక్షన్ అమలు అవుతుంది. ఈ ఫంక్షన్ స్లేవ్ పాట్ నుండి ఇన్పుట్ విలువను తీసుకుంటుంది మరియు దానిని 7-బిట్ పరంగా మారుస్తుంది మరియు ఆ విలువను మాస్టర్కు పంపుతుంది.

void requestEvent () { int potvalue = అనలాగ్ రీడ్ (A0); బైట్ స్లేవ్‌సెండ్ = మ్యాప్ (పొట్వాల్యూ, 0,1023,0,127); వైర్.రైట్ (స్లేవ్‌సెండ్); }

ఈవెంట్ స్వీకరించడానికి

మాస్టర్ బానిస చిరునామాతో బానిసకు డేటాను పంపినప్పుడు (8) ఈ ఫంక్షన్ అమలు అవుతుంది. ఈ ఫంక్షన్ మాస్టర్ మరియు స్టోర్ నుండి అందుకున్న విలువను టైప్ బైట్ యొక్క వేరియబుల్ లో చదువుతుంది.

void receEvent (int howMany { SlaveReceived = Wire.read (); }

4. శూన్య లూప్‌లో ():

మేము మాస్టర్ నుండి అందుకున్న విలువను LCD డిస్ప్లే మాడ్యూల్‌లో నిరంతరం ప్రదర్శిస్తాము.

శూన్య లూప్ (శూన్యమైనది) { lcd.setCursor (0,0); // LCD lcd.print (">> బానిస <<") యొక్క మొదటి వరుసలో కర్సర్‌ను సెట్ చేస్తుంది ; // ప్రింట్లు >> స్లేవ్ << LCD lcd.setCursor వద్ద (0,1); // LCD lcd.print ("మాస్టర్‌వాల్:") యొక్క రెండవ వరుసలో కర్సర్‌ను సెట్ చేస్తుంది ; // ప్రింట్స్ మాస్టర్వాల్: LCD lcd.print లో (స్లేవ్ రిసీవ్డ్); // ప్రింట్లు మాస్టర్ సీరియల్.ప్రింట్ల్న్ ("మాస్టర్ నుండి స్వీకరించబడిన బానిస:") నుండి పొందిన LCD లో స్లేవ్ రిసీవ్డ్ విలువ ; // సీరియల్ మానిటర్‌లోని ప్రింట్లు Serial.println (స్లేవ్ రిసీవ్డ్); ఆలస్యం (500); lcd.clear (); }

పొటెన్టోమీటర్‌ను ఒక వైపు తిప్పడం ద్వారా , మీరు ఎల్‌సిడిలో విభిన్న విలువలను మరొక వైపు చూడవచ్చు:

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

మాస్టర్ మరియు స్లేవ్ ఆర్డునో కోసం పూర్తి కోడింగ్ ప్రదర్శన వీడియోతో క్రింద ఇవ్వబడింది