176.png

LoRa jest bezprzewodowym protokołem przesyłania danych o fascynujących właściwościach: zasięg może sięgać kilometrów, a pobór prądu jest tak mały, że nawet niewielka litowa bateria wystarcza na lata. Nic za darmo, szybkość pracy jest marna i w praktyce wystarcza typowym zastosowaniem IoT ograniczonym do sterowań. Innymi słowy, obrazu tym nie prześlemy, ale już polecenia na przykład otwarcia drzwi garażowych – jak najbardziej.<a target="_blank" rel="noopener noreferrer nofollow" href="https://projecthub.arduino.cc/devansh_tangri/lora-powered-garage-door-model-using-esp32-and-rylr988-72af3d?utm_source=segment&amp;utm_medium=email&amp;utm_campaign=weekly-newsletter">W opracowaniu</a> użyto modułów RYLR998, które mogą pracować na dystansie od kilometra nawet do piętnastu przy szybkości maksymalnej 115 kb. Nadają się świetnie do zastosowań w środowisku, w którym brakuje dostępności WiFi, BT ma zbyt słaby zasięg, a podczerwień jest niepraktyczna. Projekt ma charakter użyteczno-edukacyjny, a samo programowe wdrożenie sterowania protokołem jest wyjątkowo proste dzięki użyciu bibliotek. Elementy związane z LoRa za jakiś czas znajdą w serii artykułów poświęconych zagadnieniu.

LoRa jest bezprzewodowym protokołem przesyłania danych o fascynujących właściwościach: zasięg może sięgać kilometrów, a pobór prądu jest tak mały, że nawet niewielka litowa bateria wystarcza na lata. Nic za darmo, szybkość pracy jest marna i w praktyce wystarcza typowym zastosowaniem IoT ograniczonym do sterowań. Innymi słowy, obrazu tym nie prześlemy, ale już polecenia na przykład otwarcia drzwi garażowych – jak najbardziej.

Sterowanie bramą za pomocą protokołu LoRa

31.png

Czas na wersję finałową zamka szyfrowego, która będzie już w pełni funkcjonalna. Ta wersja jednak także będzie się nieco różnić od spotykanych seryjnie rozwiązań, konkretnie – innym podejściem do zapisywania hasła użytkownika. Wykorzystam w tym celu osobny pin, którego zwarcie – w moim przypadku do stanu wysokiego – wymusi natychmiastową zmianę hasła. Przełącznik ten należy ukryć przed dostępem z zewnątrz. Oczywiście zmianę hasła można zrealizować inaczej, na przykład hasłem nadrzędnym albo którymś z przycisków – choćby krzyżykiem, podczas otwarcia zamka. Ja wybrałem taki sposób, wydaje mi się wygodny i funkcjonalny.Ponieważ sensowny zamek musi być odporny na resety, hasło należy przechowywać w pamięci nieulotnej. Jak wiadomo, Arduino ma taką na pokładzie i do jej obsługi potrzebna jest biblioteka. Dołączymy ją więc na początku.<pre class="jodit-code"><code class="language-cpp">#include &lt;Wire.h&gt; // Biblioteka obsługująca magistralę I2C
#include &lt;hd44780.h&gt; // Biblioteka obsługująca wyświetlacze 44780
#include &lt;hd44780ioClass/hd44780_I2Cexp.h&gt; // Dodatek obsługujący wyświetlacze podłączone do ekspandera I2C
hd44780_I2Cexp lcd(0x20, I2Cexp_MCP23008, 7, 6, 5, 4, 3, 2, 1, HIGH); // Konfiguracja połączeń wyświetlacza LCD
#include &lt;EEPROM.h&gt; // Biblioteka obsługująca pamięć EEPROM.

#include &lt;Keypad.h&gt; // Biblioteka obsługująca klawiaturę.
const byte rowsKeypad = 4; // Liczba wierszy matrycy klawiatury.
const byte colsKeypad = 4; // Liczba kolumn matrycy klawiatury.
const byte rowPins[rowsKeypad] = { 7, 6, 5, 4 }; // Adresy kolejnych wierszy klawiatury.
const byte colPins[colsKeypad] = { 3, 2, 1, 0 }; // Adresy kolejnych kolumn klawiatury.
const char keys[rowsKeypad][colsKeypad] = { // Tablica znaków dla kolejnych klawiszy.
 { '1', '2', '3', 'A' },
 { '4', '5', '6', 'B' },
 { '7', '8', '9', 'C' },
 { '*', '0', '#', 'D' }
};
Keypad keypad = Keypad(makeKeymap(keys), rowPins, colPins, rowsKeypad, colsKeypad); // Definiuj klawiaturę zgodnie z powyższymi deklaracjami.
const byte buzzer = 9; // Port sterujący buzzerem.
const byte lock = 13; // Port sterujący elektromagnesem zamka.
const byte changePassword = 8; // Port umożliwiający zmianę hasła.
char enteredPassword[5]; // Hasło wprowadzane.
byte keyCount = 0; // Licznik znaków hasła.
const int eepromAddr = 0; // Adres w pamięci EEPROM, w którym przechowuje się hasło.
char password[5]; // Hasło wczytywane do pamięci RAM z pamięci EEPROM

void setup() {
 lcd.begin(16, 2); // Inicjuj wyświetlacz.
 pinMode(buzzer, OUTPUT); // Inicjuj port sterujący buzzerem.
 pinMode(lock, OUTPUT); // Inicjuj port sterujący elektromagnesem zamka.
 pinMode(changePassword, INPUT_PULLUP); // Inicjuj port umożliwiający zmianę hasła.
 EEPROM.get(eepromAddr, password); // Wczytaj hasło do pamięci RAM z pamięci EEPROM
 lcdText(F("HASLO: ")); // Wyczyść wyświetlacz i wyślij napis.
}
void loop() {
 if (digitalRead(changePassword) == HIGH) { // Jeśli wciśnięto przycisk zmiany hasła...
 changePasswordMode(); // Przejdź do programu obsługi zmiany hasła.
 return; // Po powrocie pomiń resztę pętli loop.
 }
 char key = keypad.getKey(); // Pozyskaj znak klawiatury.
 if (key) { // Jeśli się pojawił...
 enteredPassword[keyCount] = key; // Zapisz znak w tablicy.
 keyCount++; // Zwiększ licznik wpisanych znaków.
 lcd.print('*'); // Wyślij na wyświetlacz gwiazdkę.
 beep(1); // Pikaj - krótko.
 if (keyCount == 4) { // Jeśli wprowadzono wszystkie cztery znaki...
 enteredPassword[4] = '\0'; // Zamknij ich ciąg.
 if (strcmp(enteredPassword, password) == 0) { // Jeśli hasło wprowadzone jest takie samo jak w pamięci EEPROM...
 lcdText(F("OTWARTE")); // Wyczyść wyświetlacz i wyślij napis.
 digitalWrite(lock, HIGH); // Włącz zasilanie elektromagnesu zamka.
 beep(100); // Pikaj - dłużej.
 delay(1000); // Czas zasilania elektromagnesu zamka.
 digitalWrite(lock, LOW); // Wyłącz zasilanie elektromagnesu zamka.
 } else { // Jeśli hasło było błędne...
 lcdText(F("BLEDNE HASLO")); // Wyczyść wyświetlacz i wyślij napis.
 beep(500); // Pikaj - długo.
 }
 keyCount = 0; // Wyzeruj licznik znaków hasła.
 lcdText(F("HASLO: ")); // Wyczyść wyświetlacz i wyślij napis.
 }
 }
}
void changePasswordMode() { // Program obsługi zmiany hasła.
 beep(100); // Pikaj - dłużej.
 lcdText(F("NOWE HASLO: ")); // Wyczyść wyświetlacz i wyślij napis.
 char newPassword[5]; // Nowe hasło.
 byte newKeyCount = 0; // Licznik znaków nowego hasła.
 while (newKeyCount &lt; 4) { // Powtarzaj aż zostaną wprowadzone wszystkie cztery znaki.
 char key = keypad.getKey(); // Pozyskaj znak klawiatury.
 if (key) { // Jeśli się pojawił...
 newPassword[newKeyCount] = key; // Zapisz znak w tablicy.
 newKeyCount++; // Zwiększ licznik wpisanych znaków.
 lcd.print(key); // Wyślij na wyświetlacz jawny znak.
 beep(1); // Pikaj - krótko.
 }
 }
 newPassword[4] = '\0'; // Jeśli wprowadzono wszystkie cztery znaki, zamknij ich ciąg.
 EEPROM.put(eepromAddr, newPassword); // Zapisz nowe hasło w pamięci EEPROM
 strcpy(password, newPassword); // Zaktualizuj hasło obowiązujące.
 lcdText(F("ZAPISANO")); // Wyczyść wyświetlacz i wyślij napis.
 beep(500); // Pikaj - długo.
 keyCount = 0; // Wyzeruj licznik znaków hasła.
 lcdText(F("HASLO: ")); // Wyczyść wyświetlacz i wyślij napis.
}
void beep(int time) { // Piknięcie: czas trwania.
 digitalWrite(buzzer, HIGH);
 delay(time);
 digitalWrite(buzzer, LOW);
 delay(100);
}
void lcdText(const __FlashStringHelper* text) {
 lcd.clear(); // Wyczyść wyświetlacz.
 lcd.print(text); // Wyślij napis na wyświetlacz.
}
</code></pre>Program będzie się różnił obecnością modułu umożliwiającego zapamiętanie nowego hasła. W deklaracja przybywa więc nowy port changePassword – tajnego przycisku oraz zmienne związane z obsługą hasła w pamięci EEPROM. W części wstępnej należy załadować hasło z tej pamięci do RAM-u. W przypadku pierwszego użycia kontrolera z tym kodem, będą tam jakieś śmieci, więc jedynym sensownym krokiem będzie zadeklarowanie nowego hasła, wciskając ów tajny przycisk.Jest on też analizowany potem, w głównej pętli, za każdym razem na jej początku. Jeśli zostanie aktywowany, program przejdzie do bloku obsługi deklaracji nowego hasła. Na wyświetlaczu pojawi się stosowny napis, po czym program będzie czekać na wprowadzenie czterech znaków. Wygląda to podobnie jak w poprzedniej wersji, ale tym razem znaki są wyświetlane jawnie zamiast gwiazdek. Dzięki temu będziemy mieli pewność co do wprowadzonego hasła. Także tutaj nie ma żadnego potwierdzania, hasło automatycznie zmienia się po wpisaniu czwartego znaku. W razie pomyłki wciskamy przycisk zmiany hasła ponownie i wpisujemy nowe hasło. Na końcu procedury hasło jest zapamiętywane w pamięci EEPROM oraz aktualizowane w RAM-ie.Reszta programu pracuje identycznie. Jak mówiłem, po resecie hasło jest zaczytywane, więc nie ma tutaj problemu z przerwami z zasilaniem. Oczywiście jeśli nie będzie prądu, zamek się nie otworzy i trzeba to uwzględnić, stosując alternatywne metody mechaniczne. Wyświetlacz w tym projekcie tak naprawdę nie jest konieczny, acz ułatwia orientację. Można także zastosować metodę ze zmienną liczbą piknięć, jak w jednym z przykładów wcześniejszych.Pozostała jeszcze jedna zmiana, tak zwana pułapka na dociekliwych, którzy – przy 65 tysiącach kombinacji – mieliby ochotę na przetestowanie ich hurtem. <pre class="jodit-code"><code class="language-cpp">#include &lt;Wire.h&gt; // Biblioteka obsługująca magistralę I2C
#include &lt;hd44780.h&gt; // Biblioteka obsługująca wyświetlacze 44780
#include &lt;hd44780ioClass/hd44780_I2Cexp.h&gt; // Dodatek obsługujący wyświetlacze podłączone do ekspandera I2C
hd44780_I2Cexp lcd(0x20, I2Cexp_MCP23008, 7, 6, 5, 4, 3, 2, 1, HIGH); // Konfiguracja połączeń wyświetlacza LCD
#include &lt;EEPROM.h&gt; // Biblioteka obsługująca pamięć EEPROM.

