Nr.26 – Zwei I²C Displays

Zwei I²C Displays am Arduino gleichzeitig verwenden.

zweiLCDergebnis

 

Achtung:

Dieser Aufbau und die damit verbundene Änderung der I²C Adresse ist nur bei Displays möglich, die über eine Jumper-funktion verfügen. Die erkennt man auf dem folgenden Bild an dem rot markierten Bereich. Auf den Stellen  A0,A1 und A2 kann eine Kontaktbrücke aufgelötet werden.

zweiLCDrueckseite

Außerdem wird für diese Anleitungen die NewliquidCrystal_1.3.4 Library benötigt, welche hier heruntergeladen werden kann: https://bitbucket.org/fmalpartida/new-liquidcrystal/downloads

Die Library muss in der Arduino Software hinzugefügt werden (siehe vorherige Anleitungen z.B. I²C Display).

Material: Arduino / 2 Displays mit I²C Modul / Breadboard / Kabel

Aufgabe: Zwei LCDs mit I²C Modul sollen gleichzeitig von einem Arduino Mikrocontroller angesteuert werden und zwei verschiedene Texte anzeigen. Dazu sollen die I²C Adressen der Displays vorher herausgefunden werden und die Adresse eines der Displays geändert werden.

Als erstes eine kurze Erläuterung zu der I²C Adresse:

Jedes I²C Modul hat eine sogenannte „HEX Adresse“. Über diese Adresse reagiert das I²C-Modul auf die Daten, die vom Arduino auf dem Datenbus an genau diese Adresse gesendet werden. Viele I²C-LCDs auch die gleiche HEX-Adresse. Das bedeutet, dass beim verwenden von zwei Displays beide Displays auf die gesendeten Daten vom Arduino-Board reagieren würden. Man könnte also auf zwei Displays keine unterschiedlichen Daten darstellen.

Die HEX-Adresse kann bei dem Display mit Hilfe der A0, A1 und A2 Lötstellen jedoch verändert werden. Im unveränderten Zustand sind alle drei Lötstellen nicht verbunden. Je nach Kombination, welche der Stellen man mit einer Lötstelle überbrückt, sind also 8 verschiedene Adressen möglich. Abhängig vom Display Typ kann diese Adresse anfangs 0x27 oder 0x3F sein (kann mit dem Adressen „Scanner“ herausgefunden werden, dazu später mehr).

Tabellen zu HEX Adressen je nach verlöteten Stellen( I = verbunden, : = nicht verbunden):

A0

A1

A2

HEX Adresse

HEX Adresse

:

:

:

0x27

0x3F

I

:

:

0x26

0x3E

:

I

:

0x25

0x3D

I

I

:

0x24

0x3C

:

:

I

0x23

0x3B

I

:

I

0x22

0x3A

:

I

I

0x21

0x39

I

I

I

0x20

0x38

Kommen wir zum I²C Adressen „Scanner“:

Der „Scanner“ ist im Prinzip nur ein Code der auf den Arduino hochgeladen wird an dem das LCD Modul angeschlossen ist und dann am seriellen Monitor die HEX Adresse anzeigt.

Schrittweise Anleitung zum I²C Adressen „Scanner“:

1. Entsprechendes LCD Modul mit dem Arduino verbinden:

I²C LCD Modul >> Arduino

VCC >> 5V

GND >> GND

SDA >> A4

SCL >> A5

2. Folgenden Sketch auf den Mikrocontroller laden:

// I2C Scanner

// Written by Nick Gammon

// Date: 20th April 2011

#include <Wire.h>

void setup() {

Serial.begin (115200);

// Leonardo: wait for serial port to connect

while (!Serial)

{

}

Serial.println ();

Serial.println („I2C scanner. Scanning …“);

byte count = 0;

Wire.begin();

for (byte i = 8; i < 120; i )

{

Wire.beginTransmission (i);

if (Wire.endTransmission () == 0)

{

Serial.print („Found address: „);

Serial.print (i, DEC);

Serial.print (“ (0x“);

Serial.print (i, HEX);

Serial.println („)“);

count ;

delay (1); // maybe unneeded?

} // end of good response

} // end of for loop

Serial.println („Done.“);

Serial.print („Found „);

Serial.print (count, DEC);

Serial.println (“ device(s).“);

} // end of setup

void loop() {}

 

3. Seriellen Monitor in der Arduino Software öffnen

4. Baudrate auf 115200 ändern

5. Ggf. Reset Knopf auf dem Arduino drücken

In dem seriellen Monitor sollte folgendes zu sehen sein (HEX Adresse ist rot markiert):

zweiLCDscanner

 

Wieder zur eigentlichen Anleitung:

Um nun auf zwei I²C Displays gleichzeitig zwei verschiedene Texte anzeigen lassen zu können müssen die Displays natürlich auch verschiedene HEX Adressen haben. Also verlöten wir in unserem Beispiel bei einem der Displays den A1 Kontakt, sodass dieser nun die Adresse 0x3D hat (kann mit dem Adressen Scanner nochmal geprüft werden). Wir nennen diesen Display ab jetzt Display 2 und den anderen Display 1.

Aufbau: Die Displays müssen nun mit dem Arduino verbunden werden:

ZweiLCDaufbau

Code:

#include <Wire.h> //Wire.h Bibliothek einbinden

#include <LiquidCrystal_I2C.h> //LiquidCrystal_I2C.h Bibliothel einbinden

LiquidCrystal_I2C lcd1(0x3F, 2, 1, 0, 4, 5, 6, 7, 3, POSITIVE); //Hier wird

//Display 1 als lcd1 benannt, die Adresse angegeben „0x3F“ und die

//Pinnbelegung durch das I²C Modul angegeben

LiquidCrystal_I2C lcd2(0x3D, 2, 1, 0, 4, 5, 6, 7, 3, POSITIVE);//Hier wird

//Display 2 als lcd2 benannt, die Adresse angegeben „0x3D“ und die

//Pinnbelegung durch das I²C Modul angegeben

void setup()

{

lcd1.begin(16,2); //Display 1 wird gestartet und die Größe des Displays

//wird angegeben(16 Zeichen, zwei Zeilen)

lcd1.backlight(); //Beleuchtung Display 1 einschalten

lcd2.begin(16,2); //Display 2 wird gestartet und die Größe des Displays

//wird angegeben(16 Zeichen, zwei Zeilen)

lcd2.backlight(); //Beleuchtung Display 2 einschalten

}

void loop()

{

lcd1.setCursor(0,0); //Text soll beim ersten Zeichen in der ersten Reihe

//bei Display 1 beginnen..

lcd2.setCursor(0,0); //bei Display 2 auch..

lcd1.print(„Display 1“); //Display 1 soll oben „Display 1“ anzeigen

lcd2.print(„Display 2“); //Display 2 soll oben „Display 2“ anzeigen

delay(1000); // Eine Sekunde warten

lcd1.setCursor(0,1); //Text soll beim ersten Zeichen in der zweiten Reihe

//bei Display 1 beginnen..

lcd2.setCursor(0,1); //bei Display 2 auch..

lcd1.print(„Eckstein GmbH“); //Display 1 soll unten „Eckstein GmbH“

//anzeigen

lcd2.print(„www.Eckstein.de“); //Display 2 soll unten „www.Eckstein.de“

//anzeigen

}

Nr.25 – Arduino-RTC

Uhrzeitmodul für Arduino: RTC – Real Time Clock

Aufbau

Mit der Arduino kompatiblen DS1307 I2C Real Time Clock kann man Uhrzeit und Datum nahezu in Echtzeit anzeigen lassen.

Material: Mikrocontrollerboard (In diesem Beispiel UNO R3), ein Drehregler (bzw. Potentiometer), Breadboard, LCD Display, DS1307 I2C Real Time Clock, Jumperkabel

Verkabelung:

