Manchmal braucht man ein Sesam öffne Dich!
Eine Stimmerkennungssoftware, ein Fingerabdrucksensor oder die gute alte Gesichtserkennung zum Öffnen einer Eingangstür, die normalerweise sowieso offen steht, wäre wohl das, was einige Menschen als Overkill bezeichnen würden.
Daher habe ich darauf verzichtet großartige Sensoren zu verwenden. es geht darum eine Türe zu öffnen, falls sie geschlossen ist. Das soll einerseits einfach und schnell ablaufen, aber dennoch nicht jedem Zutritt verschaffen. Ein geheimes Klopfzeichen könnte die Lösung sein.
So reifte der Plan ein Piezomikrofon zu verwenden nach dem Vorbild von Grathio, der ein schönes Programm geschrieben hat, um Klopfzeichen zu erkennen. Leider erwies sich meine Hardware aber als zu unzuverlässig, so dass ich stattdessen einen kapazitativen Schalter verwendete. In der Praxis erwies sich dann aber die Idee als „Schalter“ die Türklinke zu nutzen unter den gegebenen Umständen leider als zu schwierig heraus (das Kabel zu verlegen).
So lässt sich nun der Sesam an einer geheimen Schraube öffnen. Ein Arduino beherrscht das Auslesen eines kapazitativen Schalters perfekt – mit der Hilfe einer library,
Als sehr benutzerfreundlich hat sich die Visualisierung einer Berührung des Schalters durch eine LED gezeigt – viele Nutzer benötigen ein visuelles Feedback um das Gerät bedienen zu können. Das ist natürlich eine große Sicherheitslücke und gilt es noch zu bereinigen (z.B. durch Irrlicher).
Wenn das korrekte Geheimzeichen eingegeben wurde schaltet Arduino den elektrischen Türöffner für einige Sekunden ein und man kann das Haus betreten,
Ab und zu will man dann aber doch den Zugangscode ändern. Auch daran hat Grathio bereits gedacht. Ich musste nur noch eine Speicherfunktion einbauen, damit auch nach einem Stromausfall die neue Parole erhalten bleibt (es wird in das EEPROM des Arduinos geschrieben).

Für das Schaltbild übernehme ich keine Gewähr, das ist nur so schnell hingeworfen (am Besten nochmal durchchecken). In der Realität habe ich nämlich noch einen Spannungsregler vor den Arduino geschaltet, damit ihm neben der Spule nichts passiert (daher auch die Freilaufdiode).
Hier der Quellcode meiner Version:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 |
/* Detects patterns of knocks and triggers a motor to unlock it if the pattern is correct. By Steve Hoefer http://grathio.com modified by AndiGun https://andigun.de Version 0.1.10.20.10 Licensed under Creative Commons Attribution-Noncommercial-Share Alike 3.0 http://creativecommons.org/licenses/by-nc-sa/3.0/us/ (In short: Do what you want, just be sure to include this line and the four above it, and don't sell it or use it in anything you sell without contacting me.) Analog Pin 0: Piezo speaker (connected to ground with 1M pulldown resistor) Digital Pin 2: Switch to enter a new code. Short this to enter programming mode. Digital Pin 3: DC gear reduction motor attached to the lock. (Or a motor controller or a solenoid or other unlocking mechanisim.) Digital Pin 4: Red LED. Digital Pin 5: Green LED. Update: Nov 09 09: Fixed red/green LED error in the comments. Code is unchanged. Update: Nov 20 09: Updated handling of programming button to make it more intuitive, give better feedback. Update: Jan 20 10: Removed the "pinMode(knockSensor, OUTPUT);" line since it makes no sense and doesn't do anything. Update by andigun: removed piezo speaker and using a capacitive switch instead, added functionality for writing and reading EEPROM, calibration of device at startup */ #include <EEPROM.h> #include <CapacitiveSensor.h> CapacitiveSensor cs_5_6 = CapacitiveSensor(PD5,PD6); //10M Resistor between pins PD5 and PD6, you may also connect an antenna on pin 8 unsigned long csSum; // Pin definitions const int programSwitch = PD2; // If this is high we program a new code. const int lockMotor = PD3; // Gear motor used to turn the lock. const int redLED = 13; // Status LED const int feedBack = PD4; // Tuning constants. Could be made vars and hoooked to potentiometers for soft configuration, etc. int threshold = 21; // Minimum signal from the piezo to register as a knock const int rejectValue = 25; // If an individual knock is off by this percentage of a knock we don't unlock.. const int averageRejectValue = 15; // If the average timing of the knocks is off by this percent we don't unlock. const int knockFadeTime = 250; // milliseconds we allow a knock to fade before we listen for another one. (Debounce timer.) const int lockTurnTime = 7000; // milliseconds that we run the motor to get it to go a half turn. const int maximumKnocks = 8; // Maximum number of knocks to listen for. const int knockComplete = 1200; // Longest time to wait for a knock before we assume that it's finished. // Variables. int secretCode[maximumKnocks] = {50, 25, 25, 50, 100, 50, 0, 0}; // Initial setup: "Shave and a Hair Cut, two bits." int knockReadings[maximumKnocks]; // When someone knocks this array fills with delays between knocks. //int knockSensorValue = 0; // Last reading of the knock sensor. int programButtonPressed = false; // Flag so we remember the programming button setting at the end of the cycle. void setup() { pinMode(lockMotor, OUTPUT); pinMode(redLED, OUTPUT); pinMode(feedBack, OUTPUT); // pinMode(greenLED, OUTPUT); pinMode(programSwitch, INPUT); Serial.begin(9600); // Uncomment the Serial.bla lines for debugging. Serial.println("Program start."); // but feel free to comment them out after it's working right. if ( EEPROM.read ( 0 ) != 0xff ) for (int i = 0; i < maximumKnocks; ++i ) secretCode [ i ] = EEPROM.read ( i ); //triggerDoorUnlock(); calib(); } bool CSread() { digitalWrite(feedBack,LOW); long cs = cs_5_6.capacitiveSensor(10); //a: Sensor resolution is set to 10 if (cs > threshold) { csSum += cs; if (csSum >= threshold * 10) { if (csSum > 0) { csSum = 0; } //Reset cs_5_6.reset_CS_AutoCal(); //Stops readings digitalWrite(feedBack,HIGH); return true; } else return false; } else { csSum = 0; //Timeout caused by bad readings return false; } } void calib() { digitalWrite(redLED, HIGH); // calibrate during the first five seconds while (millis() < 3000) { long cs = cs_5_6.capacitiveSensor(10); //a: Sensor resolution is set to 10 threshold = max(threshold, cs+1); } cs_5_6.reset_CS_AutoCal(); //Stops readings Serial.print("threshold: "); Serial.println(threshold); // signal the end of the calibration period digitalWrite(redLED, LOW); } void loop() { // Listen for any knock at all. //knockSensorValue = getVal(); //Serial.println(knockSensorValue * (5.0 / 1023.0)); if (digitalRead(programSwitch)==HIGH){ // is the program button pressed? if (!programButtonPressed) Serial.println("programButtonPressed"); programButtonPressed = true; // Yes, so lets save that state digitalWrite(redLED, HIGH); // and turn on the red light too so we know we're programming. } else { if (programButtonPressed) Serial.println("programButtonReleased"); programButtonPressed = false; digitalWrite(redLED, LOW); } if (CSread()){ listenToSecretKnock(); } } // Records the timing of knocks. void listenToSecretKnock(){ Serial.println("knock starting"); int i = 0; // First lets reset the listening array. for (i=0;i<maximumKnocks;i++){ knockReadings[i]=0; } int currentKnockNumber=0; // Incrementer for the array. int startTime=millis(); // Reference for when this knock started. int now=millis(); // digitalWrite(greenLED, LOW); // we blink the LED for a bit as a visual indicator of the knock. if (programButtonPressed==true){ digitalWrite(redLED, LOW); // and the red one too if we're programming a new knock. } delay(knockFadeTime); // wait for this peak to fade before we listen to the next one. // digitalWrite(greenLED, HIGH); if (programButtonPressed==true){ digitalWrite(redLED, HIGH); } do { //listen for the next knock or wait for it to timeout. //knockSensorValue = getVal(); if (CSread()){ //got another knock... //record the delay time. Serial.println("knock."); now=millis(); knockReadings[currentKnockNumber] = now-startTime; currentKnockNumber ++; //increment the counter startTime=now; // and reset our timer for the next knock // digitalWrite(greenLED, LOW); if (programButtonPressed==true){ digitalWrite(redLED, LOW); // and the red one too if we're programming a new knock. } delay(knockFadeTime); // again, a little delay to let the knock decay. // digitalWrite(greenLED, HIGH); if (programButtonPressed==true){ digitalWrite(redLED, HIGH); } } now=millis(); //did we timeout or run out of knocks? } while ((now-startTime < knockComplete) && (currentKnockNumber < maximumKnocks)); //we've got our knock recorded, lets see if it's valid if (programButtonPressed==false){ // only if we're not in progrmaing mode. if (validateKnock() == true){ triggerDoorUnlock(); } else { Serial.println("Secret knock failed."); // digitalWrite(greenLED, LOW); // We didn't unlock, so blink the red LED as visual feedback. for (i=0;i<6;i++){ digitalWrite(redLED, HIGH); digitalWrite(feedBack, HIGH); delay(100); digitalWrite(redLED, LOW); digitalWrite(feedBack, LOW); delay(100); } // digitalWrite(greenLED, HIGH); } } else if (currentKnockNumber >= 5) { // if we're in programming mode we still validate the lock, we just don't do anything with the lock validateKnock(); // and we blink the green and red alternately to show that program is complete. Serial.println("New lock stored."); for ( int i = 0; i < maximumKnocks; ++i ) EEPROM.write ( i, secretCode [ i ] ); 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); } } } // Runs the motor (or whatever) to unlock the door. void triggerDoorUnlock(){ Serial.println("Door unlocked!"); int i=0; // turn the motor on for a bit. digitalWrite(lockMotor, HIGH); digitalWrite(feedBack, HIGH); // digitalWrite(greenLED, HIGH); // And the green LED too. delay (lockTurnTime); // Wait a bit. digitalWrite(lockMotor, LOW); // Turn the motor off. digitalWrite(feedBack, LOW); } // Sees if our knock matches the secret. // returns true if it's a good knock, false if it's not. // todo: break it into smaller functions for readability. boolean validateKnock(){ int i=0; // simplest check first: Did we get the right number of knocks? int currentKnockCount = 0; int secretKnockCount = 0; int maxKnockInterval = 0; // We use this later to normalize the times. for (i=0;i<maximumKnocks;i++){ if (knockReadings[i] > 0){ currentKnockCount++; } if (secretCode[i] > 0){ //todo: precalculate this. secretKnockCount++; } if (knockReadings[i] > maxKnockInterval){ // collect normalization data while we're looping. maxKnockInterval = knockReadings[i]; } } // If we're recording a new knock, save the info and get out of here. if (programButtonPressed==true){ for (i=0;i<maximumKnocks;i++){ // normalize the times secretCode[i]= map(knockReadings[i],0, maxKnockInterval, 0, 100); } // And flash the lights in the recorded pattern to let us know it's been programmed. // 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); // only turn it on if there's a delay if (secretCode[i] > 0){ delay( map(secretCode[i],0, 100, 0, maxKnockInterval)); // Expand the time back out to what it was. Roughly. // digitalWrite(greenLED, HIGH); digitalWrite(redLED, HIGH); } delay(50); } return false; // We don't unlock the door when we are recording a new knock. } if (currentKnockCount != secretKnockCount){ return false; } /* Now we compare the relative intervals of our knocks, not the absolute time between them. (ie: if you do the same pattern slow or fast it should still open the door.) This makes it less picky, which while making it less secure can also make it less of a pain to use if you're tempo is a little slow or fast. */ int totaltimeDifferences=0; int timeDiff=0; for (i=0;i<maximumKnocks;i++){ // Normalize the times knockReadings[i]= map(knockReadings[i],0, maxKnockInterval, 0, 100); timeDiff = abs(knockReadings[i]-secretCode[i]); if (timeDiff > rejectValue){ // Individual value too far out of whack return false; } totaltimeDifferences += timeDiff; } // It can also fail if the whole thing is too inaccurate. if (totaltimeDifferences/secretKnockCount>averageRejectValue){ return false; } return true; } |
To be continued …