#include &lt;Keypad.h&gt; // Biblioteka obsługująca klawiaturę.
const byte rowsKeypad = 4; // Liczba wierszy matrycy klawiatury.
const byte colsKeypad = 4; // Liczba kolumn matrycy klawiatury.
const byte rowPins[rowsKeypad] = { 7, 6, 5, 4 }; // Adresy kolejnych wierszy klawiatury.
const byte colPins[colsKeypad] = { 3, 2, 1, 0 }; // Adresy kolejnych kolumn klawiatury.
const char keys[rowsKeypad][colsKeypad] = { // Tablica znaków dla kolejnych klawiszy.
 { '1', '2', '3', 'A' },
 { '4', '5', '6', 'B' },
 { '7', '8', '9', 'C' },
 { '*', '0', '#', 'D' }
};
Keypad keypad = Keypad(makeKeymap(keys), rowPins, colPins, rowsKeypad, colsKeypad); // Definiuj klawiaturę zgodnie z powyższymi deklaracjami.
const byte buzzer = 9; // Port sterujący buzzerem.
const byte lock = 13; // Port sterujący elektromagnesem zamka.
const byte changePassword = 8; // Port umożliwiający zmianę hasła.
char enteredPassword[5]; // Hasło wprowadzane.
byte keyCount = 0; // Licznik znaków hasła.
const int eepromAddr = 0; // Adres w pamięci EEPROM, w którym przechowuje się hasło.
char password[5]; // Hasło wczytywane do pamięci RAM z pamięci EEPROM
byte wrongAttempts = 0; // Licznik błędnie wpisanych haseł.

void setup() {
 lcd.begin(16, 2); // Inicjuj wyświetlacz.
 pinMode(buzzer, OUTPUT); // Inicjuj port sterujący buzzerem.
 pinMode(lock, OUTPUT); // Inicjuj port sterujący elektromagnesem zamka.
 pinMode(changePassword, INPUT_PULLUP); // Inicjuj port umożliwiający zmianę hasła.
 EEPROM.get(eepromAddr, password); // Wczytaj hasło do pamięci RAM z pamięci EEPROM
 lcdText(F("HASLO: ")); // Wyczyść wyświetlacz i wyślij napis.
}
void loop() {
 if (digitalRead(changePassword) == HIGH) { // Jeśli wciśnięto przycisk zmiany hasła...
 changePasswordMode(); // Przejdź do programu obsługi zmiany hasła.
 return; // Po powrocie pomiń resztę pętli loop.
 }
 char key = keypad.getKey(); // Pozyskaj znak klawiatury.
 if (key) { // Jeśli się pojawił...
 enteredPassword[keyCount] = key; // Zapisz znak w tablicy.
 keyCount++; // Zwiększ licznik wpisanych znaków.
 lcd.print('*'); // Wyślij na wyświetlacz gwiazdkę.
 beep(1); // Pikaj - krótko.
 if (keyCount == 4) { // Jeśli wprowadzono wszystkie cztery znaki...
 enteredPassword[4] = '\0'; // Zamknij ich ciąg.
 if (strcmp(enteredPassword, password) == 0) { // Jeśli hasło wprowadzone jest takie samo jak w pamięci EEPROM...
 lcdText(F("OTWARTE")); // Wyczyść wyświetlacz i wyślij napis.
 wrongAttempts = 0; // Zeruj licznik błędów po poprawnym wpisaniu hasła.
 digitalWrite(lock, HIGH); // Włącz zasilanie elektromagnesu zamka.
 beep(100); // Pikaj - dłużej.
 delay(1000); // Czas zasilania elektromagnesu zamka.
 digitalWrite(lock, LOW); // Wyłącz zasilanie elektromagnesu zamka.
 } else { // Jeśli hasło było błędne...
 wrongAttempts++; // Zwiększ licznik nieudanych prób wpisywania hasła.
 lcdText(F("BLEDNE HASLO")); // Wyczyść wyświetlacz i wyślij napis.
 beep(500); // Pikaj - długo.
 if (wrongAttempts &gt; 2) { // Sprawdź czy osiągnięto limit trzech błędnie wpisanych haseł.
 wrongPasswordMode(); // Przejdź do podprogramu blokady zamka.
 }
 }
 keyCount = 0; // Wyzeruj licznik znaków hasła.
 lcdText(F("HASLO: ")); // Wyczyść wyświetlacz i wyślij napis.
 }
 }
}
void wrongPasswordMode() { // Blokada zamka na minutę - po wpisaniu trzech błędnych haseł.
 wrongAttempts = 0; // Resetuj licznik nieudanych prób wpisywania hasła.
 keyCount = 0; // Wyzeruj licznik znaków hasła.
 lcdText(F("Czekaj")); // Wyczyść wyświetlacz i wyślij napis.
 for (byte x = 60; x &gt; 0; x--) { // Odliczanie od 60 do 1 sekundy.
 lcd.setCursor(7, 0); // Przesuń kursor.
 lcd.print(x); // Wyświetl licznik.
 lcd.print(F(" sekund ")); // Wyślij napis.
 beep(1); // Pikaj - krótko.
 delay(899); // Dopełnienie do pełnej sekundy.
 }
}
void changePasswordMode() { // Program obsługi zmiany hasła.
 beep(100); // Pikaj - dłużej.
 lcdText(F("NOWE HASLO: ")); // Wyczyść wyświetlacz i wyślij napis.
 char newPassword[5]; // Nowe hasło.
 byte newKeyCount = 0; // Licznik znaków nowego hasła.
 while (newKeyCount &lt; 4) { // Powtarzaj aż zostaną wprowadzone wszystkie cztery znaki.
 char key = keypad.getKey(); // Pozyskaj znak klawiatury.
 if (key) { // Jeśli się pojawił...
 newPassword[newKeyCount] = key; // Zapisz znak w tablicy.
 newKeyCount++; // Zwiększ licznik wpisanych znaków.
 lcd.print(key); // Wyślij na wyświetlacz jawny znak.
 beep(1); // Pikaj - krótko.
 }
 }
 newPassword[4] = '\0'; // Jeśli wprowadzono wszystkie cztery znaki, zamknij ich ciąg.
 EEPROM.put(eepromAddr, newPassword); // Zapisz nowe hasło w pamięci EEPROM
 strcpy(password, newPassword); // Zaktualizuj hasło obowiązujące.
 lcdText(F("ZAPISANO")); // Wyczyść wyświetlacz i wyślij napis.
 beep(500); // Pikaj - długo.
 keyCount = 0; // Wyzeruj licznik znaków hasła.
 lcdText(F("HASLO: ")); // Wyczyść wyświetlacz i wyślij napis.
}
void beep(int time) { // Piknięcie: czas trwania.
 digitalWrite(buzzer, HIGH);
 delay(time);
 digitalWrite(buzzer, LOW);
 delay(100);
}
void lcdText(const __FlashStringHelper* text) {
 lcd.clear(); // Wyczyść wyświetlacz.
 lcd.print(text); // Wyślij napis na wyświetlacz.
}
</code></pre>W tym celu w blok wpisywania hasła dołożymy zmienną liczącą pomyłki wrongAttempts. Gdy ich liczba dojdzie do trzech, na chwilę opuścimy główną pętlę, lądując w podprogramie „kary” wrongPasswordMode() Pozostaniemy tutaj przez minutę, ale żebyśmy tak bardzo nie cierpieli, na wyświetlaczu pojawi się odliczający w dół licznik sekund. Po kwarantannie znowu będziemy mieli trzy próby na wpisanie prawidłowego hasła. Wszystkie elementy: liczbę znaków, ich zbiór, liczbę prób i tak dalej, to wszystko możemy dopasować do własnych potrzeb. Arduino jest znakomitym środowiskiem dla takich urządzeń i tylko wyobraźnia nas tu ograniczy.