Das LCD Display wird im Prinzip wie in der Anleitung Nr. 13 verkabelt. Dazu kommt dann noch die RTC, welche einmal mit 5V und GND verbunden wird, der SDA-Kontakt an den Analogen Eingang A4 und der SCL-Kontakt an den Analogen Eingang A5.

Achtung!: Bei dem MEGA2560 R3 Microcontroller gibt es für die SDA – und SCL- Kontakte eigene Eingänge auf dem Board unter 20 und 21.

MEGA

Steckeransicht für Aufbau mit UNO R3:

Arduino RTC verkabelung

 

Wenn alles richtig verkabelt ist kann auch schon fast mit dem Programmieren begonnen werden. Vorher müssen, für die Programmierung notwendige, Libraries heruntergeladen und in der Arduino Software hinzugefügt werden.

Bei den benötigten Libraries handelt es sich einmal um die Time Library, welche z.B. Unter folgendem Link : http://www.pjrc.com/teensy/td_libs_Time.html als .ZIP Datei heruntergeladen werden kann und um die DS1307RTC Library, welche zB. Unter http://www.pjrc.com/teensy/td_libs_DS1307RTC.html als .ZIP Datei heruntergeladen werden kann.

Wenn man beide Libraries runtergeladen hat muss man diese noch in der Arduino Software zu den bereits vorhandenen Libraries hinzufügen. Dazu öffnet man die Arduino Software und wählt unter dem Punk „Sketch“ das Feld „Include Libraby“ aus. Danach kann man „Add .ZIP Library“ auswählen und die vorher heruntergeladenen Time und DS1307RTC Library hinzufügen.

Auf diese kann jetzt in einem Code zurückgegriffen werden.

Als nächstes muss man den sogennanten „Set-Time“ Sketch hochladen um die Zeit und das Datum vom Gerät (Computer, Laptop etc.) an dem der Microcontroller angeschlossen ist, auf der Real-Time-Clock einzustellen.

Dies macht man, indem man unter „Datei“ auf „Beispiele“ dann „DS1307RTC“ den Punkt „Set Time“ auswählt. Es öffnet sich der entsprechende Sketch, welchen man nun auf den UNO R3 hochlädt.

Wenn man das alles erledigt hat kann man zum eigentlichen Code kommen.

Code:

#include <Time.h> Bibliotheken laden
#include <Wire.h>
#include <DS1307RTC.h>
#include <LiquidCrystal.h>
LiquidCrystal lcd(12, 11, 5, 4, 3, 2); //In dieser Zeile wird festgelegt, welche Pins des Mikrocontrollerboards für das LCD verwendet wird

void setup() 
{
lcd.begin(16, 2); //Im Setup wird angegeben, wie viele Zeichen und Zeilen werwendet werden.
Serial.begin(9600); //Öffnet den seriellen Port und legt die Baud Rate (9600) für die serielle Übertragung fest.
setSyncProvider(RTC.get); //Dies ist die Funktion um die Zeit- und Datumsangabe von der RTC zu bekommen
}

void loop() 
{
Serial.print(hour()); //Serial.print ist der Befehl etwas im seriellen Monitor anzuzeigen (Stunde, Minute, Sekunde, Leerzeichen, Tag, Leerzeichen, usw.)
printDigits(minute()); //bei den Minuten und Sekunden wird der Befehl
printDigits(second()); //printDigits angegeben welcher am Ende des Codes noch festgelegt wird.
Serial.print(" ");
Serial.print(day());
Serial.print(" ");
Serial.print(month());
Serial.print(" ");
Serial.print(year());
Serial.println();
delay(1000); //warte eine Sekunde
lcd.setCursor(2, 0); //setCursor gibt an wo der Text beginnen soll. In diesem Fall beim dritten Zeichen in der ersten Reihe.
lcd.print(hour()); //Hier soll jetzt die Uhrzeit angezeigt werden, also „hour“ „:“ „minute“ usw..
lcd.print(":");
lcd.print (minute());
lcd.print(":");
lcd.print(second());
lcd.print(" ");
lcd.print("Uhr"); //Hier soll nach der Uhrzeit noch das Wort „Uhr“ angezeigt werden, dazu müssen noch3 Leerzeichen folgen, sonst würde bei Zahlen <10 immer ein weiteres „r“ hinter Uhr angezeigt werden. Das liegt daran, dass in der LCD Library der Befehl eine 0 vor Zahlen <10 anzuzeigen nicht vorhanden ist.
lcd.print(" ");
lcd.print(" ");
lcd.print(" "); 
lcd.setCursor(1, 1); // Der nächste „Text“ soll nun beim zweiten Zeichen in der zweiten Reihe beginnen.
lcd.print(day()); // Das Datum soll nun als
lcd.print("."); // „Tag“, „.“ „Monat“ usw. angegeben werden.
lcd.print(month());
lcd.print(".");
lcd.print(year());
}

void printDigits(int digits) //In diesem Abschnitt wird festgelgt, dass bei Zahlen <10 im seriellen Monitor automatisch eine 0 vor den Ziffern angezeigt wird. Das gilt nur für den seriellen Monitor und nicht für LCD Display.Serial.print(":"); 
if(digits < 10) 
Serial.print('0'); 
Serial.print(digits); 
}

Hinweis: Die DS1307 Real Time Clock ist nicht auf die Sekunde genau. Das liegt daran, dass zwischen Hochladen des Set Time Sketch und dem Hochladen des endgültigen Sketch eine gewissen Zeit von ca. 15 Sekunden, die die RTC nicht ausgleichen kann.

Zusätzlich kann man vor dem Datum noch den Wochentag anzeigen lassen.

Hierzu muss vor dem Datum im lcd.print Abschnitt der Befehl printDay(); gegeben werden und nach dem Loop folgender Code eingefügt werden:

void printDay() // Hier wird wird für den vorher im Code schon verwendeten Befehl printDay eine Bedeutung festgelegt
{	
int day;
day = weekday(); // Die Wochentage sollen abhängig vom Datum angezeigt werden.
if(day == 1){lcd.print("So, ");} // Wenn es sich um Tag 1 handelt soll „So“ usw. angezeigt werden.
if(day == 2){lcd.print("Mo, ");}	
if(day == 3){lcd.print("Di, ");}
if(day == 4){lcd.print("Mi, ");}
if(day == 5){lcd.print("Do, ");}
if(day == 6){lcd.print("Fr, ");}
if(day == 7){lcd.print("Sa, ");}
}

 

Erweiterung:

Zwei I²C Bauteile gleichzeitig ansteuern: Uhrzeit und Datum mit einer Real Time Clock mit I²C Bus, auf einem I²C LCD anzeigen lassen.

Um zwei I²C Komponenten gleichzeitig ansteuern zu können, muss eins der Bauteile eine andere I²C Adresse als das andere. In unserem Fall können wir nur die Adresse des LCDs ändern. Sofern es die drei Lötstellen A0, A1 und A2 auf der Rückseite des I²C Moduls hat
(s. Bild).

zweiLCDrueckseite

Die I²C Adresse der Real Time Clock ist festgelegt und kann nicht geändert werden.

Um die Adresse des LCDs zu ändern, müssen die Lötstellen anders verbunden sein als zu Beginn (alle drei Lötstellen getrennt). So ändert sich die HEX Adresse des LCDs (s. Tabelle) (I = verbunden, := nicht verbunden):

I2CDeutsch

Kann ggf. mit dem „Scanner“ aus der Anleitung „Zwei Displays mit I²C Modul gleichzeitig ansteuern“ geprüft werden.

Wenn die Adresse des LCDs verändert wurde, können wir nun zur Verkabelung kommen:

I2C-RTC

Zum Programmieren werden wie oben schon erwähnt, die Time und die DS1307RTC Library benötigt. Außerdem wird für das I²C LCD die NewliquidCrystal_1.3.4 Library benötigt, welche hier heruntergeladen werden kann: https://bitbucket.org/fmalpartida/new-liquidcrystal/downloads

