Aber wäre es nicht viel praktischer, ganz auf physische Schlüssel zu verzichten? Heutzutage gibt es zahlreiche Möglichkeiten, ein Schloss zu öffnen: Fingerabdruckscanner, Gesichtserkennung, NFC, Zahlencodes, Stellräder – oder natürlich brachiale Methoden wie Sprengstoff und rohe Gewalt. Doch wenn man eine preiswerte, gewaltfreie und einfache Lösung sucht, rückt das Tastenfeldschloss in den Fokus.

Überraschenderweise gibt es im Internet kaum wirklich gute DIY-Lösungen für Hobbybastler. Also packe ich es selbst an – mein erstes Tastenfeld-Schloss, das ich schlicht „Version 1“ nenne.

Das könnte dich auch interessieren: DIY Powerbank mit Spannungsregler und Voltmeter

Konstruktion des Gehäuses

Zunächst liegt der Fokus auf dem Gehäuse und der Aufnahme für das Tastenfeld. Die erste Frage, die sich dabei immer stellt: Wie groß soll es sein? Die Antwort hängt von mehreren Faktoren ab:

• Welche Komponenten werden benötigt? Jedes Bauteil nimmt Platz ein und beeinflusst die Bauweise.
• Wie viel Raum beanspruchen die Komponenten? Ein kompaktes Design ist vorteilhaft, darf aber nicht die Funktionalität einschränken.
• Wie sind Haptik und Bedienbarkeit? Das Tastenfeld sollte angenehm zu bedienen sein, ohne dass es zu eng oder unpraktisch wird.

Diese Überlegungen bilden die Grundlage für das Gehäusedesign – denn eine gute Planung spart später Zeit und Nerven.

Was kommt ins Gehäuse?

Zentraler Bestandteil ist natürlich das Membrantastenfeld (1.0.1). Es hat die folgenden Abmessungen:

• Breite: 69 mm
• Länge: 76 mm
• Dicke: 0,6 mm (bzw. 0,95 mm über den Tasten)

Zusätzlich verfügt das Tastenfeld über ein Flachbandkabel mit DuPont-Buchsen zum Anschluss an einen Mikrocontroller. Das Kabel selbst ist 85 mm lang und 17,78 mm breit.

Die Schaltzentrale des Schlosses bildet der Nano (1.0.2). Um ihn sauber im Gehäuse unterzubringen und die Kabelverbindungen möglichst komfortabel zu gestalten, habe ich mich für ein Nano-Expansionsboard mit Schraubklemmen (1.0.4) entschieden.

Für die Notstromversorgung kommt eine Hohlbuchse (5,5 x 2,1 mm, 1.0.4) zum Einsatz, damit das Schloss auch bei einem Stromausfall weiterhin funktioniert.

Die Stift- und Buchsenleisten (1.1.1) dienen als zentrale Stromverteilung und werden später auf die Lochrasterplatte (1.1.2) gelötet. Damit alle Komponenten zuverlässig verbunden werden, kommen Jumperkabel (1.1.3) zum Einsatz. Je nach Position der Bauteile sind unterschiedliche Längen erforderlich – in diesem Fall 10 cm und 20 cm.

Für die Statusanzeige des Tastenfeldschlosses setze ich auf Neo-Pixel – adressierbare LEDs vom Typ WS2812b (1.2.1). Damit lassen sich verschiedene Farben und Effekte steuern, um den aktuellen Zustand des Schlosses visuell darzustellen.

Auf die Positionierung der Schrauben gehe ich später noch genauer ein.

Nachdem die Komponenten nun feststehen, kann ich mir Gedanken über die Größe des Gehäuses machen. Diese wird nicht nur durch die verbauten Elemente bestimmt, sondern vor allem durch die Bedienbarkeit und Haptik.

Tastenfelder begegnen uns täglich – an Bankautomaten, Telefonen, Türschlossanlagen und natürlich Smartphones. Die Entscheidung für die Tiefe des Gehäuses basiert auf einer positiven Erinnerung an meinen vorletzten Arbeitsplatz: Das dortige Tastenfeldschloss am Eingang war erhöht und von beiden Seiten gut zugänglich. Man konnte es bequem mit dem rechten oder linken Daumen bedienen, und die abgerundeten Ecken sorgten für eine angenehme Haptik beim Auflegen der Hand.

Tastenfeldschloss Gehäusedesign

Daraus ergibt sich eine Tiefe von 45 mm (2.0.3). Für eine bessere Ergonomie erhalten die Ecken einen Radius von 15 mm (R15) und die umlaufenden oberen Kanten einen Radius von 10 mm (R10). Mir ist bewusst, dass diese Verrundungen den Innenraum leicht verkleinern, aber der Komfort und die Optik überwiegen diesen Nachteil.

Die Breite und Höhe des Gehäuses ergeben sich aus den einzubauenden Komponenten. Dabei muss auch der Platz für die Verkabelung berücksichtigt werden. Besonders wichtig: Der Nano sollte im eingebauten Zustand weiterhin mit einem handelsüblichen USB-Mini-Kabel erreichbar sein, um beispielsweise neue Programme aufspielen zu können.

Montage und Befestigung

• Vier M3-Gewinde (2.0.1) an der Innenseite ermöglichen das Anschrauben der Trägerplatte.
• Zusätzlich gibt es vier Montagepunkte mit Ø4,2 mm Bohrungen zur Befestigung des Gehäuses an einer Tür, einem Deckel oder einer Wand.
• Das Gehäuse erhält ein Fenster (2.0.2) mit 60 × 67 mm, das für das Tastenfeld vorgesehen ist. Dieses wird später mit der Trägerplatte ausgefüllt.
• Haltesäulen mit M2-Gewinde sowie die Öffnung für die Hohlbuchse (1.0.4) sind mit orangen Ellipsen markiert (2.0.1, 2.0.3).
• Das nächste Bild (2.0.4) zeigt die Außenmaße: 110 mm Breite und 117 mm Höhe.
• Außerdem ist ein Durchbruch bzw. Schlitz von 50 mm Länge für die LED-Blende (2.0.5) erforderlich.

Für die Wandstärke des Gehäuses habe ich durchgehend 2 mm vorgesehen – stabil genug für den vorgesehenen Einsatzzweck.

Mit der abgeschlossenen Gehäusekonstruktion können wir nun mit den weiteren Komponenten fortfahren.

Die Trägerplatte – das zentrale Montageelement

Die nächste wichtige Komponente ist die Trägerplatte. Der Name erklärt sich von selbst: Bis auf die Hohlbuchse werden hier alle Bauteile befestigt. Dieses System bietet mehrere Vorteile gegenüber einer direkten Montage im Gehäuse:

Einfache Montage außerhalb des Gehäuses – Mehr Platz und bessere Handhabung bei der Verkabelung.
Modularität – Verschiedene Trägerplatten mit unterschiedlichen Komponenten sind möglich.
Schlichtes Gehäusedesign – Die Gehäusekonstruktion bleibt einfacher und flexibler.
Leichter Austausch – Komponenten lassen sich einfacher ersetzen oder erweitern.

Doch speziell für das Tastenfeldschloss gibt es noch einen weiteren entscheidenden Vorteil:

Das Tastenfeld wird direkt in eine vorgesehene Vertiefung der Trägerplatte (2.1.1) geklebt. Anschließend wird die Trägerplatte samt Tastenfeld von hinten in das Gehäuse eingesetzt und mit M3-Schrauben fixiert. Dabei verdeckt der Rahmen des Fensters im Gehäuse den Rand und die Kabel vollständig.

Sicherheitsaspekt: Das Fenster ist so dimensioniert, dass zwar der Rand und die Kabel verborgen bleiben, aber die Tasten vollständig sichtbar und bedienbar sind. Dadurch lässt sich das Tastenfeld nicht zerstörungsfrei entfernen – ein wichtiger Schutzmechanismus gegen Manipulation.

Befestigung der Komponenten auf der Trägerplatte

Auf der Rückseite (2.1.2) der Trägerplatte befinden sich diverse Befestigungsmöglichkeiten für die Elektronik:

M3-Gewinde für den Nano-Adapter (2.1.3) – Da Nano-Adapter im Internet oft unterschiedliche Lochabstände haben, gibt es auf der rechten Seite (2.1.2) ein zusätzliches Befestigungsgewinde zur flexiblen Anpassung. Falls die Bohrungen dennoch nicht exakt passen, lassen sie sich vorsichtig aufweiten – allerdings ohne dabei Leiterbahnen des Adapters zu beschädigen.

M2-Gewinde für den Nano R3 ATMEGA168P (2.1.4) – Eine alternative, kostengünstige Lösung anstelle eines Nano R3 mit Adapter.

M2-Gewinde für die Lochrasterplatte (20×80 mm, 1.1.2, 2.1.5) – Diese dient zur Energieverteilung und verbindet alle Stromversorgungsleitungen sauber an einem zentralen Punkt.

Die LED-Blende und ihre Befestigung

Die LED-Blende (2.2.1) wurde so konstruiert, dass sie von der Rückseite in den Schlitz (2.0.5) des Gehäuses eingeklickt wird. Der Radius an der Außenseite der LED-Blende entspricht dem Gehäuseradius, wodurch ein weicher Übergang entsteht und sich die Blende optisch nahtlos einfügt.

Die Montagebrücke (Vorderseite 2.2.2, Rückseite 2.2.3) muss ich nicht neu entwerfen, da ich sie bereits in anderen Projekten erfolgreich verwendet habe.

Die Befestigung der LEDs

Nun bleibt noch die Montage der drei WS2812b-LEDs (1.2.1). Warum genau drei LEDs benötigt werden, werde ich später im Programmierteil dieses Artikels erläutern.

Die Entwicklung des LED-Halters (SMD50, 2.2.4) war aufwendiger als erwartet. Natürlich könnte man die LED-Streifen einfach kleben, klemmen oder mit Heißkleber befestigen – doch das erschien mir zu unprofessionell.

Daher habe ich viel Zeit und Mühe investiert, um eine perfekte Halterung zu entwerfen. Das Resultat ist auf Bild 2.2.5 zu sehen.