Czas na wersję finałową zamka szyfrowego, która będzie już w pełni funkcjonalna. Ta wersja jednak także będzie się nieco różnić od spotykanych seryjnie rozwiązań, konkretnie – innym podejściem do zapisywania hasła użytkownika. Wykorzystam w tym celu osobny pin, którego zwarcie – w moim przypadku do stanu wysokiego – wymusi natychmiastową zmianę hasła. Przełącznik ten należy ukryć przed dostępem z zewnątrz

[170] Budujemy zamek szyfrowy cz. 2

21.png

Po długim wstępie związanym z obsługą klawiatury matrycowej przechodzimy do sedna, czyli właściwego zamka szyfrowego. I znowu zaczniemy od rozwiązania najprostszego, użytecznego jednak w pełni. Napiszemy pierwszą wersję zamka, która będzie pozbawiona możliwości zmiany kodu bez przeprogramowania kontrolera. Oznacza to, że jeśli będziemy chcieli zmienić szyfr, będzie potrzebny notebook i gniazdko USB – w praktyce ukryte albo znajdujące się wewnątrz chronionego pomieszczenia czy sejfu. Nie nadaje się więc to rozwiązanie dla zastosowań komercyjnych, gdy klucz jest przyznawany czasowo różnym osobom, ale jeśli będziemy chcieli tak chronić naszą tylko przestrzeń – wystarczy.<pre class="jodit-code"><code class="language-cpp">#include &lt;Keypad.h&gt; // Biblioteka obsługująca klawiaturę.
const byte rowsKeypad = 4; // Liczba wierszy matrycy klawiatury.
const byte colsKeypad = 4; // Liczba kolumn matrycy klawiatury.
const byte rowPins[rowsKeypad] = { 7, 6, 5, 4 }; // Adresy kolejnych wierszy klawiatury.
const byte colPins[colsKeypad] = { 3, 2, 1, 0 }; // Adresy kolejnych kolumn klawiatury.
const char keys[rowsKeypad][colsKeypad] = { // Tablica znaków dla kolejnych klawiszy.
 { '1', '2', '3', 'A' },
 { '4', '5', '6', 'B' },
 { '7', '8', '9', 'C' },
 { '*', '0', '#', 'D' }
};
Keypad keypad = Keypad(makeKeymap(keys), rowPins, colPins, rowsKeypad, colsKeypad); // Definiuj klawiaturę zgodnie z powyższymi deklaracjami.
const byte buzzer = 9; // Port sterujący buzzerem.
const byte lock = 13; // Port sterujący elektromagnesem zamka.
const char password[5] = "1234"; // Hasło, które należy wprowadzić.
char enteredPassword[5]; // Hasło wprowadzane.
byte keyCount = 0; // Licznik znaków hasła.

void setup() {
 pinMode(buzzer, OUTPUT); // Inicjuj port sterujący buzzerem.
 pinMode(lock, OUTPUT); // Inicjuj port sterujący elektromagnesem zamka.
}
void loop() {
 char key = keypad.getKey(); // Pozyskaj znak klawiatury.
 if (key) { // Jeśli się pojawił...
 enteredPassword[keyCount] = key; // Zapisz znak w tablicy.
 keyCount++; // Zwiększ licznik wpisanych znaków.
 beep(1); // Pikaj - krótko.
 if (keyCount == 4) { // Jeśli wprowadzono wszystkie cztery znaki...
 enteredPassword[4] = '\0'; // Zamknij ich ciąg.
 if (strcmp(enteredPassword, password) == 0) { // Jeśli hasło wprowadzone jest takie samo jak ustalone...
 digitalWrite(lock, HIGH); // Włącz zasilanie elektromagnesu zamka.
 beep(100); // Pikaj - dłużej.
 delay(1000); // Czas zasilania elektromagnesu zamka.
 digitalWrite(lock, LOW); // Wyłącz zasilanie elektromagnesu zamka.
 } else { // Jeśli hasło było błędne...
 beep(500); // Pikaj - długo.
 }
 keyCount = 0; // Wyzeruj licznik znaków hasła.
 }
 }
}
void beep(int time) { // Piknięcie: czas trwania.
 digitalWrite(buzzer, HIGH);
 delay(time);
 digitalWrite(buzzer, LOW);
 delay(100);
}
</code></pre>W tej wersji wyświetlacz jest zbędny, więc pozbyłem się wszelkich wpisów, które go dotyczą. Podobnie jak poprzednio, będziemy używać biblioteki obsługi klawiatury, ale ograniczymy się do najprostszych działań: czytania wciskanych klawiszy. Tak więc wstępne deklaracje są nam już znane, a kto chciałby to zgłębić – zapraszam do poprzedniego artykułu. Zadeklarujemy sobie też port piszczka buzzer – ja sobie wykorzystam buzzer znajdujący się na <a href="https://arduino.pl/tme-educational-board">płytce edukacyjnej TME</a> oraz nowość – port elektromagnesu zamka lock. Różnego rodzaju zamki i rygle wymagają najczęściej podania jakiegoś napięcia i szczegóły te związane są z konkretnym przypadkiem. Z naszego punktu widzenia najlepiej użyć przekaźnika, ponieważ zapewnia izolację od części wykonawczej i rozwiązuje wszelkie problemy z napięciami. Sam przekaźnik wymaga prądu większego niż wydajność pinów kontrolera, w praktyce wystarczy wzmacniający tranzystor. O przekaźnikach pisałem kiedyś tutaj. Dla nas istotne jest to, że pin, który wybrałem do tych celów – trzynasty – ma jednocześnie reprezentanta w postaci diody świecącej, więc na czas testów będziemy po prostu widzieć owo działanie przekaźnika, nawet jeśli nie zostanie jeszcze podłączony fizycznie.<pre class="jodit-code"><code class="language-cpp">const byte buzzer = 9; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp;// Port sterujący buzzerem.
const byte lock = 13; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; // Port sterujący elektromagnesem zamka.
const char password[5] = "1234"; &nbsp;// Hasło, które należy wprowadzić.
char enteredPassword[5]; // Hasło wprowadzane.</code></pre>Tak więc tutaj mamy deklarację portu przekaźnika i diody jednocześnie. Poniżej – wstawiamy hasło. Jak widać, trudne nie jest, ale oczywiście każdy może sobie wstawić własne. Dla celów szkoleniowych ma cztery pozycje, lecz nie ma tu żadnych ograniczeń. Należy także powołać tablicę enteredPassword na hasło wpisywane przez uprawnionych – bądź nie – do otwarcia zamka. Oboe mają o jedną pozycję więcej od długości hasła, bo do porównań będzie potrzebna konstrukcja, która wymaga by łańcuchy miały na końcu bajt zerowy. Tak więc dla czterech znaków długość tablicy musi mieć pięć bajtów. Do kompletu będzie potrzebna zmienna numeru wpisywanego znaku hasła keyCount. <pre class="jodit-code"><code class="language-cpp">void loop() {
 char key = keypad.getKey(); // Pozyskaj znak klawiatury.
 if (key) { // Jeśli się pojawił...
 enteredPassword[keyCount] = key; // Zapisz znak w tablicy.
 keyCount++; // Zwiększ licznik wpisanych znaków.
 beep(1); // Pikaj - krótko.
 if (keyCount == 4) { // Jeśli wprowadzono wszystkie cztery znaki...
 enteredPassword[4] = '\0'; // Zamknij ich ciąg.
 if (strcmp(enteredPassword, password) == 0) { // Jeśli hasło wprowadzone jest takie samo jak ustalone...
 digitalWrite(lock, HIGH); // Włącz zasilanie elektromagnesu zamka.
 beep(100); // Pikaj - dłużej.
 delay(1000); // Czas zasilania elektromagnesu zamka.
 digitalWrite(lock, LOW); // Wyłącz zasilanie elektromagnesu zamka.
 } else { // Jeśli hasło było błędne...
 beep(500); // Pikaj - długo.
 }
 keyCount = 0; // Wyzeruj licznik znaków hasła.
 }
 }
}</code></pre>W głównej pętli najpierw pozyskamy kod wciśniętego przycisku, zapisując go w tablicy pod adresem wyznaczonym owym numerem kolejnego znaku. Zaraz potem trzeba numer zwiększyć i piknąć – co potwierdza działanie klawiatury, zwłaszcza w warunkach braku wyświetlacza. Teraz należy sprawdzić, czy to aby nie jest już czwarta pozycja hasła. Jeśli tak jest – dopiszemy owo wspomniane zero i tak zamknięty string możemy porównać z oryginałem. Użyjemy do tego funkcji strcmp, która porównuje ze sobą dwa łańcuchy i zwraca trzy wartości: zero – jeśli są równe lub wartości liczbowe, zależne od tego, który łańcuch od którego jest mniejszy w sensie kodów ASCII. Nas będzie interesować tylko przypadek, gdy oba łańcuchy będą takie same. Funkcja wymaga wspomnianego zera na końcu wyrażeń, stąd wcześniejsza instrukcja.Jeśli w wyniku dostaniemy zero – znaczy że łańcuchy są identyczne, czyli hasło zostało wpisane poprawnie. Włączamy elektromagnes zamka, wysyłamy rozkaz piknięcia – dłuższego, czekamy sekundę i wyłączamy zamek. Jeśli hasło było błędne, wysyłamy rozkaz długiego piknięcia i to wszystko. Na koniec resetujemy licznik znaków i możemy zacząć wpisywać hasło od początku.Taki zamek będzie działać i choć jest prosty, to użyteczny. Zauważmy, że nie ma tutaj znanego rozkazu zatwierdzającego hasło – zwykle krzyżykiem. Zawsze uważałem to za zbędny dodatek, zmuszający do jeszcze jednego wciskania klawiaturki. Lepiej owo wciśnięcie wykorzystać do wprowadzenia kolejnego znaku hasła, przy tej samej ilości kliknięć dziesięciokrotnie wzrośnie nam bezpieczeństwo. Zróbmy pewną modyfikację, która nie ma znaczenia dla idei, ale uprzyjemnia działanie projektu. <pre class="jodit-code"><code class="language-cpp">#include &lt;Keypad.h&gt; // Biblioteka obsługująca klawiaturę.
const byte rowsKeypad = 4; // Liczba wierszy matrycy klawiatury.
const byte colsKeypad = 4; // Liczba kolumn matrycy klawiatury.
const byte rowPins[rowsKeypad] = { 7, 6, 5, 4 }; // Adresy kolejnych wierszy klawiatury.
const byte colPins[colsKeypad] = { 3, 2, 1, 0 }; // Adresy kolejnych kolumn klawiatury.
const char keys[rowsKeypad][colsKeypad] = { // Tablica znaków dla kolejnych klawiszy.
 { '1', '2', '3', 'A' },
 { '4', '5', '6', 'B' },
 { '7', '8', '9', 'C' },
 { '*', '0', '#', 'D' }
};
Keypad keypad = Keypad(makeKeymap(keys), rowPins, colPins, rowsKeypad, colsKeypad); // Definiuj klawiaturę zgodnie z powyższymi deklaracjami.
const byte buzzer = 9; // Port sterujący buzzerem.
const byte lock = 13; // Port sterujący elektromagnesem zamka.
const char password[5] = "1234"; // Hasło, które należy wprowadzić.
char enteredPassword[5]; // Hasło wprowadzane.
byte keyCount = 0; // Licznik znaków hasła.