Alle Bibliotheken müssen der Arduino Software hinzugefügt werden:

Sketch > Include Library > Add ZIP library > vorher heruntergelandene Datei auswählen

Als nächstes muss man den sogennanten „Set-Time“ Sketch hochladen um die Zeit und das Datum vom Gerät (Computer, Laptop etc.) an dem der Microcontroller angeschlossen ist, auf der Real-Time-Clock einzustellen.
Dies macht man, indem man unter „Datei“ auf „Beispiele“ dann „DS1307RTC“ den Punkt „Set Time“ auswählt. Es öffnet sich der entsprechende Sketch, welchen man nun auf den UNO R3 hochlädt.
Wenn man das alles erledigt hat kann man zum eigentlichen Code kommen.

Code:


#include <Time.h>

#include <Wire.h>

#include <DS1307RTC.h>

#include <LiquidCrystal_I2C.h> //Bibliotheken laden

LiquidCrystal_I2C lcd(0x3D, 2, 1, 0, 4, 5, 6, 7, 3, POSITIVE); //Das I²C Display bennen und die HEX Adresse //eingeben (bei uns 0x3D)

void setup() {

lcd.begin(16, 2); //Das Display starten, festlegen dass es sich um ein Display mit 16 Zeichen in 2 Zeilen //handelt

lcd.backlight(); //Beleuchtung des Displays einschalten

Serial.begin(9600); //Seriellen Verbindung mit Baudrate 9600 starten

setSyncProvider(RTC.get); //Daten von der RTC abrufen

}

void loop() {

Serial.print(hour()); //Serial.print ist der Befehl etwas im seriellen Monitor anzuzeigen (Stunde, Minute, //Sekunde,Leerzeichen, Tag, Leerzeichen, usw.)

printDigits(minute()); //bei den Minuten und Sekunden wird der Befehl

printDigits(second()); //printDigits verwendet, welcher am Ende des Codes noch festgelegt wird

Serial.print(“ „);

Serial.print(day());

Serial.print(“ „);

Serial.print(month());

Serial.print(“ „);

Serial.print(year());

Serial.println();

delay(1000); //eine Sekunde warten

lcd.setCursor(2, 0); // setCursor gibt an wo der Text beginnen soll. In diesem Fall beim dritten Zeichen in //der ersten Reihe.

lcd.print(hour()); //Die Uhrzeit soll angezeigt werden im Format:

lcd.print(„:“); //Stunden:minuten:sekunden

lcd.print (minute());

lcd.print(„:“);

lcd.print(second());

lcd.print(“ „);

lcd.print(„Uhr“); //Dahinter soll das Wort „Uhr“ angezeigt werden

lcd.print(“ „);

lcd.print(“ „);

lcd.print(“ „);

lcd.setCursor(1, 1); //In der zweiten Zeile soll das Datum angezeigt //werden

lcd.print(day());

lcd.print(„.“);

lcd.print(month());

lcd.print(„.“);

lcd.print(year());

}

void printDigits(int digits){ //Der printDigits Befehl für den seriellen Monitor

Serial.print(„:“);

if(digits < 10)

Serial.print(‚0‘);

Serial.print(digits);

}


Nr.24 – Tastenfeld – Schloss

Mit dem Tastenfeld ein Zahlencode-Schloss programmieren

Aufgabe: Mit der Eingabe eines 3-stelligen Codes auf dem Tastenfeld soll eine LED aufleuchten und ein Servo eine bestimmte Position einnehmen. Am Servo könnte z.B. ein Riegel befestigt werden, der eine Tür entriegelt.

Material: Arduino / Breadboard / Tastenfeld (in diesem Beispiel 4×4) / Kabel / ein rote LED/ eine grüne LED / zwei 100 Ohm Widerstände / Servo

Wir wollen mit der Eingabe eines 3-stelligen Passworts auf dem Tastenfeld ein grüne LED aufleuchten lassen und einen Servo eine bestimmte Position einnehmen lassen. Wenn das „Schloss“ gesperrt ist soll eine rote LED leuchten und der Servo eine andere Position einnehmen. Dieses Tutorial dient als Anregung und Beispiel dazu, wie aus diesen einfachen Bauteilen z.B. ein „Safe“ gebaut werden kann.

Kommen wir nun zum Aufbau. Diese ist recht simpel und geht aus der nachfolgenden Fritzing Skizze hervor.

Zur besseren Orientierung bei dem Verkabeln des Tastenfelds:

An den äußersten Kontakten des Tastenfeld sind die Zahlen 1 und 7 zu sehen. Der Kontakt 1 am Tastenfeld wird mit dem Pin 2 am Arduino verbunden. Aufsteigend geht es dann weiter bis zu Kontakt 7 am Tastenfeld welcher mit dem Pin 8 am Arduino verbunden wird.

Skizze:

arduino-schloss

Für den Code wird die Keypad Library benötigt, welche der Arduino Software erst hinzugefügt werden muss.

Arduino Software öffnen> „Sketch“ auswählen > „Include Library“ auswählen > „Manage Libraries..“ wählen > In der Suchzeile des neuen Fensters „Keypad“ eingeben > die oberste Library von Mark Stanley auswählen und installieren.

Ab jetzt kann die Keypad Library im Code verwendet werden.

Code:

#include <Keypad.h> //Keypad und Servo Library wird eingebunden

#include <Servo.h>

Servo servoblau; //Servo wird ab jetzt mit „servoblau“ angesprochen

char* password = „123“; //Das Passwort wird festgelegt. In diesem Beispiel

// „123“

int position = 0;

const byte ROWS = 4; //Hier wird angegeben wie viele Zeilen und Spalten das

const byte COLS = 3; //Tastenfeld besitzt

