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.

serielle Verbindung zwischen einem Calliope Mini 3 & Arduino UNO R3

Dieses Video auf YouTube ansehen.

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.

Inhaltsverzeichnis

• Wozu benötigt man eine serielle Verbindung in Zeiten von Bluetooth & WiFi?
• Benötigte Ressourcen für diesen Beitrag
• Aufbau der seriellen Verbindung zwischen dem Arduino und Calliope Mini 3
• Testen der seriellen Verbindung
• Abfragen der seriellen Schnittstelle am Arduino
• Abfragen der seriellen Schnittstelle am Calliope Mini 3
• Schalten einer LED am Arduino mit dem Calliope Mini 3
  • Code am Calliope Mini 3 zum Senden von Befehlen über die serielle Schnittstelle
  • Code am Arduino IDE
• Steuern eines Servomotors am Arduino mit dem Calliope Mini
• Regeln der Helligkeit einer LED am Arduino mit dem Lichtintensitätssensor vom Calliope Mini
  • MakeCode Programm zum seriellen senden der gelesenen Lichtstärke
  • Arduino Code zum setzen eines PWM Signals an einer LED

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

Hinweis von mir: Die mit einem Sternchen (*) markierten Links sind Affiliate-Links. Wenn du über diese Links einkaufst, erhalte ich eine kleine Provision, die dazu beiträgt, diesen Blog zu unterstützen. Der Preis für dich bleibt dabei unverändert. Vielen Dank für deine Unterstützung!

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.

Arduino UNO R3	Calliope Mini 3	Farbe
digitaler Pin D10 – RX	P1 – TX	lila
digitaler Pin D11 – TX	P0 – RX	orange
GND	GND	weiß

Das Pinout vom Calliope Mini 3 findest du entweder einmal auf der Rückseite des Mikrocontrollers und auch nachfolgend in der Grafik.

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 <SoftwareSerial.h>

// 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 5×5 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:

Hier die HEX-Datei zum download und importieren in MakeCode.

Im nachfolgenden kleinen Video demonstriere ich dir, wie ein Text vom Arduino an den Calliope gesendet und dieser als Lauftext auf der 5×5 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

Hier das kleine Programm für MakeCode zum Importieren.

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 <SoftwareSerial.h>

//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 <Servo.h>

#include <SoftwareSerial.h>

//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.

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 <Servo.h>

#include <SoftwareSerial.h>

//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());
  }
}