void setup() {
 pinMode(buzzer, OUTPUT); // Inicjuj port sterujący buzzerem.
 pinMode(lock, OUTPUT); // Inicjuj port sterujący elektromagnesem zamka.
}
void loop() {
 char key = keypad.getKey(); // Pozyskaj znak klawiatury.
 if (key) { // Jeśli się pojawił...
 enteredPassword[keyCount] = key; // Zapisz znak w tablicy.
 keyCount++; // Zwiększ licznik wpisanych znaków.
 if (keyCount != 4) { beep(1, keyCount); } // Pikaj - krótko i w liczbie równej pozycji znaku.
 if (keyCount == 4) { // Jeśli wprowadzono wszystkie cztery znaki...
 enteredPassword[4] = '\0'; // Zamknij ich ciąg.
 if (strcmp(enteredPassword, password) == 0) { // Jeśli hasło wprowadzone jest takie samo jak ustalone...
 digitalWrite(lock, HIGH); // Włącz zasilanie elektromagnesu zamka.
 beep(10, 10); // Pikaj - krótko i dziesięć razy.
 digitalWrite(lock, LOW); // Wyłącz zasilanie elektromagnesu zamka.
 } else { // Jeśli hasło było błędne...
 beep(250, 1); // Pikaj - długo i raz.
 }
 keyCount = 0; // Wyzeruj licznik znaków hasła.
 }
 }
}
void beep(byte time, byte repeat) { // Piknięcie: długość, liczba piknięć.
 while (repeat &gt; 0) {
 digitalWrite(buzzer, HIGH);
 delay(time);
 digitalWrite(buzzer, LOW);
 delay(100);
 repeat--;
 }
}
</code></pre>Nasz podprogram pikający poszerzymy do dwóch elementów: czasu trwania piknięcia i liczby jego powtórzeń. Czas przerwy pomiędzy piknięciami ustaliłem na 100 ms. Zmiany obejmą owe pikania: przy wprowadzaniu pierwszej, drugiej i trzeciej cyfry usłyszymy takąż liczbę piknięć. Pozwoli nam się to zorientować, którą właśnie cyfrę wciskamy z kolei. Prawidłowe hasło będzie potwierdzane serią piknięć, a błędne – jednym, długim. Prawdę powiedziawszy, nie spotkałem się z takim rozwiązaniem, a szkoda, bo jest miłe.Zanim przystąpimy do projektu ostatecznego, z powrotem podłączymy wyświetlacz. U mnie jest on osadzony na magistrali I2C i o jego podłączeniu pisałem już nie raz. Osadzę więc elementy z nim związane i teraz oprócz piknięć będą się pojawiać<fragment id="jodit-selection_marker_1785156690100_08492785053880603" style="line-height: 0; display: none;" data-jodit-temp="true" data-jodit-selection_marker="start"></fragment> napisy. W tym celu zbuduję sobie podprogram. Problem w tym, że napisy – które dla oszczędności RAM-u siedzą w pamięci FLASH – można pozyskać jedynie taką skomplikowaną instrukcją: const __FlashStringHelper* text&nbsp;To jest ustalona klasa dla łańcuchów siedzących w tej pamięci, a gwiazdka w tym wypadku to adres początku łańcucha. <pre class="jodit-code"><code class="language-cpp">#include &lt;Wire.h&gt; // Biblioteka obsługująca magistralę I2C
#include &lt;hd44780.h&gt; // Biblioteka obsługująca wyświetlacze 44780
#include &lt;hd44780ioClass/hd44780_I2Cexp.h&gt; // Dodatek obsługujący wyświetlacze podłączone do ekspandera I2C
hd44780_I2Cexp lcd(0x20, I2Cexp_MCP23008, 7, 6, 5, 4, 3, 2, 1, HIGH); // Konfiguracja połączeń wyświetlacza LCD

#include &lt;Keypad.h&gt; // Biblioteka obsługująca klawiaturę.
const byte rowsKeypad = 4; // Liczba wierszy matrycy klawiatury.
const byte colsKeypad = 4; // Liczba kolumn matrycy klawiatury.
const byte rowPins[rowsKeypad] = { 7, 6, 5, 4 }; // Adresy kolejnych wierszy klawiatury.
const byte colPins[colsKeypad] = { 3, 2, 1, 0 }; // Adresy kolejnych kolumn klawiatury.
const char keys[rowsKeypad][colsKeypad] = { // Tablica znaków dla kolejnych klawiszy.
 { '1', '2', '3', 'A' },
 { '4', '5', '6', 'B' },
 { '7', '8', '9', 'C' },
 { '*', '0', '#', 'D' }
};
Keypad keypad = Keypad(makeKeymap(keys), rowPins, colPins, rowsKeypad, colsKeypad); // Definiuj klawiaturę zgodnie z powyższymi deklaracjami.
const byte buzzer = 9; // Port sterujący buzzerem.
const byte lock = 13; // Port sterujący elektromagnesem zamka.
const char password[5] = "1234"; // Hasło, które należy wprowadzić.
char enteredPassword[5]; // Hasło wprowadzane.
byte keyCount = 0; // Licznik znaków hasła.

