Dauerkalender

Tresorschloss mit Mikrocontroller
(Schaltung mit ATtiny84A)

Ein Tresor wird mit einem Verschluss, der nur durch Eingabe eines geheimen Zahlencodes geöffnet werden kann, versehen. Die Eingabe des Geheimcodes ermöglicht und überwacht eine Schaltung, die auf einem Mikrocontroller, hier ATtiny84A, einem Taster und fünf Reedschaltern basiert.
Die Schaltung, da sie gewöhnlich nur selten in Anspruch genommen wird, bleibt im Ruhezustand komplett ausgeschaltete und verbraucht in der Zeit keine Energie. Sie wird mit einem Taster (Druckknopf) aktiviert und bleibt für die Zeit der Eingabe des Codes unter Spannung. Wird der richtige Code eingegeben, wird mit einem Elektromagneten das Schloss geöffnet.
Die Eingabe des Codes erfolgt mithilfe einer Drehscheibe, an der ein Magnet angebracht wurde. Unter der Drehscheibe befindet sich eine zweite fest montierte Scheibe mit Nummern. Unter bestimmten Nummern sind insgesamt fünf Reedschalter montiert. Sobald der Magnet mit der Drehscheibe über einem Reedschalter positioniert wird, schaltet er und meldet die Tatsache an den Mikrocontroller. Nach der Bestätigung mit dem Druckknopf wird die so erfolgte Zahl-Eingabe ausgewertet. Eine Reihe von Zahlen zwischen 1 und 20 bildet den gesamten Geheimcode, der eingegeben werden muss, um den Tresor öffnen zu können.
Jede falsche Zahleingabe verursacht sofortige Deaktivierung der Schaltung. Die Eingaben müssen in diesem Fall wiederholt werden. Für jede Eingabe steht eine bestimmte Zeitspanne zur Verfügung. Wenn diese überschritten wird, erfolgt ebenfalls Trennung von der Spannungsversorgung.

ATtiny84A

ATtiny84A hat viel gemeinsam mit den Mikrocontrollern ATtiny24A und ATtiny44A. Die Chips haben sogar ein gemeinsames Datenblatt. Bei allen drei Produkten handelt es sich um 8-Bit Mikrocontroller. Alle Bauteile haben 14 Anschlüsse (DIP-Gehäuse) und stellen 12 I/Os zur Verfügung. Alle drei Mikrocontroller können mit einer Taktfrequenz bis zu 20 MHz betrieben werden. Unter anderen gibt es Unterschiede bezüglich der Speichergröße.

Technische Daten:
Kategorie: 8-Bit Mikrocontroller - MCU
Kern: AVR
Programmspeichergröße: 8 kB
RAM-Datengröße: 512 B
Gehäuse: PDIP-14
Maximale Taktfrequenz: 20 MHz
ADC-Auflösung: 10 Bit
Anzahl der I/Os: 12 I/O
Versorgungsspannung - Min.: 1.8 V
Versorgungsspannung - Max.: 5.5 V
Minimale Betriebstemperatur: - 40 C
Maximale Betriebstemperatur: + 85 C

Reedschalter

Reddschalter sehr oft als Reedkontakte oder Reedsensoren bezeichnet, sind Schalter, die ihren Schaltzustand abhängig von einem einwirkenden Magnetfeld ändern. Wenn sich einem Reedschalter ein Magnet nähert, wird sein Kontakt geschlossen. Die Schaltkontakte sind in einem Glasröhrchen eingeschmolzen und somit von externen Einflüssen geschützt.
In unserer Schaltung werden fünf Reedschalter eingesetzt. Sie befinden sich auf der unteren, unbeweglichen Scheibe, die Nummer 1 bis 20 enthält. Für Testzwecke wurden sie einfach mit einem Kleber festgemacht.

Untere Scheibe. Rückseite mit angeklebten Reedschalter.

Untere Scheibe: Frontseite

