Zaloguj
Cały projekt miał żartobliwy początek, jak wskazuje autor, ale okazało się, że system jest zdumiewająco precyzyjny w rozpoznawaniu rytmu pukania do drzwi. Jeśli czułość algorytmu jest ustawiona na maksimum, może nawet rozpoznawać różne osoby, nawet jeśli dają ten sam stukot! Powoduje to wiele fałszywych niepowodzeń, co nie jest dobre, szczególnie gdy spieszymy się i chcemy jak najszybciej wejść do pomieszczenia.
Układ jest programowalny. Wystarczy nacisnąć przycisk programowania i wystukać nowy rytm, a wtedy układ otworzy drzwi tylko przy nowym haśle. Domyślny stukot to znana melodyjka "Shave and a Haircut", ale można go bez problemu przeprogramować na cokolwiek innego, o długości do 20 stuków.
Można użyć swojej ulubionej piosenki, ciągu znaków zaszyfrowanych morsem, słowem - cokolwiek.
Potrzebne elementy
Realizacja tego projektu zajmie kilka godzin i wymaga co najmniej podstawowych umiejętności mechanicznych, znajomości elektroniki i programowania na platformie Arduino. Oprócz tych umiejętności potrzebne będą podstawowe narzędzia, takie jak wiertarka, piła, która potrzebna będzie do cięcia rur PCV, lutownica i podstawowe narzędzia. Wśród komponenty potrzebne będą:
- płytka Arduino Duemilanove (lub inna zgodna płytka lub po prostu mikrokontroler z co najmniej 1 wejściem analogowym i 3 wyjściami cyfrowymi);
- silnik redukcyjny 5 V - im większy będzie jego moment obrotowy, tym lepiej. Autor rekomenduje silnik o momencie co najmniej 11 Ncm przy zasilaniu 5 V;
- głośnik piezoelektryczny o średnicy 30 mm. Można użyć większego lub mniejszego, pamiętając, że mniejsze będą mniej wrażliwe;
- przycisk zwykły chwilowy (normalnie wyłączony);
- czerwona i zielona dioda LED;
- tranzystor NPN P2N2222A;
- dioda prostownicza (1N4001 lub podobna);
- rezystory: 2,2 kΩ, 10 kΩ, 1 MΩ oraz 2×560 Ω (lub inne, potrzebne do zapalenia diody LED przy 5 V);
- mały kawałek płytki uniwersalnej do montażu (wystarczy 5×15 otworów);
- złącze na baterię 9 V i bateria 9 V (lub dowolny inny sposób dostarczenia 7...12 V do Arduino. Można zastąpić ją zasilaczem wtyczkowym).
Układ nie ma obudowy. Zamiast tego elementy są zainstalowane na stelażu z rurek PCV. Do konstrukcji stelaża potrzebne jest około 50 cm rurki o średnicy 1/2" i trzy łączniki do rurek do połączenia pod kątem prostym, pojedynczy łącznik do połączenia pięciu rurek i dwie zaślepki do rurek. Do zamocowania układu na drzwiach autor przewidział przyssawki - trzy sztuki o średnicy 1/2" każda, ale nie każde drzwi się do tego nadają. Jeśli na naszych drzwiach nie można zamontować przyssawek, należy rozważyć inny sposób montażu.
Dodatkowo potrzebny będzie płaskownik o szerokości 12 mm i grubości około 0,25...0,5 mm i blaszka o szerokości 25 mm i grubości 1 mm. Może ona być wykonana ze stali, miedzi itp. Do montażu całości potrzebne są śruby, dwie o średnicy 1,5 mm lub 3 mm i długości 10 mm i 2 śruby M1,6 o długości 16 mm.
Najlepiej, aby wszystkie były wyposażone w podkładki. Te ostatnie potrzebne są do mocowania silnika - jeśli nasz ma inne otwory, może wymagać M1,6 lub M2.
Oprogramowanie
Najlepiej jest wgrać program do układu przed przystąpieniem do montażu elementów elektronicznych, tak aby można je było testować na bieżąco. Postępujmy zgodnie z poniższymi krokami:
- Pobierz plik secret_knock_detector.pde na dole tej sekcji i skopiuj go do swojego folderu z programami Arduino (lub wyświetl tekst i skopiuj go do nowego programu).
- Otwórz program i skompiluj go. Powinien skompilować się poprawnie za pierwszym razem, ale zawsze warto się upewnić.
- Podłącz Arduino i wgraj program.
I na tym operacja mogłaby się zakończyć - w oprogramowaniu nie ma potrzeby wprowadzania żadnych zmian, aby dostosować je do naszej aplikacji.
Przyjrzyjmy się jednak strukturze programu i ciekawszym fragmentom kodu, które mogą być przydatne, jeżeli chcielibyśmy lepiej zrozumieć jego działanie czy też wprowadzić jakieś modyfikacje. Numery linii są orientacyjne, gdyż to, jak wyświetlać będą się u nas, zależeć może od ustawień edytora itp.
Kompletny program pokazano na listingu 1.
// Definicje pinów
// Piezo sensor
const int knockSensor = 0;
// Przycisk programowania
const int programSwitch = 2;
// Silnik otwierania zamka
const int lockMotor = 3;
const int redLED = 4; // LED
const int greenLED = 5; // LED
// Stałe sterowania detektorem
const int threshold = 3;
const int rejectValue = 25;
const int averageRejectValue = 15;
const int knockFadeTime = 150;
const int lockTurnTime = 650;
const int maximumKnocks = 20;
const int knockComplete = 1200;
// Zmienne
int secretCode[maximumKnocks] = {
50, 25, 25, 50, 100, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
// Gdy ktoś puka ta macierz wypełnia się mierzonymi opóźnieniami
int knockReadings[maximumKnocks];
// Ostatni pomiar sensora uderzenia
int knockSensorValue = 0;
// Flaga do zapamiętywania naciśnięcia przycisku programowania
int programButtonPressed = false;
void setup() {
pinMode(lockMotor, OUTPUT);
pinMode(redLED, OUTPUT);
pinMode(greenLED, OUTPUT);
pinMode(programSwitch, INPUT);
Serial.begin(9600);
Serial.println("Program start.");
// Zapalenie zielonej diody LED
digitalWrite(greenLED, HIGH);
}
void loop() {
// Nasłuchiwanie pikania
knockSensorValue = analogRead(knockSensor);
// Naciśnięcie przycisku programowania
if (digitalRead(programSwitch)==HIGH){
// Jeśli tak, to zapisujemy stan programu
programButtonPressed = true;
// i zapalamy czerwoną diodę, aby to zasygnalizować
digitalWrite(redLED, HIGH);
} else {
programButtonPressed = false;
digitalWrite(redLED, LOW);
}
// Wykryto pukanie
if (knockSensorValue >=threshold){
// Dekodowanie pukania
listenToSecretKnock();
}
}
// Zapisuje czas uderzeń
void listenToSecretKnock(){
Serial.println("knock starting");
int i = 0;
// resetuje wartości w macierzy
for (i=0;i<maximumKnocks;i++){
knockReadings[i]=0;
}
// Licznik
int currentKnockNumber=0;
// Start pomiaru czasu
int startTime=millis();
int now=millis();
digitalWrite(greenLED, LOW);
if (programButtonPressed==true){
digitalWrite(redLED, LOW);
}
// Czekamy po uderzeniu pewien czas
delay(knockFadeTime);
digitalWrite(greenLED, HIGH);
if (programButtonPressed==true){
digitalWrite(redLED, HIGH);
}
do {
// Czekamy na kolejne uderzenie lub timeout
knockSensorValue = analogRead(knockSensor);
// Jeśli wystapiło kolejne uderzenie
if (knockSensorValue >=threshold){
Serial.println("knock.");
// zapisuujemy czas,
now=millis();
knockReadings[currentKnockNumber] = now-startTime;
// zwiększamy licznik
currentKnockNumber ++;
// i resetujemy pomiar czasu
startTime=now;
digitalWrite(greenLED, LOW);
if (programButtonPressed==true){
digitalWrite(redLED, LOW);
}
// Czekamy po uderzeniu pewien czas
delay(knockFadeTime);
digitalWrite(greenLED, HIGH);
if (programButtonPressed==true){
digitalWrite(redLED, HIGH);
}
}
now=millis();
// Czy nastąpił timeout lub ditarliśmy do limitu uderzeń?
} while ((now-startTime < knockComplete)
&& (currentKnockNumber < maximumKnocks));
// sprawdzanie poprawności sekwencji uderzeń
if (programButtonPressed==false){
if (validateKnock() == true){
triggerDoorUnlock();
} else {
Serial.println("Secret knock failed.");
digitalWrite(greenLED, LOW);
for (i=0;i<4;i++){
digitalWrite(redLED, HIGH);
delay(100);
digitalWrite(redLED, LOW);
delay(100);
}
digitalWrite(greenLED, HIGH);
}
} else {
validateKnock();
Serial.println("New lock stored.");
digitalWrite(redLED, LOW);
digitalWrite(greenLED, HIGH);
for (i=0;i<3;i++){
delay(100);
digitalWrite(redLED, HIGH);
digitalWrite(greenLED, LOW);
delay(100);
digitalWrite(redLED, LOW);
digitalWrite(greenLED, HIGH);
}
}
}
// Otwiera drzwi silnikiem
void triggerDoorUnlock(){
Serial.println("Door unlocked!");
int i=0;
// Obracanie silnikiem
digitalWrite(lockMotor, HIGH);
digitalWrite(greenLED, HIGH);
// ...przez jakiś czas...
delay (lockTurnTime);
// po czym wyłączamy silnik
digitalWrite(lockMotor, LOW);
for (i=0; i < 5; i++){
digitalWrite(greenLED, LOW);
delay(100);
digitalWrite(greenLED, HIGH);
delay(100);
}
}
// Sprawdza, czy nasza sekwencja zgadza się z zapisaną
boolean validateKnock(){
int i=0;
int currentKnockCount = 0;
int secretKnockCount = 0;
int maxKnockInterval = 0;
for (i=0;i<maximumKnocks;i++){
if (knockReadings[i] > 0){
currentKnockCount++;
}
if (secretCode[i] > 0){
secretKnockCount++;
}
if (knockReadings[i] > maxKnockInterval){
maxKnockInterval = knockReadings[i];
}
}
if (programButtonPressed==true){
for (i=0;i<maximumKnocks;i++){
secretCode[i]= map(
knockReadings[i],0, maxKnockInterval, 0, 100);
}
digitalWrite(greenLED, LOW);
digitalWrite(redLED, LOW);
delay(1000);
digitalWrite(greenLED, HIGH);
digitalWrite(redLED, HIGH);
delay(50);
for (i = 0; i < maximumKnocks ; i++){
digitalWrite(greenLED, LOW);
digitalWrite(redLED, LOW);
if (secretCode[i] > 0){
delay(map(secretCode[i],0, 100, 0, maxKnockInterval));
digitalWrite(greenLED, HIGH);
digitalWrite(redLED, HIGH);
}
delay(50);
}
return false;
}
// Czy liczba uderzeń się zgadza?
if (currentKnockCount != secretKnockCount){
return false;
}
int totaltimeDifferences=0;
int timeDiff=0;
// Normalizacja czasu
for (i=0;i<maximumKnocks;i++){
knockReadings[i]= map(
knockReadings[i],0, maxKnockInterval, 0, 100);
// Różnice czasu uderzeń
timeDiff = abs(knockReadings[i]-secretCode[i]);
// Pojedynczy czas zbyt odbiega od zapisanego
if (timeDiff > rejectValue){
return false;
}
totaltimeDifferences += timeDiff;
}
if (totaltimeDifferences/secretKnockCount>averageRejectValue){
// Średnia rozbieżność z zapisanym czasem
return false;
}
return true;
}
Linia const int threshold = 4; Jest to czułość detektora stukania. Jeśli otrzymujemy dużo zakłóceń, należy podnieść tę wartość (maksymalnie do 1023), jeśli z kolei trudno jest wykryć stukanie, można ten parametr obniżyć (nawet do 1).
Linia const int rejectValue = 25; oraz const int averageRejectValue = 15; służą do określenia, jak dokładnie ktoś musi stukać. Są to procenty i powinny mieścić się w zakresie 0...100. Ich obniżenie oznacza, że trzeba mieć bardziej precyzyjny rytm, a wyższa wartość zapewnia więcej wyrozumiałości. Wartość averageRejectValue powinna zawsze być niższa niż rejectValue. Ustawienia równe około 10 i 7 sprawiają, że dwie osoby mają trudność z wykonaniem tego samego stukania, nawet jeśli znają rytm. Jednakże zwiększa to liczbę fałszywie negatywnych detekcji (tj. gdy stukamy rytm poprawnie, a drzwi i tak się nie otwierają).
Linia const int knockFadeTime = 150; to prymitywny licznik czasu dla czujnika stukania. Po usłyszeniu stukania przestaje on słuchać przez tyle milisekund, aby nie liczyć tego samego stukania więcej niż raz. Jeśli pojedyncze stukanie jest liczone jako dwa, należy zwiększyć ten czas. Jeśli nie rejestruje dwóch szybkich stuknięć, czas należy zmniejszyć.
Linia const int lockTurnTime = 650; to liczba milisekund, przez które uruchamiamy silnik, aby otworzyć drzwi. Jak długo to powinno trwać, zależy od projektu silnika i zamka. Nie ma nic złego w tym, jeśli trochę za długo działa, ponieważ w projekt został wprowadzony prosty sprzęg, ale lepiej, aby wszystkie elementy działały z umiarem.
Linia const int maximumKnocks = 20; to maksymalna liczba stuknięć jakie rejestrujemy. 20 to sporo. Można zwiększyć ten parametr, jeśli mamy dobrą pamięć. Jeśli za dużo zwiększymy długość sekwencji, może skończyć się pamięć w układzie.
Linia const int knockComplete = 1200; to maksymalna liczba milisekund przez które układ będzie czekał na stuknięcie. Jeśli układ nie usłyszy stuknięcia przez ten czas, założy, że użytkownik skończył i sprawdzi, czy sekwencja jest poprawna.
Linia int secretCode[maximumKnocks] = {50, 25, 25, 50, 100, 5..... to domyślny rytm stukania, który układ rozpoznaje po włączeniu. Jest to dziwna notacja rytmiczna, ponieważ każda wartość jest procentem najdłuższego czasu stukania.
Jeśli chodzi o debugowanie kodu, w programie zawarto kilka istotnych narzędzi:
Linia Serial.begin(9600) oraz Serial.println("Program start."); - jeśli odkomentujemy te linie, będziemy mogli zobaczyć kilka informacji debugujących na porcie szeregowym. Jest kilka innych linii kodu do debugowania rozmieszczonych w reszcie kodu, które można odkomentować, aby zobaczyć, co dzieje się wewnątrz algorytmu. Należy upewnić się, że port jest ustawiony na odpowiednią prędkość.
Budowa układu
Teraz możemy przystąpić do budowy układu, najpierw np. na płytce stykowej, aby upewnić się, że wszystko działa poprawnie. Na rysunku 1 pokazany jest schemat podłączenia zewnętrznych elementów. Montaż realizujemy krok po kroku, zgodnie z opisaną poniżej kolejnością, w ten sposób najprościej będzie sprawdzać po kolei poprawność instalacji poszczególnych komponentów.
Podłączenie czujnika piezoelektrycznego
Do głośnika piezoelektrycznego należy przylutować dwa przewody o długości 30 cm. Podłączamy je pomiędzy wejściem analogowym 0 a masą. Należy również dołączyć rezystor 1 MΩ między pinem analogowym 0 a masą. Aby przetestować ten sensor z podłączonym Arduino do komputera (za pośrednictwem USB lub kabla szeregowego), należy otworzyć monitor szeregowy w Arduino IDE. Po włączeniu Arduino powinniśmy zobaczyć tekst "Program start". Należy stuknąć w głośnik piezoelektryczny, co powinno wywołać przesłanie kolejnego tekstu na terminal - "knock starting" i "knock", za każdym razem, gdy uderzymy w sensor. Jeśli poczekamy teraz chwilę, to zobaczymy "Secret knock failed" lub "Door unlocked!", jeśli rytm był poprawny.
Jeśli nie widzimy na ekranie wiadomości albo widzimy śmieci, to należy upewnić się, że port szeregowy szeregowy jest ustawiony na 9600 bodów i zresetować zasilanie Arduino. Jeśli system przesyła komunikaty o stukaniu bez stukania, detektor może być zbyt czuły. W takim przypadku trzeba edytować program. W okolicach linii 27 należy zwiększyć wartość progową. Można ją podnieść nawet do 1032, jeśli mamy do czynienia z bardzo czułym sensorem. Parametr const int threshold = 3; określa minimalny sygnał z głośnika piezoelektrycznego, potrzebny, aby zarejestrować stuknięcie. Gdy detekcja już działa, można zakomentować lub usunąć linie zaczynające się od Serial... Nie powinny być już dalej potrzebne.
Podłączenie diody LED
W dalszej kolejności podłączamy diody LED, dzięki czemu będziemy mogli śledzić działanie układu bez podłączania kabla szeregowego do komputera. Podłączamy czerwoną diodę LED do wyjścia cyfrowego 4, a zieloną diodę LED do 5, z odpowiednimi rezystorami - np. o wartości 560 Ω (lub innymi, zależnie od naszych diod LED). Pamiętajmy o biegunowości diod i odpowiednim ich podłączeniu pomiędzy wyjścia Arduino i masę.
Jeśli zasilimy obwód, zielona dioda LED powinna się zapalić. Jeśli nie, należy sprawdzić połączenia i upewnić się, że dioda LED jest poprawnie podłączona. Za każdym razem, gdy stukniemy, zielona dioda powinna przygasać. Po zastukaniu właściwej sekwencji zielona dioda powinna mignąć kilka razy.
Stuknięcie złej sekwencji powinno zakończyć się miganiem czerwonej diody LED.
Podłączenie przycisku programowania
Do przycisku należy przylutować przewody o długości 20 cm. Jedną stronę przycisku podłączamy do +5 V. Drugi pin podłączony zostanie do wejścia cyfrowego 2 w Arduino i przez opornik 10 kΩ do masy. Po podłączeniu zasilania i naciśnięciu przycisku powinna zapalić się czerwona lampka. Przytrzymanie przycisku i wystukanie sekwencji powinno zapalić obie diody. Podczas stukania i programowania obie diody powinny migać. Po zakończeniu odtwarzania nowa sekwencja stuknięć jest zapisywana, a światła będą migać przez chwilę na przemian na czerwono i zielono, aby o tym poinformować.
Podłączenie silnika
Do silnika lutujemy przewody o długości 20 cm i podłączamy go zgodnie ze schematem. Należy upewnić się, że dioda jest podłączona we właściwy sposób, a także sprawdź piny tranzystora, aby upewnić się, że pasują do schematu - w zależności od konkretnego typu tranzystora wyprowadzenia mogą być inne.
Aby przetestować działanie silnika, wystarczy po uruchomieniu układu wystukać prawidłową melodię, aby silnik się uruchomił i działał przez około pół sekundy. Jeśli nie, to należy sprawdzić połączenia i kierunek umieszczenia diody w układzie. Teraz pozostaje tylko umieścić układ w czymś, co możemy zamocować do naszych drzwi.
Obudowa i montaż na drzwiach
Zanim zmontujemy całość, należy dopasować do siebie wszystkie elementy i je przetestować - po sklejeniu rurki PCV będą już niemożliwe do przemieszczenia czy skrócenia, więc lepiej jest sprawdzić wszystko, zanim skleimy szkielet urządzenia w całość. Na fotografii 1 pokazano przygotowane do montażu elementy.
W pierwszej kolejności konstruujemy uchwyt przycisku. Bierzemy jedno zakończenie rurki PCV i wiercimy w nim otwór przez środek, o średnicy odpowiedniej na nasz przycisk. Przycisk montujemy w otworze. Zatyczkę tę montujemy w jednym z otworów pięciodrożnego łącznika (tj. nie ten, który wskazuje w dół).
Drugie zakończenie rurki PCV wykorzystane zostanie jako uchwyt dla silnika. Wiercimy w nim otwór wystarczająco duży, aby wałek silnika mógł przez niego przejść. Można również zrobić go jeszcze większym, jeśli wybrany silnik ma wystające łożysko. W zależności od konstrukcji silnika można trochę oszlifować na grubość zatyczkę, aby więcej osi silnika wystawało z obudowy. Następnie umieszczamy w zatyczce silnik, by sprawdzić, czy wszystko pasuje. Jeśli jest zbyt ciasno, można szlifować wnętrze zatyczki.
Następnie za pomocą np. papierowego szablonu lokalizujemy na zatyczce otwory na śruby mocujące, które musimy wywiercić, aby zamocować silnik do zatyczki za pomocą dwóch niewielkich śrub - w przypadku tego silnika M2. Śruby powinny być osadzone możliwie głęboko, aby nie wystawały zbyt dużo powyżej zatyczki.
Kolejnym krokiem jest dobranie "ramion". Aby je wykonać, wkładamy najpierw kawałek rurki PCV o długości 125 cm. Nazwijmy to ramię "długim ramieniem". Na jednym końcu umieszczamy prosty łącznik. Drugi koniec wkładamy do centralnego łącznika naprzeciw przycisku. Ołówkiem lub markerem rysujemy linię wzdłuż środka góry i dna długiego ramienia. Na górnej stronie zaznaczamy dwa miejsca na otwory, jeden ok. 20 mm (3/4 cala) od łącznika, a drugie 37 mm (1 i 1/2 cala) od łącznika. Wiercimy tam otwory o średnicy ok. 4 mm (3/16 cala) w każdym z nich. To jest miejsce, gdzie zamontowane będą diody LED.
Następnie rysujemy linię wzdłuż dna, gdzie długie ramię łączy się z centralnym łącznikiem. Za pomocą piły nacinamy krótko rurkę od dołu w górę, aż powstanie otwór o szerokości około 12 mm (1/2 cala) na rurze (to jest miejsce, gdzie zamocowana będzie sprężynka dociskająca sensor urządzenia). Również na dole należy wywiercić otwór o średnicy 3 mm około 6 mm dalej w głąb rurki (dalej od centralnego łącznika). Przez ten otwór przewleczony zostanie przewód do sensora piezoelektrycznego.
Finalny element, jaki wykonamy, to "nogi", które trzymać będą układ do drzwi. Ich długość zależy od konstrukcji zamka, długości wałka silnika i ostatecznego projektu zacisku do obracania zamka, jaki opisany jest w dalszej części artykułu. W przypadku projektu autora wszystkie trzy miały długość 72 mm.
Dopasowując je do konstrukcji, pamiętajmy, że lepiej jest je odciąć za długie i przyciąć do odpowiedniego rozmiaru później. Jeśli są za długie, silnik nie sięgnie zamka. Jeśli są za krótkie, przyssawki nie będą dosięgać do drzwi - układ oprze się na zamku.
Po odcięciu nóg na odpowiednią długość osadzamy na ich końcach przyssawki (lub dowolny inny element, jakiego używamy do montażu urządzenia na naszych drzwiach).
Otwieranie zamka
Autor skonstruował prosty uchwyt, który z jednej strony zamocowany jest na osi silnika, a z drugiej strony chwyta za zamek od wewnętrznej strony drzwi. Elastyczny zacisk z giętej blachy łapie za zamek, obracając nim za pomocą silnika.
Najpierw musimy przygotować uchwyt. Bierzemy większy z przygotowanych arkuszy blachy i tniemy go na pół, aby otrzymać dwa kawałki. Sklejamy je taśmą, zaznaczając każdą stronę, aby wiedzieć, która strona jest "na zewnątrz" i zaznaczając jedną z dłuższych krawędzi jako "do góry". To wszystko pomoże nam utrzymać wszystko w porządku na bieżąco.
Mierzymy i zaznaczamy linię środkową od góry do dołu. 12 mm z każdej strony tej linii środkowej i 6 mm od górnej krawędzi zaznaczamy miejsce do wywiercenia otworów. W tych miejscach wiercimy otwory o średnicy 3 mm. Zaznaczenie punktów stemplem lub uderzenie młotkiem i gwoździem sprawi, że wiercenie będzie dokładniejsze.
Mierzymy szerokość zatrzasku zamka i dzielimy ją przez 2. Ta odległość określa, ile krawędzi zagniemy w każdym kawałku metalu. Zaznaczamy tę odległość wzdłuż każdego paska. Gniemy jeden element tak, aby zwijał się w lewo, a drugi tak, aby zwijał się w prawo. Musimy upewnić się, że otwory na śruby w górnej części elementów są wyrównane, a zagięcia nie uniemożliwiają połączenia elementów na górze.
Przez otwory w górnej części płytek możemy teraz przewlec śruby, tak aby utworzyły odwróconą literę "Y" i umieszczamy oś silnika na górze, pomiędzy śrubami. Dodajemy z drugiej strony nakrętki i mocno skręcamy, aż będą dobrze przymocowane. Niewielki luz pomiędzy metalem a wałem sprawi, że silnik zacznie się obracać, jeśli napotka zbyt duży opór. Konstrukcję taką pokazano na fotografii 2.
Uchwyt powinien lekko przylegać do zatrzasku zamka. Nie tak ściśle, aby był mocno zaciśnięty, ale też nie tak luźno, aby można było go obrócić bez obracania zamka. W razie potrzeby można wyregulować to poprzez dogięcie blaszek bocznych. Po dokonaniu prawidłowej regulacji na końcach śrub nakręcamy drugą parę nakrętek, aby je skontrować. Pomoże to zablokować je na miejscu i uniemożliwić im samodzielne odkręcanie.
Sprężyna detektora
Ostatni element, jaki należy wykonać, to sprężyna dociskająca detektor do drzwi. Jest ona wykonana z cienkiej blaszki, dzięki czemu układ jest bardziej przenośny. Mocujemy czujnik do metalowego paska, np. za pomocą taśmy dwustronnej, kleju na ciepło itp. Metoda jest dowolna. Przewody możemy owinąć wokół paska blachy, żeby były dobrze ułożone i nie przeszkadzały. Pasek mocujemy do długiego ramienia - rurki z PCV, w której wycinaliśmy wcześniej otwór. Pasek przewlekamy w szczelinę, którą przygotowaliśmy, a przewód wsuwamy w pobliski otwór, aby podłączyć go do elektroniki. Pasek z blachy powinien wysunąć się z wyczuwalnym oporem, aby nie wypadał.
Zamocowany na sprężynie dociskającej detektor powinien wyglądać jak na fotografii 3.
Podsumowanie i perspektywy na przyszłość
Najpierw upewnijmy się, że nogi mają odpowiednią długość. Upewnijmy się, że uchwyt zamka jest przymocowany do silnika, a nogi są na swoim miejscu. Spróbujmy przymocować układ do drzwi, tak aby zacisk pasował do zamka. Przy odrobinie szczęścia wszystko uda się od ręki. Zamiast przyssawek można użyć innych metod montażu - dwustronnej taśmy piankowej lub wkrętów przez zaślepki, jeśli nie mamy nic przeciwko robieniu otworów w drzwiach.
To już wszystko. Układ można przetestować i używać. Po testach zaprogramujmy własny szyfr i używajmy do woli. Być może na tym etapie będziemy musieli wprowadzić pewne zmiany, wymagające podłączenia modułu do komputera. Na przykład, jeśli silnik nie obraca się wystarczająco daleko, aby odblokować drzwi, trzeba zaktualizować szkic, aby silnik działał dłużej.
Jeśli jesteśmy ambitni, możemy natomiast ulepszyć lub zmienić ten projekt na wiele sposobów. Autor wymienia kilka pomysłów na rozwój systemu:
- dodanie mostka H do obwodu, aby mógł też zamykać, a nie tylko otwierać drzwi (potrzebne jest obracanie silnikiem w obie strony);
- można sprawić, aby działał w trybie cichym, usuwając czujnik stukowy i podłączając czujnik pojemnościowy (dotykowy) do klamki i rejestrując sekwencje dotknięć;
- można dodać potencjometr, aby wyregulować czułość sensora stukowego i inne wartości parametrów;
- warto zastanowić się nad redukcją wymiarów układu, aby cały system dało się zamaskować na drzwiach;
- dodanie kołatki, aby przekazać informację zwrotną przez drzwi. Mógłby wówczas oferować zabezpieczenie typu wezwanie-odpowiedź, w którym drzwi rozpoczynają sekwencję pukania, a użytkownik musi ją poprawnie zakończyć;
- usunąć czujnik piezoelektryczny i nagrywań naciśnięcia dzwonka lub innego ukrytego przycisku;
- zamienienie czujnika piezoelektrycznego na fotosensor w wizjerze - kod byłby przesyłany sekwencją mrugnięć latarki.
Nikodem Czechowski, EP
Źródło: https://www.instructables.com/Secret-Knock-Detecting-Door-Lock/