void setup() {
 lcd.begin(16, 2); // Inicjuj wyświetlacz.
 pinMode(buzzer, OUTPUT); // Inicjuj port sterujący buzzerem.
 pinMode(lock, OUTPUT); // Inicjuj port sterujący elektromagnesem zamka.
 lcdText(F("HASLO: ")); // Wyczyść wyświetlacz i wyślij napis.
}
void loop() {
 char key = keypad.getKey(); // Pozyskaj znak klawiatury.
 if (key) { // Jeśli się pojawił...
 enteredPassword[keyCount] = key; // Zapisz znak w tablicy.
 keyCount++; // Zwiększ licznik wpisanych znaków.
 lcd.print('*'); // Wyślij na wyświetlacz gwiazdkę.
 beep(1); // Pikaj - krótko.
 if (keyCount == 4) { // Jeśli wprowadzono wszystkie cztery znaki...
 enteredPassword[4] = '\0'; // Zamknij ich ciąg.
 if (strcmp(enteredPassword, password) == 0) { // Jeśli hasło wprowadzone jest takie samo jak ustalone...
 lcdText(F("OTWARTE")); // Wyczyść wyświetlacz i wyślij napis.
 digitalWrite(lock, HIGH); // Włącz zasilanie elektromagnesu zamka.
 beep(100); // Pikaj - dłużej.
 delay(1000); // Czas zasilania elektromagnesu zamka.
 digitalWrite(lock, LOW); // Wyłącz zasilanie elektromagnesu zamka.
 } else { // Jeśli hasło było błędne...
 lcdText(F("BLEDNE HASLO")); // Wyczyść wyświetlacz i wyślij napis.
 beep(500); // Pikaj - długo.
 }
 keyCount = 0; // Wyzeruj licznik znaków hasła.
 lcdText(F("HASLO: ")); // Wyczyść wyświetlacz i wyślij napis.
 }
 }
}
void beep(int time) { // Piknięcie: czas trwania.
 digitalWrite(buzzer, HIGH);
 delay(time);
 digitalWrite(buzzer, LOW);
 delay(100);
}
void lcdText(const __FlashStringHelper* text) {
 lcd.clear(); // Wyczyść wyświetlacz.
 lcd.print(text); // Wyślij napis na wyświetlacz.
}
</code></pre>Teraz już w wybranych miejscach będziemy wysyłać na wyświetlacz napisy z prośbą o hasło, informujące o haśle źle wpisanym i otwarciu zamka. Do tego po wciśnięciu każdego znaku pojawi się gwiazdka. Program możemy przetestować, funkcjonalnie nie różni się niczym od wersji poprzedniej. <a href="https://arduino.pl/articles/170_budujemy_zamek_szyfrowy_cz_2">W kolejnym artykule</a> zbudujemy aplikację, która pozwala na zmianę hasła z poziomu klawiaturki.

<a href="https://arduino.pl/articles/168_klawiatura_matrycowa_dla_zaawansowanych_cz_2">Po długim wstępie</a> związanym z obsługą klawiatury matrycowej przechodzimy do sedna, czyli właściwego zamka szyfrowego. I znowu zaczniemy od rozwiązania najprostszego, użytecznego jednak w pełni. Napiszemy pierwszą wersję zamka, która będzie pozbawiona możliwości zmiany kodu bez przeprogramowania kontrolera. Oznacza to, że jeśli będziemy chcieli zmienić szyfr, będzie potrzebny notebook i gniazdko USB – w praktyce ukryte albo znajdujące się wewnątrz chronionego pomieszczenia czy sejfu. Nie nadaje się więc to rozwiązanie dla zastosowań komercyjnych, gdy klucz jest przyznawany czasowo różnym osobom, ale jeśli będziemy chcieli tak chronić naszą tylko przestrzeń – wystarczy

[169] Budujemy zamek szyfrowy cz. 1

173.png

Aparat fotograficzny to nie tylko przyjemność uwieczniania wycieczek czy urodzin, ale też narzędzie inspekcyjne. Zapewne każdy, kto wypożyczał samochód, zna procedurę: najlepiej zrobić serię zdjęć, by potem nie negocjować opłat za jakąś rysę, która była tam już wcześniej, ale na którą może nas naciągnąć nieuczciwy właściciel interesu. Kamerę inspekcyjną zbudowano <a target="_blank" rel="noopener noreferrer nofollow" href="https://github.com/avazqueznj/brick1">w tym projekcie</a> i jej głównym zadaniem jest robienie serii powtarzających się ujęć, ustalonej wcześniej według pewnego algorytmu, sortowanie owych zdjęć i wysyłanie do aplikacji, która zarządza flotą pojazdów.Teoretycznie da się tak ze smartfonem, lecz tutaj można zapanować nad wszystkim, łącznie z rozpoznawaniem właściwego kadru. To właśnie dla powtarzających się, nużących czynności wszelka automatyka przyspiesza pracę i niweluje pomyłki. System bazuje na Arduino GIGA R1 WiFi i grafice GIGA Display pracującej z kamerą ArduCam Mini oraz czytniku RFID.

Aparat fotograficzny to nie tylko przyjemność uwieczniania wycieczek czy urodzin, ale też narzędzie inspekcyjne. Zapewne każdy, kto wypożyczał samochód, zna procedurę: najlepiej zrobić serię zdjęć, by potem nie negocjować opłat za jakąś rysę, która była tam już wcześniej, ale na którą może nas naciągnąć nieuczciwy właściciel interesu. Kamerę inspekcyjną zbudowano <a target="_blank" rel="noopener noreferrer nofollow" href="https://github.com/avazqueznj/brick1">w tym projekcie</a> i jej głównym zadaniem jest robienie serii powtarzających się ujęć, ustalonej wcześniej według pewnego algorytmu, sortowanie owych zdjęć i wysyłanie do aplikacji, która zarządza flotą pojazdów.

Inteligentny aparat

174.png

Najogólniej, w świecie automatyki nierozległej, że tak powiem, panują dwie szkoły: jedna to centralizacja, czyli zwykle jeden układ sterujący peryferiami, najczęściej jedynie wykonawczymi. Dopóki projekt jest względnie spójny, jest to podejście wygodne i szybsze w realizacji pod względem sprzętowym. Drugi koncept polega na wieloprocesorowości, czyli tworzeniu inteligentnych peryferiów i delegowania do każdego bloku wraz z elementami wykonawczymi także kontrolera. Wówczas centralny sterownik, albo nawet ich sieć, porozumiewa się z takimi blokami w sposób optymalny, przede wszystkim niekrytyczny czasowo, co może mieć znaczenie tam, gdzie przestoje milisekundowe mogą doprowadzić do szkód.<a target="_blank" rel="noopener noreferrer nofollow" href="https://www.instructables.com/Zeno-the-Trash-Handling-Robot/">W tym projekcie</a> tak właśnie uczyniono, choć akurat nie jest to projekt krytyczny. Urządzenie do zbierania śmieci zawiera aż 11 płytek Arduino, ale potrafi rozpoznawać głos i widzi otoczenie. Dwie kamery rozpoznają odpady, kosze na śmieci i różne problemy na drodze, w tym – ludzi. Pięć czujników zbliżeniowych zaś pozwala omijać przeszkody. Robot może być przywołany, przejąć przedmiot do wyrzucenia i udać się z nim w miejsce przeznaczone dla odpadów. Oczywiście mamy tutaj koła, chwytak i to wszystko, co powinien mieć przyzwoity robot. Ze względu na koncepcję – wieloprocesorowość – warto przyjrzeć się projektowi.

Najogólniej, w świecie automatyki nierozległej, że tak powiem, panują dwie szkoły: jedna to centralizacja, czyli zwykle jeden układ sterujący peryferiami, najczęściej jedynie wykonawczymi. Dopóki projekt jest względnie spójny, jest to podejście wygodne i szybsze w realizacji pod względem sprzętowym. Drugi koncept polega na wieloprocesorowości, czyli tworzeniu inteligentnych peryferiów i delegowania do każdego bloku wraz z elementami wykonawczymi także kontrolera. Wówczas centralny sterownik, albo nawet ich sieć, porozumiewa się z takimi blokami w sposób optymalny, przede wszystkim niekrytyczny czasowo, co może mieć znaczenie tam, gdzie przestoje milisekundowe mogą doprowadzić do szkód.

Zespół kontrolerów w urządzeniu zbierającym śmieci

172.png

Arduinowy kurnik? A jednak jest to zupełnie poważny projekt, wykorzystujący nowinkę, czyli Arduino Q. Po co i do czego tak zaawansowana wersja płytki? Otóż tym razem nie mamy prostego układu wspomagającego hodowlę, a mocno już zaawansowany, wykorzystujący także elementy rozpoznawania obrazu i dźwięku. Implementacja owego kurnika obejmuje:<ul><li>Sterowanie drzwiami umożliwiającymi oddzielenie kur od świata zewnętrznego nocą i wypuszczenie ich na światło słoneczne w ciągu dnia.</li><li>System karmienia i dystrybucji pasz.</li><li>Monitorowanie otoczenia z wykrywaniem intruzów, w tym – drapieżników.</li><li>Wykrywanie dźwięków charakterystycznych dla drapieżników.</li><li>System kontroli i sterowania temperaturą.</li><li>Monitoring zdalny i integrację z IoT</li><li>Modułowość i zaprojektowanie systemu ze względu na niezawodność i łatwy, szybki serwis.</li></ul>Całość jest w pełni użytecznym systemem, zaprojektowanym pod względem użyteczności i bardzo dobrze opisanym. Zainteresowanych zapraszam <a target="_blank" rel="noopener noreferrer nofollow" href="https://projecthub.arduino.cc/shebinjosejacob/smart-coop-20-787f34?utm_source=segment&amp;utm_medium=email&amp;utm_campaign=weekly-newsletter">tutaj</a> i nie tylko właścicieli stadka kur, bo na podstawie tych rozwiązań można nauczyć się projektowania automatyki użytkowej jako takiej.