char keys[ROWS][COLS] = { //Die Ziffern und Zeichen des Tastenfelds werden

{‚#‘, ‚0‘, ‚*‘}, //angegeben

{‚9‘, ‚8‘, ‚7‘},

{‚6‘, ‚5‘, ‚4‘},

{‚3‘, ‚2‘, ‚1‘}

};

byte rowPins[ROWS] = {5, 6, 7, 8}; //Die Verbindung mit dem Arduino wird

byte colPins[COLS] = {2, 3, 4}; //festgelegt

Keypad keypad = Keypad( makeKeymap(keys), rowPins, colPins, ROWS, COLS );

int roteLED = 12; //Die rote LED ist an Pin 12 angeschlossen

int grueneLED = 13; //Die grüne LED wird an Pin 13 angeschlossen

void setup()

{

pinMode(roteLED, OUTPUT); //Die LEDs werden als Ausgang festgelegt

pinMode(grueneLED, OUTPUT);

servoblau.attach(11); //Der Servo ist an Pin 11 angeschlossen

setLocked(true);

}

void loop()

{

char key = keypad.getKey();

if (key == ‚*‘ || key == ‚#‘) //wenn das Schloss entsperrt ist kann es mit der

//Taste „*“ oder „#“ wieder gesperrt werden

{

position = 0;

setLocked(true); //Schloss sperren wenn * oder # gedrückt wurde

}

if (key == password[position])

{

position ;

}

if (position == 3) //Diese Zeile gibt die Länge des Passwortes an. In unserem

//Fall 3 Stellen.

{

setLocked(false);

}

delay(100);

}

void setLocked(int locked)

{

if (locked) // Wenn das Schloss gesperrt ist soll..

{

digitalWrite(roteLED, HIGH); //..die rote LED leuchten..

digitalWrite(grueneLED, LOW); //..die grüner LED nicht leuchten..

servoblau.write(90); //und der Servo soll 0 Grad ansteuern.

}

else //wenn das Schloss entsperrt ist soll..

{

digitalWrite(roteLED, LOW); //..die rote LED nicht leuchten..

digitalWrite(grueneLED, HIGH); //..die grüne LED leuchten..

servoblau.write(0); //..und der Servo 90 Grad ansteuern.

}

}

Diese Anleitung dient als Beispiel und Grundstein wie man ein einfaches „Schloss“ mit Hilfe weniger Bauteile und dem Arduino konstruieren kann.

Nr.23 – Tastenfeld

Ein Tastenfeld am Arduino verwenden

Dieses Tutorial befindet sich momentan in Bearbeitung. Den Code gibt es schonmal…

Na? reicht das schon aus? 😉

 

#include <Keypad.h>
/*Einfach unter Sketch->Bibliothek einbinden->Bibliotheken verwalten...
  und dann über die Suchzeile suchen,finden und installieren
  (Version von Mark Stanly benutzen)
*/

//Hier wird die größe des Keypads definiert
const byte ROWS = 4; //4 Zeilen
const byte COLS = 3; //3 Spalten

//Die Ziffern/Zeichen
char keys[ROWS][COLS] = {
  {'#', '0', '*'},
  {'9', '8', '7'},
  {'6', '5', '4'},
  {'3', '2', '1'}
};

//Definition der Pins für die 4 Zeilen
byte rowPins[ROWS] = {5, 4, 3, 2};
//Definition der Pins für die 3 Spalten
byte colPins[COLS] = {8, 7, 6};

char pressedKey; //pressedKey entspricht in Zukunft den gedrückten Tasten

Keypad myKeypad = Keypad( makeKeymap(keys), rowPins, colPins, ROWS, COLS ); //Das Keypad kann absofort mit myKeypad angesprochen werden


void setup() {
  Serial.begin(9600);
}

void loop() {
  pressedKey = myKeypad.getKey();

  if (pressedKey)
  {
    Serial.print("Die Taste ");
    Serial.print(pressedKey);
    Serial.print(" wurde gedrueckt");
    Serial.println();
  }
}

 

 

Nr.22 – 433mhz Funkverbindung

Funkverbindung über 433mhz Signale mit dem Arduino

by Simon Spettmann

(In Bearbeitung: Fotos und abschließende Tests stehen noch aus)

Aufgabe: Mit einem Sender soll ein 433mhz Signal gesendet werden.

Hierbei wird das Protokoll 2 mit 24bit länge verwendet.

Material: Arduino / Breadboard / Kabel (3x) / 433Mhz XY-FST-Transmitter / Stromversorgung

Für diese Aufgabenstellung wird die RCSwitch Library gebraucht:
https://github.com/sui77/rc-switch

Die Library der Arduino IDE hinzufügen:
-Lade die Library herrunter und speichere sie (bsp: Desktop)
-Öffne die Arduino IDE
-Gehe auf Sketche→Bibliothek einbinden→.zip Bibliothek einbinden
-Wähle die entsprechende Library aus
-Bestätige die Eingabe und warte eine Sekunde
-Fertig !

Der Sender überträgt auf der 433mhz Frequenz Funksignale, wobei Bitlänge und Pulslänge variiert werden können. Die Signale sind nicht verschlüsselt, können also auch von jedem Empfangen werden. Man sollte also aufpassen was man sendet. Die meisten Sender können von 2,6V bis 12V betrieben werden. Hierbei gilt: Desto höher die Spannung, umso höher die Reichweite!
Zusätzlich braucht der Sender eine „Antenne“, da diese nicht von Werk aus nicht installiert ist. Hierzu reicht ein ca. 17cm langes Jumpercable (normales Kabel/Draht) !
Dieses wird an die freie Öse am Sender angelötet. Für erste Versuche kann man diese weglassen, jedoch beträgt die Reichweite dann ~4cm.
Der Sender hat drei Anschlüsse.

Beim Blick auf die Vorderseite:
links: Data / in der Mitte: VCC / rechts: GND

Um den Sender zu versenden, verbinden wir den Data-Pin mit Pin 10 des Arduinos, VCC mit 5V und GND mit GND.

Bild folgt!

Der Sketch (Sender):

#include <RCSwitch.h>  // Einfügen der RCSwitch Library
RCSwitch mySwitch = RCSwitch(); // Ab hier kann der Sender mit mySwitch angesprochen werden

void setup()
{
  Serial.begin(9600); // Initialisiert die Serielle Übertragung mit 9600baud
  mySwitch.enableTransmit(10); // Der Sender ist an Pin 10 angeschlossen
  mySwitch.setProtocol(2); // Das Protokoll 2 wird verwendet
}


void loop()
{
  mySwitch.send(1010, 24); // Sende 1010 mit 24bit länge
  delay(1000); // Warte 1000 milisekunden
  mySwitch.send(0101, 24); // Sende 0101 mit 24bit länge
  delay(1000); // Warte 1000 milisekunden

  delay(2000); // Warte 20000 milisekunden
}


 

 

Aufgabe: Mit dem Empfänger soll ein 433mhz Signal empfangen und am Serial-Monitor angezeigt werden.

Material: Arduino / Breadboard / Kabel (3x) / 433Mhz XY-MK-5V-Receiver / Stromversorgung

Der Empfänger zeichnet 433Mhz Signale auf, überträgt diese an den Arduino welcher sie dann decodiert. Sobald der Empfänger ein Signal aufzeichnet, unterbricht er den Arduino in seinem Programm (Loop). Die empfangenen Daten können dann Serial Monitor angezeigt, oder für Andere Aktionen genutzt werden. Im Gegensatz zum Sender verträgt der Empfänger nur 5V, da er ja auch nur „hören“ muss und nicht, wie der Sender, laut/weit „rufen“ muss. Um Signale zu empfangen braucht aber auch der Empfänger eine Antenne. Hier reicht auch ein ca. 17cm langes Stück eines Jumperkables, welches an die freie Öse gelötet wird.
Wenn auf eine Antenne verzichtet wird, beträgt die Reichweite nur ca. 4cm.
Der Empfänger hat 4 Anschlüsse.

Beim Blick auf die Rückseite:
links: GND / in der Mitte(2x): Data / rechts: VCC

Zur Verwendung wird ein (beliebiger) Data-Pin mit dem Pin 2 Arduinos verbunden.
Im Sketch wird diese als Pin 0 beschrieben, da er dieser der Interrupt-Pin 0 ist.

BILD folgt

Der Sketch (Empfänger):

// Sketch zum Empfangen von 433mhz Signalen mit passendem Empfänger

#include <RCSwitch.h> // Inkludiere dieRCSwitch Library
RCSwitch mySwitch = RCSwitch(); // Ab hier kann der Empfänger mit mySwitch angesprochen werden

void setup()
{
  Serial.begin(9600); // Initialisiert die Seriele Übertragung mit 9600 Baud
  mySwitch.enableReceive(0); // Hier wird festgelegt, das der Empfänger den Interrupt 0 angeschlossen ist, welcher auf dem Board Pin 2 entspricht
}

void loop()
{
  if (mySwitch.available()) // Wenn etwas Empfangen wurde
  {    
    int value = mySwitch.getReceivedValue(); // Soll value dem Empfangen entsprechen
        
    if (value == 0) // Wenn das Empfangene 0 entspricht
    {
      Serial.print("Unbekannte Codierung"); // Schreibe „Unbekannte […]
    }
    else // sonst
    {
      Serial.print("Empfangen: "); // Übertrage das Signal und weitere Informationen an den PC
      Serial.print( mySwitch.getReceivedValue() );
      
      Serial.print(" / ");
      
      Serial.print( mySwitch.getReceivedBitlength() );
      Serial.print("bit ");
      
      Serial.print("Protokol:: ");
      Serial.println( mySwitch.getReceivedProtocol() );
    }
    mySwitch.resetAvailable(); // Bereite den Empfänger auf neue Signale vor
  }
}


 

Aufgabe: Zwei Arduinos sollen mit einander kommunizieren: Wenn beim ersten Arduino ein Knopf gedrückt wird, soll beim zweiten Arduino eine Lampe angehen.

Sketch für den Sender:

#include <RCSwitch.h> // Einfügen der RCSwitch Library
RCSwitch mySwitch = RCSwitch();
#define LedAn 1010 // Definiere LedAn als 1010
#define LedAus 0101 // Definiere LedAus als 0101
#define taster 7 // Definiere taster als (Pin) 7

boolean count; // Boolean kann je true ode false sein. Er wird hier genutzt, um den Taster für zwei Anwendungszwecke zu nutzen.

void setup()
{
  Serial.begin(9600); // Initalisiere die Seriele Übertragung
  pinMode(taster, INPUT); // Der Taster (Pin7) ist jetzt ein Eingang
  mySwitch.enableTransmit(10); // Der Sender ist an Pin 10 angeschlossen
}


void loop()
{ 
 if (digitalRead(taster)==HIGH) // Wenn der Taster gedrückt ist...
 {
  if(count=false) // und vorher noch nicht gedrückt wurde
  {
    mySwitch.send(LedAn, 24); // ...Sende LedAn (1101)
    delay(1000); // Warte 1 Sekunde
    count=true; // Merke dir, das der Taster vorher gedrückt wurde
  }
  else // sonst...
  {
    mySwitch.send(LedAus, 24); // Sende LedAus (0101)
    delay(1000); // Warte 1 Sekunde
    count=false; // Beim nächsten Tastendruck soll die Led wieder angehen
  }
 }
}


 

Sketch für den Empfänger:

#include <RCSwitch.h> // Einfügen der RCSwitch Library

RCSwitch mySwitch = RCSwitch();

#define Led 13 // Definiere Led als 13. Ab hier kann der Begriff "Led" als Ersatz für 13 genommen werden



void setup()
{
  Serial.begin(9600); // Initalisiere die Seriele Übertragung
  pinMode(Led, OUTPUT); // Der Pin mit der LED (Pin 13) ist jetzt ein Ausgang
  mySwitch.enableReceive(0); // Der Empfänger ist an Pin 2 angeschlossen
}


void loop()
{
  if (mySwitch.available()) // Wenn etwas Empfangen wurde...

  {
    int value = mySwitch.getReceivedValue(); // Entspricht value dem Empfangenen

    switch (value) // Wenn value...
    {
      case 1010: // Fall1: 1010 entspricht, dann...

        digitalWrite(Led, HIGH); / ...schalte die Led an.

        break;

      case 0101: // Fall2: 0101 entspricht, dann...

        digitalWrite(Led, LOW); // schalte die Led aus.

        break;

      default: // Fall3: etwas anderem entspricht,

        Serial.println("Error, Übertragung entsprich: "); // Teile uns den Fehler mit

        Serial.print(value); // und nenne uns die Übertragung

        break;
    }
  }
}


 

 

 

Nr.21 – I²C Display

Anleitung zum LCD Display mit I2C Anschluss

Das LCD Modul  mit angelötetem I2C Bus ermöglicht die Verwendung eines LCD Moduls mit einer einfachen Verkabelung. Dies ist bei komplexeren Projekten besonders vorteilhaft. Ein weiterer Unterschied zum normalen LCD Display besteht darin, dass sich auf der Rückseite des Displays ein Drehregler befindet, mit dem die Leuchtstärke des LCD reguliert werden kann.

Hinweis:
Diese Anleitung funktioniert nur mit einem I²C Modul auf der Rückseite des Displays ohne drei Lötstellen mit der Bezeichnung A0,A1 und A2. Das Modul muss folgendermaßen aussehen:

I2Cn

Bei LCDs mit den Lötstellen auf dem I²C Modul siehe Anleitung „Zwei I²C LCD Module gleichzeitig ansteuern“.

 

Material: Mikrocontroller ( in diesem Beispiel UNO R3), LCD mit I2C Modul, Kabel

Verkabelung:  Die Verkabelung ist sehr simpel. Am I2C LCD Modul sind nur vier Kontakte vorhanden. GND wird mit dem GND Kontakt am Mikrocontroller verbunden. VCC mit dem 5V Kontakt am Microcontroller, SDA mit dem Analogen Eingang A4 und SCL mit dem Analogen Eingang A5.

Achtung!: Bei dem MEGA2560 R3 Microcontroller gibt es für die SDA – und SCL- Kontakte eigene Eingänge auf dem Board unter 20 und 21.

 

Programmieren:

Um Mit dem I2C LCD Modul zu arbeiten benötigt man eine Library welche noch nicht im Arduino Programm vorinstalliert ist. Diese kann man zum Beispiel unter https://github.com/fdebrabander/Arduino-LiquidCrystal-I2C-library als .ZIP Datei herunterladen. Danach muss die Library im Arduino Programm hinzugefügt werden.

Das kann unter dem Punkt „Sketch“ dann „Include Library“ und „add .ZIP Library ..“ gemacht werden. Jetzt kann im Code auf die Library zurückgegriffen werden.

 

Code:

#include <Wire.h> // Wire Bibliothek hochladen
#include <LiquidCrystal_I2C.h>// Vorher hinzugefügte LiquidCrystal_I2C Bibliothek hochladen
LiquidCrystal_I2C lcd(0x27, 16, 2);   //Hier wird festgelegt um was für einen Display es sich handelt. In diesem Fall einer mit 16 Zeichen in 2 Zeilen.

void setup()
{
lcd.begin(); //Im Setup wird der LCD gestartet (anders als beim einfachen LCD Modul ohne 16,2 in den Klammern denn das wurde vorher festgelegt
}

void loop()
{
lcd.setCursor(0,0); //Ab hier kann das I2C LCD Modul genau wie das einfache LCD Modul programmiert werden.
lcd.print("Eckstein GmbH");
lcd.setCursor(0,1);  // lcd.setCursor um Zeichen und Zeile anzugeben
lcd.print("Viel Erfolg!"); // lcd.print um etwas auf dem Display anzeigen zu lassen.
}

 

Anwendungsbeispiel:

Mit dem I2C LCD Modul können wie mit dem einfachen LCD Modul, auch Messwerte angezeigt werden.

Hier ein Beispielcode, bei dem ein Feuchtigkeitssensor an Pin A0 angeschlossen wurde :

#include <Wire.h>
#include <LiquidCrystal_I2C.h>
LiquidCrystal_I2C lcd(0x27, 16, 2);
int messwert=0;

void setup()
{
lcd.begin();
}

void loop()
{
messwert=analogRead(A0);  // Der Messwert vom Analogen Eingang A0 soll ausgelesen, und unter der Variablen „messwert“ gespeichert werden.
lcd.setCursor(0,0); // In der ersten Zeile soll der Text „Messwert:“ angezeigt werden.
lcd.print("Messwert:");
lcd.setCursor(0,1);  // In der zweiten Zeile soll der Messwert, der vom Feuchtigkeitssensor bestimmt wurde, angezeigt werden.
lcd.print(messwert);
delay(500);
}

 

Nr.20 – Keypad Shield

Keypadshield mit dem Arduino betreiben

Ein Keypadshield hat den Vorteil, dass man das LCD Display nicht in komplizierter Weise verkabeln muss und dass man zusätzlich sechs Taster hat, die man verwenden kann. Das besondere liegt bei den Tasten darin, dass sie im Programmcode alle über einen analogen Pin ausgelesen werden können. Denn die Taster sind über unterschiedliche Widerstände alle mit einem analogen Pin (A0) verbunden. Der Pin A0 kann daher nur eingeschränkt für andere Dinge verwendet werden. Aus dem Grund befindet sich auf dem Shield auch kein Steckplatz für den A0-Pin.

Das Keypadshield kann u.a. auf das UNO das MEGA Board aufgesteckt werden. Es wird so platziert, dass die Pins für die Spannungsversorgung genau in die Pins der Spannungsversorgung auf dem Arduino Board passt (auf dem Bild unten in der Mitte sieht man die Pins für die Spannungsversorgung. Ein Anhaltspunkt kann der Pin mit der Aufschrift „VIN“ sein). Die oberen Steckplätze des Arduinoboards werden ebenfalls durch das Shield verdeckt (Pin 0-13). Einige können eh nicht mehr verwendet werden, da das LCD Display sie verwendet. Die nicht mehr benötigten Pins wurden in einer Reihe von Steckplätzen zusammengefasst (Siehe Foto oben rechts).

Wenn man diese Steckplätze verwenden möchte, sollte man dort Kabelbuchsen auflöten.

Als Beispielcode kann der folgende verwendet werden:

 

//Sample using LiquidCrystal library
 
#include <LiquidCrystal.h>
 
/*******************************************************
This program will test the LCD panel and the buttons
Mark Bramwell, July 2010
********************************************************/
 
// select the pins used on the LCD panel
LiquidCrystal lcd(8, 9, 4, 5, 6, 7);
 
 
// define some values used by the panel and buttons
int lcd_key = 0;
int adc_key_in = 0;
#define btnRIGHT 0
#define btnUP 1
#define btnDOWN 2
#define btnLEFT 3
#define btnSELECT 4
#define btnNONE 5
 
// read the buttons
int read_LCD_buttons()
{
adc_key_in = analogRead(0); // read the value from the sensor
// my buttons when read are centered at these valies: 0, 144, 329, 504, 741
// we add approx 50 to those values and check to see if we are close
if (adc_key_in > 1000) return btnNONE; // We make this the 1st option for speed reasons since it will be the most likely result
 
if (adc_key_in < 50) return btnRIGHT;
if (adc_key_in < 195) return btnUP;
if (adc_key_in < 380) return btnDOWN;
if (adc_key_in < 555) return btnLEFT;
if (adc_key_in < 790) return btnSELECT;
 
return btnNONE; // when all others fail, return this...
}
 
void setup()
{
lcd.begin(16, 2); // start the library
lcd.setCursor(0,0);
lcd.print("NACHRICHT"); // print a simple message
pinMode (2, OUTPUT);
}
 
void loop()
{
digitalWrite (2, HIGH);
lcd.setCursor(9,1); // move cursor to second line "1" and 9 spaces over
lcd.print(millis()/1000); // display seconds elapsed since power-up
 
 
lcd.setCursor(0,1); // move to the begining of the second line
lcd_key = read_LCD_buttons(); // read the buttons
 
switch (lcd_key) // depending on which button was pushed, we perform an action
{
case btnRIGHT:
{
lcd.print("RIGHT ");
digitalWrite (2, LOW);
break;
}
case btnLEFT:
{
lcd.print("LEFT ");
break;
}
case btnUP:
{
lcd.print("UP ");
break;
}
case btnDOWN:
{
lcd.print("DOWN ");
break;
}
case btnSELECT:
{
lcd.print("SELECT");
break;
}
case btnNONE:
{
lcd.print("NONE ");
break;
 
}
}
}

 

Nr.14 LCD Display

Ein LCD Display per Arduino ansteuern

Aufgabe: Ein LCD Display soll mit einem Arduino Mikrocontroller angesteuert werden. Danach soll auf dem Display ein vorher festgelegter Text wie auf folgendem Beispielfoto erscheinen.

Material: Mikrocontrollerboard (In diesem Beispiel UNO R3), ein Drehregler (bzw. Potentiometer), 14 Jumperkabel, Breadboard

Anhand des Materials und der Skizze erkennt man schnell, dass die Verkabelung nicht so leicht ist. Das liegt daran, dass das LCD Display mit sehr vielen Kabeln verbunden werden muss. Eine weitere Schwierigkeit sind fehlende Buchsen mit denen man die Kabel anschließen könnte. Daher bietet es sich an, eine Steckbuchsenleiste aufzulöten oder die Kabel direkt an das LCD anzulöten. Im zweiten Fall bietet es sich an, ein Flachbandkabel zu verwenden (Bspw. von alten IDE-Laufwerken wie Festplatten, CD- oder DVD Laufwerken). Ohne eine gelötete Verbindung ist es nahezu ausgeschlossen, gute Ergebnisse zu erzielen.

Der Drehregler ist dazu da, den Kontrast des LCD einzustellen. Die LED Hintergrundbeleuchtung wird wie in der Skizze dargestellt mit 5V versorgt. Da man in der Skizze die Beschriftung am LCD nicht erkennen würde, wird sie nicht dargestellt. Man muss also die Position der Kabel am LCD Abzählen (Beispiel: Am LCD wird das erste Kabel von rechts mit GND verbunden. Das zweite Kabel von rechts wird mit 5V verbunden usw…) . Info: Für schnelle Basteleien benutzen viele Bastler lieber ein LCD-Keypad-Shield oder ein I2C-LCD, da man sich bei den beiden Alternativen nicht mehr um die Verkabelung des LCD kümmern muss. Allerdings sind die beiden genannten Alternativen auch teurer.

Skizze:

Wenn man die Verkabelung erfolgreich hergestellt hat, kann man sich mit der Software befassen.Wie bei vielen anderen Bauteilen, wird auch hier auf eine „Library“ zurückgegriffen. Die Library für das LCD Display ist Bestandteil der Arduino-Software und muss nicht zusätzlich installiert werden.

 

#include <LiquidCrystal.h>


LiquidCrystal lcd(12, 11, 5, 4, 3, 2);



void setup() 
{
lcd.begin(16, 2);
}

void loop() 
{
lcd.setCursor(0, 0);
lcd.print("www.eckstein-shop.de");
lcd.setCursor(0, 1);
lcd.print("Viel Erfolg");
}

 

LCD-Bibliothek ladenIn dieser Zeile wird festgelegt, welche Pins des Mikrocontrollerboards für das LCD verwendet wird (Am besten erstmal nicht verändern).

Im Setup wird angegeben, wie viele Zeichen und Zeilen werwendet werden. Hier: 16 Zeichen in 2 Zeilen.

 

Startposition der Darstellung auf dem LCD festlegen. lcd.setCursor(0,0) bedeutet: Erstes Zeichen in der ertsen Zeile. Dort soll der Text „www.eckstein-shop.de“ erscheinen. Der Befehl lcd.setCursor ist dem Mikrocontrollerboard durch das Aufrufen der Bibliothek bekannt. lcd.setCursor(0,1) bedeutet: Erstes Zeichen in der zweiten Zeile. Dort soll dann der Text „Viel Erfolg!!!“ auftauchen.

 

Eine Variation: Im Display soll abwechselnd erst oben und dann unten ein Text erscheinen. In diesem Beispiel der Text „Oben“ und „Unten“.

 

#include <LiquidCrystal.h>
LiquidCrystal lcd(12, 11, 5, 4, 3, 2);


void setup() 
{
lcd.begin(16, 2);
}

void loop() 
{
lcd.setCursor(0, 0);
lcd.print("Oben");
delay (2000);
lcd.clear();
lcd.setCursor(5, 1);
lcd.print("unten");
delay (2000);
lcd.clear();
}

 

 

Beginn beim ersten Zeichen in der ersten Zeile mit dem Text „Oben“.

Zwei Sekunden warten.

Display löschen.

Erneuter Beginn beim fünften Zeichen in der zweiten Zeile mit dem Text „Unten“.

Zwei Sekunden warten.

Display löschen.

 

Ein LCD eignet sich besonders gut, um Sensorwerte oder andere Ausgaben des Mikrocontrollerboards anzuzeigen. Weitere Hilfe bekommt man z.B. in der Arduino-Software. Unter den Beispiel-Sketches findet man eine Reihe von verschiedenen Beispielen unter dem Menüpunkt „LiquidCrystal“.

Nr.07 Bewegungsmelder

Sketch Nr.7: Der Bewegungsmelder

Aufgabe: Ein Piezo-Lautsprecher soll piepen, sobald eine Bewegung registriert wird.

Material: Arduino / Bewegungsmelder / Breadboard / Kabel / Piezo-Lautsprecher

Lerninhalt: Spannung eines Bewegungsmelders auslesen und für eine Ausgabe verwenden.

Erklärung zum Bewegungsmelder

Der Bewegungsmelder, auch PIR Sensor genannt, ist sehr einfach konstruiert. Sobald er eine Bewegung detektiert, gibt er auf einem Pin eine Spannung von 5 Volt aus. Diese muss nur ausgelesen und vom Mikrocontroller verarbeitet werden.Die Dauer des Ausgangssignals und die Sensibilität (Reichweite) kann über zwei Drehregler eingestellt werden (Bild rechts).

 

hc-sr04aAn der Unterseite des Bewegungsmelders befindet sich zudem ein Jumper, mit dem man zwischen zwei Modi wechseln kann.

1) Jumper ist ganz außen: Das Ausgangssignal wird nachdem eine Bewegung detektiert wurde für eine gewisse Zeit aufrecht erhalten und danach auf jeden Fall wieder deaktiviert, auch wenn im Aktionsbereich des Bewegungsmelders noch eine Bewegung detektiert werden könnte. Nach einer gewissen Zeit wird das Ausgangssignal erneut erzeugt.

2) Der Jumper ist wie auf dem Abbild rechts leicht nach innen versetzt. Das Ausgangssignal bleibt pausenlos aktiv, so lange vom Bewegungsmelder eine Bewegung detektiert wird. Dieser Modus wird für Arduinoprojekte empfohlen.