Weiterführende Informationen:
Für Details zur Konstruktion gibt es einen eigenen Artikel auf NerdCorner.

3D-Druck der Bauteile

Nachdem die Konstruktion abgeschlossen ist, müssen die Teile nun gedruckt werden.

Materialwahl für die einzelnen Komponenten:

• Gehäuse (3.0.1): gedruckt mit ABS-Filament, bestehend aus Vorder- und Rückseite.
• Trägerplatte (3.0.2): gefertigt aus PLA-Filament.
• LED-Blende (3.0.3): stehend im Drucker hergestellt, gedruckt mit PLA+ in der Farbe „Natur“.
• LED-Klemmen (3.0.4): ebenfalls aus PLA+, gefertigt im selben Verfahren wie die LED-Blende.
• Brücke für die Hohlbuchse: gedruckt aus PLA-Filament, analog zur Trägerplatte.

Mit diesen Materialien sind die mechanischen und thermischen Eigenschaften der Bauteile optimal auf ihre jeweiligen Einsatzzwecke abgestimmt.

Nachbearbeitung der Bauteile

Nach dem Druck müssen sowohl die gedruckten Teile als auch einige Kaufteile bearbeitet werden.

1⃣ Säubern der 3D-Druckteile

• Entfernen von Stützmaterial und überstehenden Druckrückständen.

2⃣ Gewinde schneiden

• Gehäuse (4.0.1):
  • Vier M3-Gewinde (Achtung: Sacklöcher! Beim Schneiden vorsichtig vorgehen, um den Boden nicht nach außen zu drücken).
  • Zwei M2-Gewinde (4.0.2).
• Trägerplatte (4.0.3):
  • Die blau markierten M2-Gewinde müssen auf jeden Fall geschnitten werden.
  • Bei Verwendung eines Nano-Adapters mit Schraubklemmen (2.1.4) müssen zusätzlich die rot markierten M2-Gewinde geschnitten werden.

3⃣ Lochrasterplatte kürzen

• Die Lochrasterplatte (4.0.4) muss auf 8 bis maximal 10 Lochraster gekürzt werden.
• Wichtig: Die Montagelöcher sollten erhalten bleiben (siehe 4.0.5).

4⃣ Stiftleiste kürzen

• Die Stiftleiste mit einem Seitenschneider auf acht Pins kürzen (4.0.6).

Löten der Bauteile

Nun geht es ans Löten der Teile. Zuerst konzentrieren wir uns auf die Energieversorgungsplatine:

1⃣ Löten der Energieversorgungsplatine

• Lochrasterplatte (4.0.5): Lötung der Sockelleiste (1.1.1) und der Pin-Leiste (4.0.6).
• Pin-Leiste (4.1.2): Eine zweireihige Pin- und Sockelleiste wird aufgelötet. Auf der Rückseite verbinden wir die beiden Reihen jeweils mit Lötzinn.
  • Die Reihen unterscheiden sich in Männchen und Weibchen sowie in den Farben: Rot für Plus und Schwarz für Minus. Dies erleichtert den Anschluss der Energieversorgung.

2⃣ Verlötung der WS2812B LEDs

• Verlöten der Anschlüsse des WS2812B LED-Streifens (4.1.3).

3⃣ Verlöten der Hohlbuchse

• Zum Abschluss wird die Hohlbuchse (1.0.4) verlötet (4.1.4).
• Eine detaillierte Anleitung zum Verlöten der Hohlbuchse findest du in einem separaten Artikel. Es ist wichtig, die genaue Vorgehensweise zu kennen, um Fehler zu vermeiden.

Zusammenbau des Tastenfeldschlosses

1⃣ LED-Blende einbauen

• Zuerst klicke die LED-Blende (2.2.1) in das Gehäuse ein.
• Verklebe die LED-Blende an den vorgesehenen Stellen, wie auf den Bildern 5.0.1 und 5.0.2 abgebildet.

2⃣ Nano R3 einstecken

• Stecke den Nano R3 (1.0.2) in den Nano-Adapter (5.0.3) deiner Wahl ein.

3⃣ Nano-Adapter montieren

• Schraube den Nano-Adapter (1.0.3) mit dem eingesteckten Nano R3 (1.0.2) auf der Trägerplatte-Rückseite (4.0.3) fest.
• Verwende dafür die M3-Gewinde auf der Trägerplatte und die Schrauben (1.2.2), wie auf den Bildern 5.0.4 und 5.0.5 zu sehen.

4⃣ Energieversorgung anbringen

• Befestige die Energieversorgung (4.1.2) mit den Schrauben (1.2.4) an der Trägerplatte-Rückseite (4.0.3).
• Siehe dazu das Bild 5.0.6.

Montage des Tastenfelds auf der Trägerplatte

1⃣ Wahl der Schraubenlänge

• Achte darauf, wie auf Bild 5.1.1 dargestellt, die richtige Schraubenlänge zu wählen.
• Schrauben dürfen nicht zu lang sein, da sie sonst beim Anbringen des Tastenfelds aus der Klebefläche herausragen und das Tastenfeld nicht sauber aufgeklebt werden kann.

2⃣ Tastenfeld vorbereiten

• Entferne die Schutzfolie des Tastenfelds (1.0.1).
• Um die Folie zu entfernen, benutze ein Teppichmesser, um vorsichtig an einer Ecke zwischen Klebeschicht und Schutzfolie zu kommen (siehe 5.1.2).
• Nachdem du die Ecke erreicht hast, ziehe die ganze Schutzfolie ab (siehe 5.1.3).

3⃣ Tastenfeld aufkleben

• Setze das Tastenfeld (1.0.1) in die Vertiefung auf der Trägerplatte-Vorderseite (2.1.1) ein und drücke es fest an.
• Das Tastenfeld muss komplett versenkt werden und darf nicht über den Rand hinausstehen (siehe 5.1.4).
• Achte darauf, dass auch die Kabel in der Vertiefung liegen (siehe 5.1.5).

Verkabelung des Tastenfelds mit dem Arduino Nano R3

1⃣ Jumper-Kabel verwenden

• Jumper-Kabel (10 cm lang, Männchen-Männchen) werden verwendet, um das Tastenfeld mit dem Arduino Nano R3 zu verbinden (siehe 5.2.1).

2⃣ Anschluss der Kabel

• Achte darauf, dass du die Kabel nicht verdrehst, sondern nur biegst.
• Das linke Kabel wird an D2 des Arduino angeschlossen, und das rechte Kabel an D8.
• Insgesamt sind es sieben Kabel, die die Anschlüsse D2 bis D8 belegen (siehe 5.2.3).

3⃣ Pin-Leisten verwenden

• Da das Rastermaß des Arduino-Adapters und des Tastenfelds nicht übereinstimmen, kannst du Pin-Leisten verwenden, um die Verbindung herzustellen.

4⃣ Befestigung der LED-Klemmen

• Die Klammern (3.0.4) für die WS2812B LEDs werden an den LEDs festgeklickt.
• Am besten machst du das auf einer ebenen Oberfläche (siehe 5.2.4).

5⃣ Anbringen des LED-Streifens

• Der WS2812B Streifen wird nun mittig an der Oberseite der Trägerplatte aufgeschoben (siehe 5.2.5 Vorderseite und 5.2.6 Rückseite).

Zusammenbau der Trägerplatte und Gehäuse

1⃣ Verschrauben der Trägerplatte mit dem Gehäuse (5.3.1)

• Achte darauf, dass du M3 Schrauben verwendest, die nicht zu lang sind. Andernfalls könnten sie beim Anziehen eine Erhöhung in die Vorderseite des Gehäuses drücken.
• Die Ausrichtung der Trägerplatte im Gehäuse ist wichtig: Der LED-Streifen sollte auf der gleichen Seite wie die LED-Blende sein.
• Nach dem Verschrauben sollte das Tastenfeld leicht an den inneren Rahmen des Gehäuses gepresst sein (siehe 5.3.2 und 5.3.3).

2⃣ Vormontage der Hohlbuchse für die Notstromversorgung

• Für die Notstromversorgung musst du die Hohlbuchse vormontieren und an das Gehäuse schrauben.
• Die Hohlbuchse mit Brücke und Mutter wird in Bild 5.3.4 dargestellt.
  • Stecke die Hohlbuchse in die runde Vertiefung der Brücke.
  • Kontere die Hohlbuchse mit der Mutter auf der anderen Seite der Brücke.

3⃣ Befestigung der Hohlbuchse im Gehäuse

• Die Hohlbuchse mit der Brücke wird dann an die im Gehäuse vorgesehenen Haltesäulen mit M2 Schrauben verschraubt (siehe 5.3.5 und 5.3.6).

Anschluss der Kabel und Fertigstellung der Stromversorgung

1⃣ Anschluss des Steuerkabels für den Servomotor

• Das Steuerkabel für den Servomotor wird an Pin D9 des Nano R3 angeschlossen (5.4.1).

2⃣ Anschluss der Stromversorgung für den Nano R3

• Die Stromversorgung des Nano R3 wird an den GND-Pin und den VIN-Pin des Nano R3 angeschlossen (5.4.2).

3⃣ Anschluss des Steuerkabels für den WS2812B

• Das Steuerkabel für den WS2812B LED-Streifen wird an Pin D10 des Nano R3 angeschlossen (5.4.3).

4⃣ Verkabelung des Stromverteilers

• Alle restlichen Kabel müssen an den Stromverteiler angeschlossen werden:
  • Servomotor-Anschluss
  • Arduino Nano R3
  • WS2812B LED-Streifen
  • Hohlbuchse Alle Verbindungen erfolgen mit Plus und Minus (siehe 5.4.4 und 5.4.5).

5⃣ Verwendung von unterschiedlichen Farben und Anschlussarten für die Verkabelung

• Es hilft, unterschiedliche Kabel-Farben zu verwenden:
  • Rot für Plus
  • Schwarz für Minus
• Der Stromverteiler hat unterschiedliche Anschlussarten:
  • Männlich für Plus
  • Weiblich für Minus

6⃣ Hinweis zur Hohlbuchse

