కార్యాలయాలు, షాపింగ్ మాల్స్ మరియు అనేక ఇతర ప్రదేశాలలో మాకు తెలుసు, అక్కడ అధికారం కార్డు ఉన్న వ్యక్తిని మాత్రమే గదిలోకి అనుమతించారు. ఈ వ్యవస్థలు RFID కమ్యూనికేషన్ వ్యవస్థను ఉపయోగిస్తాయి. ఉత్పత్తులను RFID చిప్‌తో ట్యాగ్ చేయబడినందున దొంగతనం ఆపడానికి షాపింగ్ మాల్‌లలో RFID ఉపయోగించబడుతుంది మరియు ఒక వ్యక్తి RFID చిప్‌తో భవనం నుండి బయలుదేరినప్పుడు అలారం స్వయంచాలకంగా పెంచబడుతుంది. RFID ట్యాగ్ ఇసుకలో భాగంగా చిన్నదిగా రూపొందించబడింది. RFID ప్రామాణీకరణ వ్యవస్థలు రూపకల్పన చేయడం సులభం మరియు తక్కువ ఖర్చుతో ఉంటాయి. ఈ రోజుల్లో కొన్ని పాఠశాలలు మరియు కళాశాలలు RFID ఆధారిత హాజరు వ్యవస్థలను ఉపయోగిస్తున్నాయి.
ఈ ప్రాజెక్టులో మేము ఓటింగ్ యంత్రాన్ని రూపొందించబోతున్నాము, అది ప్రామాణీకరించిన ఓట్లను మాత్రమే లెక్కించింది. RFID (రేడియో ఫ్రీక్వెన్సీ ఐడెంటిఫికేషన్) ట్యాగ్‌లను ఉపయోగించడం ద్వారా ఇది జరుగుతుంది. అధీకృత RFID ట్యాగ్ హోల్డర్లను మాత్రమే ఓటు వేయడానికి అనుమతించడం కోసం ఇక్కడ మేము ATMEGA కోసం ఒక ప్రోగ్రామ్ రాయబోతున్నాము. (ఈ సాధారణ ఓటింగ్ యంత్ర ప్రాజెక్టును కూడా తనిఖీ చేయండి)
భాగాలు అవసరం
హార్డ్వేర్: ATMEGA32, విద్యుత్ సరఫరా (5v), AVR-ISP PROGRAMMER, JHD_162ALCD (16x2LCD), 100uF కెపాసిటర్ (విద్యుత్ సరఫరా అంతటా కనెక్ట్ చేయబడింది), బటన్ (ఐదు ముక్కలు), 10KΩ రెసిస్టర్ (ఐదు ముక్కలు), 100nF కెపాసిటర్ (ఐదు ముక్కలు), LED (రెండు ముక్కలు), EM-18 (RFID రీడర్ మాడ్యూల్).
సాఫ్ట్‌వేర్: అట్మెల్ స్టూడియో 6.1, ప్రోగిస్ప్ లేదా ఫ్లాష్ మ్యాజిక్.
సర్క్యూట్ రేఖాచిత్రం మరియు వివరణ
సర్క్యూట్లో 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 (ఒక అనుభవశూన్యుడు కోసం గరిష్ట విరుద్ధతను ఉత్తమంగా ఇస్తుంది)
UC యొక్క PD6 కు PIN4 లేదా RS (రిజిస్టర్ ఎంపిక)
PIN5 లేదా RW (చదవడం / వ్రాయడం) భూమికి (LCD ని రీడ్ మోడ్‌లో ఉంచుతుంది వినియోగదారు కోసం కమ్యూనికేషన్‌ను సులభతరం చేస్తుంది)
UC యొక్క PD5 కు PIN6 లేదా E (ప్రారంభించు)
UC యొక్క PIN7 లేదా D0 నుండి PA0 వరకు
UC యొక్క PIN8 లేదా D1 నుండి PA1 వరకు
UC యొక్క PIN9 లేదా D2 నుండి PA2 వరకు
UC యొక్క PIN10 లేదా D3 నుండి PA3 వరకు
UC యొక్క PIN11 లేదా D4 నుండి PA4 వరకు
UC యొక్క PIN12 లేదా D5 నుండి PA5 వరకు
UC యొక్క PIN13 లేదా D6 నుండి PA6 వరకు
UC యొక్క 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 మోడ్‌లో డేటాను కంట్రోలర్‌కు పంపుతుంది. కాబట్టి ఒకేసారి రెండు అక్షరాలు నియంత్రికకు పంపబడతాయి. ఇది ఫిగర్ 3 యొక్క బ్లాక్‌లో చూపబడింది
ఫిగర్ 3 నుండి, పారిటీ బిట్స్ లేవు, మాడ్యూల్ పంపిన డేటాలో ఒక స్టాప్ బిట్.
పై లక్షణాలు నియంత్రిక రిజిస్టర్లలో సెట్ చేయబడ్డాయి; మేము వాటిని క్లుప్తంగా చర్చించబోతున్నాం,
RED (RXEN): ఈ బిట్ స్వీకరించే డేటా లక్షణాన్ని సూచిస్తుంది, ఈ బిట్ మాడ్యూల్ నుండి డేటా కంట్రోలర్ చేత స్వీకరించబడటానికి తప్పక అమర్చాలి, ఇది నియంత్రిక యొక్క RXD పిన్ను కూడా అనుమతిస్తుంది.
BROWN (RXCIE): విజయవంతమైన డేటా రిసెప్షన్ తర్వాత అంతరాయం పొందడానికి ఈ బిట్ సెట్ చేయాలి. ఈ బిట్‌ను ప్రారంభించడం ద్వారా 8 బిట్ డేటా అందుకున్న వెంటనే మనకు తెలుసు.
పింక్ (యుఆర్సెల్): యుసిఎస్ఆర్సిలో ఇతర బిట్లను ఎనేబుల్ చేసే ముందు ఈ బిట్ సెట్ చేయాలి, యుసిఎస్ఆర్సిలో అవసరమైన ఇతర బిట్లను సెట్ చేసిన తరువాత; URSEL ని నిలిపివేయాలి లేదా సున్నాకి ఉంచాలి.
YELLOW (UCSZ0, UCSZ1, UCSZ2): ఈ మూడు బిట్‌లు మనం ఒకేసారి అందుకుంటున్న లేదా పంపే డేటా బిట్ల సంఖ్యను ఎంచుకోవడానికి ఉపయోగిస్తారు.
RFID మాడ్యూల్ పంపిన డేటా 8bit డేటా రకం (FIGURE3) కాబట్టి, మేము UCSZ0, UCSZ1 ను ఒకదానికి మరియు UCSZ2 ను సున్నాకి సెట్ చేయాలి.
ఆరెంజ్ (UMSEL): సిస్టమ్ అసమకాలికంగా కమ్యూనికేట్ చేస్తుందా (రెండూ వేర్వేరు గడియారాన్ని ఉపయోగిస్తాయి) లేదా సమకాలికంగా (రెండూ ఒకే గడియారాన్ని ఉపయోగిస్తాయి) ఆధారంగా ఈ బిట్ సెట్ చేయబడింది,
మాడ్యూల్ మరియు కంట్రోలర్ వేర్వేరు గడియారాన్ని ఉపయోగిస్తున్నందున, ఈ బిట్ సున్నాకి సెట్ చేయబడాలి లేదా అప్రమేయంగా సున్నాకి సెట్ చేయబడినందున ఒంటరిగా వదిలివేయాలి.
గ్రీన్ (యుపిఎం 1, యుపిఎం 0): ఈ రెండు బిట్స్ మేము కమ్యూనికేషన్‌లో ఉపయోగిస్తున్న బిట్ పారిటీ ఆధారంగా సర్దుబాటు చేయబడతాయి.
RFID మాడ్యూల్ సమానత్వం (FIGURE3) లేని డేటాను పంపుతుంది కాబట్టి, మేము UPM1, UPM0 రెండింటినీ సున్నాకి సెట్ చేసాము లేదా ఏదైనా రిజిస్టర్లలోని అన్ని బిట్స్ అప్రమేయంగా సున్నాకి సెట్ చేయబడినందున అవి ఒంటరిగా ఉంటాయి.
బ్లూ (యుఎస్‌బిఎస్): కమ్యూనికేషన్ సమయంలో మనం ఉపయోగిస్తున్న స్టాప్ బిట్ల సంఖ్యను ఎంచుకోవడానికి ఈ బిట్ ఉపయోగించబడుతుంది.
RFID మాడ్యూల్ ఒక స్టాప్ బిట్ (ఫిగర్ 3) తో డేటాను పంపుతుంది కాబట్టి, మేము USBS బిట్‌ను ఒంటరిగా వదిలివేయాలి.
ఇప్పుడు చివరికి మేము బాడ్ రేటును సెట్ చేయాలి, ఫిగర్ 3 నుండి RFID మాడ్యూల్ 9600bps (సెకనుకు బిట్స్) యొక్క బాడ్ రేటుతో కంట్రోలర్‌కు డేటాను పంపుతుందని స్పష్టమవుతుంది.
తగిన UBRRH ని ఎంచుకోవడం ద్వారా బాడ్ రేటు నియంత్రికలో సెట్ చేయబడుతుంది,
క్రాస్ రిఫరింగ్ బాడ్ రేట్ మరియు CPU క్రిస్టల్ ఫ్రీక్వెన్సీ ద్వారా UBRRH విలువ ఎంచుకోబడుతుంది,
కాబట్టి క్రాస్ రిఫరెన్స్ ద్వారా UBRR విలువ '6' గా కనిపిస్తుంది, కాబట్టి బాడ్ రేటు సెట్ చేయబడింది.
ఇక్కడ ఐదు బటన్లు ఉన్నాయి, అభ్యర్థుల ఓట్లను పెంచడానికి నాలుగు మరియు ఐదవది అభ్యర్థుల ఓట్లను సున్నాకి రీసెట్ చేయడానికి. ఇక్కడ ఉన్న కెపాసిటర్లు బటన్ల బౌన్స్ ప్రభావాన్ని రద్దు చేయడానికి. అవి తీసివేయబడితే, నియంత్రిక ప్రతిసారీ బటన్ నొక్కినప్పుడు ఒకటి కంటే ఎక్కువ లెక్కించవచ్చు.
పిన్స్ కోసం అనుసంధానించబడిన రెసిస్టర్లు కరెంట్‌ను పరిమితం చేయడం కోసం, పిన్ను భూమికి లాగడానికి బటన్ నొక్కినప్పుడు. ఒక బటన్ నొక్కినప్పుడల్లా, కంట్రోలర్ యొక్క సంబంధిత పిన్ నేలమీదకు లాగబడుతుంది మరియు అందువల్ల కంట్రోలర్ కొన్ని బటన్ నొక్కినట్లు గుర్తించి, తీసుకోవలసిన చర్య తీసుకోవాలి, ఇది అభ్యర్థి ఓట్లను పెంచడం లేదా నొక్కిన బటన్‌ను బట్టి ఓట్లను రీసెట్ చేయడం కావచ్చు.
సంబంధిత వ్యక్తిని సూచించే బటన్ నొక్కినప్పుడు, నియంత్రిక దాన్ని ఎంచుకొని, దాని జ్ఞాపకశక్తిలో సంబంధిత వ్యక్తి సంఖ్యను పెంచిన తర్వాత 16x2 LCD డిస్ప్లేలో సంబంధిత వ్యక్తుల స్కోర్‌ను చూపుతుంది.
ఓటింగ్ మెషీన్ యొక్క పని క్రింద ఇవ్వబడిన సి కోడ్ యొక్క దశల వారీగా ఉత్తమంగా వివరించబడింది:
కోడ్ వివరణ
పిన్‌లపై డేటా ప్రవాహ నియంత్రణను ప్రారంభించడానికి # చేర్చండి // శీర్షిక
# 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 ఆలస్యం ఇస్తుంది
DDRB = 0b11110000; // కొన్ని పోర్ట్‌బి పిన్‌లను ఇన్‌పుట్‌గా తీసుకోవడం.
UCSRB - = (1 <
// డేటాను పూర్తి అంతరాయాన్ని స్వీకరించడం, డేటాను స్వీకరించే పిన్ను ప్రారంభించడం
UCSRC - = (1 <
// మొదట URSEL ను సెట్ చేయడం ద్వారా 8 బిట్ కమ్యూనికేషన్ కోసం సెట్ చేయడం ద్వారా ఇతర బిట్లను మార్చడం
UCSRC & = ~ (1 <
UBRRH & = ~ (1 <
UBRRL = 6; // బాడ్ రేటును సెట్ చేస్తుంది
int16_t VOTEA = 0; // వ్యక్తి 1 ఓట్లు మెమరీని నిల్వ చేస్తాయి
చార్ ఎ; // వ్యక్తి 1 ఓట్లు ఎల్‌సిడిలో పాత్రను ప్రదర్శిస్తాయి
int16_t VOTEB = 0;; // వ్యక్తి 2 ఓట్లు జ్ఞాపకశక్తిని నిల్వ చేస్తాయి
చార్ బి; // వ్యక్తి 2 ఓట్లు ఎల్‌సిడిలో పాత్రను ప్రదర్శిస్తాయి
int16_t VOTEC = 0;; // వ్యక్తి 3 ఓట్లు జ్ఞాపకశక్తిని నిల్వ చేస్తాయి
చార్ సి; // వ్యక్తి 3 ఓట్లు ఎల్‌సిడిలో పాత్రను ప్రదర్శిస్తాయి
int16_t VOTED = 0;; // వ్యక్తి 4 ఓట్లు జ్ఞాపకశక్తిని నిల్వ చేస్తాయి
చార్ డి; / / పర్సన్ 4 ఓట్లు ఎల్‌సిడిలో పాత్రను ప్రదర్శిస్తాయి
// కింది వాటిలో ట్యాగ్‌ల ఐడి ఉంది, వీటిని వేర్వేరు ట్యాగ్‌ల కోసం మార్చాలి, ప్రాజెక్ట్ పనిచేయడానికి ఇవి తప్పక నవీకరించబడాలి
// ప్రోగ్రామ్‌ను కంట్రోలర్‌లో డంప్ చేసిన తర్వాత తప్పనిసరిగా అధికారం ఉన్న కార్డులను తీసుకొని ట్యాగ్‌ల ఐడిని పొందాలి, వీటిని ట్యాగ్‌ను 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) గా పొందుతారు, మన వద్ద 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 <
ఓటు = 1; // అధికారం సెట్ చేస్తే ఓటు } } if (ఓటు == 0) // ఓటు సెట్ చేయకపోతే అధికారం విఫలమైంది { UCSRB - = (1 <
} (ఓటు == 1) // అధికారం ఉంటే ఓటు వేసే వరకు ఈ లూప్ చేయండి { send_a_command (0x80 + 0); // లైన్ 1 లో సున్నా స్థానానికి వెళ్ళండి send_a_string ("VOTE NOW"); // స్ట్రింగ్ ప్రదర్శిస్తుంది if (bit_is_clear (PINB, 0%)) // బటన్ ఒకటి నొక్కినప్పుడు { VOTEA ++; // మొదటి వ్యక్తి యొక్క ఓటు జ్ఞాపకశక్తిని ఒక్కొక్కటిగా పెంచండి ఓటు = 0; // ఓటింగ్ తర్వాత లూప్ వెళ్ళనివ్వండి } బటన్ 2 నొక్కినప్పుడు (bit_is_clear (PINB, 1)) // ఉంటే { VOTEB ++; // 2 వ వ్యక్తి యొక్క ఓటు మెమరీని ఒక్కొక్కటిగా పెంచండి ఓటు = 0; } బటన్ 3 నొక్కినప్పుడు (bit_is_clear (PINB, 2%)) // { VOTEC ++; // 3 వ వ్యక్తి యొక్క ఓటు మెమరీని ఒక్కొక్కటిగా పెంచండి ఓటు = 0; } if (bit_is_clear (PINB, 3%)) // బటన్ 4 నొక్కినప్పుడు { VOTED ++; // 4 వ వ్యక్తి యొక్క ఓటు మెమరీని ఒక్కొక్కటిగా పెంచండి ఓటు = 0; } if (ఓటు == 0) // ఓటు వచ్చిన తర్వాత క్లియర్ చేయబడింది { send_a_command (0x80 + 0); // లైన్ 1 యొక్క సున్నా స్థానానికి తరలించండి send_a_string ("ఓటుకు ధన్యవాదాలు"); // ప్రదర్శన స్ట్రింగ్ (k = 0; k <10; k ++) కోసం { _delay_ms (220); } PORTB & = ~ (1 <
send_a_command (0x01); send_a_command (0x80 + 0); // నలుగురు వ్యక్తుల ఓట్లను ప్రదర్శిస్తోంది send_a_string ("A ="); send_a_command (0x80 + 2); itoa (VOTEA, A, 10); send_a_string (A); send_a_command (0x80 + 8); send_a_string ("B ="); send_a_command (0x80 + 10); itoa (VOTEB, B, 10); send_a_string (B); send_a_command (0x80 + 0x40 + 0); send_a_string ("C ="); send_a_command (0x80 + 0x40 + 2); itoa (VOTEC, C, 10); send_a_string (C); send_a_command (0x80 + 0x40 + 8); send_a_string ("D ="); send_a_command (0x80 + 0x40 + 10); ఐటోవా (ఓటు, డి, 10); send_a_string (D); send_a_command (0x80 + 0x40 + 16); (k = 0; k <25; k ++) కోసం { _delay_ms (220); } UCSRB - = (1 <
send_a_command (0x01); send_a_command (0x80 + 0); // సున్నా స్థానానికి కదులుతోంది send_a_string ("RFID NUMBER"); // స్ట్రింగ్ పంపండి send_a_command (0x80 + 0x40 + 0); } } 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 ++); } } |