API tools faq
paste
Advertisement
Guest User

Celý program

a guest
Feb 28th, 2020
93
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
text 18.11 KB | None | 0 0
raw download clone embed print report
  1. #include <Adafruit_Fingerprint.h>
  2. #include <LiquidCrystal_I2C.h>
  3. #include <Servo.h>
  4. #include <SPI.h>
  5. #include <MFRC522.h>
  6. #include <SoftwareSerial.h>
  7. #include <EEPROM.h>
  8.  
  9. #define ZATVORENE A2
  10. #define ZAMOK 4
  11. #define BUZZER 5
  12. #define SERVO 8
  13. #define SS 10
  14. #define RST 9
  15. #define UID_COUNT 10
  16.  
  17. #define POTVRDENIE 6
  18. #define PREPINANIE 7
  19.  
  20. #define Z_MEKCEN 0
  21. #define E_DLZEN 1
  22. #define A_DLZEN 2
  23. #define A_BODKY 3
  24. #define C_MEKCEN 4
  25. #define KURZOR 5
  26.  
  27. #define NORMAL 0
  28. #define SERVICE 1
  29. #define PRIDANIE_KARTY 2
  30. #define VYMAZANIE_KARTY 3
  31. #define PRIDANIE_ODTLACOK 4
  32. #define VYMAZANIE_ODTLACOK 5
  33.  
  34. //Pridanie odtlačku
  35. #define PRILOZENIE 0
  36. #define KONVERTOVANIE 1
  37. #define UKLADANIE 2
  38. #define HOTOVO 3
  39.  
  40. SoftwareSerial SSerial(2, 3);
  41. Adafruit_Fingerprint finger = Adafruit_Fingerprint(&SSerial);
  42. LiquidCrystal_I2C lcd(0x27, 20, 4);
  43. MFRC522 rfid_reader(SS, RST);
  44.  
  45. const char* medzera = " ";
  46. uint32_t rfid_cas = 0;
  47. String uid = "";
  48. String uids[UID_COUNT];
  49. String pridat_uid = "";
  50. uint8_t rezim = NORMAL;
  51. uint8_t pridanie_odtlacok_stav;
  52. uint8_t fingerprint_miesta[16];
  53. uint8_t volne_miesto;
  54.  
  55. const byte z_mekcen[] = {
  56. 0b01010,
  57. 0b00100,
  58. 0b11111,
  59. 0b00010,
  60. 0b00100,
  61. 0b01000,
  62. 0b11111,
  63. 0b00000
  64. };
  65.  
  66. const byte e_dlzen[] = {
  67. 0b00010,
  68. 0b00100,
  69. 0b01110,
  70. 0b10001,
  71. 0b11111,
  72. 0b10000,
  73. 0b01110,
  74. 0b00000
  75. };
  76.  
  77. const byte a_dlzen[] = {
  78. 0b00010,
  79. 0b00100,
  80. 0b01110,
  81. 0b00001,
  82. 0b01111,
  83. 0b10001,
  84. 0b01111,
  85. 0b00000
  86. };
  87.  
  88. const byte a_bodky[] = {
  89. 0b01010,
  90. 0b00000,
  91. 0b01110,
  92. 0b00001,
  93. 0b01111,
  94. 0b10001,
  95. 0b01111,
  96. 0b00000
  97. };
  98.  
  99. const byte c_mekcen[] = {
  100. 0b01010,
  101. 0b00100,
  102. 0b01110,
  103. 0b10000,
  104. 0b10000,
  105. 0b10000,
  106. 0b01110,
  107. 0b00000
  108. };
  109.  
  110. const byte kurzor[] = {
  111. 0b00000,
  112. 0b00000,
  113. 0b11111,
  114. 0b10001,
  115. 0b10001,
  116. 0b11111,
  117. 0b00000,
  118. 0b00000
  119. };
  120.  
  121. struct dvere {
  122. uint8_t poloha = 90;
  123. uint8_t poloha_otvorene = 0;
  124. uint32_t cas_serva = 0;
  125. uint32_t cas_zopnutia = 0;
  126. bool otvaranie = false;
  127. bool zamok = false;
  128. Servo servo;
  129. } dvere;
  130.  
  131. struct Tlacidlo {
  132. bool stav;
  133. uint32_t cas;
  134. };
  135.  
  136. Tlacidlo potvrdenie{false, 0};
  137. Tlacidlo prepinanie{false, 0};
  138.  
  139. struct Menu {
  140. bool prve_zobrazenie;
  141. uint8_t kurzor;
  142. uint32_t kurzor_cas;
  143. uint32_t potvrdenie_cas;
  144. };
  145.  
  146. Menu servis{true, 0, 0, 0};
  147. Menu pridanie_karty{true, 0, 0, 0};
  148. Menu vymazanie_karty{true, 0, 0, 0};
  149. Menu pridanie_odtlacok{true, 0, 0, 0};
  150. Menu vymazanie_odtlacok{true, 0, 0, 0};
  151.  
  152. void setup() {
  153. Serial.begin(9600);
  154. finger.begin(57600);
  155.  
  156. lcd.init();
  157. lcd.createChar(Z_MEKCEN, z_mekcen);
  158. lcd.createChar(E_DLZEN, e_dlzen);
  159. lcd.createChar(A_DLZEN, a_dlzen);
  160. lcd.createChar(A_BODKY, a_bodky);
  161. lcd.createChar(C_MEKCEN, c_mekcen);
  162. lcd.createChar(KURZOR, kurzor);
  163. lcd.backlight();
  164. clearScreen();
  165.  
  166. dvere.servo.attach(SERVO);
  167. dvere.servo.write(90);
  168. _delay_ms(200);
  169. dvere.servo.detach();
  170.  
  171. SPI.begin();
  172. rfid_reader.PCD_Init();
  173.  
  174. pinMode(ZATVORENE, OUTPUT);
  175. pinMode(ZAMOK, OUTPUT);
  176. pinMode(POTVRDENIE, INPUT_PULLUP);
  177. pinMode(PREPINANIE, INPUT_PULLUP);
  178.  
  179. readId();
  180. volne_miesto = getClosestEmptyId();
  181.  
  182. uint8_t j, i;
  183.  
  184. /** Čítanie UIDov do EEPROM */
  185. for (i = 0; i < UID_COUNT; i++) {
  186. char s[9];
  187.  
  188. if (EEPROM.read(9 * i) == 255) break;
  189.  
  190. for (j = 0; j < 8; j++) {
  191. s[j] = EEPROM.read(9 * i + j);
  192. }
  193.  
  194. s[8] = '\0';
  195.  
  196. uids[i] = s;
  197. }
  198. }
  199.  
  200. void loop() {
  201. /** Potvrdzovacie tlačidlo pooling */
  202. if (millis() >= (potvrdenie.cas + 200)) {
  203. potvrdenie.stav = !digitalRead(POTVRDENIE);
  204.  
  205. potvrdenie.cas = millis();
  206. }
  207.  
  208. /** Prepínacie tlačidlo pooling */
  209. if (millis() >= (prepinanie.cas + 200)) {
  210. prepinanie.stav = !digitalRead(PREPINANIE);
  211.  
  212. if (rezim == SERVICE && prepinanie.stav) {
  213. servis.kurzor = ++servis.kurzor % 6;
  214. }
  215.  
  216. prepinanie.cas = millis();
  217. }
  218.  
  219. if (!dvere.zamok) {
  220. digitalWrite(ZATVORENE, HIGH);
  221. } else {
  222. digitalWrite(ZATVORENE, LOW);
  223. }
  224.  
  225. /** Čítanie RFID */
  226. if (!dvere.zamok && millis() >= rfid_cas + 1000) {
  227. if (rfid_reader.PICC_IsNewCardPresent()) {
  228. rfid_reader.PICC_ReadCardSerial();
  229. uid = "";
  230.  
  231. for (uint8_t i = 0; i < rfid_reader.uid.size; i++) {
  232. uid.concat(String(rfid_reader.uid.uidByte[i] < 0x10 ? "0" : ""));
  233. uid.concat(String(rfid_reader.uid.uidByte[i], HEX));
  234. }
  235.  
  236. uid.toUpperCase();
  237. Serial.println(uid);
  238. }
  239.  
  240. rfid_cas = millis();
  241. }
  242.  
  243. rfidCheck();
  244.  
  245. /** Prepínanie medzi režimami */
  246. switch (rezim) {
  247. /** Servisný režim */
  248. case SERVICE: {
  249. if (servis.prve_zobrazenie) {
  250. lcd.clear();
  251. lcd.setCursor(0, 0);
  252. lcd.print("Servisn"); lcd.write(E_DLZEN); lcd.print(" menu:");
  253. lcd.setCursor(2, 1);
  254. lcd.print("+ karta - karta");
  255. lcd.setCursor(2, 2);
  256. lcd.print("+ odtl. - odtl.");
  257. lcd.setCursor(14, 3);
  258. lcd.print("exit");
  259.  
  260. servis.prve_zobrazenie = false;
  261. }
  262.  
  263. /** Kurzor */
  264. if (millis() >= servis.kurzor_cas + 50) {
  265. switch (servis.kurzor) {
  266. case 0: {
  267. lcd.setCursor(12, 3);
  268. lcd.print(" ");
  269. break;
  270. }
  271. case 1: {
  272. lcd.setCursor(0, 1);
  273. lcd.write(KURZOR);
  274. break;
  275. }
  276. case 2: {
  277. lcd.setCursor(0, 1);
  278. lcd.print(" ");
  279. lcd.setCursor(0, 2);
  280. lcd.write(KURZOR);
  281.  
  282. break;
  283. }
  284. case 3: {
  285. lcd.setCursor(0, 2);
  286. lcd.print(" ");
  287. lcd.setCursor(10, 1);
  288. lcd.write(KURZOR);
  289. break;
  290. }
  291. case 4: {
  292. lcd.setCursor(10, 1);
  293. lcd.print(" ");
  294. lcd.setCursor(10, 2);
  295. lcd.write(KURZOR);
  296. break;
  297. }
  298. case 5: {
  299. lcd.setCursor(10, 2);
  300. lcd.print(" ");
  301. lcd.setCursor(12, 3);
  302. lcd.write(KURZOR);
  303. break;
  304. }
  305. }
  306.  
  307. servis.kurzor_cas = millis();
  308. }
  309.  
  310. /** Prepínanie medzi stavmi v servisnom menu */
  311. if (potvrdenie.stav) {
  312. if (servis.kurzor == 1) {
  313. servis.prve_zobrazenie = true;
  314. rezim = PRIDANIE_KARTY;
  315. servis.kurzor = 0;
  316. break;
  317. } else if (servis.kurzor == 2) {
  318. servis.prve_zobrazenie = true;
  319. rezim = PRIDANIE_ODTLACOK;
  320. servis.kurzor = 0;
  321. break;
  322. } else if (servis.kurzor == 3) {
  323. servis.prve_zobrazenie = true;
  324. rezim = VYMAZANIE_KARTY;
  325. servis.kurzor = 0;
  326. break;
  327. } else if (servis.kurzor == 4) {
  328. servis.prve_zobrazenie = true;
  329. rezim = VYMAZANIE_ODTLACOK;
  330. servis.kurzor = 0;
  331. } else if (servis.kurzor == 5) {
  332. servis.prve_zobrazenie = true;
  333. rezim = NORMAL;
  334. servis.kurzor = 0;
  335. clearScreen();
  336. break;
  337. }
  338. }
  339.  
  340. break;
  341. }
  342. /** Režim pridávania kariet */
  343. case PRIDANIE_KARTY: {
  344. if (pridanie_karty.prve_zobrazenie) {
  345. lcd.clear();
  346. lcd.print("Pridanie karty:");
  347. pridanie_karty.prve_zobrazenie = false;
  348. pridanie_karty.potvrdenie_cas = millis();
  349. }
  350.  
  351. if (millis() - pridanie_karty.potvrdenie_cas >= 500 && potvrdenie.stav) {
  352. rezim = SERVICE;
  353. pridanie_karty.prve_zobrazenie = true;
  354. }
  355.  
  356. if (pridat_uid != "") {
  357. lcd.setCursor(0, 1);
  358. lcd.print(pridat_uid);
  359.  
  360. if (!rfidInMemory(pridat_uid)) {
  361. static uint8_t first_empty;
  362.  
  363. for (first_empty = 0; first_empty < UID_COUNT; first_empty++) {
  364. if (uids[first_empty].c_str()[0] == '\0') {
  365. break;
  366. }
  367. }
  368.  
  369. if (first_empty == UID_COUNT) {
  370. pridat_uid = "";
  371. lcd.setCursor(0, 2);
  372. lcd.print("Pln"); lcd.write(A_DLZEN); lcd.print("pam"); lcd.write(A_BODKY); lcd.print("t");
  373.  
  374. delay(5000);
  375. rezim = SERVICE;
  376. pridanie_karty.prve_zobrazenie = true;
  377. break;
  378. } else {
  379. uids[first_empty] = pridat_uid;
  380. }
  381.  
  382. pridat_uid = "";
  383. updateEEPROM();
  384.  
  385. lcd.setCursor(0, 2);
  386. lcd.print("Karta pridan"); lcd.write(A_DLZEN);
  387. delay(5000);
  388. rezim = SERVICE;
  389. pridanie_karty.prve_zobrazenie = true;
  390. } else {
  391. /** Ak sa nachádza v pamäti odíď z menu */
  392. pridat_uid = "";
  393. lcd.setCursor(0, 2);
  394. lcd.print("U"); lcd.write(Z_MEKCEN); lcd.print(" nahrat"); lcd.write(E_DLZEN);
  395.  
  396. delay(5000);
  397. rezim = SERVICE;
  398. pridanie_karty.prve_zobrazenie = true;
  399. }
  400. }
  401.  
  402. break;
  403. }
  404. /** Režim vymazávania kariet */
  405. case VYMAZANIE_KARTY: {
  406. if (vymazanie_karty.prve_zobrazenie) {
  407. lcd.clear();
  408. lcd.print("Vymazavanie kariet:");
  409. vymazanie_karty.prve_zobrazenie = false;
  410. vymazanie_karty.potvrdenie_cas = millis();
  411. }
  412.  
  413. if (millis() - vymazanie_karty.potvrdenie_cas >= 500 && potvrdenie.stav) {
  414. rezim = SERVICE;
  415. vymazanie_karty.prve_zobrazenie = true;
  416. }
  417.  
  418. if (pridat_uid != "") {
  419. if (rfidInMemory(pridat_uid)) {
  420. static uint8_t i;
  421.  
  422. for (i = 0; i < UID_COUNT; i++) {
  423. if (pridat_uid == uids[i]) {
  424. do {
  425. uids[i] = uids[i + 1];
  426. i++;
  427. } while (i < (UID_COUNT - 1));
  428.  
  429. uids[UID_COUNT - 1] = "";
  430.  
  431. break;
  432. }
  433. }
  434.  
  435. updateEEPROM();
  436.  
  437. lcd.setCursor(0, 1);
  438. lcd.print(pridat_uid);
  439. lcd.setCursor(0, 2);
  440. lcd.print("Odstranen"); lcd.write(A_DLZEN);
  441.  
  442. delay(5000);
  443. rezim = SERVICE;
  444. vymazanie_karty.prve_zobrazenie = true;
  445. } else {
  446. pridat_uid = "";
  447. lcd.setCursor(0, 2);
  448. lcd.print("Nie je nahrat"); lcd.write(A_DLZEN);
  449.  
  450. delay(5000);
  451. rezim = SERVICE;
  452. vymazanie_karty.prve_zobrazenie = true;
  453. }
  454. }
  455.  
  456. break;
  457. }
  458. /** Pridanie odtlačku */
  459. case PRIDANIE_ODTLACOK: {
  460. if (pridanie_odtlacok.prve_zobrazenie) {
  461. lcd.clear();
  462. lcd.print("Pridanie odtla"); lcd.write(C_MEKCEN); lcd.print("ku:");
  463. lcd.setCursor(0, 1);
  464. lcd.print("Prilo"); lcd.write(Z_MEKCEN); lcd.print("te prst");
  465. pridanie_odtlacok.prve_zobrazenie = false;
  466. pridanie_odtlacok_stav = PRILOZENIE;
  467. pridanie_odtlacok.potvrdenie_cas = millis();
  468. }
  469.  
  470. if (pridanie_odtlacok_stav == HOTOVO) {
  471. rezim = SERVICE;
  472. pridanie_odtlacok.prve_zobrazenie = true;
  473. }
  474.  
  475. if (millis() - pridanie_odtlacok.potvrdenie_cas >= 500 && potvrdenie.stav) {
  476. rezim = SERVICE;
  477. pridanie_odtlacok.prve_zobrazenie = true;
  478. }
  479.  
  480. switch (pridanie_odtlacok_stav) {
  481. case PRILOZENIE: {
  482. if (finger.getImage() == FINGERPRINT_OK) {
  483. lcd.setCursor(0, 1);
  484. lcd.print("Konvertovanie...");
  485. _delay_ms(500);
  486. pridanie_odtlacok_stav = KONVERTOVANIE;
  487. }
  488.  
  489. break;
  490. }
  491. case KONVERTOVANIE: {
  492. if (finger.image2Tz(1) == FINGERPRINT_OK) {
  493. lcd.setCursor(0, 1);
  494. lcd.print("Ukladanie... ");
  495. _delay_ms(500);
  496. pridanie_odtlacok_stav = UKLADANIE;
  497. } else {
  498. lcd.setCursor(0, 1);
  499. lcd.print("Neuspesne... ");
  500. _delay_ms(1000);
  501. pridanie_odtlacok_stav = HOTOVO;
  502. }
  503.  
  504. break;
  505. }
  506. case UKLADANIE: {
  507. if (finger.storeModel(volne_miesto) == FINGERPRINT_OK) {
  508. lcd.setCursor(0, 1);
  509. lcd.print("Ulo"); lcd.write(Z_MEKCEN); lcd.print("ene... ID: "); lcd.print(volne_miesto);
  510. _delay_ms(1000);
  511. storeId(volne_miesto, true); //uloží miesto
  512. volne_miesto = getClosestEmptyId(); //nájde nové voľné miesto
  513. pridanie_odtlacok_stav = HOTOVO;
  514. } else {
  515. lcd.setCursor(0, 1);
  516. lcd.print("Neuspesne... ");
  517. _delay_ms(1000);
  518. pridanie_odtlacok_stav = HOTOVO;
  519. }
  520. }
  521. }
  522.  
  523. break;
  524. }
  525. /** Vymazanie odtlačku */
  526. case VYMAZANIE_ODTLACOK: {
  527. if (vymazanie_odtlacok.prve_zobrazenie) {
  528. lcd.clear();
  529. lcd.print("Vymazanie odtla"); lcd.write(C_MEKCEN); lcd.print("ku:");
  530. vymazanie_odtlacok.kurzor = 0;
  531. vymazanie_odtlacok.prve_zobrazenie = false;
  532. vymazanie_odtlacok.potvrdenie_cas = millis();
  533. }
  534.  
  535. /** fixme: meh */
  536. if (prepinanie.stav) {
  537. do {
  538. vymazanie_odtlacok.kurzor = ++vymazanie_odtlacok.kurzor % 127;
  539. } while (!readId(vymazanie_odtlacok.kurzor) || vymazanie_odtlacok.kurzor != 0);
  540. }
  541.  
  542. if (millis() - vymazanie_odtlacok.potvrdenie_cas > 500 && potvrdenie.stav) {
  543. if (vymazanie_odtlacok.kurzor != 0) {
  544. lcd.print("Vymazané ID: ");
  545. lcd.print(vymazanie_odtlacok.kurzor);
  546. } else {
  547. rezim = SERVICE;
  548. vymazanie_odtlacok.prve_zobrazenie = true;
  549. }
  550. }
  551.  
  552. if (millis() - vymazanie_odtlacok.kurzor_cas >= 500) {
  553. lcd.setCursor(0, 1);
  554. lcd.print(vymazanie_odtlacok.kurzor);
  555. lcd.print(" ");
  556.  
  557. vymazanie_odtlacok.kurzor_cas = millis();
  558. }
  559.  
  560. break;
  561. }
  562. /** Primárny režim */
  563. case NORMAL: {
  564. /** Otváranie dverí */
  565. if (dvere.zamok && (millis() >= (dvere.cas_zopnutia + 500)) || dvere.otvaranie) {
  566. dvere.otvaranie = true;
  567.  
  568. if (dvere.poloha == dvere.poloha_otvorene) {
  569. dvere.otvaranie = false;
  570. } else if (millis() >= dvere.cas_serva + 5) {
  571. dvere.servo.write(--dvere.poloha);
  572.  
  573. dvere.cas_serva = millis();
  574. }
  575. }
  576.  
  577. /** Zatvorenie dverí */
  578. if (dvere.zamok && millis() >= (dvere.cas_zopnutia + 3000) && !dvere.otvaranie) {
  579. dvere.zamok = false;
  580. digitalWrite(ZAMOK, LOW);
  581.  
  582. noTone(BUZZER);
  583.  
  584. dvere.servo.write(90);
  585. dvere.poloha = 90;
  586.  
  587. clearScreen();
  588. _delay_ms(200);
  589. dvere.servo.detach();
  590. }
  591.  
  592. /** Odomknutie pomocou odtlačku */
  593. if (!dvere.zamok && fingerprintCheck() != -1) {
  594. otvor();
  595. }
  596.  
  597. break;
  598. }
  599. }
  600. }
  601.  
  602. /** Otvorí dvere */
  603. void otvor() {
  604. dvere.servo.attach(SERVO);
  605. dvere.zamok = true;
  606. digitalWrite(ZAMOK, HIGH);
  607. lcd.setCursor(0, 0);
  608. lcd.print(medzera);
  609. lcd.setCursor(0, 1);
  610. lcd.print(medzera);
  611. lcd.setCursor(3, 2);
  612. lcd.print("Dvere otvoren"); lcd.write(E_DLZEN);
  613. tone(BUZZER, 500);
  614. dvere.cas_zopnutia = millis();
  615. }
  616.  
  617. /** Vyčistí a nastavý základnú obrazovku primárneho režimu (NORMAL) */
  618. void clearScreen() {
  619. lcd.clear();
  620. lcd.setCursor(4, 0);
  621. lcd.print("Prilo"); lcd.write(Z_MEKCEN); lcd.print(" prst");
  622. lcd.setCursor(7, 1);
  623. lcd.print("alebo");
  624. lcd.setCursor(7, 2);
  625. lcd.print("kartu");
  626. }
  627.  
  628. /** Skontroľuje validáciu RFID */
  629. int8_t rfidCheck() {
  630. if (uid != "") {
  631. if (rezim == NORMAL && potvrdenie.stav && uid == uids[0]) {
  632. rezim = SERVICE;
  633. } else if (rezim == NORMAL) {
  634. if (rfidInMemory(uid)) {
  635. otvor();
  636. }
  637. } else if (rezim == PRIDANIE_KARTY || rezim == VYMAZANIE_KARTY) {
  638. pridat_uid = uid;
  639. }
  640.  
  641. uid = "";
  642. }
  643. }
  644.  
  645. /** Kontroluje či sa nachádza UID v pamäti */
  646. bool rfidInMemory(String uid) {
  647. for (uint8_t i = 0; i < UID_COUNT; i++) {
  648. if (uid == uids[i]) {
  649. return true;
  650. } else if (uids[i][0] == '\0') {
  651. return false;
  652. }
  653. }
  654.  
  655. return false;
  656. }
  657.  
  658. /** Zapisovanie UID do EEPROM */
  659. void updateEEPROM() {
  660. static uint8_t i, j;
  661. for (i = 0; i < UID_COUNT; i++) {
  662. const char* s = uids[i].c_str();
  663.  
  664. if (s[0] == '\0') break;
  665.  
  666. for (j = 0; s[j] != '\0'; j++) {
  667. EEPROM.update(9 * i + j, s[j]);
  668. }
  669.  
  670. EEPROM.update(9 * i + j + 1, '\0');
  671. }
  672. }
  673.  
  674. /** Skontroľuje validitu fingerprintu */
  675. int8_t fingerprintCheck() {
  676. uint8_t p = finger.getImage(); //Skenovanie
  677. if (p != FINGERPRINT_OK) return -1;
  678.  
  679. p = finger.image2Tz(); //Konvertovanie
  680. if (p != FINGERPRINT_OK) return -1;
  681.  
  682. p = finger.fingerFastSearch(); //Porovnavanie s pamäťou v module DY-50
  683. if (p != FINGERPRINT_OK) return -1;
  684.  
  685. return finger.fingerID;
  686. }
  687.  
  688. /** Nájde najbližšie voľné miesto v pamäti fingerprint senzora */
  689. uint8_t getClosestEmptyId() {
  690. for (int i = 0; i < 16; i++) {
  691. for (int j = 0; j < 8; j++) {
  692. uint8_t power = (uint8_t)(0.5 + pow(2, j));
  693.  
  694. if ((fingerprint_miesta[i] & power) == 0 && !(i == 0 && j == 0)) {
  695. return 8 * i + j;
  696. }
  697. }
  698. }
  699.  
  700. return -1;
  701. }
  702.  
  703. /** Uloží ID do EEPROM, 0 je neobsadená */
  704. void storeId(uint8_t id, bool type) {
  705. int byteNumber = id / 8;
  706. int bytePosition = id % 8;
  707.  
  708. if (type) {
  709. fingerprint_miesta[byteNumber] |= 1 << bytePosition;
  710. } else {
  711. fingerprint_miesta[byteNumber] &= 0 << bytePosition;
  712. }
  713.  
  714. EEPROM.update(100 + byteNumber, fingerprint_miesta[byteNumber]);
  715. }
  716.  
  717. /** Nájde stav konkrétneho ID */
  718. bool readId(uint8_t id) {
  719. uint8_t power = (uint8_t)(0.5 + pow(2, id % 8));
  720. return fingerprint_miesta[id / 8] & power != 0;
  721. }
  722.  
  723. /** Prečíta EEPROM kde sa nachádzajú ID odtlačkov */
  724. void readId() {
  725. for (int i = 0; i < 16; i++) {
  726. fingerprint_miesta[i] = EEPROM.read(100 + i);
  727. }
  728. }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!