• Zur Verkabelung und Anschluss der Hohlbuchse gibt es einen eigenen Artikel, den du unbedingt lesen solltest

7⃣ Anbringen der Stecker-Gehäuse für den Servomotor und die Energieversorgung

• Für den Servomotor-Anschluss wird ein drei-poliger Stecker benötigt.
• Für die externe Energieversorgung wird ein zwei-poliger Stecker benötigt.
  • Weitere Details zum Konstruktionsprozess und den Download-Links für Stecker-Gehäuse findest du hier.

Im Bild 5.5.1 ist nochmal die ganze Verkabelung dargestellt.

Arduino Code

Nach der intensiven Arbeit mit der Hardware und dem 3D-Drucker widmen wir uns nun der Strategie und der Programmierung des Tastenfeldschlosses. Warum ist eine Strategie für ein Tastenfeldschloss wichtig? Eine durchdachte Handlungsabfolge – also die Reihenfolge, in der das Tastenfeldschloss bedient wird, welche Ereignisse sich aus bestimmten Aktionen ergeben und welches Ziel verfolgt wird – bildet die Grundlage für eine funktionale Steuerung. Dieser Leitfaden ist daher auch entscheidend für die Programmierung des Tastenfeldschlosses: Er legt fest, was wann passieren soll und welche Hardware dabei zum Einsatz kommt. Ziel ist es, eine logische und nachvollziehbare Abfolge von Ereignissen zu schaffen, die in diesem Fall auch optisch nachzuvollziehen ist.

Beispiel 1:
Das Tastenfeldschloss soll anzeigen, wie viele Stellen bereits eingegeben wurden. (Siehe Bilder 7.0.1 bis 7.0.4)

Beispiel 2:
Das Tastenfeldschloss soll nach Betätigung einer bestimmten Taste mitteilen, ob das eingegebene Kennwort korrekt ist. (Siehe Bild 7.0.5)

Beispiel 3:
Das Tastenfeldschloss soll anzeigen, wenn etwas falsch eingegeben wurde, wie etwa ein falsches Kennwort oder zu viele Tastenanschläge. (Siehe Bild 7.0.8)

Beispiel 4:
Das Tastenfeldschloss soll den aktuellen Zustand anzeigen. (Siehe Bilder 7.0.5 bis 7.0.7)

Kommen wir nun zur Programmierung des Tastenfeldschlosses, die sich in einigen Punkten von herkömmlichen Programmen im Internet unterscheidet. Zu Beginn werden die drei notwendigen Bibliotheken eingebunden: <Keypad.h> für das Tastenfeld, <Adafruit_NeoPixel.h> für die WS2812B LEDs und <Servo.h> für den Servomotor (Bild 6.0.1). Im folgenden Abschnitt wird die Pin-Belegung für die LEDs festgelegt, wobei Pin D10 verwendet wird und die Anzahl der LEDs sowie das Farbschema bestimmt werden. Ebenso wird die Helligkeit der LEDs festgelegt – dieser Wert kann je nach Standort angepasst werden, wobei höhere Werte für mehr Helligkeit sorgen (Werte von 0 bis 255). (Siehe Bild 6.0.2) Der dritte Abschnitt widmet sich der Beschreibung des verwendeten Tastenfelds, einschließlich der Anzahl der Reihen und Spalten sowie der Belegung der Tasten. (Siehe Bild 6.0.3)

Im vierten Abschnitt wird der Servomotor konfiguriert, indem der Gradbereich festgelegt wird, den er zurücklegen kann, sowie die Geschwindigkeit, mit der er sich bewegen soll (siehe Bild 6.1.1). Anschließend folgt der Abschnitt zur Kennworteingabe. Hier habt ihr die Möglichkeit, das Standardkennwort 1516 zu ändern, um ein neues vierstelliges Kennwort festzulegen. Das Programm funktioniert nur korrekt, wenn ein vierstelliger Code eingegeben wird. In diesem Abschnitt wird außerdem der Steuer-Pin für den Servomotor auf D9 gesetzt (siehe Bild 6.1.2). Der darauf folgende Abschnitt widmet sich der Festlegung der Farben für die verschiedenen Ereignisse.

In den letzten beiden Abschnitten wird das Verhalten des Tastenfeldschlosses bei bestimmten Handlungen erläutert. Diese Beschreibung stellt natürlich nur einen groben Überblick über das Programm dar. In einem zukünftigen Artikel für Tastenfeldschloss Version 2 werden wir dann das Programm detaillierter und umfassender erklären.

//==========================================Librarys==============================================================
#include <Keypad.h>
#include <Adafruit_NeoPixel.h>
#include <Servo.h>
//========================================Neo-Pixel==============================================================
#define LED_PIN 10
#define LED_COUNT 3
Adafruit_NeoPixel strip(LED_COUNT, LED_PIN, NEO_GRB + NEO_KHZ800);
int led_strength = 75; //controlls Brighttness (0 - 255)
//========================================Keypad=================================================================
const byte rows = 4;
const byte cols = 3;
char keys[rows][cols] = {
 {'1', '2', '3'},
 {'4', '5', '6'},
 {'7', '8', '9'},
 {'*', '0', '#'}
};
byte rowPins[rows] = {8, 7, 6, 5};
byte colPins[cols] = {4, 3, 2};
Keypad keypad = Keypad( makeKeymap(keys), rowPins, colPins, rows, cols );
//=========================================Servo============================================================
Servo lock;
int pos = 0;
int servo_angle = 180;
int servo_speed = 15;
//======================================Password===============================================================
String input;
const String password = "1516"; //Set Password
int n = 1;

 

void setup() {
 input.reserve(password.length() +2);
 strip.begin();
 strip.show();
 lock.attach(9); //motor pin
}

void loop() {
//-------------------colours------------------------------------------------------------------- 
 uint32_t blue = strip.Color(0, 0, led_strength);
 uint32_t green = strip.Color(0, led_strength, 0);
 uint32_t red = strip.Color(led_strength, 0, 0);
 uint32_t orange = strip.Color(led_strength, led_strength/2, 0);

 char key = keypad.getKey();

if (key != NO_KEY) {
//-------------------------End conditions------------------------------------------------------
 if (key == '#') {
 if (input == password) {
 //unlock
 strip.clear();
 strip.fill(green, 0, LED_COUNT);
 strip.show();
 for (pos = 0; pos <= servo_angle; pos += 1) {
 lock.write(pos);
 delay(servo_speed );
 }
 while (1 == 1)
 { char key = keypad.getKey();
 strip.clear();
 strip.fill(orange, 0, LED_COUNT);
 strip.show();
 if (key == '*')
 {
 strip.clear();
 strip.fill(green, 0, LED_COUNT);
 strip.show();
 break;
 }
 }

 for (pos = servo_angle; pos >= 0; pos -= 1) {
 lock.write(pos);
 delay(servo_speed );
 }
 n = 1;
 input = "";
 delay (1000);
 strip.clear();
 strip.show();
 } else {
 //wrong password
 strip.clear();
 strip.fill(red, 0, LED_COUNT);
 strip.show();
 n = 1;
 input = "";
 delay (1000);
 strip.clear();
 strip.show();
 }
 }
 else if (n == password.length() + 1) {
 //Input too long
 strip.clear();
 strip.fill(red, 0, LED_COUNT);
 strip.show();
 n = 1;
 input = "";
 delay (1000);
 strip.clear();
 strip.show();
 }
//----------------------------------Buttons------------------------------------------
 else {
 input += key;
 if (n == password.length() ) {
 strip.clear();
 strip.fill(blue, 0, LED_COUNT); 
 strip.show();
 n++;
 }
 else {

 strip.clear();
 strip.setPixelColor(n-1, blue);
 strip.show();
 n++;
 }
 }
 }

}

Funktion

Die Bedienung des Tastenfeldschlosses ist sehr intuitiv. Sobald die erste Taste gedrückt wird, leuchtet die rechte LED blau (7.0.1). Beim zweiten Tastendruck wird die mittlere LED blau (7.0.2). Nach der dritten Taste strahlt die linke LED in Blau (7.0.3). Mit der vierten Taste leuchten schließlich alle drei LEDs blau (7.0.4). Wenn diese drei LEDs in Blau leuchten, weiß der Benutzer, dass die #-Taste gedrückt werden muss.

Wird die #-Taste betätigt, erfolgt die Überprüfung des Passworts. Ist das Passwort korrekt, leuchten alle drei LEDs gleichzeitig grün, und der Servomotor wird aktiviert (7.0.5). Das grüne Licht bleibt so lange an, wie der Servomotor seine Endlage (offen) noch nicht erreicht hat. Sobald der Servomotor die Endlage (offen) erreicht, wechseln die LEDs von Grün zu Orange (7.0.6). Die orange Farbe bleibt so lange erhalten, bis der Benutzer die *-Taste drückt.

Nach dem Drücken der *-Taste wechseln die LEDs wieder auf Grün (7.0.7) und bleiben in dieser Farbe, bis der Servomotor die Endlage (geschlossen) erreicht hat. Ist dies der Fall, erlöschen die LEDs, und das Tastenfeldschloss ist bereit für neue Eingaben.

Falls jedoch das Passwort nach dem Drücken der #-Taste in Schritt 7.0.4 falsch ist, leuchten alle drei LEDs rot (7.0.8). Ebenso wird das rote Licht angezeigt, wenn mehr als vier Tasten, abgesehen von der #-Taste, gedrückt werden.

Türmontage

Natürlich ist diese Variante nicht für den Einsatz an einer gewöhnlichen Tür gedacht, bei der man einfach hindurchgeht und die Tür sich von selbst wieder schließt. Der Grund dafür liegt im offenbleiben des Schlosses, bis die *-Taste gedrückt wird. Doch wie kann man die *-Taste drücken, wenn man sich auf der anderen Seite des Tastenfeldschlosses befindet, hinter der Wand? Eine Verzögerung im Programm könnte zwar helfen, aber wer weiß schon, wie lange man braucht, um die Tür zu passieren und hinter sich zu schließen? Eine viel sinnvollere Lösung wäre es, einen zusätzlichen Schalter zu implementieren, der auf der anderen Seite der Tür angebracht wird. Dieser Schalter würde, ohne eine Passworteingabe, bei Betätigung direkt zu Punkt 7.0.6 führen und das Schloss öffnen, sodass die Tür von innen geöffnet werden kann.