Arduinowy kurnik? A jednak jest to zupełnie poważny projekt, wykorzystujący nowinkę, czyli Arduino Q. Po co i do czego tak zaawansowana wersja płytki? Otóż tym razem nie mamy prostego układu wspomagającego hodowlę, a mocno już zaawansowany, wykorzystujący także elementy rozpoznawania obrazu i dźwięku. Implementacja owego kurnika obejmuje:

Kurnik z Arduino

Bez histerezy nie ma poprawnego mierzenia

00.png

Mając wiedzę z poprzedniego
artykułu, moglibyśmy już napisać właściwy szkic, jednak system
zastawił na nas pułapkę. Gdy akurat czujnik ustawi się w pozycji
pomiędzy, może dojść do niekontrolowanego przełączania
się odczytów i naliczą nam się litry, choć nic nie będzie
kapać. Brakuje tak zwanej histerezy. Można to zrobić
elektronicznie, ale od czego mamy Arduino?<pre class="jodit-code"><code class="language-cpp">const byte phototransistor = A0; // Port fototranzystora.
const byte led = 13; // Port diody stanu fototranzystora.
const int threshold = 303; // Środek między napięciem "ciemnym" i "jasnym", początkowo 512.
const int hysteresis = 50; // Histereza.
bool ledState = false; // Stan diody stanu fototranzystora.

void setup() {
 pinMode(led, OUTPUT);
 Serial.begin(115200);
}
void loop() {
 int voltage = analogRead(phototransistor); // Prześlij wartość napięcia fototranzystora do zmiennej.
 Serial.println(voltage); // Wyślij ją na monitor.
 if (voltage &lt; threshold - hysteresis) { // Jeśli napięcie spadło poniżej progu i histerezy...
 ledState = true; // Ustaw stan diody.
 } else if (voltage &gt; threshold + hysteresis) { // Jeśli napięcie wzrosło powyżej progu i histerezy...
 ledState = false; // Zeruj stan diody.
 }
 digitalWrite(led, ledState); // Prześlij stan diody do portu diody.
 delay(100);
}
</code></pre>Podłączymy się teraz na pin analogowy. Powołamy do życia port fototranzystora, który nie będzie badać stanu cyfrowego, a napięcie. Ten szkic będzie wymagać kalibracji, więc na początek próg przełączania ustawimy na środek – czyli na wartość 512. Utworzymy też współczynnik histerezy. Co to jest? To pewna wartość, tak dobrana, że przełączanie stanu diody nastąpi tylko jeśli napięcie będzie niższe od połowy minus ta wartość albo wyższe od połowy plus ta wartość. Innymi słowy, jeśli napięcie będzie sobie pływać na progu przełączania, czyli w okienku o podwójnej wartości histerezy, żadnej reakcji nie będzie.Skompilujmy tę wersję, na razie nie przejmując się jej działaniem. Ustawmy tarczę w najciemniejszej pozycji i sczytajmy wartości wyświetlane w polu monitora. Potem przesuńmy ją w pozycję najjaśniejszą i ponownie sczytajmy te wartości. U mnie wyszło mniej więcej 25 oraz 580. Nie musimy ich traktować tak dokładnie, tylko mniej więcej. Teraz rozwiążemy równianie: dodajemy obie wartości do siebie i wynik dzielimy przez dwa. Da nam to 303 i tę wartość należy wpisać do szkicu. Parametr „histereza” powinien przyjmować mniej więcej dziesięć procent zakresu pracy. Wstawiłem 50. Po kompilacji dioda powinna się przełączać już bez ryzyka mrugania w stanach pośrednich. Szczegóły działania algorytmu wyjaśniłem w komentarzach.I jeszcze jedna moja uwaga: środek przedziału możemy równie dobrze określić mierząc napięcia woltomierzem i przeliczając wynik na dziesięciobitową wartość – jak widać, wyszło praktycznie tyle samo. Skoro wszystko działa, zbudujmy licznik. W tym celu użyję wyświetlacza na <a href="https://arduino.pl/tme-educational-board">płytce edukacyjnej TME.</a> Ograniczę się do pierwszych ośmiu znaków, dzięki czemu można będzie użyć takich właśnie małych wyświetlaczy.<pre class="jodit-code"><code class="language-cpp">#include &lt;Wire.h&gt; // Biblioteka obsługująca magistralę I2C
#include &lt;hd44780.h&gt; // Biblioteka obsługująca wyświetlacze 44780
#include &lt;hd44780ioClass/hd44780_I2Cexp.h&gt; // Dodatek obsługujący wyświetlacze podłączone do ekspandera I2C
hd44780_I2Cexp lcd(0x20, I2Cexp_MCP23008, 7, 6, 5, 4, 3, 2, 1, HIGH); // Konfiguracja połączeń wyświetlacza LCD

const byte phototransistor = A0; // Port fototranzystora.
const byte led = 13; // Port diody stanu fototranzystora.
const int threshold = 303; // Środek między napięciem "ciemnym" i "jasnym", początkowo 512.
const int hysteresis = 50; // Histereza.
bool currDisc = false; // Obecny stan tarczy.
bool prevDisc = false; // Poprzedni stan tarczy.
unsigned long waterMeter = 999999; // Licznik wodomierza.
char text[8]; // Tablica dla reprezentanta znakowego licznika wodomierza.

void setup() {
 pinMode(led, OUTPUT);
 lcd.begin(16, 2);
 lcd.print("000000 &gt;"); // Wyślij grafikę startową.
}
void loop() {
 int voltage = analogRead(phototransistor); // Prześlij wartość napięcia fototranzystora do zmiennej.
 if (voltage &lt; threshold - hysteresis) { // Jeśli napięcie spadło poniżej progu i histerezy...
 currDisc = true; // Ustaw stan tarczy.
 } else if (voltage &gt; threshold + hysteresis) { // Jeśli napięcie wzrosło powyżej progu i histerezy...
 currDisc = false; // Zeruj stan tarczy.
 }
 if (!prevDisc &amp;&amp; currDisc) { // Jeśli stan tarczy zmienił się z niskiego na wysoki...
 waterMeter++; // Zwiększ wartość licznika wodomierza
 if (waterMeter &gt; 999999) { // Jeśli przekroczył wartość maksymalną...
 waterMeter = 0; // Zeruj go.
 }
 lcd.setCursor(0, 0); // Ustaw kursor na początku wyświetlacza.
 snprintf(text, sizeof(text), "%06lu", waterMeter); // Formatuj tekst licznika wodomierza.
 lcd.print(text); // Prześlij go na wyświetlacz.
 lcd.print(" &gt;"); // Wyświetl grafikę związaną z obrotem tarczy.
 } else if (prevDisc &amp;&amp; !currDisc) { // Jeśli stan tarczy zmienił się z wysokiego na niski...
 lcd.setCursor(6, 0); // Ustaw kursor.
 lcd.print(" &lt;"); // Wyświetl grafikę związaną z obrotem tarczy.
 }
 prevDisc = currDisc; // Załaduj obecny stan tarczy do zmiennej jej poprzedniego stanu.
 digitalWrite(led, currDisc); // Prześlij stan tarczy do portu diody.
}
</code></pre>Ponieważ ten mój jest podłączony przez ekspander I2C, trzeba użyć stosownych bibliotek. Wyświetlacz ten już wielokrotnie wystąpił w artykułach, więc ten etap omawiania programu pominę. Zmienimy nazwy niektórych zmiennych, bo teraz będą mieć inny sens. W części wstępnej wyświetlimy sześć zer oraz wskaźnik obrotu tarczy – odpowiednik diody świecącej z poprzedniego szkicu, której obsługę zresztą pozostawię. Użyłem znaków mniejszości i większości, będą one naprzemiennie ukazywać się na końcu wyświetlacza, tworząc taką prymitywną animację.Zaczynamy podobnie: mierzymy napięcie i ładujemy do binarnej zmiennej stan odczytany – z uwzględnieniem histerezy, co poznaliśmy już w poprzednim szkicu. W kolejnym warunku będziemy rozpoznawać chwile, gdy stan zmienił się z niskiego na wysoki lub odwrotnie. Jeśli zaszło pierwsze zdarzenie, zwiększamy licznik litrów – przypomnę: jeden obrót tarczy to jeden litr. Jeśli przeczymy wartość licznika, wyzerujemy go. Oprócz tego ustawimy kursor na początku wyświetlacza i za pomocą sprytnej instrukcji zamieniającej liczby na łańcuchy, sformatujemy stan licznika tak, by zawsze widać było sześć cyfr – z zerami nieznaczącymi. Na końcu wyświetlimy jeszcze pierwszą grafikę animacji.W przypadku odwrotnym, czyli zmiany stanu wysokiego na niski, nie będziemy liczyć litrów, a tylko zadbamy o wyświetlenie drugiej grafiki animacji. Po tym wszystkim jeszcze trzeba przepisać stan fototranzystora do pomocniczej zmiennej, przechowującej poprzedni jego stan i wysłać go na diodę świecącą.I to już wszystko. Mamy prosty licznik, dublujący ten na cyferblacie, ze wskaźnikiem aktywności przepływu. Tutaj należałoby zadbać o zasilanie buforowe, by nam się całość przypadkiem nie zresetowała. Stan licznika można też zapisywać w pamięci nieulotnej, na przykład co metr sześcienny. Mając komputerek, możemy wykrywać zbyt duży przepływ – zdarzający się gdy pęknie jakaś rura oraz zbyt długi przepływ – na wypadek jakiegoś wycieku o mniejszej mocy, ale trwającego zdecydowanie za długo. Można także dane eksportować w świat, radiowo czy jakkolwiek inaczej. Ale o tym napiszę innym razem.

