Lucrare de Diplomă

Curpins:
Sarcina: ……………………………………………………………………………….....3
Introducere……………………………………………………………………………….4
1. Elaborarea schemei de structură a dispozitivului ………………………………….…5
2. Descrierea principiului de funcționare………………………………………………..7
3. Argumentarea alegerii principalelor componente…………………………………….8
4. Codul programului…………………………………………………………………..18
Mod Coala № Docum. Semnat. Data

CEEE 61110 003 NE
Elaborat Candu Ion Lit. Coala Coli
Verificat Muntean Mihail. 2 47
Proiect de curs CEEE
Cont STAS
Aprobat Gr. C-0217
Sarcina: Elaborarea unei sisteme biometrice de acces a controlului prin citirea
amprentelor digitale, pe baza microcontrolerului Atmega 32. Dispozitivul va fi dotat cu
butoane de control, afișor de tip LCD și dispozitiv de citire a amprentelor. Dispozitivul
se va alimenta de la o sursă de alimentare de 5 V, obținută dintr-un stabilizator de
tensiune de 5V care se alimentează de la o sursă de alimentare de 12V. De asemenea în
sistem va fi implementat o bază de date, în care se vor înscrie datele utilizatorilor
(amprenta), precum și timpul când aceasta a avut loc, furnizat de ceasul de timp real.
1.
Coala
CEEE 6111 03 001 NE 3
Mod Coala № Docum. Semnatura Data
Introducere
Istoric, primelor calculatoare ce foloseau un microprocesor în rol de UCP li s-a
spus calculatoare pe bază de microprocesor, sau microcalculatoare. Toate
calculatoarele moderne sunt construite cu microprocesoare cu funcţia de UCP, unele
fiind bazate pe un sigur microprocesor (calculatoare uni-procesor), altele conţinând
mai multe microprocesoare în scopul creşterii puterii de calcul şi a vitezei de
prelucrare (calculatoare multi-procesor). Microprocesoarele, ca şi UCP de uz general,
sunt utilizate pentru aplicaţii de prelucrare de înaltă performanţă, fiind folosite pentru
construcţia calculatoarelor de uz general. Microprocesoarele sunt utilizate în PC-uri
(Personal Computers), staţii de lucru, servere, laptopuri, unde compatibilitatea
software, performanţa, generalitatea şi flexibilitatea sunt importante. Imediat după
apariţia primului microprocesor (1971) firma Intel a scos pe piaţă o familie de
microcontrolere numită MCS-48 (începând cu 1976) cu circuitele integrate 8048, 8035
şi 8748.
Aceste circuite nu erau destinate operaţiilor de prelucrare de uz general, ci celor
specifice pentru controlul unor aplicaţii din lumea externă circuitului. La momentul
apariţiei, circuitele au fost numite "microcalculatoare pe un chip", pentru că ele
includeau în aceeaşi capsulă de circuit integrat toate componentele unui calculator:
UCP, memorie şi sistem I/O. În momentul de faţă circuitele similare sunt numite
microcontrolere, pentru că, aşa cum sugerează şi numele sunt destinate aplicaţiilor de
control (nu calculului de uz general). Microcontrolerele sunt proiectate pentru a se
obţine o dimensiune redusă a chip-ului, pentru micşorarea costurilor şi includerea de
spaţiu de memorie şi interfeţe IO pe chip. Microcontrolerele sunt adesea “specializate
pe aplicaţii” în dauna flexibilităţii. Indiferent de ceea ce este controlat în lumea
externă (de exemplu controlul turaţiei unor motoare electrice, reglarea temperaturii
într-o incintă, comanda sistemului antiblocare a frânelor la automobil-ABS), sistemul
de comandă digitală este alcătuit din: UCP (nucleu microprocesor), memorie de date
şi program, interfeţe şi controlere de periferie. Ideea de bază la microcontrolere este
integrarea într-un singur circuit a tuturor acestor componente, prin simplificarea şi
micşorarea dimensiunilor diverselor unităţi funcţionale (de exemplu capacitate de
Coala
CEEE 6111 03 001 NE 4
stocare în memorie mult mai mică faţă de calculator, interfeţe seriale cu lumea
externă etc.
1 Elaborarea schemei de structură a dispozitivului:
Figura 1 – Scheama bloc a dispozitivului
-Sursa de alimentare – Are rolul de a alimenta toată schema, el este compus dintr-
un stabilizator de tensiune de 5V și o sursă de alimentare de 12V.
-Ceas de timp real – reprezintă un microcircuit ce timpul într-un anumit moment,
are scopul de a oferi datele despre ora și data când a fost înregistrat un utilizator nou,
precum și când utilizatorul solicită accesul în sistem. Microcircuitul este dotat cu bateria
pentru a continua să numeri timpul când dispozitivul este deconectat de la alimentare.
-Modulul de citire a amprentelor - reprezintă un dispozitiv care crează imaginea
amprentelor a utilizatorului când acesta aplică degetul pe suprafața de citire
-Speaker – reprezintă un mic difuzor, care semnalizează sonor în cazul când
utilizatorul este recunoscut.
-Led indicator – este utilizat pentru a informa utilizatorul despre faptul că de la el
este așteptată o acțiune (în cazul când are loc înregistrarea unui nou utilizator).
Coala
CEEE 6111 03 001 NE 5
-Afișor – reprezintă un ecran LCD, care afișează ora și dată când utilizatorul intră
în sistem, precum și informația referitor la starea procesului (ex. ‘Record Deleted
successfully’ când are loc finisarea ștergerii datelor din memoria dispozitivului)
-Blocul butoanelor – reprezintă modalitatea de control al dispozitivului, cum ar fi

adăugarea unui utilizator nou, sau ștergerea cestuia.
-Microporocesorul – În cazul dat este reprezentat de către Atmega 32 și are rolul
de a controla toate procesele din dispozitiv, precum și de a memora datele utilizatorilor,
timpul etc.
Coala
CEEE 6111 03 001 NE 6
2 Descrierea principiului de funcționare
Figura 2 - Schema electrică principială
Sistemul de control al accesului pe baza amprentelor digitale lucrează pe bază de

senzor cititor de amprente care are ca rol indentificarea unui utilizator individual.
Senzorul captează imaginea amprentei, o convertează în șablonul corespunzător și îl
salvează în memorie, împreună cu indicatorul utilizatorului.
Deasemenea sunt utilizate 4 butoane pentru a înscri (introduce în listă, înregistra), a
șterge, a incrementa, decrementa datele amprentelor digitale. Butonul 1 este utilizat
pentru înregistrarea amprentelor noi, astfel pentru a înscrie un utilizator nou este nevoie
de a apăsa butonul 1, apoi ecranul LCD va ruga utilizatorul să aplice degetul de 2 ori pe
cititorul de amprente, ulterior el va cere indentificatorul noului utilizator. Lucru acre va
fi făcut prin intermediul butoanelor 3 și 4, apoi apăsând din nou butonul 1 datele se vor
salva. Butonul 2 este utilizat pentru a șterge datele din memoria volatilă EEPROM,
lucru făcut prin apăsarea continuă a butonului respectiv.
Coala
CEEE 6111 03 001 NE 7
3 Argumentarea alegerii principalelor componente
3.1 Descrierea microcontrolerului Atmega32.
Atmega32 AVR 8-bit este un circuit integrat de înaltă performanță ce se bazează

pe un microcontroler RISC, combinând 32 KB ISP flash o memorie cu capacitatea de a
citi-în-timp-ce-scrie, 1 KB de memorie EEPROM, 2 KB de SRAM, 23 linii E/S de uz
general, 32 registre de uz general, trei cronometre flexibile/contoare în comparație
cu, întreruperi internă și externă, programator de tip USART, orientate interfață serială
byte de 2 cabluri, SPI port serial, 6-canale 10-bit Converter A/D (8-canale
în TQFP și QFN/MLF packages), "watchdog timer" programabil cu oscilator intern, și
cinci moduri de software-ul intern de economisire a energiei selectabil. Dispozitivul
funcționează la 1,8-5,5 volți.
Prin executarea instrucțiuni puternice într-un singur ciclu de ceas, aparatul

realizează un răspuns de 1 MIPS.
Miezul AVR combină un set bogat de instrucțiuni cu 32 de registre de lucru de uz

general. Toate cele 32 registrele sunt conectate direct la Unitatea Aritmetico-Logică
(UAL), permițând două registre independente să să fie accesate în cadrul unei
instrucțiuni executată într-un singur ciclu de ceas. Arhitectura rezultată este mai mult
cod eficient, obținând în același timp randamente de până la zece ori mai rapide decât
microcontrolerele CISC convenționale.
ATmega32A oferă următoarele caracteristici: 32 Kbyte de memorie Flash
programabilă, cu funcții Read-While-Write, 1024bytes EEPROM, 2048bytes SRAM,
32de linii I / O de uz general, 32 de registre de lucru de uz general, o interfață JTAG
pentru scanarea limitelor, depanare pe cip suport și programare, trei temporizatoare /
contoare flexibile cu moduri de comparare, un USART programabil în serie, o interfață
serială cu două fire orientată pe octeți, un canal pe 8 biți ADC cu etapă de intrare
diferențială opțională cu câștig programabil (numai pachetul TQFP, un port serial SPI și
șase economii de energie selectabile de software moduri. Modul Repaus oprește CPU în
timp ce permite USART, interfață cu două fire, convertor A / D, SRAM, Timer /
Counters, portul SPI și sistemul de întrerupere pentru a continua să funcționeze. Modul
de oprire salvează conținutul registrului, dar blochează oscilatorul, dezactivând toate
Coala
CEEE 6111 03 001 NE 8
celelalte funcții ale cipului până la următoarea Întrerupere externă sau resetare
hardware. În modul de economisire a energiei, cronometrul asincron continuă să ruleze,
permițând utilizatorului să mențină o bază de cronometru în timp ce restul dispozitivului
doarme. Zgomotul ADC Modul de reducere oprește procesorul și toate modulele I / O,
cu excepția Asynchronous Timer și ADC, pentru a minimiza zgomot de comutare în
timpul conversiilor ADC. În modul de așteptare, oscilatorul de cristal / rezonator
funcționează în timp ce restul dispozitivului doarme. Acest lucru permite pornirea foarte
rapidă combinată cu consum redus de energie consum. În modul Extended Standby, atât
oscilatorul principal, cât și temporizatorul asincron continuă a alerga.
Dispozitivul este fabricat folosind tehnologia de memorie non-volatilă Atmel de
înaltă densitate. ISP-ul On-chip Flash permite reprogramarea memoriei programului în
sistem printr-o interfață serială SPI, prin intermediul unui programator convențional de
memorie nevolatilă sau de un program de pornire On-chip care rulează pe nucleul AVR.
Programul de boot poate utiliza orice interfață pentru a descărca programul de aplicație
în aplicația Flash memorie. Software-ul din secțiunea Boot Flash va continua să ruleze
în timp ce secțiunea Application Flash este actualizat, oferind o operațiune de citire-
scriere adevărată. Prin combinarea unui procesor RISC pe 8 biți cu sistemul integrat
Flash auto-programabil pe un cip monolitic, Atmel ATmega32A devine un
microcontroler puternic care oferă o soluție extrem de flexibilă și rentabilă pentru multe
aplicații de control încorporate.
Atmel AVR ATmega32A este acceptat cu o suită completă de instrumente de
dezvoltare de programe și sisteme inclusiv: compilatoare C, macro asamblatoare,
depanatoare / simulatoare de programe, emulatoare în circuit și truse de evaluare.
Coala
CEEE 6111 03 001 NE 9
Caracteristici ATmega32
Nr. Pini 32
Flash (KB) 32
SRAM (KB) 1
EEPROM (KB) 23
Pinii I/O de uz general 1
SPI 1
TWI ( I 2C) 1
USART 10-bit, până la 76.9ksps
Canale ADC 8
Întârziere progragare AC
Temporizatoare / Contoare pe 8 biți 2
Temporizatore / Contoare pe 16 biți 1
PWM canale 4
Osccilator RC +/-3%
VREF bandgap
Voltaj operativ 2.7 – 5.5V
Fregvența maximală de operare 16MHz
Diapazonul de temperatură -55 °C la +125 °C
JTAG Da
Figura 1 – Rezumatul configurației.
Coala
CEEE 6111 03 001 NE 10
Figura 3 - Schema bloc a microprocesorului
Unitatea centrală execută instrucțiunile pe care le primește prin magistrala de date

din memoria program. Structura Harvard este posibilă și răspândită la MC pentru că de
regulă instrucțiunile sunt stocate în memoria ROM, iar datele în cea RAM. Magistrala
de date și cea de adrese pot fi separate sau multiplucate.
Modulele I/O pot fi seriale sau paralele. Fiecare modul transferă date cu exteriorul
prin intermediul registrului de date (RD). Modulul este comandat de unitatea centrală
prin intermediul unui registru de comenzi (RC) și se poate citi starea modului prin
registru de stare (RS). Prin RS se pot genera întreruperi. Registrele modulelor I/O pot fi
văzute de UC ca locații de momorie sau ca dispozitive I/O într-un spațiu de adrese
separat. De regulă, structura de bază a familiei conține anumite interfețe considerate
foarte importante și liniile I/o grupate în porturi paralele de uz general. Pe structura de
Coala
CEEE 6111 03 001 NE 11
bază se adugă diferite tipuri de interfețe care folosesc în comun liniile I/O cu porturile
paralele de uz general.
3.2 Configurarea pinilor microcontrolerului ATmega32A.
Figura 4 - Configurarea pinilor microcontrolerului Atmega32A
3.3 Programatorul AVR-ISP.
Alegerea a căzut anume pe acest tip de programator datorită faptului că este una
dintre cele mai populare alegeri de tipul Atmel, care ne permite programarea a oricărui
microprocesor cu nucleu AVR prin portul serial SPI.
Figura 5 – Schema electrică principială a analogului AVR-ISP.
Coala
CEEE 6111 03 001 NE 12
Caracteristici tehnice:
 Tensiune programare microcontrollere: 3.3V sau 5V;

 Poate alimenta uC-ul programat (max 500mA);
 Dispune de conexiune cu header AVRISP cu 10 pini;
 Comunică pe USB cu laptop/calculator, având integrate diode zener 3v6
3.4 Modulul de citire a amprentelor r305.
Figura 6 – Cititorul de amprente R305
Modulul de citire a aprentelor r305 reprezintă un cititor de amprente optic, ales în

favoarea altor cititoare datorită mărimilor mici, eficacității lucrului și costului redus.
Mai jos sunt prezentate principalele caracteristici:
Tabelul 2 – Caracteristicile modulului R305
Interfață USB,UART
(RS232TTL)
Rezoluție 508DPI
Voltaj DC 4.2-6V
Capacitatea cititorului 980
Masivul sensibil 648*488
Dimensiuni 55*32*21,5 (mm)
Conector MX 1,25mm 4Pin
Viteza de scanare <0,2 secunde
Viteza de verificare <0,3 secunde
Metoda de corespundere 1: 1: 1: N
Coala
CEEE 6111 03 001 NE 13
FRR ≤0.1%
FAR ≤0.001%
Mediul de lucru -20C +50°
Capacitatea antistatică 15kV
3.5 Afișor JHD162A LCD.

Display-ul dat a fost ales datorită faptului că este una dintre cele mai populare
alegeri când vine vorba despre dispozitive cu microprocesoare și în special cu Arduino,
dar și deoarece reprezintă una dintre cele mai ieftine și ușor de utilizate afișoare.
Ce ține de caracteristici, display-ul este compus din 2 linii a câte 16 simboluri
fiecare. Mărimile 80 x 36 mm, temperatura de lucru 0 ~ 50 °C, iluminare albastră,
culoarea simbolurilor albă, mărimea simbolului 4.35 x 2.95 mm, mărimea punctului 0.5
x 0.5 mm, interfața HD44780, partea vizibilă: 64.5 x 13.8 mm, alimentare 5V.
Figura 7 – JHD162A LCD
Coala
CEEE 6111 03 001 NE 14
Figura 8 – Schema conexiunii
3.6 Ceas de timp real DS1307

DS 1307, reprezintă un ceas de timp real cu interfață serială, cu calendar zecimal
binar cu putere redusă cu 56 de octeți de memorie statică nevolatilă. Adresele și datele
sunt transmise secvențial pe un bus bidirecțional cu două fire. Un ceas calendaristic
contează secunde, minute, ore, zi, dată lună și an. Ultima dată lunile sunt ajustate
automat pentru luni cu mai puțin de 32 de zile, inclusiv o corecție pentru anul bisect.
Ceasul funcționează atât în \u200b\u200bmoduri de 24 ore cât și de 12 ore cu
indicatorul AM / PM. DS1307 are un circuit integrat de monitorizare a puterii care
detectează întreruperile de curent și trece automat la alimentarea bateriei.
Specificații:
 Interfață I2C;
 Format: oră : minute : secunde AM/PM;
 Format dată: zi, lună, an;
 Compensare an bisect;
 Calendar până în anul 2100;
 Frecvență ieșire 1Hz;
 Memorie de 56 octeți disponibilă pentru utilizator;
 Adresă I2C: 0x68;
 Compatibil cu nivelul de 5V;
 Dimensiuni: 20x20mm.
Coala
CEEE 6111 03 001 NE 15
Figura 9 – Ceas de timp real DS1307
3.7 Stabilizator de tensiune LM7805

CI 7805 este un CI de reglementare iconic utilizat în majoritatea dispozitivelor cu
microprocesor, din aceste considerente a fost ales, având ca avantaj multiple recenzii
pozitive. Numele 7805 înseamnă două semnificații, „78” înseamnă că este un regulator
de tensiune pozitivă și „05” înseamnă că furnizează 5V ca ieșire. Deci, 7805-ul nostru
va oferi o tensiune de ieșire de + 5V.
Curentul de ieșire al acestui CI poate merge până la 1,5A. Dar, CI suferă de
pierderi mari de căldură, prin urmare, un radiator este recomandat pentru proiectele care
consumă mai mult curent. De exemplu, dacă tensiunea de intrare este de 12V și
consumați 1A, atunci (12-5) * 1 = 7W. Acești 7 wați vor fi disipate sub formă de
căldură.
Figura 10 – figura electrică principială LM7805
Condensatorul de intrare 0.33uF este un condensator ceramic care se ocupă de

problema inductanței de intrare, iar condensatorul de ieșire 0.1uF este, de asemenea, un
condensator ceramic care adaugă stabilitatea circuitului. Acești condensatori ar trebui să
Coala
CEEE 6111 03 001 NE 16
fie amplasați aproape de terminale pentru ca aceștia să funcționeze eficient. De
asemenea, acestea ar trebui să fie de tip ceramic, deoarece condensatoarele ceramice
sunt mai rapide decât electrolitice.
3.8 Butoane membranare.
Butoanele membranare (Figura 11) au fost incluse în dispozitivul dat datorită

prețului redus și a simplității includerii lor, precum și a corespunderii numărului de
butoane (unele butoane au funcție dublă).
Caracteristici:
 Mărimea blocului – 69x20 mm
 Mărimea butoanelor – 11x11 mm
 Mărimea șleifului – 14 mm
 Grosimea conectorului – 2,5 mm
 Pasul pinilor conectorului – 2,54
Figura 11 – Butoane membranare
Coala
CEEE 6111 03 001 NE 17
4 Codul programului
Codul programei este foarte voluminos și poate părea puțin complicat, de aceea el
va fi amplasat la sfârșitul paragrafului, iar unele blocuri vor fi explicate.
Pentru început trebuie de conectat fișierele de antet și de creat macrosurile
necesare:
#define F_CPU 8000000ul

1
#include <avr/io.h>
2
#include <util/delay.h>
3
#include <avr/interrupt.h>
4

5
/***MACROS*/
6

7
#define USART_BAUDRATE 9600
8
#define BAUD_PRESCALE (((F_CPU / (USART_BAUDRATE * 16UL))) -
9
1)
10

11
#define uchar unsigned char
12
#define uint unsigned int
13

14
#define LCDPORTDIR DDRB
15
#define LCDPORT PORTB
16
#define rs 0
17
#define rw 1
18
#define en 2
19

20
#define RSLow (LCDPORT&=~(1<<rs))
21
#define RSHigh (LCDPORT|=(1<<rs))
22
#define RWLow (LCDPORT&=~(1<<rw))
23
#define ENLow (LCDPORT&=~(1<<en))
24
#define ENHigh (LCDPORT|=(1<<en))
25

26
#define KeyPORTdir DDRA
27
#define key PINA
28
#define KeyPORT PORTA
După asta vom declara variabilele și masivele necesare pentru prelucrarea

datelelor despre amprentele digitale. Deasemenea vom adăuga câteva funcții pentru
interacțiunea cu modulul de timp real.
1 void RTC_stp()
Coala
CEEE 6111 03 001 NE 18
{
2 TWCR=(1<<TWINT)|(1<<TWEN)|(1<<TWSTO); //остановить
3 взаимодействие
4 }
5
6 void RTC_read()
7 {
8 TWCR=(1<<TWINT)|(1<<TWSTA)|(1<<TWEN);
9 while((TWCR&0x80)==0x00);
10 TWDR=0xD0; //RTC write (slave address)
11 TWCR=(1<<TWINT)|(1<<TWEN);
12 while(!(TWCR&(1<<TWINT)));
13 TWDR=0x00; //RTC write (word address)
16 TWCR=(1<<TWINT)|(1<<TWSTA)|(1<<TWEN); //start
17 RTC communication again
18 while ((TWCR&0x80)==0x00);
19 TWDR=0xD1; // RTC command to read
}
Următorul pas, vom defini câteva funcții pentru lucru cu ecranul LCD, vom
interacționa în regim de 4 biți. Deasemenea vom defini câteva funcții pentru
inițializarea portului serial (UART), și schimbul de date dintre scanerul de amprente și
microprocesorului.
1 void serialbegin()
2 {
3 UCSRC = (1 << URSEL) | (1 << UCSZ0) | (1 << UCSZ1);
4 UBRRH = (BAUD_PRESCALE >> 8);
5 UBRRL = BAUD_PRESCALE;
6 UCSRB=(1<<RXEN)|(1<<TXEN)|(1<<RXCIE);
7 sei();
8 }
9
10 ISR(USART_RXC_vect)
11 {
12 char ch=UDR;
13 buf[ind++]=ch;
14 if(ind>0)
Coala
CEEE 6111 03 001 NE 19
15 flag=1;
16 //serial1Write(ch);
17 }
18
19 void serialwrite(char ch)
20 {
21 while ((UCSRA & (1 << UDRE)) == 0);
22 UDR = ch;
23 }
24
25 void serialprint(char *str)
26 {
27 while(*str)
28 {
29 serialwrite(*str++);
30 }
31 }
Urmează definirea a unui număr de funcții pentru portul serial UART, care se vor
utiliza pentru UART de program (software). El se va utiliza pentru transmiterea datelor
salvate în calculator.
1 void SerialSoftWrite(char ch)

2 {
3 PORTD&=~(1<<7);
4 _delay_us(104);
5 for(int i=0;i<8;i++)
6 {
7 if(ch & 1)
8 PORTD|=(1<<7);
9 else
10 PORTD&=~(1<<7);
11 _delay_us(104);
12 ch>>=1;
13 }
14 PORTD|=(1<<7);
15 _delay_us(104);
16 }
17
18 void SerialSoftPrint(char *str)
19 {
20 while(*str)
21 {
22 SerialSoftWrite(*str);
23 str++;
Coala
CEEE 6111 03 001 NE 20
24 }
25 }
Urmează funcțiile care vor răspunde de afișarea timpului real pe ecranul LCD.
Funcțiile date sunt utilizate pentru înscrierea datelor în memoria EEPROM și citirea lor
de acolo.
1 int eeprom_write(unsigned int add,unsigned char data)

2 {
3 while(EECR&(1<<EEWE));
4 EEAR=add;
5 EEDR=data;
6 EECR|=(1<<EEMWE);
7 EECR|=(1<<EEWE);
8 return 0;
9 }
10 char eeprom_read(unsigned int add)
11 {
12 while(EECR & (1<<EEWE));
13 EEAR=add;
14 EECR|=(1<<EERE);
15 return EEDR;
16 }
Următoarele merg funcțiile care răspund de citirea amprentelor digitale,

convertarea lor într-un șablon corespunzător, compararea lor cu memoria imaginilor
amprentelor înregistrate deja și afișarea informației pe ecranul LCD.
1 void matchFinger()
2 {
3 // lcdwrite(1,CMD);
4 // lcdprint("Place Finger");
5 // lcdwrite(192,CMD);
6 // _delay_ms(2000);
7 if(!sendcmd2fp((char *)&f_detect[0],sizeof(f_detect)))
8 {
9 if(!sendcmd2fp((char *)&f_imz2ch1[0],sizeof(f_imz2ch1)))
10 {
11 if(!sendcmd2fp((char *)&f_search[0],sizeof(f_search)))
12 {
13 LEDHigh;
14 buzzer(200);
15 uint id= data[0];
16 id<<=8;
17 id+=data[1];
Coala
CEEE 6111 03 001 NE 21
18 uint score=data[2];
19 score<<=8;
20 score+=data[3];
21 (void)sprintf((char *)buf1,"Id: %d",(int)id);
22 lcdwrite(1,CMD);
23 lcdprint((char *)buf1);
24 saveData(id);
25
26 _delay_ms(1000);
27 lcdwrite(1,CMD);
28 lcdprint("Attendance");
29 lcdwrite(192,CMD);
30 lcdprint("Registered");
31 _delay_ms(2000);
32 LEDLow;
33 }
Urmează funcțiile care răsund de înscrierea unei amprente noi și afișarea

statutului pe ecranului LCD, după ea merge funcția care șterge imaginea amprentei
păstrate în modul prin intermediul identificatorului ei(id number), și afișarea statutului
pe ecranul LCD.
1 void deleteFinger()
2 {
3 id=getId();
4 f_delete[10]=id>>8 & 0xff;
5 f_delete[11]=id & 0xff;
6 f_delete[14]=(21+id)>>8 & 0xff;
7 f_delete[15]=(21+id) & 0xff;
8 if(!sendcmd2fp(&f_delete[0],sizeof(f_delete)))
9 {
10 lcdwrite(1,CMD);
11 sprintf((char *)buf1,"Finger ID %d ",id);
12 lcdprint((char *)buf1);
13 lcdwrite(192, CMD);
14 lcdprint("Deleted Success");
15
16 }
17 else
18 {
19 lcdwrite(1,CMD);
20 lcdprint("Error");
21 }
22 _delay_ms(2000);
Coala
CEEE 6111 03 001 NE 22
23 }
Următoarea funcție este responsabilă de transferarea datelor de acces la terminalul serial

cu ajutorul UART program (cantactul PD7) și TTL la convertorul USB.
1 /*function to show attendence data on serial monitor using softserial pin PD7*/
2 void ShowAttendance()
3 {
4 char buf[128];
5 lcdwrite(1,CMD);
6 lcdprint("Downloding....");
7 SerialSoftPrintln("Attendance Record");
8 SerialSoftPrintln(" ");
9 SerialSoftPrintln("S.No ID1 ID2 Id3 ID4 ID5
10 ");
11 //serialprintln("Attendance Record");
12 //serialprintln(" ");
13 //serialprintln("S.No ID1 ID2 Id3
14 ID4 ID5");
15 for(int cIndex=1;cIndex<=8;cIndex++)
16 {
17 sprintf((char *)buf,"%d "
18 "%d:%d:%d %d/%d/20%d "
19 "%d:%d:%d %d/%d/20%d "
20 "%d:%d:%d %d/%d/20%d "
21 "%d:%d:%d %d/%d/20%d "
22 "%d:%d:%d %d/%d/20%d ",
23 cIndex,
24 eeprom_read((cIndex*6)),eeprom_read((cIndex*6)+1),eeprom_read((cIndex*6)
25 +2),eeprom_read((cIndex*6)+3),eeprom_read((cIndex*6)+4),eeprom_read((cIn
26 dex*6)+5),
27 eeprom_read((cIndex*6)+48),eeprom_read((cIndex*6)+1+48),eeprom_read((cI
28 ndex*6)+2+48),eeprom_read((cIndex*6)+3+48),eeprom_read((cIndex*6)+4+48
29 ),eeprom_read((cIndex*6)+5+48),
30 eeprom_read((cIndex*6)+96),eeprom_read((cIndex*6)+1+96),eeprom_read((cI
31 ndex*6)+2+96),eeprom_read((cIndex*6)+3+96),eeprom_read((cIndex*6)+4+96
32 ),eeprom_read((cIndex*6)+5+96),
33 eeprom_read((cIndex*6)+144),eeprom_read((cIndex*6)+1+144),eeprom_read((
34 cIndex*6)+2+144),eeprom_read((cIndex*6)+3+144),eeprom_read((cIndex*6)+
35 4+144),eeprom_read((cIndex*6)+5+144),
eeprom_read((cIndex*6)+192),eeprom_read((cIndex*6)+1+192),eeprom_read((
cIndex*6)+2+192),eeprom_read((cIndex*6)+3+192),eeprom_read((cIndex*6)+
4+192),eeprom_read((cIndex*6)+5+192));

Coala
CEEE 6111 03 001 NE 23

SerialSoftPrintln(buf);
//serialprintln(buf);
}
lcdwrite(192,CMD);
lcdprint("Done");
_delay_ms(2000);
}
Următoarea funcție este utilizată pentru ștergerea datelor de acces din memoria
volatilă EEPROM a microprocesorului.
1 void DeleteRecord()
2 {
3 lcdwrite(1,CMD);
4 lcdprint("Please Wait...");
5 for(int i=0;i<255;i++)
6 eeprom_write(i,10);
7 _delay_ms(2000);
8 lcdwrite(1,CMD);
9 lcdprint("Record Deleted");
10 lcdwrite(192,CMD);
11 lcdprint("Successfully");
12 _delay_ms(2000);
13 }
Codul programului în limbajul C.
1 /*
2 *
3 AttandeceSystem.
4 c
5 *
6 * Created:
7 1/8/2019 10:10:44
8 PM
9 * Author: Evan
10 */
11
12 #define F_CPU
13 8000000ul
14 #include
15 <avr/io.h>
Coala
CEEE 6111 03 001 NE 24
16 #include
17 <util/delay.h>
18 #include
19 <avr/interrupt.h>
20
21 /***MACROS*/
22
23 #define
24 USART_BAUDR
25 ATE 9600
26 #define
27 BAUD_PRESCA
28 LE (((F_CPU /
29 (USART_BAUD
30 RATE * 16UL))) -
31 1)
32
33 #define uchar
34 unsigned char
35 #define uint
36 unsigned int
37
38 #define
39 LCDPORTDIR
40 DDRB
41 #define
42 LCDPORT
43 PORTB
44 #define rs 0
45 #define rw 1
46 #define en 2
47
48 #define RSLow
49 (LCDPORT&=~(
50 1<<rs))
51 #define RSHigh
52 (LCDPORT|
53 =(1<<rs))
54 #define RWLow
55 (LCDPORT&=~(
56 1<<rw))
57 #define ENLow
58 (LCDPORT&=~(
59 1<<en))
60 #define ENHigh
61 (LCDPORT|
Coala
CEEE 6111 03 001 NE 25
62 =(1<<en))
63
64 #define
65 KeyPORTdir
66 DDRA
67 #define key PINA
68 #define KeyPORT
69 PORTA
70
71 #define OK 3
72 #define UP 0
73 #define DOWN 1
74 #define DEL 3
75 #define MATCH
76 1
77 #define ENROL 2
78
79 #define enrol (key
80 & (1<<ENROL))
81 // key 1
82 #define match
83 (key &
84 (1<<MATCH)) /
85 / key 4
86 #define delet (key
87 & (1<<DEL)) //
88 key 2
89 #define up (key &
90 (1<<UP)) // key
91 3
92 #define down (key
93 &
94 (1<<DOWN)) //
95 key 4
96 #define ok (key &
97 (1<<OK)) //
98 key 2
99
100 #define LEDdir
101 DDRC
102 #define LEDPort
103 PORTC
104
105 #define LED 3
106 #define BUZ 2
107
Coala
CEEE 6111 03 001 NE 26
108 #define LEDHigh
109 (LEDPort +=
110 (1<<LED))
111 #define LEDLow
112 (LEDPort &=
113 ~(1<<LED))
114
115 #define BUZHigh
116 (LEDPort +=
117 (1<<BUZ))
118 #define BUZLow
119 (LEDPort &=
120 ~(1<<BUZ))
121
122 #define HIGH 1
123 #define LOW 0
124
125 #define PASS 0
126 #define ERROR 1
127
128 #define check(id)
129 id=up<down?+
130 +id:down<up?--
131 id:id;
132
133 #define maxId 5
134 #define dataLenth
135 6
136 #define
137 eepStartAdd 10
138
139 /*variable*/
140
141 uchar buf[20];
142 uchar buf1[20];
143 volatile uint ind;
144 volatile uint flag;
145 uint msCount=0;
146 uint
147 g_timerflag=1;
148 volatile uint
149 count=0;
150 uchar data[10];
151 uint id=1;
152 int s,a,b,c;
153
Coala
CEEE 6111 03 001 NE 27
154 const char
155 passPack[]={0xE
156 F, 0x1, 0xFF,
157 0xFF, 0xFF,
158 0xFF, 0x1, 0x0,
159 0x7, 0x13, 0x0,
160 0x0, 0x0, 0x0,
161 0x0, 0x1B};
162 const char
163 f_detect[]={0xEF,
164 0x1, 0xFF, 0xFF,
165 0xFF, 0xFF, 0x1,
166 0x0, 0x3, 0x1,
167 0x0, 0x5};
168 const char
169 f_imz2ch1[]={0x
170 EF, 0x1, 0xFF,
171 0xFF, 0xFF,
172 0xFF, 0x1, 0x0,
173 0x4, 0x2, 0x1,
174 0x0, 0x8};
175 const char
176 f_imz2ch2[]={0x
177 EF, 0x1, 0xFF,
178 0xFF, 0xFF,
179 0xFF, 0x1, 0x0,
180 0x4, 0x2, 0x2,
181 0x0, 0x9};
182 const char
183 f_createModel[]=
184 {0xEF,0x1,0xFF,0
185 xFF,0xFF,0xFF,0
186 x1,0x0,0x3,0x5,0x
187 0,0x9};
188 char
189 f_storeModel[]={
190 0xEF,0x1,0xFF,0x
191 FF,0xFF,0xFF,0x
192 1,0x0,0x6,0x6,0x1
193 ,0x0,0x1,0x0,0xE
194 };
195 const char
196 f_search[]={0xEF,
197 0x1, 0xFF, 0xFF,
198 0xFF, 0xFF, 0x1,
199 0x0, 0x8, 0x1B,
Coala
CEEE 6111 03 001 NE 28
200 0x1, 0x0, 0x0,
201 0x0, 0xA3, 0x0,
202 0xC8};
203 char
204 f_delete[]={0xEF,
205 0x1,0xFF,0xFF,0x
206 FF,0xFF,0x1,0x0,
207 0x7,0xC,0x0,0x0,
208 0x0,0x1,0x0,0x15
209 };
210 //const char
211 f_readNotepad[]=
212 {0xEF,0x1,0xFF,0
213 xFF,0xFF,0xFF,0
214 x1,0x0,0x4,0x19,0
215 x0,0x0,0x1E};
216 //char
217 f_writeNotepad[]=
218 {0xEF,0x1,0xFF,0
219 xFF,0xFF,0xFF,0
220 x1,0x0,0x24};
221
222 int
223 timeStamp[7],day;
224
225 enum
226 {
227 CMD=0,
228 DATA,
229 };
230
231 void buzzer(uint);
232
233 void lcdwrite(char
234 ch,char r)
235 {
236 LCDPORT=ch
237 & 0xF0;
238 RWLow;
239 if(r == 1)
240 RSHigh;
241 else
242 RSLow;
243 ENHigh;
244 _delay_ms(5);
245 ENLow;
Coala
CEEE 6111 03 001 NE 29
246 _delay_ms(10);
247
248
249 LCDPORT=ch<<
250 4 & 0xF0;
251 RWLow;
252 if(r == 1)
253 RSHigh;
254 else
255 RSLow;
256 ENHigh;
257 _delay_ms(5);
258 ENLow;
259 _delay_ms(10);
260 }
261
262 void lcdprint(char
263 *str)
264 {
265 while(*str)
266 {
267 lcdwrite(*str
268 ++,DATA);
269 //__delay_ms
270 (20);
271 }
272 }
273
274 void lcdbegin()
275 {
276 uchar
277 lcdcmd[5]={0x02,
278 0x28,0x0E,0x06,0
279 x01};
280 uint i=0;
281 for(i=0;i<5;i++)
282 lcdwrite(lcdcm
283 d[i], CMD);
284 }
285
286 void serialbegin()
287 {
288 UCSRC = (1 <<
289 URSEL) | (1 <<
290 UCSZ0) | (1 <<
291 UCSZ1);
Coala
CEEE 6111 03 001 NE 30
292 UBRRH =
293 (BAUD_PRESCA
294 LE >> 8);
295 UBRRL =
296 BAUD_PRESCA
297 LE;
298 UCSRB=(1<<R
299 XEN)|
300 (1<<TXEN)|
301 (1<<RXCIE);
302 sei();
303 }
304
305 ISR(USART_RX
306 C_vect)
307 {
308 char ch=UDR;
309 buf[ind++]=ch;
310 if(ind>0)
311 flag=1;
312 //serial1Write(ch);
313 }
314
315 void
316 serialwrite(char
317 ch)
318 {
319 while ((UCSRA &
320 (1 << UDRE)) ==
321 0);
322 UDR = ch;
323 }
324
325 void
326 serialprint(char
327 *str)
328 {
329 while(*str)
330 {
331 serialwrite(*s
332 tr++);
333 }
334 }
335
336 void
337 serialprintln(char
Coala
CEEE 6111 03 001 NE 31
338 *str)
339 {
340 serialprint(str);
341 serialwrite(0x0d);
342 serialwrite(0x0a);
343 }
344
345 void serialFlush()
346 {
347 for(int
348 i=0;i<sizeof(buf);i
349 ++)
350 {
351 buf[i]=0;
352 }
353 }
354
355 void
356 SerialSoftWrite(c
357 har ch)
358 {
359 PORTD&=~(1<<
360 7);
361 _delay_us(104);
362 for(int i=0;i<8;i+
363 +)
364 {
365 if(ch & 1)
366 PORTD|=(1<<7);
367 else
368 PORTD&=~(1<<
369 7);
370 _delay_us(104);
371 ch>>=1;
372 }
373 PORTD|=(1<<7);
374 _delay_us(104);
375 }
376
377 void
378 SerialSoftPrint(ch
379 ar *str)
380 {
381 while(*str)
382 {
383 SerialSoftWrite(*s
Coala
CEEE 6111 03 001 NE 32
384 tr);
385 str++;
386 }
387 }
388
389 void
390 SerialSoftPrintln(c
391 har *str)
392 {
393 SerialSoftPrint(str
394 );
395 SerialSoftWrite(0
396 x0D);
397 SerialSoftWrite(0
398 x0A);
399 }
400
401 int bcdtochar(char
402 num)
403 {
404 return ((num/16 *
405 10) + (num %
406 16));
407 }
408
409 void RTC_start()
410 {
411 TWCR=(1<<TWI
412 NT)|
413 (1<<TWSTA)|
414 (1<<TWEN);
415 while((TWCR&0
416 x80)==0x00);
417 }
418
419 void RTC_stp()
420 {
421 TWCR=(1<<TWI
422 NT)|(1<<TWEN)|
423 (1<<TWSTO);
424 //stop
425 communication
426 }
427
428 void RTC_read()
429 {
Coala
CEEE 6111 03 001 NE 33
430 TWCR=(1<<TWI
431 NT)|
432 (1<<TWSTA)|
433 (1<<TWEN);
434 while((TWCR&0
435 x80)==0x00);
436 TWDR=0xD0;
437
438 //RTC write
439 (slave address)
440 TWCR=(1<<TWI
441 NT)|(1<<TWEN);
442 while(!
443 (TWCR&(1<<TW
444 INT)));
445 TWDR=0x00;
446
447 //RTC write
448 (word address)
449 TWCR=(1<<TWI
450 NT)|(1<<TWEN);
451 while(!
452 (TWCR&(1<<TW
453 INT)));
454 TWCR=(1<<TWI
455 NT)|
456 (1<<TWSTA)|
457 (1<<TWEN);
458 //start
459 RTC communicat
460 ion again
461 while
462 ((TWCR&0x80)=
463 =0x00);
464 TWDR=0xD1;
465
466 // RTC command
467 to read
468 TWCR=(1<<TWI
469 NT)|(1<<TWEN);
470 while(!
471 (TWCR&(1<<TW
472 INT)));
473 }
474
475 void
Coala
CEEE 6111 03 001 NE 34
476 sec_init(unsigned
477 char d)
478 {
479 TWDR=d;
480
481 //second init
482 TWCR=(1<<TWI
483 NT)|(1<<TWEN);
484 while(!
485 (TWCR&(1<<TW
486 INT)));
487 }
488
489 void
490 min_init(unsigned
491 char d)
492 {
493 TWDR=d;
494 //
495 minute init
496 TWCR=(1<<TWI
497 NT)|(1<<TWEN);
498 while(!
499 (TWCR&(1<<TW
500 INT)));
501 }
502
503 void
504 hr_init(unsigned
505 char d)
506 {
507 TWDR=d;
508 //
509 hour init
510 TWCR=(1<<TWI
511 NT)|(1<<TWEN);
512 while(!
513 (TWCR&(1<<TW
514 INT)));
515 }
516
517 void
518 day_init(unsigned
519 char d)
520 {
521 TWDR=d;
Coala
CEEE 6111 03 001 NE 35
522 /
523 /days init
524 TWCR=(1<<TWI
525 NT)|(1<<TWEN);
526 while(!
527 (TWCR&(1<<TW
528 INT)));
529 }
530
531 void
532 date_init(unsigned
533 char d)
534 {
535 TWDR=d;
536 /
537 /date init
538 TWCR=(1<<TWI
539 NT)|(1<<TWEN);
540 while(!
541 (TWCR&(1<<TW
542 INT)));
543 }
544
545 void
546 month_init(unsign
547 ed char d)
548 {
549 TWDR=d;
550 /
551 /month init
552 TWCR=(1<<TWI
553 NT)|(1<<TWEN);
554 while(!
555 (TWCR&(1<<TW
556 INT)));
557 }
558
559 void
560 yr_init(unsigned
561 char d)
562 {
563 TWDR=d;
564 /
565 /year init
566 TWCR=(1<<TWI
567 NT)|(1<<TWEN);
Coala
CEEE 6111 03 001 NE 36
568 while(!
569 (TWCR&(1<<TW
570 INT)));
571 }
572
573 int sec_rw()
574 {
575 TWCR|
576 =(1<<TWINT)|
577 (1<<TWEA);
578 //RTC
579 second read
580 while((TWCR &
581 0x80)==0x00);
582 return
583 bcdtochar(TWDR
584 );
585 }
586
587 int min_rw()
588 {
589 TWCR|
590 =(1<<TWINT);
591
592 //RTC minute read
593 TWCR|
594 =(1<<TWEA);
595 while((TWCR &
596 0x80)==0x00);
597 return
598 bcdtochar(TWDR
599 );
600 }
601
602 int hr_rw()
603 {
604 TWCR|
605 =(1<<TWINT)|
606 (1<<TWEA);
607 //RTC
608 hour read
609 while((TWCR &
610 0x80)==0x00);
611 return
612 bcdtochar(TWDR
613 );
Coala
CEEE 6111 03 001 NE 37
614 }
615
616 int day_rd()
617 {
618 TWCR|
619 =(1<<TWINT)|
620 (1<<TWEA);
621 //RTC
622 day read
623 while((TWCR&0
624 x80)==0x00);
625 return
626 bcdtochar(TWDR
627 );
628 }
629
630 int date_rw()
631 {
632 TWCR|
633 =(1<<TWINT)|
634 (1<<TWEA);
635 //RTC
636 date read
637 while((TWCR &
638 0x80)==0x00);
639 return
640 bcdtochar(TWDR
641 );
642 }
643
644 int month_rw()
645 {
646 TWCR|
647 =(1<<TWINT)|
648 (1<<TWEA);
649 //RTC
650 month read
651 while((TWCR &
652 0x80)==0x00);
653 return
654 bcdtochar(TWDR
655 );
656 }
657
658 int yr_rw()
659 {
Coala
CEEE 6111 03 001 NE 38
660 TWCR|
661 =(1<<TWINT);
662 /
663 /RTC year read
664 TWCR&=(~(1<<
665 TWEA));
666 while((TWCR &
667 0x80)==0x00);
668 return
669 bcdtochar(TWDR
670 );
671 }
672
673 void device()
674 {
675 TWDR=0xD0;
676
677 //RTC write
678 (slave address)
679 TWCR=(1<<TWI
680 NT)|(1<<TWEN);
681 while(!
682 (TWCR&(1<<TW
683 INT)));
684
685 TWDR=0x00;
686
687 // word address
688 write
689 TWCR=(1<<TWI
690 NT)|(1<<TWEN);
691 while(!
692 (TWCR&(1<<TW
693 INT)));
694 }
695
696 void
697 RTCTimeSet()
698 {
699 RTC_start();
700 device();
701 sec_init(0);
702 min_init(0x47);
703 hr_init(0x22);
704 day_init(0x03);
705 date_init(0x23);
Coala
CEEE 6111 03 001 NE 39
706 month_init(0x08);
707 yr_init(0x19);
708 RTC_stp();
709 }
710
711 void show()
712 {
713 char tem[20];
714 sprintf(tem,"%d",t
715 imeStamp[0]);
716 lcdwrite(0x80,CM
717 D);
718 lcdprint("Time:");
719 lcdprint(tem);
720 lcdwrite(':',DATA
721 );
723 imeStamp[1]);
724 lcdprint(tem);
725 lcdwrite(':',DATA
726 );
728 imeStamp[2]);
729 lcdprint(tem);
730 lcdprint(" ");
731 lcdwrite(0xc0,CM
732 D);
733 lcdprint("Date:");
735 imeStamp[3]);
736 lcdprint(tem);
737 lcdwrite('/',DATA
738 );
740 imeStamp[4]);
741 lcdprint(tem);
742 lcdwrite('/',DATA
743 );
745 imeStamp[5]);
746 lcdprint("20");
747 if(timeStamp[5]<1
748 0)
749 lcdwrite('0',DATA
750 );
751 lcdprint(tem);
Coala
CEEE 6111 03 001 NE 40
752 lcdprint(" ");
753 }
754
755 void RTC()
756 {
757 RTC_read();
758 timeStamp[2]=sec
759 _rw();
760 timeStamp[1]=mi
761 n_rw();
762 timeStamp[0]=hr_
763 rw();
764 day=day_rd();
765 timeStamp[3]=dat
766 e_rw();
767 timeStamp[4]=mo
768 nth_rw();
769 timeStamp[5]=yr_
770 rw();
771 RTC_stp();
772 show();
773 }
774
775 int
776 eeprom_write(uns
777 igned int
778 add,unsigned char
779 data)
780 {
781 while(EECR&(1<
782 <EEWE));
783 EEAR=add;
784 EEDR=data;
785 EECR|
786 =(1<<EEMWE);
787 EECR|
788 =(1<<EEWE);
789 return 0;
790 }
791 char
792 eeprom_read(unsi
793 gned int add)
794 {
795 while(EECR &
796 (1<<EEWE));
797 EEAR=add;
Coala
CEEE 6111 03 001 NE 41
798 EECR|
799 =(1<<EERE);
800 return EEDR;
801 }
802
803 void saveData(int
804 id)
805 {
806 uint cIndex=
807 eeprom_read(id);
808 if(cIndex == 0)
809 cIndex=1;
810 uint cAddress=
811 (cIndex*6) + (id-
812 1)*48;
813
814 for(int i=0;i<6;i+
815 +)
816 eeprom_write(cA
817 ddress+i,timeStam
818 p[i]);
819 eeprom_write(id,c
820 Index+1);
821 }
822
823 int
824 sendcmd2fp(char
825 *pack, int len)
826 {
827 int res=ERROR;
828 serialFlush();
829 ind=0;
830 _delay_ms(100);
831 for(int
832 i=0;i<len;i++)
833 {
834 serialwrite(*(pa
835 ck+i));
836 }
837 _delay_ms(1000)
838 ;
839 if(flag == 1)
840 {
if(buf[0] ==
0xEF && buf[1]
== 0x01)
Coala
CEEE 6111 03 001 NE 42
{
if(buf[6] ==
0x07) // ack
{
if(buf[9] ==
0)
{
uint
data_len= buf[7];
data_len<<
=8;
data_len|
=buf[8];

f
o
r
(
i
n
t
i
=
0
;
i
<
d
a
t
a
_
l
e
Coala
CEEE 6111 03 001 NE 43
n
;
i
+
+
)

d
a
t
a
[
i
]
=
0
;
//data=(cha
r
*)calloc(data_len,
sizeof(data));
for(int
i=0;i<data_len-
2;i++)
{
data[i]=
buf[10+i];
}
res=PASS;
}
Coala
CEEE 6111 03 001 NE 44
else
{

res=ERROR;
}
}
}
ind=0;
flag=0;
return res;
}
return res;
}
uint getId()
{
uint id=0;
lcdwrite(1,
CMD);
while(1)
{
//check(id);
if(up == LOW)
{
id++;
buzzer(200);
}
else if(down ==
LOW)
{
id--;
if(id==0)
id=0;
buzzer(200);
}
else if(ok ==
LOW)
{
buzzer(200);
return id;
}
lcdwrite(0x80,
CMD);
(void)sprintf((char
*)buf1,"Enter Id:
%d ",id);
Coala
CEEE 6111 03 001 NE 45
lcdprint((char
*)buf1);
_delay_ms(200);
}
}
void
matchFinger()
{
// lcdwrite(1,C
MD);
// lcdprint("Pla
ce Finger");
// lcdwrite(192,
CMD);
// _delay_ms(2
000);
if(!
sendcmd2fp((char
*)&f_detect[0],siz
eof(f_detect)))
{
if(!
sendcmd2fp((char
*)&f_imz2ch1[0],
sizeof(f_imz2ch1)
))
{
if(!
sendcmd2fp((char
*)&f_search[0],siz
eof(f_search)))
{
LEDHigh;
buzzer(200);
uint id=
data[0];

id<<=8;

id+=data[1];
uint
score=data[2];
sco
re<<=8;
sco
Coala
CEEE 6111 03 001 NE 46
re+=data[3];
(void)sp
rintf((char
*)buf1,"Id: %d",
(int)id);
lcdwrite
(1,CMD);
lcdprint(
(char *)buf1);
saveData(id);
_delay_ms(1000);
lcdwrite(1,CMD);
lcdprint("Attendan
ce");
lcdwrite(192,CM
D);
lcdprint("Register
ed");
_delay_ms(2000);
LEDLow;
}

else
{
LEDHigh;
lcdwrite
(1,CMD);
lcdprint(
"Not Found");
buzzer(5000);
LEDLow;
}
}
else
{
LEDHigh;
lcdwrite(1,CMD);
lcdprint("Not
Found");
buzzer(2000);
LEDLow;
}
}

Coala
CEEE 6111 03 001 NE 47
else
{

//lcdprint("No
Finger");
}
//_delay_ms(2
00);
}
void enrolFinger()
{

lcdwrite(1,CMD);

lcdprint("Enroll
Finger");

_delay_ms(2000);

lcdwrite(1,CMD);
lcdprint("Place
Finger");

lcdwrite(192,CM
D);

_delay_ms(1000);
for(int i=0;i<3;i+
+)
{
if(!
sendcmd2fp((char
*)&f_detect[0],siz
eof(f_detect)))
{

//lcdprint("Finger
Detected");

//__delay_ms(100
0);
if(!
sendcmd2fp((char
*)&f_imz2ch1[0],
sizeof(f_imz2ch1)
Coala
CEEE 6111 03 001 NE 48
))
{
lcdwrite(192,CM
D);
lcdprint("F
inger Detected");
_delay_ms
(1000);
// lcdwrite(
1,CMD);
// lcdprint("
Tamplate 1");
// __delay_
ms(1000);
lcdwrite(1,
CMD);
lcdprint("P
lace Finger");
lcdwrite(1
92,CMD);
lcdprint("
Again ");
_delay_ms
(2000);
if(!
sendcmd2fp((char
*)&f_detect[0],siz
eof(f_detect)))
{
if(!
sendcmd2fp((char
*)&f_imz2ch2[0],
sizeof(f_imz2ch2)
))
{
lcdwr
ite(1,CMD);
lcdpri
nt("Finger
Detected");
_dela
y_ms(1000);
if(!
sendcmd2fp((char
*)&f_createModel
[0],sizeof(f_create
Coala
CEEE 6111 03 001 NE 49
Model)))
{
id=
getId();
f_st
oreModel[11]=
(id>>8) & 0xff;
f_st
oreModel[12]= id
& 0xff;
f_st
oreModel[14]=
14+id;
if(!
sendcmd2fp((char
*)&f_storeModel[
0],sizeof(f_storeM
odel)))
{
buzzer(200);
l
cdwrite(1,CMD);
l
cdprint("Finger
Stored");
(
void)sprintf((char
*)buf1,"Id:%d",
(int)id);
l
cdwrite(192,CMD
);
l
cdprint((char
*)buf1);
_
delay_ms(1000);
}

else
{
l
cdwrite(1,CMD);
l
cdprint("Finger
Not Stored");
Coala
CEEE 6111 03 001 NE 50
buzzer(3000);
}
}
else
lcd
print("Error");
}
else

lcdprint("Error");
}
else
i=2;
}
break;
}
if(i==2)
{
lcdwrite(0xc0,CM
D);
lcdprint("No
Finger");
}
}

_delay_ms(2000);
}
void
deleteFinger()
{
id=getId();

f_delete[10]=id>>
8 & 0xff;
f_delete[11]=id
& 0xff;

f_delete[14]=(21+
id)>>8 & 0xff;

f_delete[15]=(21+
id) & 0xff;
if(!
sendcmd2fp(&f_d
elete[0],sizeof(f_d
Coala
CEEE 6111 03 001 NE 51
elete)))
{

lcdwrite(1,CMD);
sprintf((char
*)buf1,"Finger ID
%d ",id);
lcdprint((char
*)buf1);
lcdwrite(192,
CMD);

lcdprint("Deleted
Success");

}
else
{

lcdwrite(1,CMD);

lcdprint("Error");
}

_delay_ms(2000);
}

void lcdinst()
{
lcdwrite(0x80,
CMD);
lcdprint("1-
Enroll Finger");
lcdwrite(0xc0,
CMD);
lcdprint("2-
delete Finger");
_delay_ms(10);
}
void buzzer(uint t)
{
BUZHigh;
for(int i=0;i<t;i+
+)
_delay_ms(1);
Coala
CEEE 6111 03 001 NE 52
BUZLow;
}
/*function to show
attendence data on
serial moinitor
using softserial
pin PD7*/
void
ShowAttendance()
{
char buf[128];
lcdwrite(1,CMD);
lcdprint("Downlo
ding....");
SerialSoftPrintln("
Attendance
Record");
SerialSoftPrintln("
");
SerialSoftPrintln("
S.No ID1
ID2 Id3
ID4 I
D5 ");
//serialprintln("Att
endance Record");
//serialprintln(" ");
//serialprintln("S.
No ID1

ID2
Id3
ID4
ID5");
for(int
cIndex=1;cIndex<
=8;cIndex++)
{
sprintf((char
*)buf,"%d "
"%d:%d:%d %d/
%d/20%d "
"%d:%d:%d %d/
%d/20%d "
"%d:%d:%d %d/
Coala
CEEE 6111 03 001 NE 53
%d/20%d "
"%d:%d:%d %d/
%d/20%d "
"%d:%d:%d %d/
%d/20%d ",
cIndex,
eeprom_read((cIn
dex*6)),eeprom_r
ead((cIndex*6)+1)
,eeprom_read((cIn
dex*6)+2),eeprom
_read((cIndex*6)+
3),
eeprom_read((cIn
dex*6)+4),eeprom
_read((cIndex*6)+
5),
eeprom_read((cIn
dex*6)+48),eepro
m_read((cIndex*6
)+1+48),eeprom_r
ead((cIndex*6)+2
+48),
eeprom_read((cIn
dex*6)+3+48),eep
rom_read((cIndex
*6)+4+48),eepro
m_read((cIndex*6
)+5+48),
eeprom_read((cIn
dex*6)+96),eepro
m_read((cIndex*6
)+1+96),eeprom_r
ead((cIndex*6)+2
+96),
eeprom_read((cIn
dex*6)+3+96),eep
rom_read((cIndex
*6)+4+96),eepro
m_read((cIndex*6
)+5+96),
eeprom_read((cIn
dex*6)+144),eepr
om_read((cIndex*
6)+1+144),eepro
m_read((cIndex*6
Coala
CEEE 6111 03 001 NE 54
)+2+144),
eeprom_read((cIn
dex*6)+3+144),ee
prom_read((cInde
x*6)+4+144),eepr
om_read((cIndex*
6)+5+144),eepro
m_read((cIndex*6
)+192),eeprom_re
ad((cIndex*6)+1+
192),eeprom_read
((cIndex*6)+2+19
2),
eeprom_read((cIn
dex*6)+3+192),ee
prom_read((cInde
x*6)+4+192),eepr
om_read((cIndex*
6)+5+192));
SerialSoftPrintln(
buf);
//serialprintln(buf)
;
}
lcdwrite(192,CM
D);
lcdprint("Done");
_delay_ms(2000);
}
void
DeleteRecord()
{
lcdwrite(1,CMD);
lcdprint("Please
Wait...");
for(int
i=0;i<255;i++)
eeprom_write(i,10
);
_delay_ms(2000);
lcdwrite(1,CMD);
lcdprint("Record
Deleted");
lcdwrite(192,CM
Coala
CEEE 6111 03 001 NE 55
D);
lcdprint("Successf
ully");
_delay_ms(2000);
}
int main()
{
LEDdir= 0xFF;
LEDPort=0x03;
KeyPORTdir=0x
F0;
KeyPORT=0x0F
;
LCDPORTDIR=
0xFF;
DDRD+=1<<7;
PORTD+=1<<7;
serialbegin();
SerialSoftPrint("
Circuit Digest");
//serialprint("Sad
dam Khan");
buzzer(2000);

lcdbegin();
lcdprint("Attenda
nce Systm");
lcdwrite(192,CM
D);
lcdprint("Using
AVR and FP");
_delay_ms(2000)
;

if(down ==
LOW)
ShowAttendance
();

else if(delet ==
LOW)
DeleteRecord();
ind=0;
while(sendcmd2f
Coala
CEEE 6111 03 001 NE 56
p((char
*)&passPack[0],si
zeof(passPack)))
{

lcdwrite(1,CMD);
lcdprint("FP
Not Found");

_delay_ms(2000);
ind=0;
}
lcdwrite(1,CMD)
;
lcdprint("FP
Found");
_delay_ms(1000)
;
lcdinst();
_delay_ms(2000)
;
lcdwrite(1,CMD)
;
//RTCTimeSet();
while(1)
{
RTC();
// if(match ==
LOW)
// {
matchFinger();
// }

if(enrol ==
LOW)
{
buzzer(200);
enrolFinger()
;
_delay_ms(2
000);
// lcdinst();
}

else if(delet ==
Coala
CEEE 6111 03 001 NE 57
LOW)
{
buzzer(200);
getId();
deleteFinger(
);
_delay_ms(1
000);
}
}
return 0;
}
Coala
CEEE 6111 03 001 NE 58
Biliografie:
1. https://www.tme.eu/ro/details/atmega32-16au/gama-avr-8-bit/microchip-atmel/
2. https://www.tme.eu/Document/71c294f20b46f518abf4e142f75ea1d5/BC546_50.pdf
3. http://vega.unitbv.ro/~romanca/Carte-MpMc%202015/Microprocesoare%20si
%20microcontrolere-978-606-19-0683-3.pdf
4. https://components101.com/7805-voltage-regulator-ic-pinout-datasheet
5. https://market.yandex.ru/catalog--aksessuary/54530/list?text=Адаптер%20USB
%20AM%20-%20DC%20jack%203.5%20mm%20(Greenconnect%20GCR-
50644)%20(черный)&cvredirect=3&track=srch_ddl&cpa=0&onstock=1&hid=91070&
local-offers-first=0
Coala
CEEE 6111 03 001 NE 59
Concluzie: Înlucrării de diplomă, am creat un dispozitiv de acces al controlului
prin intermediul cititorului de amprente, pe baza microprocesorului Atmega 32.
Dispozitivul dat are un areal larg de utilizare putând fi implementat oriunde este necesar
de un control al
Coala
CEEE 6111 03 001 NE 60

Lucrare de Diplomă

Încărcat de

Informații document

Drepturi de autor

Formate disponibile

Partajați acest document

Partajați sau inserați document

Opțiuni de partajare

Vi se pare util acest document?

Este necorespunzător acest conținut?

Drepturi de autor:

Formate disponibile

Lucrare de Diplomă

Încărcat de

Drepturi de autor:

Formate disponibile

Curpins:

1. Elaborarea schemei de structură a dispozitivului ………………………………….…5

2. Descrierea principiului de funcționare………………………………………………..7

3. Argumentarea alegerii principalelor componente…………………………………….8

Mod Coala № Docum. Semnat. Data

1 Elaborarea schemei de structură a dispozitivului:

Figura 1 – Scheama bloc a dispozitivului

-Blocul butoanelor – reprezintă modalitatea de control al dispozitivului, cum ar fi

Figura 2 - Schema electrică principială

Sistemul de control al accesului pe baza amprentelor digitale lucrează pe bază de

Atmega32 AVR 8-bit este un circuit integrat de înaltă performanță ce se bazează

Prin executarea instrucțiuni puternice într-un singur ciclu de ceas, aparatul

Miezul AVR combină un set bogat de instrucțiuni cu 32 de registre de lucru de uz

Figura 1 – Rezumatul configurației.

Unitatea centrală execută instrucțiunile pe care le primește prin magistrala de date

3.2 Configurarea pinilor microcontrolerului ATmega32A.

Figura 4 - Configurarea pinilor microcontrolerului Atmega32A

3.3 Programatorul AVR-ISP.

Figura 5 – Schema electrică principială a analogului AVR-ISP.

 Tensiune programare microcontrollere: 3.3V sau 5V;

3.4 Modulul de citire a amprentelor r305.

Figura 6 – Cititorul de amprente R305

Modulul de citire a aprentelor r305 reprezintă un cititor de amprente optic, ales în

3.5 Afișor JHD162A LCD.

Figura 7 – JHD162A LCD

3.6 Ceas de timp real DS1307

3.7 Stabilizator de tensiune LM7805

Figura 10 – figura electrică principială LM7805

Condensatorul de intrare 0.33uF este un condensator ceramic care se ocupă de

Butoanele membranare (Figura 11) au fost incluse în dispozitivul dat datorită

Figura 11 – Butoane membranare

#define F_CPU 8000000ul

După asta vom declara variabilele și masivele necesare pentru prelucrarea

1 void SerialSoftWrite(char ch)

1 int eeprom_write(unsigned int add,unsigned char data)

Următoarele merg funcțiile care răspund de citirea amprentelor digitale,

Urmează funcțiile care răsund de înscrierea unei amprente noi și afișarea

Următoarea funcție este responsabilă de transferarea datelor de acces la terminalul serial

Codul programului în limbajul C.

S-ar putea să vă placă și