Doch das ist Zukunftsmusik. Nun kommen wir zur Montage des Tastenfeldschlosses an einer Tür. Hierfür habe ich auf der Rückseite des Gehäuses vier Bohrungen vorgesehen. Diese Bohrungen haben an der Innenseite eine Vertiefung für herkömmliche Sechskantmuttern M4 DIN 934. Die entsprechenden Bohrungen sind in Bild 8.0.1 (Rückansicht) und Bild 8.0.2 (Vorderansicht) zu sehen, wobei das Gehäuse zur besseren Anschauung etwas transparent dargestellt ist. Die Installation der Muttern ist denkbar einfach: Nachdem sichergestellt wurde, dass sämtliches Supportmaterial entfernt ist, wird die Mutter von hinten in die vorgesehene Vertiefung gedrückt. Es sollten keine Einpressmuttern verwendet werden, da diese unnötig teuer sind.

Für die Befestigung an der Wand oder Tür habe ich eine Bohrschablone entwickelt (Bild 8.0.3). Diese Schablone enthält an den vier Ecken jeweils eine Bohrung mit einem Durchmesser von 4 mm. Der Abstand der Bohrungen entspricht dem Abstand der Bohrungen am Gehäuse. Man kann die Schablone bequem an der Oberfläche der Tür fixieren, zum Beispiel mit Klebeband (Bild 8.0.4). So spart man sich das mühsame Anreißen der Bohrlöcher und vermeidet Fehler.

Auf Bild 8.1.1 sehen wir die gebohrten Montagelöcher von der Vorderseite, markiert durch magentafarbene Kreise. Dank der Bohrschablone haben diese Löcher den richtigen Abstand zueinander. Falls beim Bohren die Position leicht verrutscht oder nicht ganz exakt eingehalten wurde, stellt das kein Problem dar. In diesem Fall kann man die Montagelöcher einfach etwas größer bohren, um das Tastenfeldschloss beim Anschrauben präzise auszurichten. Zusätzlich sind auf diesem Bild in gelben Kreisen zwei Bohrungen zu sehen, die leider etwas am Rand ausgebrochen sind. Diese Bohrungen sind für das Kabel des Servos und die Energieversorgung vorgesehen. Nachdem die Bohrungen fertiggestellt waren, habe ich das Tastenfeldschloss angebracht und die Kabel zuvor durch die vorgesehenen Bohrungen auf der Rückseite der Tür (Bild 8.1.2) geführt.

Die gesamte Montagearbeit des Tastenfeldschlosses ist auf der Vorderseite der Tür in Bild 8.2.1 zu sehen. Wer mit dieser Montagelösung nicht zufrieden ist, kann ich beruhigen: Als letzten Schritt habe ich einen Rückendeckel entworfen, der es ermöglicht, das Tastenfeldschloss an einer Wand oder einem Rahmen zu befestigen (Bild 8.2.2). Dazu steckt man einfach das Gehäuse des Tastenfeldschlosses auf den Rückendeckel und verschraubt es von hinten mit M4 Senkkopfschrauben (markiert durch magentafarbene Kreise in Bild 8.2.2). Danach wird das ganze Konstrukt an der Wand befestigt, wofür zwei Laschen mit jeweils zwei Bohrungen zur Verfügung stehen (gelbe Kreise in Bild 8.2.2).

Nicht zu vergessen ist, dass man am Gehäuse zusätzlich eine oder mehrere Bohrungen für die Kabel des Servos und der Energieversorgung anbringen muss. Dabei sollte man auch das Sicherheitsrisiko bedenken, dass eine unbefugte Person das Tastenfeldschloss über die zugänglichen Schrauben abschrauben könnte.

Schließmechanismus

Wer jetzt noch einen echten Schließmechanismus vermisst, der nicht nur einen Servo-Anschluss nutzt, kann sich auf den „Schließer“ freuen, der sich bereits in der Entwicklung befindet und in den kommenden Versionen des Tastenfeldschlosses präsentiert wird.

Die Entwicklung des Tastenfeldschlosses war eine spannende, aber auch herausfordernde Aufgabe. Besonders hervorzuheben sind einige Eigenschaften der VERSION 1 des Tastenfeldschlosses:

• Verschiedene Arduino Nano-Modelle und Adapter können verwendet werden – Flexibilität bei der Hardwarewahl.
• Optisches Feedback – Über die Zahleneingabe und den Status des Tastenfeldschlosses wird der Benutzer direkt informiert.
• Notstromversorgung über Hohlbuchse – Garantiert zuverlässige Funktion im Falle von Stromausfällen.
• Stabiles Programm – Die Software wurde so entwickelt, dass sie zuverlässig funktioniert.
• Optimale Haptik für Links- und Rechtshänder – Das Tastenfeldschloss wurde ergonomisch gestaltet, um allen Nutzern gerecht zu werden.

Dateien zum Herunterladen

• Tastenfeldschloss Gehäuse

The post DIY Tastenfeldschloss – 3D Druck und Programmierung appeared first on Nerd Corner.

Ich sehe leider sehr oft Blogartikel in denen der HTML Code in der Arduino Datei eingebettet wird. Sowas kann man für eine Mini Demonstration zwar machen, ist aber im Alltag völliger Schwachsinn. Es ist viel zu unübersichtlich und sobald das Projekt wächst nicht mehr nutzbar.

Die ordentliche Alternative ist einen Ordner namens „data“ einzurichten und in diesem die Webseiten als html Dateien abzulegen. Zusätzlich wird das Styling als CSS Datei gespeichert und es können sogar Funktionen per JavaScript Datei ausgeführt werden. Also alles 1:1 wie auf einem gewöhnlichem Webserver!

Das könnte dich auch interessieren: WeMos D1 R2 erste Schritte und Wlan Integration

Liste der Komponenten

• Arduino IDE (Entwicklungsumgebung)
• WeMos D1 R2

Das Einrichten des Dateisystems (offiziell SPIFFS) geschieht einmalig und ist kinderleicht:

(Zunächst sollte man die grundlegende Einrichtung aus dem ersten Teil abgeschlossen haben!)

1. Auf GitHub eine Kopie der Datei „ESP8266FS-0.2.0.zip“ herunterladen und entpacken
2. Die Datei esp8266fs.jar im Arduino-Tool-Verzeichnis ablegen. Der Pfad sieht etwa so aus: [home_dir]\Arduino\tools\ESP8266FS\tool\esp8266fs.jar (Siehe Bild) Ich musste den Pfadteil tools\ESP8266FS\tool\ im Arduino Ordner selbst erstellen.
3. Die Arduino IDE neustarten.

Das wars auch schon! Man kann jetzt in der Arduino DIE unter Tools den neuen Punkt „ESP8266 Sketch Data Upload“ sehen.

Wie kann man das neue Dateisystem jetzt nutzen?

1. Erstellen Sie in ihrem aktuellen WeMos Projekt Ordner einen zusätzlichen Ordner mit dem Namen „data“. So wie in dem nachfolgendem Bild

2. Legen Sie die Dateien, die Sie hochladen möchten, in das ‚data‘-Verzeichnis
3. Wählen Sie in der Arduino IDE im Menü ‚Tools‘ den WeMos aus und wählen Sie eine Größe bei ‚Flash Size‘
4. Das Dialogfeld für den seriellen Monitor schließen!
5. Wählen Sie aus dem Menü ‚Tools‘ die Option ‚ESP8266 Sketch Data Upload‘.

Sobald der Upload abgeschlossen ist zeigt das Nachrichtenfenster der Arduino IDE 100% Upload an.

WeMos Beispielprogramm zum Ein- und Ausschalten der OnBoard LED

Ähnlich wie im ersten Teil wird der Webserver die OnBoard LED steuern. Als Basis dient ebenfalls der Code aus dem ersten Teil. Der überarbeitete Code sieht so aus:

#include <ESP8266WiFi.h>
#include <ESP8266WebServer.h>
#include <ESP8266mDNS.h>

ESP8266WebServer server(80);

void setup() {
  Serial.begin(115200); //Baudrate
  Serial.println("ESP starts");

  WiFi.begin("NerdCornerWiFi","NerdCornerPassword");


  Serial.print("Connecting...");

  while(WiFi.status()!=WL_CONNECTED){ //Loop which makes a point every 500ms until the connection process has finished

    delay(500);
    Serial.print(".");
  }
  Serial.println();

  Serial.print("Connected! IP-Address: ");
  Serial.println(WiFi.localIP()); //Displaying the IP Address

  if (MDNS.begin("nerd-corner")) {
    Serial.println("DNS started, available with: ");
    Serial.println("http://nerd-corner.local/");
  }

  server.serveStatic("/", SPIFFS, "/", "max-age=86400");
  SPIFFS.begin();

  server.onNotFound([](){ 
    server.send(404, "text/plain", "Landing page not found! Don't forget to name your landing page 'index.html'!");  
  });
 
  server.on("/led", HTTP_POST, []() {    
     
    const String ledState = server.arg("ledstate");
    if(ledState=="on"){
      switchLedOn();
    }
    else if(ledState=="off"){
      switchLedOff();
    }
    server.send(200, "text/json", "{\"result\":\"ok\"}");
  });

  server.begin();
  // initialize digital pin LED_BUILTIN as an output.
  pinMode(LED_BUILTIN, OUTPUT);
}

void loop() {
  server.handleClient();
  MDNS.update();

}

void switchLedOff(){ 
  digitalWrite(LED_BUILTIN, HIGH);   // turn the D1 LED off 
}

void switchLedOn(){ 
  digitalWrite(LED_BUILTIN, LOW);    // turn the LED on 
}

Auf ein paar Besonderheiten möchte ich dabei hinweisen. Wir haben beispielsweise folgendes hinzugefügt:

server.serveStatic("/", SPIFFS, "/", "max-age=86400"); 
SPIFFS.begin();