Mając wiedzę <a href="https://arduino.pl/articles/165_odczyt_licznika_wody_cz_1">z poprzedniego artykułu,</a> moglibyśmy już napisać właściwy szkic, jednak system
zastawił na nas pułapkę. Gdy akurat czujnik ustawi się w pozycji
pomiędzy, może dojść do niekontrolowanego przełączania
się odczytów i naliczą nam się litry, choć nic nie będzie
kapać. Brakuje tak zwanej histerezy. Można to zrobić
elektronicznie, ale od czego mamy Arduino?

[166] Odczyt licznika wody cz. 2

171.png

Z pewnością wielu słyszało o autonomicznych odkurzaczach, a niejeden taki posiada. Podwaliny tej technologii stworzyła Roomba i często owe pełzające w rytm własnych zasad odkurzacze tak nazywamy, niezależnie od tego, kto je zaprojektował i wyprodukował. Na pewno jest to świetny przykład robotyki praktycznej i jedyny problem dla nas – konstruktorów – to tajemnica jego działania, czy raczej algorytmów, którymi się posługuje. Na świecie oczywiście łamie się te zasady, przejmując system jak również wykorzystuje się sam sprzęt, implementując własne systemy zarządzania i sterowania. Co by nie mówić, mamy tu kompletnego robota, przeznaczonego do długotrwałej pracy w ciężkich warunkach, bo od premiery pierwszych egzemplarzy minęło już sporo lat, a wiele z nich pracuje do dziś.Na stronie pewnego <a target="_blank" rel="noopener noreferrer nofollow" href="https://www.youtube.com/watch?v=yivvNzgzQ5c">projektu</a> wykorzystano podwozie takiego odkurzacza, tworząc od nowa całą resztę, już zgodną z zamysłem projektanta. Możemy się przyjrzeć jego działaniom, inspirując się podczas tworzenia własnych rozwiązań. W końcu jeżdżący, widzący i słyszący świat odkurzacz wcale nie musi nim być. Może na przykład podawać różne przedmioty, może dokonywać inspekcji całkiem rozległych terenów, może tyle ile może wyobraźnia człowieka. A ponieważ odkurzacze takie już wyeksploatowane czy uszkodzone są powszechnie dostępne za grosze, okazuje się, że powstał jeszcze jeden rynek taniej automatyki do zastosowań własnych.

Z pewnością wielu słyszało o autonomicznych odkurzaczach, a niejeden taki posiada. Podwaliny tej technologii stworzyła Roomba i często owe pełzające w rytm własnych zasad odkurzacze tak nazywamy, niezależnie od tego, kto je zaprojektował i wyprodukował. Na pewno jest to świetny przykład robotyki praktycznej i jedyny problem dla nas – konstruktorów – to tajemnica jego działania, czy raczej algorytmów, którymi się posługuje. Na świecie oczywiście łamie się te zasady, przejmując system jak również wykorzystuje się sam sprzęt, implementując własne systemy zarządzania i sterowania. Co by nie mówić, mamy tu kompletnego robota, przeznaczonego do długotrwałej pracy w ciężkich warunkach, bo od premiery pierwszych egzemplarzy minęło już sporo lat, a wiele z nich pracuje do dziś.

Robot z robota, czyli przerabiamy odkurzacz

170.png

Jednym ze znanych i często przytaczanych przykładów działań, z którymi radzi sobie Arduino trzydziestodwubitowe, a nie radzi ośmiobitowe, jest rozpoznawanie obrazu. Zwykle się o tym pisze, ale rzadko daje konkretne przykłady, a jeśli w ogóle, dotyczą one jakichś mało fascynujących elementów będących częścią dużych systemów produkcyjnych czy przemysłowych w ogóle.W projekcie BirdFeedR zaimplementowano ów mechanizm do detekcji ptaków i wiewiórek. Po co? Kto zajmuje się dokarmianiem jednych i drugich z pewnością zauważył, że o ile ptaki raczej zachowują umiar, wiewiórki potrafią z karmnika wynieść wszystko i zachomikować gdzieś w sobie tylko znanych miejscach (dlaczego nie zawiewiórkować? :) Projektant systemu dokarmiania w oparciu o Arduino Q zbudował karmnik, który wydaje ziarenka czy jakiekolwiek ptasie przysmaki wyłącznie ptakom, analizując obraz z kamery USB spiętej z platformą i to jedynie w oparciu o przykładowy szkic Detect Objects on Camera korzystający z biblioteki Video Object Detection Brick, która znowu jest częścią całego systemu FOMO (Faster Objects, More Objects) firmy Edge Impulse. Pokładowy kontroler otrzymuje informację od mikroprocesora i zajmuje się już typową arduinową resztą, a więc steruje serwomechanizmem. Oczywiście sam projekt ma charakter edukacyjny, ale nie do końca; dla miłośników przyrody może być całkiem użyteczny. Więcej o projekcie <a target="_blank" rel="noopener noreferrer nofollow" href="https://www.hackster.io/ishotjr/birdfeedr-the-bird-only-feeder-powered-by-arduino-uno-q-2c3259">tutaj.</a>

Jednym ze znanych i często przytaczanych przykładów działań, z którymi radzi sobie Arduino trzydziestodwubitowe, a nie radzi ośmiobitowe, jest rozpoznawanie obrazu. Zwykle się o tym pisze, ale rzadko daje konkretne przykłady, a jeśli w ogóle, dotyczą one jakichś mało fascynujących elementów będących częścią dużych systemów produkcyjnych czy przemysłowych w ogóle.

Rozpoznawanie obrazu na wesoło

Budujemy interfejs bez ingerencji w urządzenie

0.png

1.png

2.png

3.png

4.png

5.png

6.png

