కార్యాలయాలు, షాపింగ్ మాల్స్ మరియు అనేక ఇతర ప్రదేశాలలో మాకు తెలుసు, అక్కడ అధికారం కార్డు ఉన్న వ్యక్తిని మాత్రమే గదిలోకి అనుమతించారు. ఈ వ్యవస్థలు RFID కమ్యూనికేషన్ వ్యవస్థను ఉపయోగిస్తాయి. ఉత్పత్తులను RFID చిప్తో ట్యాగ్ చేయబడినందున దొంగతనం ఆపడానికి షాపింగ్ మాల్లలో RFID ఉపయోగించబడుతుంది మరియు ఒక వ్యక్తి RFID చిప్తో భవనం నుండి బయలుదేరినప్పుడు అలారం స్వయంచాలకంగా పెంచబడుతుంది. RFID ట్యాగ్ ఇసుకలో భాగంగా చిన్నదిగా రూపొందించబడింది. RFID ప్రామాణీకరణ వ్యవస్థలు రూపకల్పన చేయడం సులభం మరియు తక్కువ ఖర్చుతో ఉంటాయి. ఈ రోజుల్లో కొన్ని పాఠశాలలు మరియు కళాశాలలు RFID ఆధారిత హాజరు వ్యవస్థలను ఉపయోగిస్తున్నాయి.
ఈ ప్రాజెక్టులో మేము భద్రతా ప్రయోజనాల కోసం RFID ఆధారిత టోల్ సేకరణ వ్యవస్థను రూపొందించబోతున్నాము. కాబట్టి ఈ వ్యవస్థ గేట్లను తెరిచి, అధీకృత RFID ట్యాగ్లతో మాత్రమే ప్రజలను అనుమతిస్తుంది. అధీకృత ట్యాగ్స్ హోల్డర్ ID లు ATMEGA మైక్రోకంట్రోలర్కు ప్రోగ్రామ్ చేయబడతాయి మరియు ఆ హోల్డర్లకు మాత్రమే ప్రాంగణాన్ని వదిలి వెళ్ళడానికి లేదా ప్రవేశించడానికి అనుమతి ఉంది.
భాగాలు అవసరం
హార్డ్వేర్: ATmega32 మైక్రోకంట్రోలర్, విద్యుత్ సరఫరా (5v), AVR-ISP ప్రోగ్రామర్, JHD_162ALCD (16x2 LCD మాడ్యూల్), 100uF కెపాసిటర్ (విద్యుత్ సరఫరా అంతటా కనెక్ట్ చేయబడింది), బటన్, 10KΩ రెసిస్టర్, 100nF కెపాసిటర్, LED (రెండు ముక్కలు), EM-18 (RFID రీడర్ మాడ్యూల్), L293D మోటారు డ్రైవర్ IC, 5V DC మోటారు.
సాఫ్ట్వేర్: అట్మెల్ స్టూడియో 6.1, ప్రోగిస్ప్ లేదా ఫ్లాష్ మ్యాజిక్.
సర్క్యూట్ రేఖాచిత్రం మరియు వర్కింగ్ వివరణ
లో RFID టోల్ సేకరణ వ్యవస్థ సర్క్యూట్ పైన చూపిన ATMEGA32 యొక్క PORTA LCD యొక్క డేటా పోర్ట్ కు కనెక్ట్. ఇక్కడ మేము PORTC ని ఒక సాధారణ కమ్యూనికేషన్ పోర్ట్గా ఉపయోగించాలనుకుంటే, ఫ్యూజ్ బైట్లను మార్చడం ద్వారా PORTC లోని JTAG కమ్యూనికేషన్ను ATMEGA కి నిలిపివేయాలని గుర్తుంచుకోవాలి. 16x2 LCD లో, బ్యాక్ లైట్ ఉంటే అన్నింటికంటే 16 పిన్స్ ఉన్నాయి, బ్యాక్ లైట్ లేకపోతే 14 పిన్స్ ఉంటాయి. మేము వెనుక లైట్ పిన్నులను శక్తివంతం చేయవచ్చు లేదా వదిలివేయవచ్చు. ఇప్పుడు 14 పిన్లలో 8 డేటా పిన్స్ (7-14 లేదా డి 0-డి 7), 2 విద్యుత్ సరఫరా పిన్స్ (1 & 2 లేదా విఎస్ఎస్ & విడిడి లేదా జిఎన్డి & + 5 వి), కాంట్రాస్ట్ కంట్రోల్ కోసం 3 వ పిన్ (VEE- ఎంత మందంగా నియంత్రిస్తుంది అక్షరాలు చూపించబడాలి), 3 కంట్రోల్ పిన్స్ (RS & RW & E).
సర్క్యూట్లో, నేను రెండు కంట్రోల్ పిన్స్ మాత్రమే తీసుకున్నానని మీరు గమనించవచ్చు. ఇది మంచి అవగాహన యొక్క సౌలభ్యాన్ని ఇస్తుంది. కాంట్రాస్ట్ బిట్ మరియు READ / WRITE తరచుగా ఉపయోగించబడవు కాబట్టి వాటిని భూమికి తగ్గించవచ్చు. ఇది ఎల్సిడిని అత్యధిక కాంట్రాస్ట్ మరియు రీడ్ మోడ్లో ఉంచుతుంది. అక్షరాలు మరియు డేటాను తదనుగుణంగా పంపడానికి మేము ఎనేబుల్ మరియు RS పిన్లను నియంత్రించాలి.
LCD కోసం తయారు చేయబడిన కనెక్షన్లు క్రింద ఇవ్వబడ్డాయి:
PIN1 లేదా VSS భూమికి
PIN2 లేదా VDD లేదా VCC నుండి + 5v శక్తికి
PIN3 లేదా VEE to ground (ఒక అనుభవశూన్యుడు కోసం గరిష్ట విరుద్ధతను ఉత్తమంగా ఇస్తుంది)
MCU యొక్క PD6 కు PIN4 లేదా RS (రిజిస్టర్ ఎంపిక)
PIN5 లేదా RW (చదవడం / వ్రాయడం) భూమికి (LCD ని రీడ్ మోడ్లో ఉంచుతుంది వినియోగదారు కోసం కమ్యూనికేషన్ను సులభతరం చేస్తుంది)
మైక్రోకంట్రోలర్ యొక్క PD5 కు PIN6 లేదా E (ప్రారంభించు)
PIN7 లేదా D0 నుండి PA0 వరకు
PIN8 లేదా D1 నుండి PA1 వరకు
PIN9 లేదా D2 నుండి PA2 వరకు
PIN10 లేదా D3 నుండి PA3 వరకు
PIN11 లేదా D4 నుండి PA4 వరకు
PIN12 లేదా D5 నుండి PA5 వరకు
PIN13 లేదా D6 నుండి PA6 వరకు
PIN14 లేదా D7 నుండి PA7 వరకు
సర్క్యూట్లో, మేము 8 బిట్ కమ్యూనికేషన్ (D0-D7) ను ఉపయోగించామని మీరు చూడవచ్చు. అయితే ఇది తప్పనిసరి కాదు మరియు మేము 4 బిట్ కమ్యూనికేషన్ (డి 4-డి 7) ను ఉపయోగించవచ్చు కాని 4 బిట్ కమ్యూనికేషన్ ప్రోగ్రామ్ కొంచెం క్లిష్టంగా మారుతుంది, కాబట్టి నేను 8 బిట్ కమ్యూనికేషన్కు ప్రాధాన్యత ఇచ్చాను.
కాబట్టి పై పట్టికను పరిశీలించడం నుండి మేము 10 పిన్స్ ఎల్సిడిని కంట్రోలర్కు కలుపుతున్నాము, ఇందులో 8 పిన్లు డేటా పిన్స్ మరియు నియంత్రణ కోసం 2 పిన్స్.
ముందుకు వెళ్ళే ముందు, సీరియల్ కమ్యూనికేషన్ గురించి మనం అర్థం చేసుకోవాలి. ఇక్కడ RFID మాడ్యూల్ సీరియల్లోని కంట్రోలర్కు డేటాను పంపుతుంది. ఇది ఇతర కమ్యూనికేషన్ మోడ్ను కలిగి ఉంది కాని సులభమైన కమ్యూనికేషన్ కోసం మేము RS232 ని ఎంచుకుంటున్నాము. RS232 పిన్ మాడ్యూల్ ATMEGA యొక్క RXD పిన్తో అనుసంధానించబడింది.
RFID మాడ్యూల్ పంపిన డేటా ఇలా ఉంటుంది:
ఇప్పుడు RFID మాడ్యూల్ ఇంటర్ఫేస్ కోసం, ఈ క్రింది లక్షణాలు అవసరం:
1. నియంత్రిక యొక్క RXD పిన్ (డేటా స్వీకరించే లక్షణం) తప్పక ప్రారంభించబడాలి.
2. కమ్యూనికేషన్ సీరియల్ కాబట్టి డేటా బై అందుకున్నప్పుడల్లా మనం తెలుసుకోవాలి, తద్వారా పూర్తి బైట్ వచ్చేవరకు ప్రోగ్రామ్ను ఆపవచ్చు. డేటాను పూర్తి అంతరాయాన్ని స్వీకరించడం ద్వారా ఇది జరుగుతుంది.
3. RFID 8bit మోడ్లో డేటాను కంట్రోలర్కు పంపుతుంది. కాబట్టి ఒకేసారి రెండు అక్షరాలు నియంత్రికకు పంపబడతాయి. ఇది పై చిత్రంలో చూపబడింది.
4. పై సంఖ్య నుండి, మారిటీ పంపిన డేటాలో పారిటీ బిట్స్, ఒక స్టాప్ బిట్ లేవు.
పై లక్షణాలు నియంత్రిక రిజిస్టర్లలో సెట్ చేయబడ్డాయి; మేము వాటిని క్లుప్తంగా చర్చించబోతున్నాం,
RED (RXEN): ఈ బిట్ స్వీకరించే డేటా లక్షణాన్ని సూచిస్తుంది. మాడ్యూల్ నుండి డేటా కంట్రోలర్ స్వీకరించడానికి ఈ బిట్ సెట్ చేయాలి. ఇది నియంత్రిక యొక్క RXD పిన్ను కూడా అనుమతిస్తుంది.
BROWN (RXCIE): విజయవంతమైన డేటా రిసెప్షన్ తర్వాత అంతరాయం పొందడానికి ఈ బిట్ సెట్ చేయాలి. ఈ బిట్ను ప్రారంభించడం ద్వారా 8 బిట్ డేటా అందుకున్న వెంటనే మనకు తెలుసు.
పింక్ (యుఆర్సెల్): యుసిఎస్ఆర్సిలో ఇతర బిట్లను ప్రారంభించడానికి ముందు ఈ బిట్ సెట్ చేయాలి. సెట్ చేసిన తరువాత, UCSRC, URSEL లో అవసరమైన ఇతర బిట్స్ తప్పనిసరిగా నిలిపివేయబడాలి లేదా సున్నాకి ఉంచాలి.
YELLOW (UCSZ0, UCSZ1, UCSZ2): ఈ మూడు బిట్లు మనం ఒకేసారి అందుకుంటున్న లేదా పంపే డేటా బిట్ల సంఖ్యను ఎంచుకోవడానికి ఉపయోగిస్తారు.
RFID మాడ్యూల్ పంపిన డేటా 8bit డేటా రకం కాబట్టి, మేము UCSZ0, UCSZ1 ను ఒకదానికి మరియు UCSZ2 ను సున్నాకి సెట్ చేయాలి.
ఆరెంజ్ (UMSEL): సిస్టమ్ అసమకాలికంగా కమ్యూనికేట్ చేస్తుందా (రెండూ వేర్వేరు గడియారాన్ని ఉపయోగిస్తాయి) లేదా సమకాలికంగా (రెండూ ఒకే గడియారాన్ని ఉపయోగిస్తాయి) ఆధారంగా ఈ బిట్ సెట్ చేయబడింది.
మాడ్యూల్ మరియు కంట్రోలర్ వేర్వేరు గడియారాన్ని ఉపయోగిస్తున్నందున, ఈ బిట్ సున్నాకి సెట్ చేయబడాలి లేదా అప్రమేయంగా సున్నాకి సెట్ చేయబడినందున ఒంటరిగా వదిలివేయాలి.
గ్రీన్ (యుపిఎం 1, యుపిఎం 0): ఈ రెండు బిట్స్ మేము కమ్యూనికేషన్లో ఉపయోగిస్తున్న బిట్ పారిటీ ఆధారంగా సర్దుబాటు చేయబడతాయి.
RFID మాడ్యూల్ సమానత్వం లేకుండా డేటాను పంపుతుంది కాబట్టి, మేము UPM1, UPM0 రెండింటినీ సున్నాకి సెట్ చేసాము లేదా ఏదైనా రిజిస్టర్లలోని అన్ని బిట్స్ అప్రమేయంగా సున్నాకి సెట్ చేయబడినందున వాటిని ఒంటరిగా ఉంచవచ్చు.
బ్లూ (యుఎస్బిఎస్): కమ్యూనికేషన్ సమయంలో మనం ఉపయోగిస్తున్న స్టాప్ బిట్ల సంఖ్యను ఎంచుకోవడానికి ఈ బిట్ ఉపయోగించబడుతుంది.
RFID మాడ్యూల్ ఒక స్టాప్ బిట్తో డేటాను పంపుతుంది కాబట్టి, మేము యుఎస్బిఎస్ బిట్ను ఒంటరిగా వదిలివేయాలి.
ఇప్పుడు చివరికి మేము బాడ్ రేటును సెట్ చేయాలి, పైన ఉన్న బొమ్మ నుండి RFID మాడ్యూల్ 9600bps (సెకనుకు బిట్స్) యొక్క బాడ్ రేటుతో కంట్రోలర్కు డేటాను పంపుతుందని స్పష్టమవుతుంది.
తగిన UBRRH ని ఎంచుకోవడం ద్వారా బాడ్ రేటు నియంత్రికలో సెట్ చేయబడుతుంది.
క్రాస్ రిఫరింగ్ బాడ్ రేట్ మరియు సిపియు క్రిస్టల్ ఫ్రీక్వెన్సీ ద్వారా యుబిఆర్ఆర్హెచ్ విలువ ఎన్నుకోబడుతుంది, కాబట్టి క్రాస్ రిఫరెన్స్ ద్వారా యుబిఆర్ఆర్ విలువ '6' గా కనిపిస్తుంది, కాబట్టి బాడ్ రేట్ సెట్ చేయబడింది.
ఇప్పుడు చిత్రంలో చూపినట్లుగా, కంట్రోలర్ నుండి రెండు పిన్స్ L293D కి వెళతాయి, ఇది తక్కువ శక్తి DC మోటార్లు కోసం భ్రమణ దిశ మరియు దిశను నియంత్రించడానికి ఉపయోగించే H-BRIDGE.
L293D అనేది తక్కువ శక్తి గల DC మోటార్లు నడపడానికి రూపొందించబడిన H-BRIDGE IC మరియు ఇది చిత్రంలో చూపబడింది, ఈ IC రెండు h- వంతెనలను కలిగి ఉంది మరియు కనుక ఇది రెండు DC మోటార్లు నడపగలదు. కాబట్టి మైక్రోకంట్రోలర్ యొక్క సిగ్నల్స్ నుండి రోబోట్ మోటార్లు నడపడానికి ఈ ఐసిని ఉపయోగించవచ్చు.
ఇప్పుడు ఈ IC కి ముందు చర్చించినట్లుగా DC మోటారు యొక్క భ్రమణ దిశను మార్చగల సామర్థ్యం ఉంది. INPUT1 మరియు INPUT2 వద్ద వోల్టేజ్ స్థాయిలను నియంత్రించడం ద్వారా ఇది సాధించబడుతుంది.
పిన్ ప్రారంభించండి |
ఇన్పుట్ పిన్ 1 |
ఇన్పుట్ పిన్ 2 |
మోటార్ డైరెక్షన్ |
అధిక |
తక్కువ |
అధిక |
కుడివైపుకు తిరుగు |
అధిక |
అధిక |
తక్కువ |
ఎడమవైపు తిరగండి |
అధిక |
తక్కువ |
తక్కువ |
ఆపు |
అధిక |
అధిక |
అధిక |
ఆపు |
కాబట్టి పై పట్టికలో చూపినట్లుగా, గడియారం వారీగా భ్రమణం 2A ఎక్కువగా ఉండాలి మరియు 1A తక్కువగా ఉండాలి. అదేవిధంగా యాంటీ సవ్యదిశలో 1A ఎక్కువగా ఉండాలి మరియు 2A తక్కువగా ఉండాలి.
మాడ్యూల్ దగ్గరకు అధీకృత కార్డు తీసుకువచ్చినప్పుడల్లా, మోటారు సెకనుకు సవ్యదిశలో కదలడానికి ప్రోగ్రామ్ చేయబడుతుంది, టోల్ గేట్ తెరిచినట్లు చూపించడానికి ఒక సెకను తర్వాత తిరిగి వస్తుంది, టోల్ గేట్ మూసివేయబడిందని చెబుతుంది. టోల్ ప్లాజా యొక్క పని సి కోడ్ యొక్క దశల వారీగా క్రింద వివరించబడింది.
ప్రోగ్రామింగ్ వివరణ
RFID టోల్ కలెక్షన్ సిస్టమ్ యొక్క కోడ్ కోసం లైన్ టు లైన్ వివరణ క్రింద ఉంది. దిగువ కోడ్ చదవడం ద్వారా మీరు ఈ ప్రాజెక్ట్ యొక్క భావన మరియు పనిని అర్థం చేసుకోవచ్చు. డౌన్లోడ్ చేయడానికి లేదా కాపీ చేయడానికి, మీరు పూర్తి కోడ్ను పేజీ దిగువన కనుగొనవచ్చు.
పిన్లపై డేటా ప్రవాహ నియంత్రణను ప్రారంభించడానికి # చేర్చండి // శీర్షిక
# F_CPU 1000000 ను నిర్వచించండి // కంట్రోలర్ క్రిస్టల్ ఫ్రీక్వెన్సీని జతచేయడం
# చేర్చండి
# E 5 ని నిర్వచించండి PORTD యొక్క 5 వ పిన్కు “ఎనేబుల్” పేరు ఇవ్వడం, ఎందుకంటే ఇది LCD ఎనేబుల్ పిన్తో అనుసంధానించబడి ఉంది
# RSD // ని నిర్వచించండి PORTD యొక్క 6 వ పిన్కు “రిజిస్టర్ సెలెక్షన్ ” పేరు ఇవ్వడం, ఎందుకంటే ఇది LCD RS పిన్తో అనుసంధానించబడి ఉంది
void send_a_command (సంతకం చేయని చార్ కమాండ్);
void send_a_character (సంతకం చేయని చార్ అక్షరం);
రద్దు పంపండి_అ_ స్ట్రింగ్ (చార్ * స్ట్రింగ్_ఆఫ్_చరాక్టర్స్);
పూర్ణాంకానికి ప్రధానమైనది (శూన్యమైనది)
{
DDRA = 0xFF; // పోర్టాను అవుట్పుట్ పిన్లుగా ఉంచడం
డిడిఆర్డి = 0 బి 11111110;
_delay_ms (50); // 50ms ఆలస్యం ఇస్తుంది
డిడిఆర్బి = 0 బి 11110000; // కొన్ని పోర్ట్బి పిన్లను ఇన్పుట్గా తీసుకోవడం.
UCSRB - = (1 <
UCSRC - = (1 <
UCSRC & = ~ (1 <
UBRRH & = ~ (1 <
UBRRL = 6; // బాడ్ రేటును అమర్చుట // కింది వాటిలో ట్యాగ్ల ID ఉంది, వీటిని వేర్వేరు ట్యాగ్ల కోసం మార్చాలి, ప్రాజెక్ట్ పనిచేయడానికి ఇవి తప్పక నవీకరించబడాలి
/ * ప్రోగ్రామ్ను కంట్రోలర్లో డంప్ చేసిన తర్వాత తప్పనిసరిగా అధికారం కలిగిన కార్డులను తీసుకొని ట్యాగ్ల ఐడిని పొందాలి. ట్యాగ్ను RFID మాడ్యూల్ దగ్గర ఉంచడం ద్వారా ఇవి పొందబడతాయి మరియు ID తెరపై చూపబడుతుంది. ID లను పొందిన తరువాత, ఈ క్రింది ID సంఖ్యలను కొత్త ID సంఖ్యలతో భర్తీ చేయడం ద్వారా ప్రోగ్రామ్ను నవీకరించాలి.
చార్ ADMIT = {0 (0x97), (0xa1), (0x90), (0x92)}, {(0x97), (0xa1), (0x90), (0x93)}, {(0x97), (0xa1), (0x90), (0x94)}, {(0x97), (0xa1), (0x90), (0x95)}, {(0x97), (0xa1), (0x90), (0x96)}}; |
ఇప్పుడు పైన మేము ఐదు కార్డులకు మాత్రమే అధికారం ఇస్తున్నాము, వీటిని ఏ సంఖ్యకైనా మార్చవచ్చు.
ఉదాహరణకు, డిఫాల్ట్ ప్రోగ్రామ్ కంట్రోలర్లో డంప్ చేయబడిందని పరిగణించండి, అధికారం పొందవలసిన కార్డులను పొందండి. మాడ్యూల్ దగ్గర ఒకదాని తరువాత ఒకటి ఉంచండి, మీరు ప్రతిదానికీ xxxxxxxx (907a4F87) గా ID ని పొందుతారు, మన వద్ద 7 ట్యాగ్లు ఉంటే, మనకు 7 ఎనిమిది బిట్ ఐడి ఉంటుంది. * /
// ఇప్పుడు ఏడు కార్డుల కోసం ఇది జరుగుతుంది // చార్ ADMIT = {0 (0x90), (0x7a), (0x4F), (0x87)},; // మాడ్యూల్ ద్వారా పంపిన ID ని చూపించడానికి మెమరీని కేటాయించడం int i = 0; పూర్ణాంకం ఓటు = 0; int k = 0; send_a_command (0x01); // క్లియర్ స్క్రీన్ 0x01 = 00000001 _delay_ms (50); send_a_command (0x38); // lcd కి చెప్పడం మనం 8bit కమాండ్ / డేటా మోడ్ ఉపయోగిస్తున్నాం _delay_ms (50); send_a_command (0b00001111); // LCD స్క్రీన్ ఆన్ మరియు కోర్సర్ మెరిసేది చార్ MEM; ట్యాగ్ యొక్క పూర్తి ID ని నిల్వ చేయడానికి మెమరీని కేటాయించడం send_a_string ("RFID NUMBER"); // పంపే స్ట్రింగ్ send_a_command (0x80 + 0x40 + 0); // కోర్సర్ను రెండవ పంక్తికి తరలించడం అయితే (1) { అయితే (! (UCSRA & (1 <
{ } COUNTA = UDR; // UDR అందుకున్న ఎనిమిది బిట్ డేటాను నిల్వ చేస్తుంది మరియు పూర్ణాంకంలోకి తీసుకుంటుంది. MEM = COUNTA; // మొదటి రెండు అక్షరాలు మెమరీకి నవీకరించబడతాయి itoa (COUNTA, SHOWA, 16); ఎల్సిడిలో వేరియబుల్ నంబర్ను ఉంచడానికి // ఆదేశం (వేరియబుల్ నంబర్, ఏ అక్షరాన్ని మార్చాలి, ఏ బేస్ వేరియబుల్ (ఇక్కడ బేస్ 10 లో మనం సంఖ్యను లెక్కిస్తున్నందున పది)) send_a_string (SHOWA); // LCD లో కోర్సర్ను ఉంచిన తర్వాత రెండవ వ్యక్తి యొక్క పాత్రను (వేరియబుల్ నంబర్తో భర్తీ) చూపించమని డిస్ప్లేకి చెప్పడం అయితే (! (UCSRA & (1 <
{ } COUNTA = UDR; itoa (COUNTA, SHOWA, 16); send_a_string (SHOWA); MEM = COUNTA; // మూడవ మరియు నాల్గవ అక్షరాలు మెమరీకి నవీకరించబడతాయి అయితే (! (UCSRA & (1 <
{ } COUNTA = UDR; itoa (COUNTA, SHOWA, 16); send_a_string (SHOWA); MEM = COUNTA; // ఐదవ మరియు ఆరవ అక్షరాలు మెమరీకి నవీకరించబడతాయి అయితే (! (UCSRA & (1 <
{ } COUNTA = UDR; itoa (COUNTA, SHOWA, 16); send_a_string (SHOWA); MEM = COUNTA; // ఏడవ మరియు ఎనిమిది అక్షరాలు మెమరీకి నవీకరించబడతాయి send_a_string (""); send_a_command (0x80 + 0x40 + 0); UCSRB & = ~ (1 <
(i = 0; i <5; i ++) { if ((MEM == ADMIT) & (MEM == ADMIT) & (MEM == ADMIT) & (MEM == ADMIT)) {// అధికారం కోసం తనిఖీ చేయడం మెమరీలోని అక్షరాలతో ఒకేసారి రెండు అక్షరాలను పోల్చడం PORTB - = (1 <
PORTB & = ~ (1 <
_delay_ms (220); // ఆలస్యం _delay_ms (220); _delay_ms (220); _delay_ms (220); _delay_ms (220); _delay_ms (220); PORTB - = (1 <
PORTB & = ~ (1 <
_delay_ms (220); _delay_ms (220); _delay_ms (220); _delay_ms (220); _delay_ms (220); _delay_ms (220); PORTB & = ~ (1 <
PORTB - = (1 <
} } UCSRB - = (1 <
} } void send_a_command (సంతకం చేయని చార్ కమాండ్) { PORTA = ఆదేశం; PORTD & = ~ (1 <
PORTD - = 1 <
_delay_ms (50); PORTD & = ~ 1 <
పోర్టా = 0; } send_a_character (సంతకం చేయని చార్ అక్షరం) { పోర్టా = అక్షరం; PORTD - = 1 <
PORTD - = 1 <
_delay_ms (50); PORTD & = ~ 1 <
పోర్టా = 0; } పంపే_అ_ స్ట్రింగ్ (చార్ * స్ట్రింగ్_ఆఫ్_చారెక్టర్లు) { అయితే (* string_of_characters> 0) { send_a_character (* string_of_characters ++); } } |