Ohne die beiden Zeilen wäre der Zugriff auf die Dateien im „data“ Ordner nicht möglich. Bitte beachten, dass der Name „index.html“ als default für die Landing Page eingestellt ist. Wenn man unbedingt möchte kann man das aber auch ändern.

server.on("/led", HTTP_POST, []() {    
     
    const String ledState = server.arg("ledstate");
    if(ledState=="on"){
      switchLedOn();
    }
    else if(ledState=="off"){
      switchLedOff();
      }
      server.send(200, "text/json", "{\"result\":\"ok\"}");
  });

Der „/led“ Endpoint empfängt die Befehle vom Webserver. Lautet der Befehl „on“ wird die LED eingeschaltet und bei „off“ wird die LED ausgeschaltet.

Wemos Webseite zum Ein- und Ausschalten der WeMos OnBoard LED

Die Beispielwebseite ist ganz einfach aufgebaut. Sie besteht in erster Linie aus 2 Buttons zum Ein- und Ausschalten der LED.

Die Ordnerstruktur der Webseite ist sehr übersichtlich gehalten. Es gibt eine Hauptseite mit dem Namen „index.html“ Dieser Name ist weltweit üblich für die Hauptseiten und wird auch automatisch vom WeMos entsprechend erkannt. Darüber hinaus einen „CSS“ Ordner fürs Styling und einen „JS“ Ordner für Funktionen.

Im Header Bereich der Webseite verlinken wir die Styles. Da wäre zum einen ein Standard Bootstrap, der alles automatisch bischen schöner macht und zusätzlich eine custom Styles Datei mit meinen eigenen Anpassungen. Außerdem werden im Header Bereich auch die Funktionen der Webseite verlinkt. Ich benutze den jQuery Standard um von der Webseite Requests an den WeMos zu senden. Meine eigenen custom Funktionen liegen in der „index.js“.

Bitte beachten, dass die jQuery Datei VOR der eigenen Datei eingebunden werden muss, sonst können keine jQuery Befehle im eigenen Code benutzt werden! Die eigenen Funktionen werden anschließend von den Buttons verwendet. Der HTML Code der Seite sieht insgesamt folgendermaßen aus:

<!DOCTYPE html>
<html lang="en"></html>
<html>
  <head>
    <meta charset="utf-8" />
    <meta
      name="viewport"
      content="width=device-width, initial-scale=1, shrink-to-fit=no"
    />
    <script type="text/javascript" src="js/jquery-3.5.1.min.js"></script>
    <script type="text/javascript" src="./js/index.js"></script>
    <link rel="stylesheet" href="css/bootstrap.min.css" />
    <link rel="stylesheet" href="css/custom-style.css" />
    <title>D1 Webserver</title>
  </head>
  <body>
    <h1>D1 Webserver with filesystem</h1>
    <p>
      This is an example for a WeMos Webserver with a filesystem. You can easily
      create webpages with html, css and js!
    </p>

    <h3>Example to turn on and off the built in LED</h3>
    <button class="button-style" onclick="changeLEDState('on')">Turn on</button>
    <button class="button-style" onclick="changeLEDState('off')">
      Turn off
    </button>

    <h3>Example to demo a JS function</h3>
    <button class="button-style" onclick="showAlert()">Show alert</button>
  </body>
</html>

Besonderes Augenmerk gilt der JavaScript Funktion „changeLEDState(value)“

function changeLEDState(value) {
  $.post("/led", { ledstate: value });
}

Dadurch, dass jQuery genutzt wird für die Kommunikation mit dem WeMos, reicht ein einfaches Dollarzeichen mit dem entsprechendem Request Befehl. Bei diesem POST Request wird ebenfalls ein Wert mit geschickt, welcher entweder „on“ oder „off“ ist zum ein- und ausschalten der LED.

Die Webseite kann nachfolgend als zip Datei heruntergeladen werden.

Dateien zum Herunterladen

• Wemos example webserver to control OnBoard LED

The post WeMos D1 R2 – Ganze Webseite mit html, css & js hosten appeared first on Nerd Corner.

Das könnte dich auch interessieren: Wie man einen Lüfter mit einem Arduino steuert!

Liste der Komponenten

• Arduino IDE (Entwicklungsumgebung)
• WeMos D1 R2

Unterschiede zwischen dem WeMos D1 R2 und dem Arduino UNO R3

Ein Arduino UNO R3 ähnelt optisch sehr dem WeMos D1. Der Hauptunterschied ist, dass der D1 ein ESP2866 WIFI Modul auf seiner Platine integriert hat. Dadurch hat man die Möglichkeit den D1 mit dem Internet zu verbinden. Grob gesagt ist der D1 ein wlanfähiger Arduino!

Man sollte allerdings beachten, dass die Taktfrequenz der beiden Prozessoren unterschiedlich sind. Der Arduino besitzt einen 8 bit Atmel Prozessor und der D1 einen Wlan fähigen ESP8266 Prozessor mit 32 bit Taktfrequenz. Die Pins des D1 sind zwar ähnlich angeordnet wie bei einem Arduino UNO, aber unterscheiden sich in der Betriebsspannung. Bei einem Arduino UNO liegt die Spannung der Pins bei 5V und bei dem D1 bei 3,3V. Zusätzlich ist aber auch auf dem D1 ein 5V Ausgang vorhanden. Aufgrund der Spannungsunterschiede an den Pins sollte man nicht blindlings ein Arduino Shield auf einen D1 stecken. Es empfiehlt sich zuerst die Kompatibilität zu prüfen!

Außerdem sollte man beachten, dass der D1 im Gegensatz zum Arduino nur einen analog Pin besitzt und zusätzlich die Anzahl der digitalen Pins unterschiedlich ist. Der Arduino besitzt 20 digitale Pins und der D1 nur 16 digitale Pins. Allerdings haben die digitalen Pins des D1 mehr nützliche Zusatzfunktionen.

Bitte beachten: Auch die Bezeichnung der digitalen D1 Pins unterscheidet sich von denen des Arduino und müssen daher softwaretechnisch angepasst werden.

Als letztes noch der Hinweis, dass sich der USB Anschluss ebenfalls unterscheidet. Im Gegensatz zum Arduino besitzt der D1 den deutlich verbreiteteren Micro USB Standard.

Einrichtung des D1

Die Arduino IDE öffnen und den D1 mit dem Computer verbinden. Unter Tools > Port den entsprechenden COM Port des D1 auswählen. Sollte der D1 hier nicht erkannt werden liegt das vermutlich an einem fehlenden Treiber.

Wenn nun der passende COM Port ausgewählt wurde und man einen Beispiel sketch auf den D1 lädt wird vorraussichtlich folgende Fehlermeldung auftauchen: „An error occurred while uploading the sketch avrdude: stk500_getsync() attempt 1 of 10: not in sync: resp=0x2e“. Der Grund für diesen Fehler ist, dass das falsche Board ausgewählt wurde. Der Name des ausgewählten Boards taucht rechts unten in der IDE auf:

Um den D1 auswählen zu können muss der Boardmanager für den ESP8266 noch hinzugefügt werden. Hier folgenden Link in Preferences > Board Manager einfügen: http://arduino.esp8266.com/stable/package_esp8266com_index.json

Anschließend in Tools > Board > Board Manager nach ESP8266 suchen und die neuste Version installieren:

Jetzt in Tools > Board > ESP8266 Boards > LOLIN (WEMOS D1 R2 &mini) auswählen:

Nun kann man wieder ein Beispielprojekt unter File > Examples > 01.Basics > Blink auswählen und mit einem Klick auf Upload funktioniert das Ganze. Das Beispielprojekt lässt jetzt die blaue LED auf dem ESP8266 Modul blinken.

Achtung: Dieses Setup war einmalig für die erstmalige Benutzung und muss nicht erneut wiederholt werden!

WeMos D1 mit dem Internet verbinden

Der Programmaufbau entspricht dem eines regulären Microcontrollers wie man es auch vom Arduino kennt. Es gibt eine setup() Funktion, welche nur einmal direkt zum Programmstart aufgerufen wird und eine loop() Funktion, welche nach dem setup() in Dauerschleife läuft.

Als erstes wird die ESP WiFi Bibliothek benötigt. Diese wird mittels #include <ESP8266WiFi.h> eingebunden. Sobald der ESP mit Strom versorgt wird, soll eine WLAN-Verbindung hergestellt werden. Daher wird der Code in die setup() Funktion geschrieben.

Wir brauchen den Seriellen Monitor um uns den aktuellen Stand des Verbindungsaufbaus anzeigen zu lassen. Die Baudrate kann selbst festgelegt werden. Für den D1 nehme ich 115200. Den Seriellen Monitor findet man unter Tools > Serial Monitor. Im Fenster des Seriellen Monitors kann rechts unten die Baudrate eingestellt werden. Bitte hier ebenfalls 115200 auswählen. Wählt man nicht die gleiche Baudrate wie im setup() definiert, werden einem nur unleserliche Sonderzeichen angezeigt.

Um sich mit dem Wlan zu verbinden reicht der einfache Befehl WiFi.beginn(„WlanName“, „WlanPasswort“). Es kann sehr hilfreich sein wenn man sich hier gleich die IP Adresse des D1 anzeigen lässt. Dazu nutzt man den Befehl WiFi.localIP()

#include <ESP8266WiFi.h>

void setup() {
  Serial.begin(115200); //Baudrate
  Serial.println("ESP starts");

  WiFi.begin("NerdCornerWiFi","NerdCornerPassword");

  Serial.print("Connecting...");

  while(WiFi.status()!=WL_CONNECTED){ //Loop which makes a point every 500ms until the connection process has finished

    delay(500);
    Serial.print(".");
  }
  Serial.println();

  Serial.print("Connected! IP-Address: ");
  Serial.println(WiFi.localIP()); //Displaying the IP Address

}

void loop() {
  // put your main code here, to run repeatedly:

}

Der D1 als Webserver und DNS-Server