hc-sr04cDie Kunststofflinse ist nur leicht gesteckt. Wenn man sie abhebt kann man den Infrarotdetektor erkennen und man sieht anhand der Beschriftung unter der Linse, wie der Sensor verkabelt werden muss: GND ( – ), OUT (Ausgang des Signals), VCC ( ).Links sind die Kontakte noch einmal als Bild.
hc-sr04b

Der Aufbau

Sketch zum Bewegungsmelder

int piezo=5; //Das Wort „piezo“ steht jetzt für den Wert 5.
int bewegung=7; //Das Wort „bewegung“ steht jetzt für den Wert 7.
int bewegungsstatus=0; //Das Wort „bewegungsstatus“ steht jetzt zunächst für den Wert 0. Später wird unter dieser Variable gespeichert, ob eine Bewegung erkannt wird oder nicht.

void setup() //Hier beginnt das Setup.
{
pinMode(piezo, OUTPUT); //Der Pin mit dem Piezo (Pin 5) ist jetzt ein Ausgang.
pinMode(bewegung, INPUT); //Der Pin mit dem Bewegungsmelder (Pin 7) ist jetzt ein Eingang.
}

void loop() //Der Loop-Teil beginnt//Mit dieser Klammer wird der Loop-Teil geöffnet.
bewegungsstatus=digitalRead(bewegung); //ier wird der Pin7 ausgelesen. Das Ergebnis wird unter der Variablen „bewegungsstatus“ mit dem Wert „HIGH“ für 5Volt oder „LOW“ für 0Volt gespeichert.
if (bewegungsstatus == HIGH) //Verarbeitung: Wenn eine Bewegung detektiert wird (Das Spannungssignal ist hoch)//Programmabschnitt des IF-Befehls öffnen.
digitalWrite(piezo, HIGH); //dann soll der Piezo piepsen.
delay(5000); //...und zwar für für 5 Sekunden.
digitalWrite(piezo, LOW); //...danach soll er leise sein.//Programmabschnitt des IF-Befehls schließen.
else //ansonsten...//Programmabschnitt des else-Befehls öffnen.
digitalWrite(piezo, LOW); //...soll der Piezo-Lautsprecher aus sein.//Programmabschnitt des else-Befehls schließen.//Mit dieser letzten Klammer wird der Loop-Teil geschlossen.

