Arduino

Abb.:Nr.1 Der Arduino

Einführung

Die Physical-Computing-Plattform [Arduino] (siehe Abb. 1) bietet einen einfachen Einstieg in die Welt der Programmierung und der Mikrocontroller. Die Hardware-Komponente der Plattform besteht dabei aus einem Mikrocontroller, welcher mit einem Eingabe-Ausgabe-Board interagiert, welches Pins für den Input/Output digitaler oder auch analoger sIgnale bietet. Die Programmierung erfolgt dabei in einer C/C++ - ähnlichen Sprache, wobei technische Details weitgehend vom Benutzer verborgen werden. In diesem Projekt sollen Versuche die grundlegende Funktionsweise des Arduino sowie dessen Programmierung dem Leser verständlich gemacht werden. Dabei werden Sensoren und Aktoren genutzt, welche an Pins des Boards angeschlossen werden und miteinander interagieren. Zuallererst jedoch werden die Hardware- sowie Softwarekomponenten der Arduino-Plattform, exemplarisch die des Arduino Uno, kurz erläutert.

Hardware

Die Hardware des Arduino Uno besteht aus einem [Microchip-AVR-Mikrocontroller] der megaAVR-Serie, wie z.B. dem ATmega328, sowie einem Board, auf welchem 6 analoge sowie 13 digitale Pins verbaut sind. Zusätzlich zu diesen Pins gibt es Pins für Erdung sowie eine Spannungsversorgung mit 5 Volt. Versorgt werden kann der Uno entweder mit 5 Volt über seinen USB-Anschluss oder 6-12 Volt mittels Netzteil.

Software

Die Software-Seite der Plattform stellt eine eigene Entwicklungsumgebung, die Java-basierte [Arduino-IDE], bereit. Diese bindet wichtige Bibliotheken. wie z.B. die avr-gcc-Library, ein und bindet den gcc als Compiler ein. Dadurch ist die Programmierung mit C/C++ wesentlich einfacher. Ein funtionierendes Programm für einen Arduino muss zwei Funktionen enthalten: Die setup() sowie die loop() - Funktion. Die setup() - Funktion, wie der Name bereits vermuten lässt, dient zur Festlegung von Pins als Eingang oder Ausgang und ähnlichen Vorbereitungen. Diese läuft bei Hochladen des Programms oder Betätigen des Resets einmalig ab. Die loop() - Funktion wird hingegen für die gesamte Zeit, in welcher der Arduino eingeschaltet ist, immer wieder ausgeführt. Hier befindet sich also für gewöhnlich der „eigentliche“ Teil des Programms, wie z.B. die Logik.

Door Lock mit Arduino

In diesem Versuch wurde mit Hilfe des Arduinos ein Passwort Abfrage Programm entwickelt, welches den Input über ein Keypad bekommt und die Ausgabe auf einem LCD Display mit I2C Backpack, sowie physisch durch einen Servo-Motor wiedergibt.

Abb.:Nr.2 Verkabelung des Door-Lock Versuchs

Der I2C LCD Adapter (LCM1602 IIC in Abb.2)

Zuerst ist es wichtig zu erklären wie das [I2C-Backpack] oder auch I2C-LCD-Adapter funtioniert. Dieser Adapter ist in diesem Versuch dafür da, Pins zu sparen damit mehr Geräte an den Arduino angeschlossen werden können. Auf diesem Adapter ist ein 8-Bit I/O erweiterungs Chip - [PCF8574]. Dieser Chip convertiert die I2C Signale vom Arduino in die parallelen Signale welche von dem LCD benötigt werden. Auf diesem Adapter ist auch ein Potentiometer mit dem sich die Helligkeit des LCD regulieren lässt.

Abb.:Nr.3 I2C-LCD-Adapter

Die standart I2C Adresse dieses Chips ist 0x27Hex welche man entweder durch ein I2C Scanner scetch für den Arduino selbst erkennen kann, oder durch einen Blick auf die 6 Lötfelder auf dem Chip. Diese können durch kurzschlüsse auch für eine ander Adresse sorgen welche von 0x20Hex bis 0x27Hex reichen kann.

Die 4 pins an der Seite gehen zum Arduino. Der GND pin geht zu Ground. Der VCC pin geht auf den 5V pin. SDA ist der serial Data pin welcher für die Übertragung und Empfang der Daten zuständig ist. Dieser wird auf dem Arduino Uno mit dem Pin A4 verbunden. SCL ist ein serial Clock pin, welcher ein timing signal übergibt. Dieser wird mit A5 auf dem Arduino verbunden.

Das Keypad

Abb.:Nr.4 Keypad

Mit dem Keypad lassen sich Eingaben auf den Arduino machen. Ich verbinde hier alle Pins des Keypads mit den Digitalen Pins des Arduinos. Später lassen sich dann diese Pins per Library im Programmcode ansprechen.

Der Servo-Motor