Nach den bisherigen Schritten ist der D1 zwar mit dem WiFi verbunden, aber selbst noch nicht über einen Browser erreichbar. Damit der D1 bequem über den Browser angesteuert werden kann braucht man die #include <ESP8266WebServer.h> Bibliothek. Anschließend wird mit dem Befehl ESP8266WebServer server(80) ein Webserver Objekt erstellt und der Port 80 festgelegt. Der Server lässt sich nun mit dem Befehl server.begin() starten. Damit der D1 zu jederzeit prüfen kann, ob Anfragen zu bearbeiten sind, wird der server.handleClient() in die loop() Funktion geschrieben.

Gibt man nun die IP Adresse des D1 in einem Browser ein, von einem Gerät, dass sich im selben WiFi befindet, ist der D1 bereits erreichbar. Es wurde nur noch nicht spezifiziert was bei einem Aufruf des D1 passieren soll.

Man kann sich hier auch vorgefertigte Funktionen anzeigen lassen. Für den Anfang beispielsweise einen Satz, wenn der Link nicht definiert wurde, oder einen Text für einen custom Link. Es können auch eigene Funktionen für bestimmte Links ausgeführt werden.

server.onNotFound([](){ 
  server.send(404, "text/plain", "Link was not found!");  
});
 
server.on("/", []() {
  server.send(200, "text/plain", "Landing page!");
});
 
server.on("/custom", []() {
  server.send(200, "text/plain", "Just a custom route!");
  ownFunction();
});

Die Webserver Einrichtung ist jetzt abgeschlossen. Da es aber meist sehr nervig ist jedesmal die IP-Adresse des D1 in den Browser einzutippen bzw. die sich auch ändern kann, macht es Sinn dem DNS des D1 einen Namen zuzuweisen. Dafür wird wieder eine Bibliothek verwendet, welche mittels #include <ESP8266mDNS.h> eingebunden wird. Der DNS wird einmalig definiert und daher in die setup() Funktion geschrieben. Um den DNS Namen festzulegen, nutzt man die Methode MDNS.begin(DNS Name), beispielsweise MDNS.begin(nerd-corner). Zusätzlich muss noch MDNS.update() in die loop Funktion geschrieben werden.

#include <ESP8266WiFi.h>
#include <ESP8266WebServer.h>
#include <ESP8266mDNS.h>

ESP8266WebServer server(80);

void setup() {
  Serial.begin(115200); //Baudrate
  Serial.println("ESP starts");

  WiFi.begin("NerdCornerWiFi","NerdCornerPassword");

  Serial.print("Connecting...");

  while(WiFi.status()!=WL_CONNECTED){ //Loop which makes a point every 500ms until the connection process has finished

    delay(500);
    Serial.print(".");
  }
  Serial.println();

  Serial.print("Connected! IP-Address: ");
  Serial.println(WiFi.localIP()); //Displaying the IP Address

  if (MDNS.begin("nerd-corner")) {
    Serial.println("DNS started, available with: ");
    Serial.println("http://nerd-corner.local/");
  }

  server.onNotFound([](){ 
    server.send(404, "text/plain", "Link was not found!");  
  });
 
  server.on("/", []() {
    server.send(200, "text/plain", "Landing page!");
  });
 
  server.on("/custom", []() {
    server.send(200, "text/plain", "Just a custom route!");
    ownFunction();
  });

  server.begin();

}

void loop() {
  server.handleClient();
  MDNS.update();

}

void ownFunction(){ //go to "IP-Adress/custom" to call this function
  Serial.println("Own function was called");

}

Anschließend kann man im Browser http://nerd-corner.local eingeben und man erreicht den D1. Bitte beachten, dass die Endung immer „.local“ sein muss! Manche Android Geräte unterstützen mDNS nicht, dann muss weiterhin die tatsächliche IP Adresse angegeben werden. Jetzt steht der Verwendung für eigene Projekte eigentlich nichts mehr im Weg! Hier findet Ihr ein paar spannende Anwendungsbeispiele: https://makesmart.net/tag/d1-mini/

Beispielprogramm zum Ein- und Ausschalten der OnBoard LED

Zum Abschluss des Blogposts noch ein simples Beispielprogramm bei dem wir das bisher gelernte anwenden. Wir schreiben zwei zusätzliche Funktionen. Eine um die fest verbaute BuiltIn Led einzuschalten und eine Funkton zum Ausschalten. Ein kleiner Hinweis, im Gegensatz zum Arduino wird die LED mit digitalWrite(LED_BUILTIN, LOW) eingeschalten statt ausgeschalten, also genau invertiert!

Die Funktionen können über http://nerd-corner.local/on und http://nerd-corner.local/off aufgerufen werden. Anbei der vollständige Programmcode:

#include <ESP8266WiFi.h>
#include <ESP8266WebServer.h>
#include <ESP8266mDNS.h>

ESP8266WebServer server(80);

void setup() {
  Serial.begin(115200); //Baudrate
  Serial.println("ESP starts");

  WiFi.begin("NerdCornerWiFi","NerdCornerPassword");

  Serial.print("Connecting...");

  while(WiFi.status()!=WL_CONNECTED){ //Loop which makes a point every 500ms until the connection process has finished

    delay(500);
    Serial.print(".");
  }
  Serial.println();

  Serial.print("Connected! IP-Address: ");
  Serial.println(WiFi.localIP()); //Displaying the IP Address

  if (MDNS.begin("nerd-corner")) {
    Serial.println("DNS started, available with: ");
    Serial.println("http://nerd-corner.local/");
  }

  server.onNotFound([](){ 
    server.send(404, "text/plain", "Link was not found!");  
  });
 
  server.on("/", []() {
    server.send(200, "text/plain", "Landing page!");
  });
 
  server.on("/on", []() {
    server.send(200, "text/plain", "Switching LED on!");
    switchLedOn();
  });

  server.on("/off", []() {
    server.send(200, "text/plain", "Switching LED off!");
    switchLedOff();
  });

  server.begin();


  // initialize digital pin LED_BUILTIN as an output.
  pinMode(LED_BUILTIN, OUTPUT);
}

void loop() {
  server.handleClient();
  MDNS.update();

}

void switchLedOff(){ 
  digitalWrite(LED_BUILTIN, HIGH);   // turn the D1 LED off 
}

void switchLedOn(){ 
  digitalWrite(LED_BUILTIN, LOW);    // turn the LED on 
}

The post WeMos D1 R2 erste Schritte und Wlan integration appeared first on Nerd Corner.

Das könnte dich auch interessieren: Textnachrichten mittels Lichtsignale senden

Eng mit diesem Artikel verbunden: Fehlererkennung bei der Datenübertragung

Ebenfalls relevant: Taktgeschwindigkeit für eine Datenübertragung festlegen in C

Liste der Bauteile

• 2x Raspberry Pi 4
• 2x 5V Solarzelle
• 2x 5V Laserdiode
• Jumper Kabel
• 3D Drucker
• Filament
• 2x 5V Lüfter
• NPN Transistor
• 2x ADC Board mit einem LM393

Verkabelung