Sketch ohne Erklärungen

int piezo=5;
int bewegung=7;
int bewegungsstatus=0;

void setup()
{
pinMode(piezo, OUTPUT);
pinMode(bewegung, INPUT);
}

void loop()
{
bewegungsstatus=digitalRead(bewegung);
if (bewegungsstatus == HIGH)
{
digitalWrite(piezo, HIGH);
delay(5000);
digitalWrite(piezo, LOW);
}
else
{
digitalWrite(piezo, LOW);
}
}

 

Nr.19 RFID Kit

Anleitung zum RFID Kit mit Arduino

Der RFID („radio-frequency identification“) Reader wird verwendet, um von RFID Sendern (auch „RFID Tags“ genannt) per Funk einen bestimmten Code auszulesen. Jeder Sender hat dabei nur einen einmaligen ganz individuellen Code. Damit lassen sich mit dem Arduino Schließanlagen oder ähnliche Projekte verwirklichen, bei denen sich eine Person mit einem Sender identifizieren soll.

RFID-TAGs können verschiedene Formen haben, wie z.B. Schlüsselanhänger oder Karten im Kreditkartenformat.

Auf dem folgenden Bild sieht man Links oben und unten zwei RFID-TAGs, rechts oben den RFID-Empfänger RFID-RC522 und unten rechts Stiftleisten zum anlöten an den Empfänger.