Ein einfacher Servomotor ist an dem Arduino angeschlossen. Er teilt sich die Ground und 5V Pins mit dem Lcd Bildschirm und belegt den digitalen Ansteuerungspin 10 auf dem Arduino. Dieser Motor wird später als Visualisierung des Schlosses dienen. Man könnte zum Beispiel einen Tür-Riegel bauen und diesen mit dem Motor verschieben um eine Tür auf und zu zusperren.

Code

Um nun alles zusammenzufügen binden wir zuerst einige Librarys ein, welche es vereinfachen die angeschlossen Peripherie zu bedienen.

#include <Wire.h>
#include <LiquidCrystal_I2C.h>
#include <Keypad.h>
#include <Servo.h>

Die Wire Library ermöglicht es mit I2C-Adaptern zu kommunizieren. Die [LiquidCrystal_I2C] bietet dementsprechend die Wire Signale für das LCD lesbar zu machen. Die Keypad und Servo Library ist selbstredent für die kommunikation zwischen Peripherie und Arduino zuständig.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
char keys[ROWS][COLS] =
{
    {'1','2','3','A'},
    {'4','5','6','B'},
    {'7','8','9','C'},
    {'*','0','#','D'}
};
byte rowPins[ROWS] = {9,8,7,6};
byte colPins[COLS] = {5,4,3,2};

Keypad keypad = Keypad( makeKeymap(keys), rowPins, colPins, ROWS, COLS );
LiquidCrystal_I2C lcd(0x27, 16, 2);
Servo servo;

In diesen Code-Zeilen wird die Keypad Matrix festgelegt. Außerdem werden Keypad, LCD und der Servo-Motor instanziiert. In Zeile 11 kann man außerdem undsere Hex Adresse des LCD sehen welche 0x27Hex entspricht.

1
2
3
4
5
6
7
8
9
void setup()
{
lcd.clear();
lcd.begin();
lcd.backlight();
servo.attach(10);
servo.write(90);
lcd.print("Passwort: ");
}

Hier wird die setup() Funktion des Arduinos geschireben. Der LCD wird gestarted, das Hintergrundlicht des LCD wird eingeschaltet und der Servo-Motor wird auf seine Ausgangsposition von 90° gestellt.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
void loop(){
char key = keypad.getKey();
lcd.blink();

if (key) {
    lcd.print(key);

    if (key == '*') {
    input_pass = "";
    setup();
    }
    else if (key == '#') {
    if (input_pass == pass) {
        lcd.clear();
        lcd.print("unlocked");
        servo.write(0);

        delay(5000);
    }
    else {
        lcd.clear();
        lcd.print("locked");
        delay(1000);
    }
    input_pass = "";
    setup();

    }
    else {
    input_pass += key;
    }
}
}

Zum Schluss wird in einer Schleife ein String mit einem am Anfang des Codes festgelegten String verglichen. Stimmen diese überein bewegt sich der Servo-Motor um 90° nach links auf 0°. Auf dem LCD wird dann „unlocked“ geschrieben was bestätigt, dass die potentielle Tür geöffnet ist. Danach wird die Eingabe zurückgesetzt und der Code von neu gestartet. Es besteht die Möglichkeit eine Fehleingabe durch betätigung der * Taste auf dem Keypad zurückzusetzten. Außerdem muss die Eingabe mit einem # bestätigt werden.

Der gesamte Code kann auf https://r-n-d.informatik.hs-augsburg.de:8080/dvati/berichte-ws21/2/-/blob/main/Arduino/DoorLock.ino eingesehen werden.

Hier noch einmal die Funktionen in einem Video. Man kann einmal eine richtige Eingabe des Passworts sehen, einmal eine falsche und einmal das ein falsch eingegebenes Passwort zurückgesetzt wird.

Video Nr.1 Door Lock in Aktion

Lichtabhängiger Motor

In diesem Versuch soll ein DC - Motor mit dem Auslesewerten aus einem Photoresistor angesteuert werden sowie 3 LEDs die Intensität der vorherrschenden Beleuchtung anzeigen. Der Motor wird dabei mittels eines externen Netzeils sowie eines Transistors angesprochen, sodass es möglich ist seine Drehzahl beliebig zu steuern. Um die Unversehrtheit des Arduino - Boards sicherzustellen gibt es die Möglichkeit, eine externe Spannungsquelle bei Betrieb eines solchen Motors zu verwenden, da bei dessen Betrieb Induktionsströme auftreten können. Nachfolgend eine Auflistung der verwendeten Teile sowie der zugehörige Steckplan:

  • 3,3 V/ 5 V Netzteil
  • DC - Motor
  • 3 x LEDs
  • Photoresistor
  • 4 x 220 Ohm Widerstand
  • Transistor PN2222

Abb.:Nr.5 Steckplan zum Versuch Nr.2