Od razu napiszę: to wszystko można kupić i to w najróżniejszych kombinacjach. Ale nasza seria to klasyczne: zrób to sam, bardzo dosłownie, bo staram się nie przedstawiać kompletnych projektów, a sposoby, by szczegóły każdy już dopracował sobie do własnych potrzeb. Tak więc rozważania w tym artykule będą dotyczyć ogólnie przeniesienia informacji o zużyciu wody – z wodomierza do świata elektroniki. A co będzie potem – to już niech każdy użyje własnej wyobraźni. Ja oczywiście przedstawię rozwiązanie startowe, ale po kolei.<img src="https://cdzpcayhaa.cloudimg.io/v7/_ard_/1-6a43e3cf07bac.png?force_format=webp&amp;ci_sign=92a9ac197f08a1a91945a5b4d86d9729ed2d91af" alt="1.png" style="max-width: 100%; height: auto; margin: 16px auto; width: 540px; display: block;">Liczniki zwykle składają się z dwóch części. W tak zwanej mokrej płynie woda, która wprawia w obroty turbinkę. Na jej szczycie jest zamocowany magnes, sprzężony z bliźniakiem w tak zwanej części suchej, izolowanej od mokrej, zawierającej redukcyjne koła zębate i dekadowy licznik analogowy.<fragment id="jodit-selection_marker_1782834617949_5324279213981229" style="line-height: 0; display: none;" data-jodit-temp="true" data-jodit-selection_marker="start"></fragment><img src="https://cdzpcayhaa.cloudimg.io/v7/_ard_/2-6a43e3cee642a.png?force_format=webp&amp;ci_sign=4d48783fc58a9d72d66e625bf6bc428bb3e22cf1" alt="2.png" style="max-width: 100%; height: auto; margin: 16px auto; width: 540px; display: block;"><fragment id="jodit-selection_marker_1782834617949_0919900993481767" style="line-height: 0; display: none;" data-jodit-temp="true" data-jodit-selection_marker="end"></fragment>Dla nas istotny będzie jeden element. Zanim o nim powiem, przypomnę że licznik jest, że tak powiem, dobrem urzędowym, któremu można się przyglądać, ale nijak nie wolno weń ingerować – oczywiście z wyjątkiem, kiedy już w obrębie własnej instalacji wstawimy sobie własny, prywatny licznik. Nie ma możliwości, byśmy rozkręcili wodomierz, którym rozliczamy się z dostawcą wody i podłączyli się gdzieś tam z takim czy innym czujnikiem zliczającym impulsy. Jedyna metoda na pozyskanie informacji z licznika to obserwacja z zewnątrz. Sprawa wydaje się beznadziejna, ale wcale tak nie jest.<fragment id="jodit-selection_marker_1782834626017_8818504759074705" style="line-height: 0; display: none;" data-jodit-temp="true" data-jodit-selection_marker="start"></fragment><img src="https://cdzpcayhaa.cloudimg.io/v7/_ard_/3-6a43e3ceed1be.png?force_format=webp&amp;ci_sign=b68dc9c0a0053e1fbd4a3949c6a9336fffc6ea4b" alt="3.png" style="max-width: 100%; height: auto; margin: 16px auto; width: 540px; display: block;"><fragment id="jodit-selection_marker_1782834626017_4569599391104021" style="line-height: 0; display: none;" data-jodit-temp="true" data-jodit-selection_marker="end"></fragment>Znakomita większość liczników mechanicznych oprócz cyferek posiada także widoczny wirujący element albo dwa. I tutaj jest problem. Licznik, który jest bohaterem dzisiejszego opracowania, ma takie elementy: śmigiełko i wskazówkę, jednak nie do końca w wersji, która będzie nam pasować. Pierwszy element, w czarnym kolorze, obraca się 42 razy na każdy litr, wskazówka (czerwona) wykonuje natomiast jeden pełen obrót. Nie są to najlepsze obiekty do rozpoznawania, ale teoretycznie – da się. Natomiast większość liczników posiada innego rodzaju wskaźnik litra: tarczę mniej więcej w połowie czarną, w drugiej – lustrzaną.<fragment id="jodit-selection_marker_1782834634477_5533488939206089" style="line-height: 0; display: none;" data-jodit-temp="true" data-jodit-selection_marker="start"></fragment><img src="https://cdzpcayhaa.cloudimg.io/v7/_ard_/4-6a43e3cf45661.png?force_format=webp&amp;ci_sign=a6cdcb21afecb90fe626d4cd309d87b7c8573c8d" alt="4.png" style="max-width: 100%; height: auto; margin: 16px auto; width: 540px; display: block;"><fragment id="jodit-selection_marker_1782834634477_08677323332108577" style="line-height: 0; display: none;" data-jodit-temp="true" data-jodit-selection_marker="end"></fragment>Dla naszych celów jest to zdecydowanie najlepsza opcja. Tarcza ta współpracuje z nakładką na obudowę licznika, która zawiera diodę podczerwieni i fototranzystor oraz elektronikę obrabiającą zliczane impulsy. Dzisiaj sami zrobimy sobie taką nakładkę, którą w pełni legalnie można przytwierdzić do obudowy licznika na przykład taśmą klejącą – nie ma ona żadnego wpływu na odczyt. Zasada działania będzie bardzo podobna do <a href="https://arduino.pl/articles/135-budujemy-licznik-nie-tylko-do-magnetofonu-cz-1">opisywanego przeze mnie kiedyś licznika obrotów do magnetofonu,</a> z tym że będzie jeszcze prościej, ponieważ zrezygnujemy z identyfikacji kierunku przepływu wody. Cofki w praktyce zdarzają się wyłącznie awaryjnie albo na minimalną skalę, przy wyrównywaniu ciśnień.<fragment id="jodit-selection_marker_1782834643261_6370474009274554" style="line-height: 0; display: none;" data-jodit-temp="true" data-jodit-selection_marker="start"></fragment><img src="https://cdzpcayhaa.cloudimg.io/v7/_ard_/5-6a43e3cfb1fd2.png?force_format=webp&amp;ci_sign=97663568dadb38e1312ee01f35062acb1c411da6" alt="5.png" style="max-width: 100%; height: auto; margin: 16px auto; width: 540px; display: block;"><fragment id="jodit-selection_marker_1782834643261_6913676068313376" style="line-height: 0; display: none;" data-jodit-temp="true" data-jodit-selection_marker="end"></fragment>A więc: dioda świecąca będzie oświetlać wirującą tarczę, a fototranzystor będzie naprzemiennie: oświetlany światłem odbitym od części lustrzanej czy białej i zaciemniany, gdy pojawi się przed nim część ciemna. Zasada prosta, a niezawodna stanie się wówczas, gdy dobierzemy właściwy punkt pracy fototranzystora i położenie wszystkich elementów względem siebie. W artykule o liczniku do magnetofonu użyłem własnoręcznie wykonanego czujnika z elementów SMD. Dziś użyję takiego gotowca, który właśnie do takich celów służy: w sprytnej obudowie siedzą dwa wymienione elementy, lekko skierowane ku sobie.<fragment id="jodit-selection_marker_1782834713725_8072447188021652" style="line-height: 0; display: none;" data-jodit-temp="true" data-jodit-selection_marker="start"></fragment><img src="https://cdzpcayhaa.cloudimg.io/v7/_ard_/6-6a43e3cfcd545.png?force_format=webp&amp;ci_sign=a5047041b5f695f8d5e2f78f9737a4e8e7d6ad31" alt="6.png" style="max-width: 100%; height: auto; margin: 16px auto; width: 540px; display: block;"><fragment id="jodit-selection_marker_1782834713725_059937855636467474" style="line-height: 0; display: none;" data-jodit-temp="true" data-jodit-selection_marker="end"></fragment>Elementy zwykle dopasowane są pod względem pasma i kątów pracy, więc w tego typu projektach dobrze użyć czegoś takiego – zaoszczędzimy sobie pracy na budowie mechanicznej i kalibracji. Element ten można przylepić do przezroczystej obudowy licznika (byle nie trwale – to znaczy tak, by pozostały jam jakieś ślady po odklejeniu). Oczywiście musi być skierowany w dół, na wspomnianą tarczę. A co, gdy tarczy nie ma i dysponujemy takimi elementami jak w moim liczniku? Cóż, tutaj kombinowania będzie więcej. Najlepiej użyć diody laserowej, czy układu z soczewkami, dającymi tak wąski kąt światła, by był w pełni zasłaniany obracającą się wskazówką. Jeśli będziemy obserwować jej cień, dostaniemy podobną informację. Ale obecnie większość liczników ma już wspomnianą tarczę, więc usprawniłem swój egzemplarz – jak mówiłem – już zdelegalizowany, naklejając na wskazówkę tarczę z czarnego kartonu, z naklejoną folią aluminiową, która udaje rozwiązania fabryczne.Schemat jest bardzo prosty: przez diodę świecącą modułu musimy przepuścić odpowiedni prąd. Znajdziemy go w katalogu, a jeśli nie, możemy założyć, że 10 mA będzie wartością aż za dobrą. Wstawiłem z zapasem rezystor 220R i podłączyłem go do pięciu woltów. Katoda diody jest oczywiście połączona z masą. Z nią też łączę emiter fototranzystora – dlatego z modułu wychodzą trzy, a nie cztery przewody. Kolektor dostarczy informację o stanie oświetlenia, ale trzeba go spolaryzować, podłączając rezystor także do pięciu woltów. Metodą prób i błędów określiłem jego wartość na 10 kR. Jak go dobrać?Po przylepieniu modułu do obudowy wodomierza należy spuścić odrobinę wody, by w polu widzenia fototranzystora pojawiło się pole czarne. Mierzymy napięcie na kolektorze, po czym znowu spuszczamy odrobinę wody, by obrócić tarczę do pozycji srebrnej. W pierwszym przypadku napięcie powinno być znacznie wyższe od dwóch woltów. W drugim powinno być znacznie niższe od ośmiu dziesiątych wolta. Gdyby któreś z napięć zbytnio zbliżało się do wymienionej granicy – należy zmienić rezystor, gdyby różnica napięć była zbyt niska – wymieniamy fototranzystor albo sprawdzamy, czy oba elementy pracują w tym samym paśmie światła. Skoro wszystko mamy podłączone, napiszmy prosty program, który sprawdzi logikę układu.<pre class="jodit-code"><code class="language-cpp">const byte phototransistor = 12; // Port fototranzystora.
const byte led = 13; // Port diody stanu fototranzystora.

void setup() {
 pinMode(phototransistor, INPUT);
 pinMode(led, OUTPUT);
}
void loop() {
 digitalWrite(led, !digitalRead(phototransistor)); // Prześlij zanegowany stan portu fototranzystora do portu diody świecącej.
}</code></pre> Fototranzystor podłączę do 12 pinu, na trzynastym znajduje się dioda świecąca. Będziemy na nią zrzucać odczytany stan sensora, ale po zaprzeczeniu, żeby było intuicyjnie: ciemna tarcza – dioda nie świeci, jasna – świeci. Po kompilacji możemy trochę pochlapać, przyglądając się korelacji obracającej się tarczy z diodą. Powinna migać z częstotliwością raz na litr. Teoretycznie wszystko gra, więc można napisać jakiś użyteczny program. Ale o tym napiszę już <a href="https://arduino.pl/articles/166_odczyt_licznika_wody_cz_2">w kolejnym artykule</a>.

Od razu napiszę: to wszystko można kupić i to w najróżniejszych kombinacjach. Ale nasza seria to klasyczne: zrób to sam, bardzo dosłownie, bo staram się nie przedstawiać kompletnych projektów, a sposoby, by szczegóły każdy już dopracował sobie do własnych potrzeb. Tak więc rozważania w tym artykule będą dotyczyć ogólnie przeniesienia informacji o zużyciu wody – z wodomierza do świata elektroniki. A co będzie potem – to już niech każdy użyje własnej wyobraźni. Ja oczywiście przedstawię rozwiązanie startowe, ale po kolei.

[165] Odczyt licznika wody cz. 1

<a href="https://www.tme.eu/pl/details/tme-edu-ard-2/rozwiazania-kompatybilne-z-arduino/transfer-multisort-elektronik/">Sprawdź Tutaj</a>

Projekty

Przeglądaj wg kategorii

Nasi partnerzy