Wie funktioniert das ganze? Ein RFID-Empfänger enthält eine kleine Kupferspule, die ein magnetisches Feld erzeugt. Ein RFID-Sender enthält ebenfalls eine Kupferspule, die das magnetische Feld aufgreift und in dem Sender eine elektrische Spannung erzeugt. Diese Spannung wird dann verwendet um einen kleinen elektronischen Chip dazu zu bringen, per Funk einen elektrischen Code auszusenden. Dieser Code wird dann direkt vom Sender empfangen und so verarbeitet, dass der Arduino-Mikrocontroller den empfangenen Code weiterverarbeiten kann.

Es ist auch möglich, RFID-TAGs zu mit einem Code zu beschreiben. Dies wird aufgrund der Komplexität in dieser Anleitung nicht behandelt. Weiterführende Tutorials finden sich genügend im Netz.

Einen RFID-TAG mit Arduino auslesen und die Daten verarbeiten

Material: Arduino UNO oder MEGA, RFID-READER, mindestens einen RFID-TAG, Breadboard, einige Breadboardkabel, eine LED, ein 200 Ohm Widerstand

Aufgabe: Mit Hilfe eines Arduino-Mikrocontrollers soll ein RFID-TAG ausgelesen werden. Sofern es sich um den richtigen TAG handelt, soll eine Leuchtdiode für 5 Sekunden leuchten.

 

Verkabelung des Arduino-Boards mit dem RFD-Empfänger:

Board:

Arduino Uno

Arduino Mega

MFRC522-READER

Pin:

10

53

SDA

Pin:

13

52

SCK

Pin:

11

51

MOSI

Pin:

12

50

MISO

Pin:

unbelegt

unbelegt

IRQ

Pin:

GND

GND

GND

Pin:

9

5

RST

Pin:

3,3V

3,3V

3,3V

 

Foto vom Aufbau. In diesem Beispiel wurden an den RFID-Empfänger die um 90° gebogenen Kontaktstifte angelötet, damit der Empfänger senkrecht in ein Breadboard gesteckt werden kann:

Progammierung

Beim Auslesen und verarbeiten der Daten eines RFID-Empfängers wären wie auch bei anderen komplexen Aufgaben sehr viele Zeilen Quellcode erforderlich. Daher bedienen wir uns einer vorgefertigten Library aus dem Internet. Es gibt einige verschiedene im Netz zu finden. In dieser Anleitung haben wir uns für die Library von der Internetseite https://github.com/miguelbalboa/rfidentschieden. Damit man damit arbeiten kann, muss man sich die Library zunächst herunterladen und im Arduino Programmordner abspeichern. Auf der Internetseite klickt man dazu unten rechts auf „Download ZIP“ und speichert die gepackte Datei auf seiner Festplatte.

 