Anders als bei der Verkabelung im letzten Artikel, in dem Textnachrichten mittels Lichtsignale von einem Pi zu einem Arduino gesendet wurden ( Link: https://nerd-corner.com/de/textnachrichten-mittels-lichtsignale-senden-pi-zu-arduino/ ), gibt es jetzt keinen definierten Empfänger und keinen definierten Sender. Es werden stattdessen zwei baugleiche Stationen aufgebaut, die sowohl Daten senden und empfangen können.

Aus diesem Grund werden die Raspberry Pi’s sowohl mit einem 5V Laser als auch mit einer 5V Solarzelle verbunden. Für den Laser wurde der GPIO18 Pin gewählt, welcher in der „wiringPi“ Library Pin 1 entspricht. Die „wiringPi“ Library wird im Programmcode verwendet. Direkt unter GPIO18 befindet sich ein Ground, welcher mit dem Minus Pol des Lasers verbunden wird.

Die Solarzelle liefert je nach Lichtintensität einen entsprechenden Spannungswert. Da die digitalen Pins des Raspberry Pi aber nur 1 und 0 erkennen können, muss mit Hilfe eines Komparators der analoge Wert der Solarzelle in einen digitalen Wert gewandelt werden. Der Vorgang wird genauer im Abschnitt „ADC Board mit einem LM393 Komparator“ erläutert. Für die Verkabelung wird der Plus und Minus Pol der Solarzelle mit den Plus und Minus Kontakten des ADC Boards verbunden. Anschließend wird der Ground des ADC Boards an einen Raspberry Pi Ground verbunden und für die Spannungsversorgung der Plus Pol des ADC Boards mit 5V des Pi verbunden. Der D0 Pin des ADC Boards liefert den digitalen Wert 0 oder 1, abhängig von der Lichtintensität der Solarzelle. Diesen Pin habe ich mit GPIO17, welcher in der „wiringPi“ Library Pin 0 entspricht, verbunden.

Da mir aufgefallen ist, dass der Pi im Betrieb sehr heiß wird, habe ich noch einen Lüfter angeschlossen. Damit der Lüfter sich nicht dauerhaft im Betrieb befindet, was sich negativ auf die Leistung des Lasers auswirken würde, kann der Lüfter durch einen NPN Transistor geschalten werden. Hierfür verbindet man den Plus Pol des Lüfters direkt mit einem 5V Pin des Raspberry Pi und den Minus Pol des Lüfters mit dem Emitter des NPN Transistors. Der Collector des Transistors wird mit einem Ground des Pi verbunden. Um nun den Lüfter über den Transistor ein- und ausschalten zu können wird die Transistor Basis mit einem GPIO Pin verbunden. Ich habe beispielsweise GPIO27 (entspricht in der „wiringPi“ Library Pin 2) gewählt. In der Nachfolgenden Tabelle werden die Pins des Pi der Nummerierung der „wiringPi“ Library gegenüber gestellt.

ADC Board mit einem LM393 Komparator

Die Solarzelle gibt abhängig von der Lichtintensität einen Spannungswert zurück. Leider hat der Raspberry Pi aber keine analogen Pins um diesen Spannungswert auszulesen. Daher muss das analoge Signal in ein digitales Signal umgewandelt werden. Mit Hilfe des LM393 Komparators ist das möglich. Dieser ist häufig auf ADC Boards verbaut. Hier habe ich einfach den ursprünglichen Sensor (es war ein Fotowiderstand) durch die Solarzelle ersetzt. Mit Hilfe eines Potentiometers kann der Komparator eingestellt werden. Das bedeutet, sobald der Spannungswert der Solarzelle, welcher von der Lichtintensität abhängt, den eingestellten Wert des Potentiometers übersteigt, wird eine digitale 1 gemessen, anderenfalls eine digitale 0.

Aufbau des Datenframes

Der Datenframe für das Versenden der Textnachrichten mittels visueller Lichtkommunikation (Link: https://nerd-corner.com/de/textnachrichten-mittels-lichtsignale-senden-pi-zu-arduino/ ) bestand aus einer Preamble, der Länge der Textnachricht, dem Textinhalt und der zyklischen Redundanzprüfung. Um aber statt Textnachrichten alle möglichen Arten von Daten verschicken zu können muss anstelle der Länge der Textnachricht der Dateiname, die Dateiendung, die Gesamtzahl der Pakete und die Nummer des aktuellen Pakets angegeben werden. Anschließend kann der Dateninhalt und der Code der zyklischen Redundanzprüfung angefügt werden.

Softwarecode für Datentransfer mittels VLC

Im Grunde wurden die Empfänger- und Senderskripte aus dem vorherigen Projekt zum Senden von Textnachrichten mittels visueller Lichtkommunikation (Link: https://nerd-corner.com/de/textnachrichten-mittels-lichtsignale-senden-pi-zu-arduino/ ) weiterentwickelt und zu einem gemeinsamen Skript zusammengefasst. Welches auf beiden Raspberry Pi’s Anwendung findet. Es wurde beispielsweise eine „ReadFile“ und „WriteFile“ Funktion ergänzt, welche Dateien einlesen und empfangene Datenpakete zu einer Datei zusammenfassen und abspeichern können. Das Programm wurde wieder in C geschrieben, da eine hohe Geschwindigkeit bei der Datenübertragung erreicht werden soll. Details zur präzisen Programmierung in C für eine schnelle Datenübertragung in diesem Beitrag: https://nerd-corner.com/de/wie-programmiert-man-einen-praezisen-timer-in-c-fuer-linux/

Der gesamte Softwarecode zum Datentransfer mittels VLC kann am Ende des Artikels heruntergeladen werden. Der Kern des Programms ist wieder eine State Maschine mit Hilfe derer ausgewählt werden kann, ob Daten gesendet oder empfangen werden sollen. Außerdem schaltet das Programm automatisch den Lüfter an, wenn keine Datenübertragung stattfindet. Wichtig: Beim Kompilieren bitte nicht die „wiringPi“ Bibliothek und die „math.h“ Bibliothek vergessen! Der Befehl lautet: „gcc -o transceiver transceiver.c -lwiringPi -lm“

while(1)
    {
        digitalWrite (2, HIGH);
        printf("Press the R button for Receiver Mode or any other key for Sender Mode\n");
        scanf(" %c",&mode);
        
        if (mode=='R'||mode=='r')
        {
            digitalWrite(2,LOW);
            modeReceiver=true;
        }
        
        if (mode!='R'&&mode!='r')
        {
            digitalWrite(2,LOW);
            modeReceiver=false;
            
            char dataName[NAME_MAX];
            char dataExtension[NAME_MAX];
            
               
            printf("\n Name of file WITHOUT extension: ");
            scanf("%s",dataName);

            printf("\n Extension: ");
            scanf("%s",dataExtension);

            if (read_file(dataName, dataExtension, file_content) != OK)
            {
                printf("File read error, size exceeds array size\n");
                return -1;
            }
            BuildDataFrame(dataName, dataExtension, file_content);
        }
        
        
        
        while(modeReceiver)
        {
            gettimeofday(&tval_after, NULL);
            timersub(&tval_after, &tval_before, &tval_result);
            double time_elapsed = (double)tval_result.tv_sec + ((double)tval_result.tv_usec/1000000.0f);
            
            while(time_elapsed < 0.001)
            {
                gettimeofday(&tval_after, NULL);
                timersub(&tval_after, &tval_before, &tval_result);
                time_elapsed = (double)tval_result.tv_sec + ((double)tval_result.tv_usec/1000000.0f);
            }
            gettimeofday(&tval_before, NULL);
            
            int data = digitalRead(0);
            
            
            switch (state)
            {
                case 0:
                    //looking for preamble pattern
                    synchro_Done=false;
                    LookForSynchro(data);
                    
                    if (synchro_Done==true)
                    {
                        state=1;
                    }
                    break;
                    
                case 1:
                    //receive the actual data
                    receiveData_Done=false;
                    senderState=false;
                    ReceiveData(data);
                    
                    if(receiveData_Done&&senderState==false)
                    {
                        state=0;
                    }
                    if(senderState==true){
                        senderState=false;
                        state=0;
                        modeReceiver=false;
                        }
                    break;
                  
            }
            
        }
    }

Gehäuse

Um die Komponenten an Ort und Stelle fixieren zu können, wurde im CAD ein Gehäuse konstruiert. Dies hat auch den Vorteil, dass keine komplizierte Ausrichtung der Laser und der Solarzellen für die Datenübertragung notwendig ist. Für Anfänger eignet sich TinkerCAD zum Gehäuse design. TinkerCAD ist kostenlos und kann direkt im Browser benutzt werden. Alternativ können die STL Files für den 3D Drucker auch hier heruntergeladen werden.

Das Gehäuse zum Datentransfer mittels VLC besitzt eine Öffnung für die Solarzelle und den Laser. Außerdem wurde ein Abluftschacht für den Lüfter konstruiert und zusätzlich Platz für ein Raspberry Pi Gehäuse frei gelassen. Im nachfolgenden Bild wird der Einbau der Komponenten dargestellt.

Fazit zum Datentransfer mittels VLC

Es wurde das bereits bestehende System zum Senden von Textnachrichten mittels visueller Lichtsignale weiterentwickelt, sodass jetzt alle Arten von Daten gesendet und empfangen werden können. Das System funktioniert erstaunlich erfolgreich. Es ist sehr robust und erreicht eine Datenrate von 1 kBit/s bis 10 kBit/s. Alle ankommenden Datenpakete können durch den intelligenten Aufbau des Datenframes direkt zugeordnet werden. Lediglich ein Acknowledgement Signal wäre noch eine sinnvolle Ergänzung. Ein solches Signal wäre eine Rückmeldung vom Empfänger an den Sender um dem Sender mitzuteilen, dass alle Pakete angekommen sind, oder eventuell ein bestimmtes Paket fehlerhaft war und erneut gesendet werden muss.

Ebenfalls interessant für die Zukunft wäre andere Modulationsarten auszuprobieren. Besonders das speziell für visuelle Lichtkommunikation erdachte Colour Shift Keying würde ich gerne näher untersuchen und die daraus resultierenden Datenraten vergleichen.

Dateien herunterladen:

• Softwarecode Transceiver
• STL files housing
• Pi Case with free pins (Creative Common License from Thingiverse)

The post Upgrade: Datentransfer mittels VLC und LiFi – Pi zu Pi Übertragung appeared first on Nerd Corner.

Das könnte dich auch interessieren: Raspberry Pi Timer programmieren in C

Liste der Komponenten

• Arduino Uno
• LED
• Jumper Kabel
• 220 Ohm Widerstand
• Steckbrett

Was ist eigentlich ein Timer?

Ein Timer ist im Grunde nichts anderes als ein bestimmtes Register im Mikrocontroller, das hardwaregesteuert kontinuierlich um 1 erhöht (oder verringert) wird. Anstatt Anweisungen im Programm zu kodieren, die regelmäßig ausgeführt werden und ein Register um 1 erhöhen, macht der Mikrocontroller das ganz von alleine!

Dies wird nützlich, wenn eine Aktion bei bestimmten Zählerwerten ausgeführt wird. Einer dieser ‚bestimmten Zählerstände‘ ist zum Beispiel der Überlauf. Das Zählregister eines Timers kann nicht beliebig lange inkrementiert werden. Z.B. ist der höchste Zählerstand, den ein 8-Bit-Timer erreichen kann, 2^8 – 1 = 255. Der nächste Schritt ist nicht 256, sondern es kommt zu einem Überlauf, der den Timer wieder auf 0 setzt. Das ist die ganze Magie! Wir können den Controller so konfigurieren, dass ein Interrupt ausgelöst wird, wenn der Timer überläuft. Anschließend können wir einen Code in das Arduino Programm schreiben, der im Falle eines Interrupts ausgeführt wird. Zum Beispiel können wir eine LED zum Leuchten bringen oder einen bestimmten Sensorwert abfragen.

Arduino Uno Mikrocontroller ATMEGA328P

Der ATMEGA328P-Mikrocontroller ist das Herzstück des Arduino Uno-Boards. (ACHTUNG: Der Arduino Mega z.B. hat einen anderen Mikrocontroller!) Der ATMEGA328P Mikrocontroller hat 3 Timer (Datenblatt), die teilweise in Arduino-Funktionen und/oder teilweise in Bibliotheken verwendet werden. Das Überschreiben der Timer-Register kann daher zu Komplikationen mit bestehenden Timer-Funktionen wie millis(), micros() oder delay() führen und sollte mit Vorsicht verwendet werden. Die 3 Timer sind Timer0 (8Bit), Timer1 (16Bit) und Timer2 (8Bit).

• 8 Bit-Timer0: wird genutzt für die Funktionen millis(), micros(), delay() und für PWM an Pin D5 und D6
• 16 Bit-Timer1: wird z. B. für die Bibliothek Servo, VirtualWire, TimerOne und für PWM an Pin D9 und D10 genutzt
• 8 Bit Timer2: wird genutzt für Funktion tone() und für PWM an Pin D3 und D11

Wie variiert man die Taktgeschwindigkeit?

Der Systemtakt des Arduino Uno beträgt 16 MHz (CPU-Frequenz). Das bedeutet, dass Timer0, Timer1 und Timer2 16 Millionen Mal pro Sekunde hochlaufen. Die 8-Bit-Timer zählen z. B. jeweils von 0 bis 255. Bei 256 tritt ein Überlauf auf und die Timer beginnen wieder bei 0. Das bedeutet 16000000/256 = 62500 Überläufe pro Sekunde (62,5kHz Taktrate). Das ist für die meisten Timer-Anwendungen wahrscheinlich zu schnell!

Deshalb gibt es einen Trick, um die Taktraten zu verlangsamen. Man verwendet einen sogenannten Vorteiler (Prescaler). Ein Vorteiler kann auf die Werte 1, 8, 64, 256 oder 1024 eingestellt werden. Er ermöglicht es, den Systemtakt (16MHz) durch den gewählten Faktor zu teilen und eine niedrigere Taktrate für die Timer einzustellen. Ein Vorteiler von 1024 würde z. B. die Timer-Register nur beim 1024sten Systemtakt um 1 erhöhen. Das wären 16000000/1024=15625 Inkremente pro Sekunde und damit bei einem 8-Bit-Timer 15625/256= 61,035 Überläufe pro Sekunde (~61 Hz Taktrate des Timers).

Anwendungsbeispiel: LED soll mit 50 Hz blinken

Im Folgenden wird die Ansteuerung von Arduino Timer Interrupts mit dem 16-Bit Timer1 gezeigt. Damit soll eine LED im 50 Hz-Takt aufleuchten. Schaltplan, Arduino-Code und Bilder sind ebenfalls enthalten. (Die Vorgehensweise für den 8-Bit-Timer0 und Timer2 ist analog.) Für den zeitgesteuerten Impuls benötigen Sie den sogenannten „CTC-Modus“.

Im CTC-Modus („Clear Timer on Compare Mode“) wird der Zähler gelöscht, wenn der Wert des Zählers (TNCT1) entweder mit dem Wert des OCR1A-Registers oder dem Wert des ICR1-Registers (in unserem Fall OCR1A) übereinstimmt. Das OCR1A-Register bestimmt also den Maximalwert des Zählers und damit seine Auflösung.

Der 16 Bit Timer1 braucht die folgenden Register:

• Timer Counter Register 1: TCNT1
• Output Compare Register A: OCR1A
• Timer Counter Control Register A: TCCR1A
• Timer Counter Control Register B: TCCR1B
• Timer/Counter Interrupt Mask Register: TIMSK1
• (Für Timer0 und Timer2 würden die entsprechenden Register TCNT0 bzw. TCNT2 heißen)

Berechnung des OCR1A Registers für Arduino Timer Interrupts

Der Wert des Registers OCR1A ist abhängig von der gewünschten Interruptfrequenz und dem gewählten Vorteiler. Es gilt die folgende Formel:

Wir setzen unsere Spezifikationen in die Formel ein:

• CPU-Frequenz Arduino Uno: 16.000.000 Hz
• Gewünschte Interruptfrequenz: 50 Hz (= 20 ms Periodendauer)
• Möglicher Vorteiler: 1, 8, 64, 256 oder 1024

Berechnungsbeispiel mit Vorteiler 1024:
OCR1A= (16.000.000 / (1024 * 50)) – 1 = 311,5

Berechnungsbeispiel mit Vorteiler 8:
OCR1A= (16,000,000 / (8 * 50)) – 1 = 39,999

ACHTUNG: Der OCR1A-Wert muss kleiner als 65,536 (2^16 ) sein!

Daher kann ein Vorteiler 8 NICHT die 10 Hz Interruptfrequenz erreichen:
OCR1A= (16.000.000 / (8 * 10)) – 1 = 199.999

Der Wert 199,999 ist größer als das Register mit 65,536, daher muss ein anderer Vorteiler verwendet werden, um 10 Hz zu erreichen

Stattdessen ein Vorteiler 64 für 10 Hz Interruptfrequenz:
OCR1A= (16.000.000 / (64 * 10)) – 1 = 24.999

Wird nun ein Timer1-Interrupt ausgelöst, springt der Programmablauf in eine zu erstellende Interrupt-Service-Routine „ISR(TIMER1_COMPA_vect)“. (Siehe Arduino Code)

Bit Kombination für die gewünschten Vorteiler

Arduino Timer Interrupts Code für die 50 Hz Frequenz

void setup() {

  pinMode(11,OUTPUT);  //LED pin (to blink in 50Hz frequency)
  
//START TIMER SETUP
//TIMER SETUP for highly preceise timed measurements 

  cli();//stop all interrupts

  // turn on CTC mode
  TCCR1A = 0;// set entire TCCR1A register to 0
  TCCR1B = 0;// same for TCCR1B
  TCCR1B |= (1 << WGM12);

  // Set CS11 bit for prescaler 8
  TCCR1B |= (1 << CS11); 
  
  //initialize counter value to 0;
  TCNT1  = 0;
  
  // set timer count for 50Hz increments
  OCR1A = 39999;// = (16*10^6) / (50*8) - 1  
  
  // enable timer compare interrupt
  TIMSK1 |= (1 << OCIE1A);
  
  sei();//allow interrupts
  //END TIMER SETUP
}



ISR(TIMER1_COMPA_vect) {//Interrupt at frequency of 50 Hz
 //write your timer code here

 digitalWrite(11,HIGH);
 delay(15);
 digitalWrite(11,LOW);
}




void loop() {

//when the timer is over, your program will stop in the loop function and jump to the timer code. 
//After the timer code it will jump back to the point where it left the loop function
}

The post Arduino Timer Interrupts – Arduino Register programmieren appeared first on Nerd Corner.

Nachfolgend eine Erklärung wieso die Library „sys/time.h“ genutzt wurde, sowie ein Codebeispiel mit anschließender Erläuterung. Dieses Codebeispiel eignet sich sehr gut für bitweise Datenübertragung in der Kommunikationstechnik.

Das könnte Sie ebenfalls interessieren: Präzise Timer Interrupts für den Arduino programmieren!

Liste der Komponenten

• Linux Betriebssystem (zum Beispiel Raspberry Pi)
• Editor für C – Programmierung

Die Library „sys/time.h“

Funktionen wie „usleep()“ oder „nanosleep()“ würden das komplette Programm anhalten. Für einfache Anwendungen mag das vielleicht ausreichen, allerdings war das für meine Zwecke zu ungenau. Ich wollte einen Timer, der wirklich exakt im 1 ms Takt bzw. 0,1 ms Takt arbeitet. Deswegen wurde anstelle von „usleep()“ oder „nanosleep()“ eine andere Lösung gewählt. Die Library „sys/time.h“. Diese kann die aktuelle „System Clock Time“ (System Uhrzeit) auslesen und vergleichen.

Codebeispiel für präzisen Timer in C

#include <sys/time.h>

int main()
{
    struct timeval tval_before, tval_after, tval_result;
    int counter=0;
    bool stop=false;
   
    gettimeofday(&tval_before, NULL);
    while(stop!=true)
    {
        gettimeofday(&tval_after, NULL);
        timersub(&tval_after, &tval_before, &tval_result);
        double time_elapsed = (double)tval_result.tv_sec + ((double)tval_result.tv_usec/1000000.0f);
        
        while(time_elapsed < 0.001)  //1ms; you can change your desired time interval here
        {
            gettimeofday(&tval_after, NULL);
            timersub(&tval_after, &tval_before, &tval_result);
            time_elapsed = (double)tval_result.tv_sec + ((double)tval_result.tv_usec/1000000.0f);
        }
        gettimeofday(&tval_before, NULL);
        
        if (counter==10000)
        {
            stop=true;
        }
            
        else 
        {
            counter++;
        }
    }
    return 0;
}

Erklärung zum Codebeispiel:

Eine Funktion „gettimeofday“ schreibt die aktuelle System Uhrzeit in die Variable „tval_before“. Eine While Schleife wird anschließend solange ausgeführt bis die eigentliche Aufgabe erledigt ist.

Innerhalb der While Schleife wird als Erstes erneut die System Uhrzeit in eine Variable „tval_after“ abgespeichert. Anschließend wird die zeitliche Differenz zwischen „tval_after“ und „tval_before“ gemessen und in „tval_result“ abgespeichert.

Der nächste Schritt des Timers in C erschließt sich nicht sofort auf den ersten Blick: „tv_result“ besteht per Definition aus 2 Teilen. Zum einen ein Sekunden Anteil „.tv_sec“ und zum anderen ein Mikrosekunden Anteil „.tv_usec“. Eben dieser Mikrosekundenanteil muss erst noch durch eine Million geteilt werden, damit man den Wert in Sekunden erhält. Anschließend, kann der Mikrosekundenanteil zum Sekundenanteil addiert werden.

Der addierte Wert wird im Code als „time_elapsed“ bezeichnet. Falls dieser Wert kleiner als eine Millisekunde ist, wird eine weitere innere While Schleife geöffnet, die solange den Wert für „time_elapsed“ neu berechnet, bis exakt 1 ms vergangen ist. Anschließend wird mittels der „gettimeofday“ Funktion der Wert für „tval_before“ neu festgelegt.

Da zu diesem Zeitpunkt exakt 1 ms vergangen ist, kann der Timer nun seinen eigentlichen Arbeitsschritt ausführen. In diesem einfachen Codebeispiel wird lediglich eine Variable „counter“ um 1 erhöht. Das bedeutet für jeden Intervallschritt (im Codebeispiel 1 ms) erhöht sich der counter um 1. Sobald ein festgelegter Wert für counter erreicht wurde stoppt das Programm. In diesem Fall ist der festgelegte Wert 10000. Anschließend wird die While Schleife beendet. Aber dieser Teil des Codes kann natürlich problemlos für die eigenen Zwecke angepasst werden.

Meine Messungen mit dem Oszilloskop haben eine exakte Frequenz von 1 ms gemessen, sogar 0,1 ms wurde exakt gemessen. Dieses Codebeispiel eignet sich deswegen auch sehr gut für eine exakte Datenübertragung in der Kommunikationstechnik.

Dateien herunterladen

• Downloadfile Timer in C

The post Wie programmiert man einen präzisen Timer in C für Linux appeared first on Nerd Corner.