In den ersten Zeilen sowie der setup-Funtktion des Quellcodes werden benötigte Variablen für die Led - Pins sowie für den ausgelesenen Wert des Photoresistors deklariert. Obendrein werden der Steuerungs - Pin für den Transistor sowie die Led - Pins auf Ausgabe gestellt, sowie der serielle Monitor gestartet. Anmerkung: Will man den seriellen Monitor in der für Visual Studio Code bereitgestellten Erweiterung zum Hochladen von Arduino - Sketches nutzen, so muss man die Baud - Rate in VS Code der dem seriellen Monitor übergebenen (hier 9600) anpassen. Eine ausführliche Beschreibung zur Einrichtung der [Extension] in VS Code findet sich im Literaturverzeichnis.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
int val = 0;
int led1 = 5;
int led2 = 6;
int led3 = 7;


void setup()
{
 pinMode(10, OUTPUT);
 pinMode(5, OUTPUT);
 pinMode(6, OUTPUT);
 pinMode(7, OUTPUT);
 Serial.begin(9600);
 }

Der Photoresistor wird in Reihe mit einem 220 Ohm - Widerstand an den 5 Volt - Pin sowie GND - Pin des Arduino angeschlossen. Parallel zum 220 Ohm - Widerstand wird dabei am analogen Pin A0 des Arduino die nach dem Spannungsabfall am Photoresistor verbleibende Restspannung gemessen und ein entsprechender Wert zwischen 0 und 1023 ausgegeben.

In der loop - Funktion wird nun mittels if - Abfragen ermittelt, in welches von 3 Intervallen dieser gemessene Wert fällt, um die Anzahl der belechteten Leds sowie die Drehzahl des Motors festzulegen. Dabei wird der Wert vom Pin 10 des Arduino mittels analogWrite() - Funktion an die Basis des Transistors übergeben und damit gesteuert, wie viel Spannung der Motor vom externen Netzteil erhält.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
void loop()
{
val = analogRead(A0);
Serial.println(val);
if(val <= 100)
{
    digitalWrite(5, LOW);
    digitalWrite(6, LOW);
    digitalWrite(7, LOW);
    analogWrite(10, 0);
}
if(val > 100 && val <= 300)
{
    digitalWrite(5, HIGH);
    digitalWrite(6, LOW);
    digitalWrite(7, LOW);
    analogWrite(10, 80);
}
if(val > 300 && val <= 600)
{
    digitalWrite(5, HIGH);
    digitalWrite(6, HIGH);
    digitalWrite(7, LOW);
    analogWrite(10, 120);
}
if(val > 600)
{
    digitalWrite(5, HIGH);
    digitalWrite(6, HIGH);
    digitalWrite(7, HIGH);
    analogWrite(10, 200);
}
}

Der hier verwendete Transistor ist ein PNP - Transistor. Dieser besitzt, wie sein Artverwandter, der NPN - Transistor, 3 Pins: Den Emitter, die Base und den Collector. Dabei stellt die Basis die Steuerelektrode dar, mit welcher der Stromfluss durch den Transistor reguliert werden kann. In diesem Versuch wurde mit einem PNP - Transistor gearbeitet.

Abb. Nr.6: Ein NPN und ein PNP - Transistor

Das nachfolgende VIdeo demonstriert den Versuch:

Video Nr.2: Versuch 2

Fazit

Die Arduino - Plattform bietet, wie einleitend bereits erwähnt, einen guten Eintieg in die Programmierung und den Umgang mit elektronischen Bauteilen und Schaltungen. Dabei ist vor allem das Verbergen von techischen Details und die Abstraktion in der Programmierung des Mikrocontrollers ein entscheidender Faktor, welcher zur schnellen Erzielung von ersten Erfolgen beiträgt und somit die Motivation steigert, sich näher mit den Komponenten und ihrer Funktionsweise auseinanderzusetzen. Einsteiger - Sets, welche meist eine Vielzahl an Aktoren und Sensoren bieten, ermöglichen es bereits früh spannende Projekte zu realisieren und sich nach dem „Playground“ - Prinzip mit teilweise recht anspruchsvollen Konzepten auseinanderzusetzen.

Literaturangaben

[Arduino]Die Adroino Hompage (besucht am 8.11.2021) https://www.arduino.cc/
[Microchip-AVR-Mikrocontroller]Eine Website mit Informationen zum AVR-Mikrocontroller (besucht am 8.11.2021) https://www.digikey.de/de/product-highlight/a/atmel/megaavr-microcontrollers
[Arduino-IDE]Die Download Website für die Arduino-IDE (besucht am 8.11.2021) https://www.arduino.cc/en/software
[I2C-Backpack]Infoseite über I2C-Adapter und LCD 16x2 (besucht am 8.11.2021) https://funduino.de/nr-19-i%C2%B2c-display
[PCF8574]Eine Infoseite über den 8-Bit I/O Port Expander welcher auf dem I2C-Adapter benutzt wird (besucht am 8.11.2021) https://www.mikrocontroller.net/articles/Port-Expander_PCF8574
[LiquidCrystal_I2C]Download der LCD Libary (besucht am 8.11.2021) https://www.arduino.cc/reference/en/libraries/liquidcrystal-i2c/
[Extension]Einrichtung der Extension (besucht am 8.11.2021) https://daniel-ziegler.com/arduino/mikrocontroller/ide/2017/07/10/Microsoft-Visual-Studio-Code-alternative-Arduino-IDE/