Calliope Mini 3 Tutorial: Datenübertragung zwischen Calliope und Arduino über die serielle Schnittstelle
In diesem Beitrag möchte ich dir erläutern, wie du über die serielle Schnittstelle Daten zwischen dem Calliope und einem Arduino austauschen kannst. Über eine serielle Schnittstelle kannst du Sensordaten und auch Befehle zum steuern eines anderen Mikrocontrollers oder angeschlossenen Aktor senden.
https://youtu.be/CQPTF6WixiA
Ich habe bereits in verschiedenen Beiträgen hier im Blog sowohl den Calliope Mini 3 als auch den Arduino UNO R3 vorgestellt. Jetzt möchte ich dir anschaulich zeigen, wie du diese beiden Mikrocontroller miteinander verbinden und Daten zwischen ihnen austauschen kannst. Während der Calliope Mini 3 eine Bluetooth-Schnittstelle für drahtlose Datenübertragung bietet, fehlt diese Funktion beim Arduino UNO R3.
Wozu benötigt man eine serielle Verbindung in Zeiten von Bluetooth & WiFi?
Zunächst möchte ich gerne klären, warum wir uns mit dem Aufbau und der Programmierung einer seriellen Verbindung in Zeiten von Bluetooth und WiFi überhaupt befassen.
Serielle Schnittstellen sind immer noch relevant, da sie eine zuverlässige und einfache Möglichkeit bieten, Geräte miteinander zu verbinden. Sie sind oft schneller, stabiler und benötigen weniger Energie als drahtlose Verbindungen wie Bluetooth / WiFi. Außerdem sind serielle Schnittstellen in vielen eingebetteten Systemen, Sensoren und IoT-Geräten weit verbreitet.
Benötigte Ressourcen für diesen Beitrag
Wenn du die kleine Schaltung und die damit verbundenen Beispiele nachbauen / programmieren möchtest, dann benötigst du:
- einen Calliope Mini 3 mit Datenkabel,
- einen Arduino UNO R3 oder Arduino Nano V3 mit passendem Datenkabel,
- drei Breadboardkabel 10 cm, männlich - männlich
Für die nachfolgenden Beispiele benötigst du noch:
- eine 10 mm oder 5 mm LED mit 220 Ohm Vorwiderstand,
- ein 170 Pin Breadboard,
- zwei Printtaster 12 mm x 12 mm mit Kappe,
- einen kleinen Servomotor SG90,
- diverse Breadboardkabel
Bauteile für die serielle Verbindung von Calliope zum Arduino
Da der Calliope Mini 3 über diverse Sensoren verfügt, zeige ich dir auch Beispiele in welche wir einen Temperatursensor, Lichtsensor, 3-Achsen Lagesensor verwenden und am Arduino auswerten.
Aufbau der seriellen Verbindung zwischen dem Arduino und Calliope Mini 3
Bauen wir zunächst die serielle Verbindung zwischen den beiden Mikrocontrollern auf. Dazu benötigen wir drei Breadboardkabel (männlich - männlich, 10 cm).
Wir verwenden jedoch nicht die digitalen Pins D0 & D1 vom Arduino UNO R3, denn diese sind mit dem USB-Anschluss verbunden. Immer wenn wir ein neues Programm auf den Mikrocontroller aufspielen möchten, müssen wir dann die Verbindung zwischen den beiden Mikrocontrollern trennen.
Als alternative können wir jeden beliebigen anderen digitalen Pin vom Arduino verwenden. Denn wir lösen dieses Problem im Code mit SoftwareSerial.
serielle Verbindung zwischen einem Calliope Mini 3 und einem Arduino UNO R3
Arduino UNO R3Calliope Mini 3Farbedigitaler Pin D10 - RXP1 - TXliladigitaler Pin D11 - TXP0 - RXorangeGNDGNDweiß
Das Pinout vom Calliope Mini 3 findest du entweder einmal auf der Rückseite des Mikrocontrollers und auch nachfolgend in der Grafik.
Pinout der Buchsenleiste am Calliope Mini 3
Testen der seriellen Verbindung
Zunächst möchte ich dir gerne zeigen, wie du deine serielle Verbindung testen kannst. Das ist besonders wichtig, wenn der Code mal nicht so funktioniert, wie du es erwarten würdest und du dich auf die Fehlersuche begeben musst.
In der Arduino IDE bekommst du ein kleines Tool, mit welchem du dir die Daten von der seriellen Schnittstelle ausgegeben und auch soweit dieses Zahlen sind, in einem Liniendiagramm visualisieren kannst.
Abfragen der seriellen Schnittstelle am Arduino
Der nachfolgende Code funktioniert für die meisten Mikrocontroller der Arduino Familie, ich beziehe mich jedoch auf den am meisten verbreiteten, den Arduino UNO R3.
Mit dem nachfolgenden Code geben wir die empfangenen Daten auf der seriellen Schnittstelle des Arduinos aus und damit können wir dann diese im seriellen Monitor oder seriellen Plotter (soweit diese aus Zahlen bestehen) betrachten.
#include
// erster Parameter 10 für Pin RX,
// zweiter Parameter 11 für Pin TX
SoftwareSerial softwareSerial(10, 11);
void setup() {
//beginn der seriellen Kommunikation mit 9600 baud
//auf der "normalen" seriellen Schnittstelle
Serial.begin(9600);
//beginn der seriellen Kommunikation mit 9600 baud
//auf der neuen seriellen Schnittstelle
softwareSerial.begin(9600);
}
void loop() {
//Wenn Daten an der Schnittstelle anliegen, dann...
if (softwareSerial.available() > 0) {
//auslesen und ausgeben der Daten
Serial.println(softwareSerial.readString());
}
}
Mit diesem kleinen Programm lassen wir die Daten, welche vom Calliope Mini 3 gesendet wurden, auf der "normalen" seriellen Schnittstelle ausgeben.
Abfragen der seriellen Schnittstelle am Calliope Mini 3
Eine serielle Verbindung klappt auch in die andere Richtung, daher können wir ebenso gut am Calliope Mini 3 die Daten anzeigen. Hier haben wir die Möglichkeiten, die Daten auf der 5x5 LED Matrix in einem Lauftext anzuzeigen. Wenn die Daten nur aus Zahlen bestehen, dann kannst du diese Werte auch im Datenlogger anzeigen.
Der Datenlogger kann nur Zahlen anzeigen. Ein kleiner Hack wäre es den Text als Spaltenname zu verwenden, jedoch ist dieses nicht wirklich brauchbar.
Das kleine Programm dazu sieht wie folgt aus:
Programm in MakeCode zum lesen der seriellen Schnittstelle am Calliope Mini 3
Hier die HEX-Datei zum download und importieren in MakeCode.
Programm - lesen der seriellen Schnittstelle am Calliope Mini 3Herunterladen
Im nachfolgenden kleinen Video demonstriere ich dir, wie ein Text vom Arduino an den Calliope gesendet und dieser als Lauftext auf der 5x5 LED Matrix angezeigt wird.
Schalten einer LED am Arduino mit dem Calliope Mini 3
Als Erstes möchte ich dir gerne zeigen, wie du eine LED am Arduino mit dem Calliope Mini 3 schalten kannst. Es gibt diverse LEDs, ich verwende gerne die 10 mm LED für solche Schaltungen, da hier der 220 Ohm Vorwiderstand entfällt.
Code am Calliope Mini 3 zum Senden von Befehlen über die serielle Schnittstelle
In MakeCode schreiben wir nun ein kleines Programm, in welchem wir zunächst beim Starten die serielle Verbindung auf die Pins P0 & P1 mit 9600 Baud umleiten.
Wenn der Taster A betätigt wird, dann soll ein A über die serielle Schnittstelle gesendet. Wird der Taster B betätigt, dann wird ein B gesendet.
Alternativ kann man auch noch das Logo auf der Rückseite verwenden und mit diesem einen weiteren Befehl senden.
MakeCode - Programm zum senden von Befehlen über die serielle Schnittstelle am Calliope Mini
Hier das kleine Programm für MakeCode zum Importieren.
Programm - Calliope Mini 3 Taster zum serielles senden von BefehlenHerunterladen
Code am Arduino IDE
Am Arduino müssen wir jetzt die Befehle vom Calliope Mini empfangen und auswerten. Wie zuvor bereits erläutert verwende ich eine SoftwareSerial Schnittstelle, da diese es einfacher erlaubt das Programm zu wechseln, ohne die Verkabelung zum Calliope Mini zu trennen.
#include
//10mm LED am digitalen Pin D7 angeschlossen
#define ledBlau1 7
//5mm LED am digitalen Pin D6 angeschlossen
#define ledBlau2 6
// RX, TX
SoftwareSerial softwareSerial(10, 11);
void setup() {
//beginn der seriellen Kommunikation mit 9600 baud
Serial.begin(9600);
softwareSerial.begin(9600);
//definieren das die Pins der LEDs als Ausgang dienen
pinMode(ledBlau1, OUTPUT);
pinMode(ledBlau2, OUTPUT);
}
void loop() {
//Wenn Daten an der seriellen Schnittstelle
//anliegen, dann...
if (softwareSerial.available() > 0) {
//lesen der gesamten Zeile
String data = softwareSerial.readString();
//entfernen der unnötigen Leerzeichen
//am Anfang und Ende
data.trim();
//Ausgeben der empfangenen Daten auf
//dem seriellen Monitor der Arduino IDE
Serial.println(data);
//Wenn ein "A" empfangen wurde, dann...
if (data == "A") {
//LEDs aktivieren
digitalWrite(ledBlau1, HIGH);
digitalWrite(ledBlau2, HIGH);
} else if (data == "B") {
//Wenn ein "B" empfangen wurde,
//dann sollen die LEDs deaktiviert werden
digitalWrite(ledBlau1, LOW);
digitalWrite(ledBlau2, LOW);
}
}
}
Steuern eines Servomotors am Arduino mit dem Calliope Mini
Statt eine LED kannst du auch einen Servomotor steuern. Der hier verwendete Servomotor kann einen Winkel zwischen 0° und 180° ansteuern. Den Servomotor schließen wir am digitalen Pin D9 beim Arduino UNO an.
Wir belassen das Programm auf dem Calliope Mini wie zuvor und ändern lediglich das kleine Programm am Arduino.
#include
#include
//Der Servomotor ist am digitalen Pin D9 angeschlossen
#define servoPin 9
// RX, TX
SoftwareSerial softwareSerial(10, 11);
//Erzeugen eines neuen Servoobjektes
Servo servo;
//Feld zum speichern der Servoposition
int servoPosition = 0;
//Konstante mit dem Wert wieviele Schritte der Servomotor fahren soll
const int SERVO_STEPS = 20;
void setup() {
//beginn der seriellen Kommunikation mit 9600 baud
Serial.begin(9600);
softwareSerial.begin(9600);
//verbinden des Pins des Servomotors mit dem Servoobjekt
servo.attach(servoPin);
//anfahren der Position 0
servo.write(servoPosition);
}
void loop() {
//Wenn Daten an der seriellen Schnittstelle
//anliegen, dann...
if (softwareSerial.available() > 0) {
//lesen der gesamten Zeile
String data = softwareSerial.readString();
//entfernen der unnötigen Leerzeichen
//am Anfang und Ende
data.trim();
//Ausgeben der empfangenen Daten auf
//dem seriellen Monitor der Arduino IDE
Serial.println(data);
//Variable zum speichern der neuen Servoposition
int newServoPosition = 0;
//Soll der Wert auf oder ab gezählt werden?
bool countUp = false;
//Wenn der empfange Wert "A" ist UND
//die aktuelle Servoposition kleiner als 180 ist, dann...
if (data == "A" && servoPosition < 180) {
//der aktuellen Servoposition die Schritte welche gefahren
//werden sollen hinzu addieren
newServoPosition = servoPosition + SERVO_STEPS;
//das Feld countUp auf true setzen,
//so das später das Feld um 1 incrementiert wird
countUp = true;
} else if (data = "B" && servoPosition > SERVO_STEPS) {
//Wenn jedoch ein "B" empfangen wurde UND die
//aktuelle Servoposition größer als die Schritte die gefahren werden sollen
//ist, dann soll dieser Wert abgezogen werden
newServoPosition = servoPosition - SERVO_STEPS;
//die Variable countUp wird hier nicht manipuliert / verändert, da
//wir diese bereits mit false initialisiert haben
}
//Schleife, sollange der Wert von servoPosition ungleich des Wertes
//der Variable newServoPosition ist, mache...
while (servoPosition != newServoPosition) {
//prüfen in welche richtung die Variable verändert werden soll
if (countUp) {
servoPosition = servoPosition + 1;
} else {
servoPosition = servoPosition - 1;
}
//anfahren von einem Grad
servo.write(servoPosition);
//eine kleine Pause von 25 ms.
delay(25);
//ausgeben der neuen Servoposition auf dem seriellen Monitor
Serial.println(servoPosition);
}
}
}
Regeln der Helligkeit einer LED am Arduino mit dem Lichtintensitätssensor vom Calliope Mini
Der Lichtintensitätssensor vom Calliope Mini 3 liefert Werte in bereich von bis 255 das passt sehr gut auf den Wertebereich eines PWM Signals mit welchem wir sehr einfach die Helligkeit einer LED regeln können.
Wenn wir mit einer Taschenlampe auf die LED Matrix leuchten dann erhöht sich der Wert bis zu einem maximum von 255.
MakeCode Programm zum seriellen senden der gelesenen Lichtstärke
Hier das kleine Programm zum auslesen der Lichtstärke am Calliope Mini 3 und absenden über die serielle Schnittstelle.
Und natürlich das Programm als HEX-Datei zum download und importieren in MakeCode.
Programm - lesen und senden der Lichtstärke am Calliope Mini 3 über die serielle SchnittstelleHerunterladen
Arduino Code zum setzen eines PWM Signals an einer LED
Da der Wert vom Lichtintensitätssensor vom Calliope Mini einen Wert zwischen 0 und 255 liefert können wir diesen 1:1 für unser PWM Signal verwenden und müssen diesen hier lediglich nur empfangen und der LED aks analogen Wert zuweisen.
#include
#include
//die LED ist am digitalen PWM Pin 9 angeschlossen
#define led 9
// RX, TX
SoftwareSerial softwareSerial(10, 11);
void setup() {
//beginn der seriellen Kommunikation mit 9600 baud
Serial.begin(9600);
softwareSerial.begin(9600);
//Pin der LED als Ausgang definieren
pinMode(led, OUTPUT);
}
void loop() {
//Wenn Daten an der seriellen Schnittstelle
//anliegen, dann...
if (softwareSerial.available() > 0) {
//lesen der gesamten Zeile
String data = softwareSerial.readString();
//entfernen der unnötigen Leerzeichen
//am Anfang und Ende
data.trim();
//Ausgeben der empfangenen Daten auf
//dem seriellen Monitor der Arduino IDE
Serial.println(data);
//schreiben des empfangenen Wertes als PWM Signal auf den Pin der LED
//mit der Funktion toInt() wird die Zeichenkette in eine Zahl umgewandelt
analogWrite(led, data.toInt());
}
}
Read the full article