Danach entpackt man den Inhalt in die Arduino-Software auf der Festplatte und zwar in den Ordner „libraries“. Für gewöhnlich befindet sich der Ordner auf der Festplatte unter dem Pfad „C:Programmearduinolibraries…“ (Wenn man das Programm an einer anderen Stelle gespeichert hat, muss man dort den Ordner „libraries“ verwenden.

Sobald die Datei entpackt ist, entsteht im Ordner „libraries“ die Datei „rfid-master“. Jetzt MUSS zunächst der Bindestricht entfernt werden. Man benennt den Ordner also um in den Ordner „rfidmaster“. So, das wäre geschafft. Die Library kann in der Arduino-Software verwendet werden.

Vorbereitung – der erste Sketch mit dem RFID-READER

Zunächst werden wir die UID („Unique Identification Number“), also die individuelle Bezeichnung eines RFID-TAGs auslesen. Dazu verwenden wir das folgende Programm (Achtung, das Programm funktioniert nur, wenn die library wie oben beschrieben zur Arduino-Software hinzugefügt wurde). Das Programm ist für den UNO R3 Mikrocontroller vorgesehen. Bei MEGA2560 und anderen Controllern müssen die Pins entsprechend angepasst werden.

#include <SPI.h> // SPI-Bibiothek hinzufügen

#include <MFRC522.h> // RFID-Bibiothek hinzufügen

#define SS_PIN 10 // SDA an Pin 10 (bei MEGA anders)

#define RST_PIN 9 // RST an Pin 9 (bei MEGA anders)

MFRC522 mfrc522(SS_PIN, RST_PIN); // RFID-Empfänger benennen



void setup() // Beginn des Setups:

{

Serial.begin(9600); // Serielle Verbindung starten (Monitor)

SPI.begin(); // SPI-Verbindung aufbauen

mfrc522.PCD_Init(); // Initialisierung des RFID-Empfängers

}



void loop() // Hier beginnt der Loop-Teil

{

if ( ! mfrc522.PICC_IsNewCardPresent()) // Wenn eine Karte in Reichweite ist...

{

return; // gehe weiter...

}



if ( ! mfrc522.PICC_ReadCardSerial()) // Wenn ein RFID-Sender ausgewählt wurde

{

return; // gehe weiter...

}



Serial.print("Die ID des RFID-TAGS lautet:"); // "Die ID des RFID-TAGS lautet:" wird auf den Serial Monitor geschrieben.



for (byte i = 0; i < mfrc522.uid.size; i  )

{

Serial.print(mfrc522.uid.uidByte[i], HEX); // Dann wird die UID ausgelesen, die aus vier einzelnen Blöcken besteht und der Reihe nach an den Serial Monitor gesendet. Die Endung Hex bedeutet, dass die vier Blöcke der UID als HEX-Zahl (also auch mit Buchstaben) ausgegeben wird

Serial.print(" "); // Der Befehl „Serial.print(" ");“ sorgt dafür, dass zwischen den einzelnen ausgelesenen Blöcken ein Leerzeichen steht.

}


Serial.println(); // Mit dieser Zeile wird auf dem Serial Monitor nur ein Zeilenumbruch gemacht.

}

 

Wenn alles funktioniert hat, sieht das Ergebnis am Serial-Monitor (Abgesehen von der eigenen UID) so aus:

Mit dieser hintereinander geschrieben HEX-Zahl lässt sich nicht gut arbeiten. Also ändern wir die Zeile „Serial.print(mfrc522.uid.uidByte[i], HEX);“ um in „Serial.print(mfrc522.uid.uidByte[i], DEC;“. Dann bekommt man als Ergebnis die einzelnen Blöcke des UID-Codes als Dezimalzahl ausgegeben:

RFID Sketch 2

Jetzt wird der UID-Code zwar als Dezimalzahl ausgegeben, aber er ist immernoch in vier Blöcke aufgeteilt. Wir verändern den Code jetzt mit ein wenig Mathematik dahingehend, dass wir für die UID eine einzige zusammenhängende normale Zahl erhalten (Dezimalzahl).

Warum machen wir das? Wenn wir später den Sketch verwenden wollen um etwas in Abhängigkeit eines richtig ausgelesenen RFID-TAGs auszulösen (Z.B. eine LED soll leuchten oder eine Servomotor soll sich um 90 Grad drehen…) können wir mit einer zusammenhängenden Zahl besser einen IF-Befehl verwenden. Zum beispiel:

„Wenn der RFID-Code=1031720 ist, dann soll eine LED für 5 Sekunden leuchten“.

Schwerer wäre es dagegen mit dem Befehl „Wenn der erste Block 195 lautet und der zweite Block 765 lautet und der dritte Block 770 lautet und der vierte Block 233 lautet … Dann schalte eine LED für 5 Sekunden an.

Nachteil ist jedoch, dass der Sketch dadurch etwas unsicherer wird, weil nicht alle Zahlen der vier Blöcke (Max. 12 Ziffern) in einer Zusammenhängenden Zahl dargestellt werden können. Wenn es sicherer sein soll, müsste man jeden einzelnen Block als solchen abfragen.

#include <SPI.h>
#include <MFRC522.h>
#define SS_PIN 10
#define RST_PIN 9
MFRC522 mfrc522(SS_PIN, RST_PIN);

void setup()
{
Serial.begin(9600);
SPI.begin();
mfrc522.PCD_Init();
}

void loop()
{
  
if ( ! mfrc522.PICC_IsNewCardPresent())
{
return;
}

if ( ! mfrc522.PICC_ReadCardSerial())
{
return;
}

long code=0; // Als neue Variable fügen wir „code“ hinzu, unter welcher später die UID als zusammenhängende Zahl ausgegeben wird. Statt int benutzen wir jetzt den Zahlenbereich „long“, weil sich dann eine größere Zahl speichern lässt.

for (byte i = 0; i < mfrc522.uid.size; i  )
{
code=((code mfrc522.uid.uidByte[i])*10); // Nun werden wie auch vorher die vier Blöcke ausgelesen und in jedem Durchlauf wird der Code mit dem Faktor 10 „gestreckt“. (Eigentlich müsste man hier den Wert 1000 verwenden, jedoch würde die Zahl dann zu groß werden.
}

Serial.print("Die Kartennummer lautet:"); // Zum Schluss wird der Zahlencode (Man kann ihn nicht mehr als UID bezeichnen) ausgegeben.
Serial.println(code);
}

 

Prima, jetzt können wir von einem RFID-TAG eine eindeutige Identifikationsnummer auslesen (Die Nummer wird am Serial Monitor angezeigt). In diesem Fall lautet die Identifikationsnummer dieses individuellen RFID-TAGs 1031720.

Und wie geht es weiter? Jetzt wollen wir eine LED für 5 Sekunden einschalten, falls der gewünschte RFID-TAG vor den RFID-READER gehalten wird.

RFID Sketch 3

#include <SPI.h>
#include <MFRC522.h>
#define SS_PIN 10
#define RST_PIN 9
MFRC522 mfrc522(SS_PIN, RST_PIN);

void setup()
{
Serial.begin(9600);
SPI.begin();
mfrc522.PCD_Init();
pinMode (2, OUTPUT); // Der Pin 2 ist jetzt ein Ausgang (Hier wird eine LED angeschlossen)
}

void loop()
{
if ( ! mfrc522.PICC_IsNewCardPresent())
{
return;
}

if ( ! mfrc522.PICC_ReadCardSerial())
{
return;
}

long code=0;

for (byte i = 0; i < mfrc522.uid.size; i  )
{
code=((code mfrc522.uid.uidByte[i])*10);
}

Serial.print("Die Kartennummer lautet:");

Serial.println(code);

// Ab hier erfolgt die erweiterung des Programms.

if (code==1031720) // Wenn der Zahlencode 1031720 lautet...// Programmabschniss öffnen

digitalWrite (2, HIGH); // ...dann soll die LED an Pin 2 leuchten...

delay (5000); // für 5 Sekunden

digitalWrite (2, LOW); // … und danach wieder aus gehen.// Programmabschnitt schließen// Sketch abschließen