- Mga Materyal na Kinakailangan
- GT511C3 Fingerprint Sensor (FPS) Module
- Pagkonekta sa GT511C3 Finger Print Sensor sa Arduino
- Arduino kasama ang GT511C3
- Programming Arduino para sa GT511C3 Finger Print Sensor
- Paggawa ng GT511C3 Finger Print Sensor kasama si Arduino
Ang biometric ay ginamit bilang isang maaasahang sistema ng pagpapatotoo sa loob ng mahabang panahon ngayon. Ngayon may umiiral na mga kumplikadong biometric system na maaaring makilala ang isang tao sa pamamagitan ng kanyang heart beat ritmo o kahit sa pamamagitan ng kanyang DNA. Ang iba pang mga magagawa na pamamaraan ay may kasamang pagkilala sa boses, Pagkilala sa mukha, pag-scan ng Iris at pag-scan ng Finger print. Kung saan ang pagkilala sa pag-print ng daliri ay ang pinaka malawak na ginagamit na pamamaraan, mahahanap namin ito mula sa isang simpleng sistema ng pagdalo hanggang sa mga smart phone hanggang sa mga tseke sa Seguridad at marami pa.
Sa tutorial na ito matututunan natin kung paano gamitin ang sikat na GT511C3 Finger Print Sensor (FPS) kasama ang Arduino. Maraming magagamit na FPS at natutunan na namin kung paano gamitin ang mga ito upang makabuo ng mga disenyo tulad ng Attendance system, Voting Machine, Security system atbp. Ngunit ang GT511C3 ay mas advanced na may mataas na kawastuhan at mas mabilis na oras ng pagtugon, kaya matututunan natin kung paano ito gamitin kasama si Arduino upang magpatala ng mga print ng daliri dito at pagkatapos ay tuklasin ang mga fingerprint kahit kailan kinakailangan. Kaya't magsimula tayo.
Mga Materyal na Kinakailangan
- Arduino Nano / UNO
- GT511C3 Finger Print Sensor
- 16x2 LCD screen
- Palayok - 10k at 1k, 10k, 22k resistors
- Push button
- Mga Koneksyon sa Mga Wires
- Bread board
GT511C3 Fingerprint Sensor (FPS) Module
Bago sumisid sa proyekto ipaalam sa amin ang tungkol sa GT511C3 fingerprint sensor Module at kung paano ito gumagana. Ang sensor na ito ay ibang-iba form na Capacitive at Ultrasonic Fingerprint sensor na karaniwang ginagamit sa aming mga smart phone. Ang GT511C3 ay isang optical Fingerprint sensor, nangangahulugang umaasa ito sa mga imahe ng iyong fingerprint upang makilala ang pattern nito. Oo nabasa mo na ang tama, ang sensor ay talagang may camera sa loob nito na kumukuha ng mga larawan ng iyong fingerprint at pagkatapos ay pinoproseso ang mga imaheng ito gamit ang malakas na built-in na ARM Cortex M3 IC. Ipinapakita ng imahe sa ibaba ang harap at likod na bahagi ng sensor na may mga pinout.
Tulad ng nakikita mo ang sensor ay may isang kamera (itim na lugar) na napapalibutan ng mga asul na LED, ang mga LED na ito ay kailangang naiilawan upang kumuha ng isang malinaw na imahe ng fingerprint. Ang mga imaheng ito ay naproseso at na-convert sa binary halaga sa pamamagitan ng paggamit ng ARM Microcontroller na isinama sa EEPROM. Ang module ay mayroon ding berdeng kulay SMD LED upang ipahiwatig ang lakas. Ang bawat imahe ng fingerprint ay 202x258 pixel na may resolusyon na 450dpi. Maaaring magpatala ang sensor ng hanggang 200 na mga fingerprint at para sa bawat template ng pag-print ng daliri ay nagtatalaga ito ng isang form ng ID na 0 hanggang 199. Pagkatapos sa pagtuklas maaari itong awtomatikong ihambing ang na-scan na fingerprint sa lahat ng 200 mga template at kung matagpuan ang isang tugma ay binibigyan nito ang numero ng ID ng partikular na fingerprint na iyon gamit ang Smack Finger 3.0Ang algorithm sa ARM Microcontroller. Ang sensor ay maaaring gumana mula sa 3.3V hanggang 6V at nakikipag-usap sa pamamagitan ng Serial na komunikasyon sa 9600. Ang mga pin ng komunikasyon (Rx at Tx) ay sinasabing mapagparaya lamang na 3.3V, subalit ang datasheet ay hindi tumutukoy ng marami tungkol dito. Ang pin-out ng isang GT511C3 FPS ay ipinapakita sa ibaba.
Bukod sa serial komunikasyon ang module ay maaari ring direktang ma-interfaced sa computer kahit na koneksyon ng USB gamit ang mga pin na ipinakita sa nakaraang imahe. Kapag nakakonekta sa computer ang module ay maaaring makontrol gamit ang SDK_DEMO.exe application na maaaring ma-download mula sa link. Pinapayagan ng application na ito ang gumagamit na mag-enrol / mag-verify / magtanggal ng mga fingerprint at makilala din ang mga fingerprint. Maaari ka ring matulungan ng software na basahin ang imaheng nakunan ng sensor na kung saan ay sulit na subukan ito. Maaari mo ring gamitin ang Software na ito kahit na ang sensor ay konektado sa Arduino, tatalakayin namin ito sa paglaon sa artikulong ito.
Ang isa pang kagiliw-giliw na tampok tungkol sa sensor ay ang metal na pambalot sa paligid ng rehiyon ng sensing. Tulad ng sinabi ko nang mas maaga ang asul na LED ay dapat na buksan para gumana ang sensor. Ngunit sa mga application kung saan ang sensor ay dapat na aktibong maghintay para sa isang fingerprint hindi posible na panatilihing naka-on ang LED palagi dahil maiinit nito ang sensor at sa gayon ay masisira ito. Samakatuwid sa mga kasong iyon ang metal na pambalot ay maaaring mai-wire sa isang capacitive touch input pin ng isang MCU upang makita kung ito ay hinawakan. Kung oo ang LED ay maaaring i-on at ang proseso ng sensing ay maaaring simulan. Ang pamamaraang ito ay hindi ipinakita dito sapagkat nasa labas ng saklaw ng artikulong ito.
Kapag nagpapatakbo sa 3.3V ang sensor ay kumakain ng halos 130mA. Nangangailangan ito ng halos 3 segundo para sa pagpapatala ng isang daliri at 1 segundo upang makilala ito. Gayunpaman kung ang nakatala na bilang ng template ay mas mababa ang bilis ng pagkilala ay magiging mataas. Para sa karagdagang detalye tungkol sa sensor maaari kang mag-refer sa datasheet na ito mula sa ADH-Tech na opisyal na tagagawa ng modyul.
Pagkonekta sa GT511C3 Finger Print Sensor sa Arduino
Ang GT511C3 FPS ay may dalawang power pin na maaaring pinalakas ng + 5V pin ng Arduino at dalawang pin ng komunikasyon na Rx at Tx na maaaring konektado sa anumang digital pin ng Arduino para sa serial na komunikasyon. Bilang karagdagan nagdagdag din kami ng isang pindutan ng push at isang LCD upang maipakita ang katayuan ng sensor. Ang kumpletong diagram ng circuit para sa interfacing GT511C3 FPS sa Arduino ay matatagpuan sa ibaba.
Dahil ang mga pin ng Rx at Tx ay mapagparaya sa 3.3V nagamit namin ang isang potensyal na divider sa gilid ng Rx upang i-convert ang 5V sa 3.3V. Ang 10k resistor at 22k resistor ang nagko-convert ng 5V signal mula sa Arduino Tx pin sa 3.3V bago maabot ang Rx pin ng FPS. Ang Sensor ay maaari ring pinalakas ng 3.3V ngunit tiyaking ang iyong Arduino ay maaaring mapagkukunan ng sapat na kasalukuyang para sa sensor. Nakakonekta namin ang LCD sa 4-bit mode na pinalakas ng 5V pin ng Arduino. Ang isang pindutan ng push ay konektado sa pin D2 na kapag pinindot ay ilalagay ang programa sa mode na magpatala kung saan ang gumagamit ay maaaring magpatala ng bagong daliri. Matapos ang pagpapatala ng programa ay mananatili sa mode ng pag-scan upang mag-scan para sa anumang daliri na hawakan ang sensor.
Arduino kasama ang GT511C3
Tulad ng nabanggit nang mas maaga ang GT511C3 FPS ay nakikipag-usap sa pamamagitan ng serial na komunikasyon, naiintindihan ng sensor ang hex code at para sa bawat hex code isang partikular na operasyon ang ginaganap. Maaari mong suriin ang datasheet upang malaman ang lahat ng mga halaga ng hex at ang kaukulang pag-andar nito kung interesado ka. Ngunit, masuwerte para sa amin ang bboyho ay lumikha na ng isang silid -aklatan na maaaring magamit nang direkta sa Arduino upang Mag-Enrol at makita ang mga kopya ng daliri. Maaaring mai-download ang library ng Github para sa GT511C3 FPS mula sa link sa ibaba
GT511C3 Arduino Library
Mag-download ang link ng isang ZIP file, kakailanganin mong idagdag ito sa iyong Arduino IDE sa pamamagitan ng pagsunod sa utos na Sketch -> Isama ang Library -> Idagdag.ZIP Library. Kapag naidagdag mo na ang library i-restart ang iyong IDE at dapat mong makita ang mga e xample na programa para sa GT511C3 FSP sa ilalim ng File -> Halimbawa -> Fingerprint Scanner TTL tulad ng ipinakita sa ibaba
Dapat mong makita ang apat na halimbawang mga programa, ang blink na programa ay magpapikit ng asul na humantong sa FPS, ang programa sa pagpapatala at daliri ng ID ay maaaring magamit upang magpatala at kilalanin ang mga daliri nang naaayon. Tandaan na ang isang daliri sa sandaling naka-enrol ay palaging maaalala ng module kahit na ito ay pinapatay.
Ang programa ng Serial Pass-through ay maaaring mai-upload sa Arduino upang magamit ang application na Demo_SDK.exe na tinalakay namin nang mas maaga sa artikulong ito. Upang tanggalin ang anumang template ng fingerprint o upang makatipid ng isang kopya sa iyong computer maaaring magamit ang SDK application na ito.
Programming Arduino para sa GT511C3 Finger Print Sensor
Ang aming hangarin dito ay upang magsulat ng isang programa na magpapalista sa isang daliri kapag pinindot ang isang pindutan at ipakita ang numero ng ID ng daliri na na-enrol. Dapat din naming maipakita ang lahat ng impormasyon sa LCD upang paganahin ang proyekto na maging isang nag-iisa. Ang kumpletong code upang gawin ang pareho ay ibigay sa ilalim ng pahinang ito. Narito ko pinaghiwalay ang pareho sa maliliit na mga snippet upang matulungan kang maunawaan nang mas mahusay.
Tulad ng lagi naming sinisimulan ang programa sa pamamagitan ng pagsasama ng mga kinakailangang aklatan, dito kakailanganin namin ang FPS_GT511C3 library para sa aming module na FPS, serial ng Software upang magamit ang D4 at D5 sa serial na komunikasyon at Liquid na kristal para sa LCD interfacing. Pagkatapos ay kailangan naming banggitin sa aling mga pin ang FPS at LCD ay konektado. Kung sinundan mo ang circuit diagram tulad nito ay 4 at 5 para sa FPS at D6 hanggang D11 para sa LCD. Ang code para sa pareho ay ipinapakita sa ibaba
# isama ang "FPS_GT511C3.h" // Kumuha ng library mula https://github.com/sparkfun/Fingerprint_Scanner-TTL # isama ang "SoftwareSerial.h" // Software serial library #include
Sa loob ng pag- andar ng pag- setup , ipinapakita namin ang ilang pambungad na mensahe sa LCD at pagkatapos ay pinasimulan ang module ng FPS. Ang command fps.SetLED (totoo) ay magpapasara sa asul na LED sa sensor, maaari mo itong i-off ng fps.SetLED (false) kapag hindi kinakailangan dahil maiinit nito ang sensor kung maiiwan nang tuloy-tuloy. Ginawa rin namin ang pin D2 bilang input pin at ikinonekta ito sa panloob na resistor na pull-up upang maiugnay ang isang pindutan ng push sa pin.
void setup () { Serial.begin (9600); lcd.begin (16, 2); // Initialise 16 * 2 LCD lcd.print ("GT511C3 FPS"); // Intro Message line 1 lcd.setCursor (0, 1); lcd.print ("may Arduino"); // Intro Message line 2 pagkaantala (2000); lcd.clear (); fps. Buksan (); // send serial command to initialize fp fps.SetLED (totoo); // i-on ang LED upang makita ng fps ang fingerprint pinMode (2, INPUT_PULLUP); // Kumonekta sa panloob na hilahin ang risistor bilang input pin }
Sa loob ng pag- andar ng void loop kailangan nating suriin kung ang pindutan ay pinindot, kung pinindot magpapalista kami ng isang bagong daliri at mai-save ang template nito gamit ang isang numero ng ID sa pamamagitan ng paggamit ng pagpapaandar na pagpapatakbo. Kung hindi man ay patuloy kaming naghihintay para sa isang daliri na mapindot sa sensor. Kung pinindot gagamitin namin ang pagkakakilanlan ng daliri sa pamamagitan ng paghahambing nito sa lahat ng naka-enrol na template ng mga fingerprint gamit ang pamamaraang 1: N. Kapag natuklasan ang numero ng ID ay ipapakita namin ang maligayang pagdating na sinusundan ng numero ng ID. Kung ang pag-print ng daliri ay hindi tugma sa alinman sa mga nakatala na daliri ang bilang ng id ay magiging 200, sa kasong iyon ipapakita namin ang maligayang pagdating na hindi kilala.
kung (digitalRead (2)) // Kung ang pindutan ay pinindot ang { Enroll (); // Enroll a fingerprint } // Kilalanin ang pagsubok sa fingerprint kung (fps.IsPressFinger ()) { fps.CaptureFinger (false); int id = fps.Identify1_N (); lcd.clear (); lcd.print ("Maligayang pagdating:"); kung (id == 200) lcd.print ("Hindi Kilalang"); // Kung hindi kinikilala lcd.print (id); pagkaantala (1000); }
Ang pagpapaandar sa pagpapatala ay kailangang kumuha ng tatlong mga sample na input upang matagumpay na makapagpatala ng isang daliri. Kapag na-enrol ang isang template para sa partikular na daliri na iyon ay malilikha na hindi matatanggal maliban kung pinilit ito ng gumagamit kahit na ang HEX ay nag-uutos. Ang code upang magpatala ng isang daliri ay ipinapakita sa ibaba. Ang pamamaraang IsPressFinger ay ginagamit upang suriin kung ang isang daliri ay napansin, kung oo kung gayon ang imahe ay nakunan gamit ang CaptureFinger at pagkatapos ay sa wakas Enroll1, Enroll2 at Enroll3 ay ginagamit para sa tatlong magkakaibang mga sample upang matagumpay na magpatala ng isang daliri. Ipinapakita ng LCD ang numero ng ID ng daliri kung matagumpay na naka-enrol ay magpapakita ito ng isang mensahe ng pagkabigo na may code. Nangangahulugan ang code 1 na ang pag-print ng daliri ay hindi nakuha nang malinaw at samakatuwid kailangan mong subukang muli. Ang Code 2 ay isang indikasyon na nabigo sa memorya at ang code 3 ay upang ipahiwatig na na-enrol na ang daliri.
void Enroll () // Enrol function mula sa programang exmaple ng library { int enrollid = 0; bool usedid = totoo; habang (usedid == totoo) { usedid = fps.CheckEnrolled (nakatala); kung (usedid == true) nakatala ++; } fps.EnrollStart (nakatala); // enroll lcd.print ("Mag-enrol #"); lcd.print (nakatala); habang (fps.IsPressFinger () == false) pagkaantala (100); bool bret = fps.CaptureFinger (totoo); int iret = 0; kung (bret! = false) { lcd.clear (); lcd.print ("Alisin ang daliri"); fps.Enroll1 (); habang (fps.IsPressFinger () == totoo) pagkaantala (100); lcd.clear (); lcd.print ("Pindutin muli"); habang (fps.IsPressFinger () == false) pagkaantala (100); bret = fps.CaptureFinger (totoo); kung (bret! = false) { lcd.clear (); lcd.print ("Alisin ang daliri"); fps.Enroll2 (); habang (fps.IsPressFinger () == totoo) pagkaantala (100); lcd.clear (); lcd.print ("Pindutin muli muli"); habang (fps.IsPressFinger () == false) pagkaantala (100); bret = fps.CaptureFinger (totoo); kung (bret! = false) { lcd.clear (); lcd.print ("Alisin ang daliri"); iret = fps.Enroll3 (); kung (iret == 0) { lcd.clear (); lcd.print ("Tagumpay sa Pag-enrol"); } iba pa { lcd.clear (); lcd.print ("Nabigo ang Pag-enrol:"); lcd.print (iret); } } iba pa lcd.print ("Nabigo 1"); } iba pa lcd.print ("Nabigo 2"); } iba pa lcd.print ("Nabigo 3"); }
Paggawa ng GT511C3 Finger Print Sensor kasama si Arduino
Ngayon na handa na ang aming hardware at code oras na upang subukan ang aming proyekto. I-upload ang code sa Arduino at i-power up ito, gumagamit lang ako ng micro-usb port upang mapagana ang proyekto. Sa pag-boot dapat makita natin ang intro message sa LCD at pagkatapos ay dapat itong ipakita sa "Hi!..". Nangangahulugan ito na ang FPS ay handa nang mag-scan para sa daliri, kung ang anumang naka-enrol na daliri ay pinindot sasabihin na "Maligayang pagdating" na sinusundan ng numero ng ID ng daliri na iyon tulad ng ipinakita sa ibaba.
Kung ang isang bagong daliri ay kailangang naitala pagkatapos ay maaari naming gamitin ang pindutan ng push upang makapasok sa mode na magpatala at sundin ang tagubilin sa LCD upang magpatala ng isang daliri. Matapos makumpleto ang proseso ng pag-enrol ay ipapakita muli ng LCD ang "Hi!.." upang ipahiwatig na binasa na ito upang muling kilalanin ang mga daliri. Ang kumpletong pagtatrabaho ay matatagpuan sa video na naka-link sa ibaba.
Mula dito maaari kang bumuo ng maraming mga kagiliw-giliw na bagay sa tuktok dito gamit ang module ng sensor ng Finger Print. Inaasahan kong naintindihan mo ang tutorial at nasiyahan sa pagbuo ng isang bagay na kapaki-pakinabang, kung mayroon kang anumang mga katanungan iwanan sila sa seksyon ng komento o gamitin ang mga forum para sa iba pang mga teknikal na katanungan.