Die Reedschalter „verstecken“ sich hinter den Nummern: 3, 7, 10, 12 und 19. Diese Nummern werden dann für die Bildung des Tresorcodes verwendet. Ein Einbrecher weißt das natürlich nicht.
Auf der oberen, beweglichen Scheibe befindet sich ein Magnet, mit dem die Reedschalter geschaltet werden.

Obere Scheibe, Rückseite

Bei Bewegung der oberen Scheibe kommt der Magnet in die Nähe der Reedschalter. Wird die richtige Nummer angewählt, schaltet der zuständige Reedschalter und schickt ein Signal zu dem Mikrocontroller.

Obere Scheibe, Frontseite

Drucktaster

Die Aktivierung der Schaltung sowie Bestätigung jeder Eingabe erfolgt mithilfe eines Tasters. Für diese Funktion kann jeder beliebige Taster verwendet werden. In der Testschaltung kommt ein Drehschalter mit der Bezeichnung KY-040 zum Einsatz. Er kann auch als Drehgeber verwendet werden. Für den Testeinsatz, damit er als gewöhnliche ein/aus-Drucktaster fungiert, mussten die hinten eingelöteten Widerstände entfernt werden.

Relais

Die Schaltung enthält zwei Relais, die von dem Mikrocontroller gesteuert werden. Mit dem Relais K2 wird für die Spannungsversorgung der Schaltung gesorgt. Im Ruhezustand ist die Schaltung von der Spannungsversorgung 12 VDC getrennt. Beim Betätigen des Tasters S1 wird zunächst über den Spannungsregler der Mikrocontroller mit Spannung versorgt. Das Programm startet und schaltet über den Transistor T2 das Relais ein. Jetzt läuft die Versorgung mit der Spannung über den Schließer-Kontakt K2.1 und der Taster kann losgelassen werden. Ab jetzt übernimmt das Programm die Regie und entscheidet, wann das Relais wieder abgeschaltet wird.
Nachdem die Einschaltung erfolgreich abgeschlossen wurde und der Taster S1 dafür nicht mehr gebraucht wird, wird das Relais K1 eingeschaltet. Über die Kontakte K1.1 und K1.2 wird der Taster in den 5V – Kreis eingebunden und kann für die Eingabe des Tresorcodes verwendet werden.

Spannungsregler

Da der Elektromagnet und die Relais in der Testschaltung für 12V ausgelegt sind, beträgt die Hauptspannungsversorgung 12VDC. Mit dem Spannungsregler wird die Spannung von 5V für den Mikrocontroller bereitgestellt. Bei passenden Komponenten kann die Schaltung einfacher gestaltet werden. Ein Spannungsregler wäre dann überflüssig.

Elektromagnet

Zum Öffnen der Tresortür wird in der Testschaltung ein elektromagnetischer Zunge-Türschloss verwendet. Als Komponente der Schaltung hat er nicht viel zu tun. Klappt es mit der Eingabe des Codes, wird er gerade für eine Sekunde eingeschaltet. Das ist schon alles.

Transistoren

Die Spulen der Relais und des Elektromagneten würden wegen ihrer Stromaufnahme die Ausgänge des Mikrocontrollers überlasten. Das Problem wird mit Transistoren, die in der Schaltung als einfache Schalter auftreten, gelöst. Die Transistoren BD135-16 können Ströme bis zu 1,5 A weiterleiten.

Schaltplan

Programm (Sketch)

int Status_LED = 8;                              // Status LED für Testzwecke (Pin 5)
int K2_Selbsthaltung = 9;                        // Selbsthaltung-Relais K2 (Pin 3)
int K1_Umschaltung_5V = 10;                      // K1: S1 Umschaltung von 12V auf 5V
int Elektromagent = 6;                           // Elektromagnet (Schloss-Zunge)
int Reedkontakt [] = { 1, 2, 3, 4, 5};           // I/O - Reedkontakte
int S1_Druckknopf = 0;                           // I/O - Druckknopf (Pin 13)

int Code_Zahl [] = {3, 7, 10, 12, 19};           // Zuordnung Zahlen zu Reedkontakten
int Zutritts_Code [] = {7, 12, 10, 3, 7, 12, 19};     // Zugangscode
int VersuchsZahl;                                // Aktuelle Versuchszahl
int Gelungene_Versuche;                          // Anzahl der gelungenen Versuche
int VersuchsNummer;                              // Nummer des aktuellen Versuches
unsigned long Zeit_Start;
unsigned long Eingabezeit_Maximal = 10000;       // 10 Sek. für eine Eingabe

// **************************************************************************************
void setup() {

    pinMode(K1_Umschaltung_5V, OUTPUT);          // Ausgang K1
    pinMode(K2_Selbsthaltung, OUTPUT);           // Ausgang K2
    pinMode(Status_LED, OUTPUT);                 // Ausgang LED
    pinMode(Elektromagent, OUTPUT);              // Ausgang Elektromagnet
    pinMode(S1_Druckknopf, INPUT_PULLUP);        // Eingänge als PullUp definiert
    for (int i=0; i<5; i++) {
        pinMode(Reedkontakt [i], INPUT_PULLUP);
    }
    digitalWrite(K2_Selbsthaltung, HIGH);        // Selbsthaltung EIN nach Spannung EIN
    digitalWrite(Status_LED, HIGH);              // Status LED Ein
    delay (300);                                 // Prellen abwarten
    digitalWrite(K1_Umschaltung_5V, HIGH);       // S1 auf 5V umschalten
    delay(100);                                  // Prellen abwarten
    Druckknopf_loslassen();                      // S1 losgelassen?
    Zeit_Start = millis();
}

// **************************************************************************************
void loop() {

    if (digitalRead(S1_Druckknopf) == LOW) {          // Code-Eingabe überprüfen
        Zeit_Start = millis();                        // Eingabe, Zeit verlängern
        digitalWrite(Status_LED, LOW);                // Status LED Aus
        VersuchsNummer++;                             // VersuchsNUmmer aktualisieren
        delay (100);                                  // Prellen abwarten
        for (int i=0; i<5; i++) {                     // Reedkontakte überprüfen
            if (digitalRead(Reedkontakt [i]) == LOW) {
                VersuchsZahl = Code_Zahl [i];         // Aktuelle Eingabe-Zahl festhalten
            }
        }
        Druckknopf_loslassen();                       // S1 losgelassen?          
                                                      // Korrekter Versuch
        if (VersuchsZahl == Zutritts_Code [VersuchsNummer-1]) { 
            Gelungene_Versuche++;                     // Variable aktualisieren
            if (Gelungene_Versuche == 7) {            // Falls kompletter Code OK:
                digitalWrite(Elektromagent, HIGH);    // Tresortür AUF
                delay (1000);
                digitalWrite(K2_Selbsthaltung, LOW);  // Schaltung komplett AUS
            }
        }
    } else {
        digitalWrite(Status_LED, HIGH);
    }
    if (VersuchsNummer != Gelungene_Versuche) {       // Falsche Eingabe = Alles AUS
        delay (300); 
        Druckknopf_loslassen();                       // S1 losgelassen?
         digitalWrite(K2_Selbsthaltung, LOW);         // Selbsthaltung lösen
    }
    if (millis() - Zeit_Start > Eingabezeit_Maximal) {       // Zeit abgelaufen
        digitalWrite(K2_Selbsthaltung, LOW);         // Selbsthaltung lösen
    }    
}       
// **************************************************************************************

void Druckknopf_loslassen() {
                                                 // Fortsetzung, wenn S1 losgelassen
    while (digitalRead(S1_Druckknopf) == LOW) {
        delay(100);
    }
}
// **************************************************************************************

Das Programm wurde mit Arduino IDE erstellt. Bevor das Programm in den Mikrocontroller geladen wird, soll zuerst der Vorgang „Bootloader brennen“ ausgeführt werden. Ein Beispiel für Vorgehensweise beim Programmieren mit einem Programmer findest du unter diesem Link:

Testschaltung

Kurzvideo

Kurzvideo

Weitere Themen: