Der sprechende Farbdetektor mit DFPlayer und TCS3200 - [Teil 1]

Einführung

In dieser Blogreihe möchte ich mit Ihnen einen einfachen sprechenden Farbdetektor bauen. Solche Geräte werden häufig von Menschen mit Sehbehinderung eingesetzt. Es wird ihnen dadurch ermöglicht, z.B. die Farbe der Kleidung im Schrank zu erkennen.

Wir wollen ein Gerät konstruieren, dass an eine Farbfläche gehalten und anschließend per Knopfdruck die Farbe als gesprochener Text ausgegeben wird. Im ersten Teil nehmen wir den MP3-Player für die Sprachausgabe in Betrieb und schließen einen Taster für die Modusänderung, sowie ein Potentiometer für die Lautstärkeänderung an. Los geht's. 

Benötigte Hardware

Anzahl Bauteil Anmerkung
1 TCS3200 Farbsensor Modul (im zweiten Teil)
1 DFPlayer Mini MP3 Player Modul
1 Mikro-SD Karte
1 Arduino Nano
1 Lautsprecher (Max 3W)
1 Taster
Veränderbarer Widerstand (Potentiometer)
Widerstand 1 KOhm
Verbindungskabel
Computer mit Arduino IDE und Internetverbindung
Externe Spannungsquelle (empfohlen), 7 - 12V


Sprachausgabe

Mit der Arduino Bibliothek "Talkie" wird der Arduino in einen Sprachgenerator verwandelt. Das habe ich ausprobiert. Ich gehe darauf allerdings nicht weiter ein. Mit der Sprachqualität war ich für dieses Projekt nicht zufrieden.

Eine andere Variante ist, Audiodateien abzuspielen. Dafür verwende ich den DFPlayer von DFRobot. Albert Vu und Matthias Kammerer haben in ihren Blogbeiträgen bereits gezeigt, wie diese Komponente in Betrieb genommen wird. Der Nachteil hier ist, dass man einen Sprecher braucht, mit dem man die Wörter aufzeichnet, die später wiedergegeben werden.

Außerdem müssen die Audiodateien bearbeitet werden. Ich habe dafür Online-Sprachgeneratoren verwendet. Diese finden Sie z.B. bei voicebooking.com oder wideo.com. Darüber erhalten Sie kostenlos für den privaten Gebrauch die benötigten Dateien. Für die Bearbeitung der Audiodateien können Sie z.B. den freien Audioeditor Audacity verwenden. Wir werden einen Startsound und folgende Texte benötigen:

Audiodatei Text
0001_startsound.wav [Startsound]
0002_info.wav Taster gedrückt und Sensor nah an das Objekt halten.
0003_scanne.wav Scanne.
0004_rot.wav Rot.
0005_gruen.wav Grün.
0006_blau.wav Blau.
0007_schwarz.wav Schwarz.
0008_weiss.wav Weiß.
0009_gelb.wav Gelb.
0010_orange.wav Orange.
0011_pink.wav Pink.
0012_braun.wav Braun.
0013_kalibriere.wav Kalibriere.
0014_deutsch.wav Deutsch.


Besuchen Sie eine der Webseiten und lassen den Text komplett am Stück in eine Sprachdatei umwandeln:

Taster gedrückt und Sensor nah an das Objekt halten. Scanne. Rot. Grün. Blau. Schwarz. Weiß. Gelb. Orange. Braun. Kalibriere. Deutsch.

Bearbeiten Sie diese dann mit einem Audioeditor Ihrer Wahl, um am Ende einzelne Dateien zu erhalten. Als Alternative können Sie auch die Texte selber aufnehmen. Die Benennung der Dateien ist wichtig. Zumindest die ersten vier Zeichen.

Der DFPlayer, den wir verwenden, sucht auf der SD-Karte nach Dateien mit den Nummern 0001.mp3 oder 0001.wav. Für eine bessere Übersicht kann nach den vier Ziffern beliebiger Text folgen. Diese Benennung können Sie frei wählen. Wir werden zu bestimmten Zeitpunkten ganz bestimmte Audiodateien abspielen. Vergessen Sie nicht den Startsound. Haben Sie Ihre Dateien vorliegen und entsprechend benannt, kopieren Sie sie nacheinander auf die Mikro-SD-Karte. Hier ist tatsächlich ebenfalls die Reihenfolge wichtig, in der die Dateien kopiert werden. Unterordner werden wir vorerst nicht benötigen.

Wir werden zuerst den Player in Betrieb nehmen und dafür sorgen, dass der Startsound abgespielt wird. Die Komponenten werden wie folgt angeschlossen:


Zwischen dem RX-Pin des DFPlayer und dem TX-Pin des Arduinos sollte ein 1 KOhm-Widerstand angeschlossen werden. Es ist außerdem ratsam, eine externe Spannungsquelle anzuschließen, die zwischen 7 und 12V am VIN-Pin des Arduinos liefert.

DFPlayer Mini Pins Arduino Nano Pins
VCC 5V
GND GND
RX über 1 KOhm an D11 (TX)
TX D10 (RX)
Lautsprecher
SPK_1 Rot (Plus)
SPK_2 Schwarz (Minus)


Nachdem wir alles angeschlossen haben, müssen wir nun ein Porgramm schreiben. In der Bibliotheksverwaltung der Arduino IDE sind einige Bibliotheken erhältlich. Wir nutzen die vom Hersteller DFRobot zur Verfügung gestellte Bibliothek DFRobotDFPlayerMini.

Ich habe auch die Bibliothek DFPlayerMini_Fast getestet. Sie ist gut beschrieben und etwas schlanker. An dem Punkt, an dem ich die Info brauchte, ob der Player gerade eine Audiodatei abspielt, bin ich damit jedoch nicht weitergekommen. Es ist zwar möglich, diese Information abzufragen, jedoch erzeugt das ständig wiederholte Kommando Fehler in der Wiedergabe. In der DFRobot-Bibliothek passiert das gleiche.

Jedoch kann man dort zusätzlich abfragen, ob und mit welchem Parameter sich der Status verändert hat. Daraufhin kann man dann abfragen, ob die Wiedergabe angehalten wurde und welche Audiodatei zuletzt abgespielt wurde. Diese Möglichkeit habe ich in der Fast-Bibliothek nicht gefunden.

Nachdem Sie die Bibliothek installiert haben, stehen ihnen einige Beispiele zur Verfügung. Öffnen Sie das Projekt GetStarded und übertragen es auf den Arduino.

Natürlich dürfen Sie nicht vergessen, die SD-Karte einzulegen, auf der sich die Audiodateien befinden. Wenn alles ordnungsgemäß verlaufen ist, sollte der Startsound für drei Sekunden zu hören sein. Wenn nicht, könnten verschiedene Fehlerquellen die Ursache sein.

Vergewissern Sie sich, ob die LED am DFPlayer leuchtet. Wenn ja, wird die Audiodatei wiedergegeben. Dann könnte der Lautsprecher nicht korrekt angeschlossen sein. Man könnte die Lautsprecherausgänge am DFPlayer verwechseln. Er sollte nicht an SPK1 und GND angeschlossen werden, wie man eventuell vermuten würde. Es ist ein Monoausgang und muss an SPK1 und SPK2 angeschlossen werden. Verfügen Sie über einen Audioverstärker, kann das Audiosignal auch vom Digital-Analog-Wandler abgegriffen werden, der sich auf dem Modul befindet. Dafür nutzen Sie die Anschlüsse DACL und DACR. In dem Fall handelt es sich um ein Stereosignal. Sollte die LED auf dem DFPlayer Modul nicht leuchten, könnte es sein, dass der Strom nicht stark genug ist. Öffnen Sie den Seriellen Monitor und achten auf die Bildschirmausgabe. Dort müsste die Zeile "DFPlayer Mini online." erscheinen. Wenn nicht, sehen Sie eine Fehlermeldung. Es könnte sein, dass die RX- und TX-Leitungen vertauscht sind. Das ist ein häufig auftretender Fehler. Auch mir ist das passiert. Es ist etwas verwirrend, wenn man die Pins initialisiert. Man legt nicht fest, mit welchem DFPlayer-Pin der Arduino-Pin verbunden ist, sondern man erzeugt sich eigene RX- und TX-Pins. Anschließend müssen diese zwischen den beiden Komponenten kreuzverbunden werden. Eine weitere Möglichkeit ist, dass die SD-Karte nicht erkannt wird. Diese darf nicht größer als 32GB sein. Achten Sie darauf, dass sie nur mit dem FAT16 oder FAT32 Dateisystem formatiert werden darf. Leuchtet die LED am DFPlayer-Modul und sie hören trotzdem noch nichts, prüfen Sie die Audiodateien auf das richtige Dateiformat. Dem [Datenblatt](https://cdn.shopify.com/s/files/1/1509/1638/files/MP3PlayerModulDatenblatt.pdf?10537896017176417241) des DFPlayers können Sie die passenden Spezifikationen entnehmen. Eventuell ist der Audiopegel der Datei zu gering. Standardmäßig ist die Lautstärke im Beispielprogramm auf 10 eingestellt. Maximum ist der Wert 30.

Ich gehe nun davon aus, dass die Audiodatei abgespielt wird. An dieser Stelle möchte ich Ihnen kurz erklären, wie der Quellcode in dem Beispiel funktioniert, damit wir ihn besser für unser Projekt einsetzen können:

#include "SoftwareSerial.h"
#include "DFRobotDFPlayerMini.h"

Für die serielle Kommunikation wird die SoftSerial Bibliothek benötigt. So ist es möglich, gleichzeitig eine Ausgabe auf dem Seriellen Monitor zu erhalten, denn dieser nutzt die Hardware-Schnitstelle, die ebenfalls verwendet werden kann. Die DFRobot-Bibliothek stellt uns die nötigen Funktionen für die Bedienung des MP3-Players zur Verfügung.

SoftwareSerial mySoftwareSerial(10, 11); // RX, TX
DFRobotDFPlayerMini myDFPlayer;

Die SoftSerial-Schnittstelle erlaubt es uns, eigene Pins für die Kommunikation zuzuweisen. Wie bereits erwähnt, erstellen wir uns eigene RX- und TX-Pins. Der RX-Pin des Arduinos (hier 10) muss dann mit dem TX-Pin des DFPlayers verbunden werden. Der TX-Pin Nr. 11 des Arduinos über den 1 KOhm-Widerstand mit dem RX-Pin des DFPlayers. Das Objekt myDFPlayer wird später für die Audiowiedergabe verwendet.

Im setup() starten wir die Kommunikation mit:

  mySoftwareSerial.begin(9600);
  Serial.begin(115200);

Der DFPlayer kommuniziert standardmäßig mit einer Baudrate von 9600 über die SoftSerial-Schnittstelle. Die Ausgabe auf dem Seriellen Monitor ist hier mit 115200 angegeben. Achten Sie darauf, dass im Seriellen Monitor der gleiche Wert eingestellt ist.

  if (!myDFPlayer.begin(mySoftwareSerial)) {}

Mit diesem Befehl in der Abfrage wird die Kommunikation des DFPlayers über die SoftSerial-Schnittstelle mit dem Arduino gestartet. Wenn das nicht erfolgreich war, wird eine Fehlermeldung ausgegeben.

  myDFPlayer.volume(10);  //Set volume value. From 0 to 30
  myDFPlayer.play(1);     //Play the first mp3

Mit diesen beiden Funktionsaufrufen können Sie die Lautstärke einstellen und einen bestimmten Audiotrack von der SD-Karte abspielen. Ist der Ton zu leise, erhöhen Sie den Wert auf maximal 30. Unser Startsound ist 0001_Startsound.wav. Mit play(1) wird diese Datei abgespielt. Wichtig dabei ist, dass sie als erstes auf die SD-Karte kopiert wurde und sie im Stammverzeichnis liegt. Der Name hinter 0001 ist irrelevant.

In der loop()-Funktion wird als Erstes ein Timer gestartet. Der sorgt dafür, dass die Wiedergabe alle drei Sekunden neugestartet wird.

myDFPlayer.next();

Mit dieser Funktion wird anschließend die nächste Audiodatei wiedergegeben. Somit sollten alle Dateien auf der SD-Karte für drei Sekunden angespielt werden.

if (myDFPlayer.available()) {
      printDetail(myDFPlayer.readType(), myDFPlayer.read());
}

Mit der available()-Funktion ist es Möglich, auf Veränderungen oder Fehler zu reagieren. Der DFPlayer liefert mit readType() den Typen der Änderung sowie einen passenden Parameter mit der Funktion read().

Für die Ausgabe der dazugehörigen Informationen wurde die printDetail()-Funktion weiter unten im Quelltext geschrieben. Wird z.B. die Wiedergabe angehalten, ist der zurückgegebene Typ DFPlayerPlayFinished und der dazugehörige Parameter die Nummer der zuletzt abgespielten Audiodatei.

Möchten Sie also Beispielsweise darauf reagieren, dass die Wiedergabe beendet wurde, können Sie das abfragen. Hier ein kurzer Beispiel-Code:

if (myDFPlayer.available() && myDFPlayer.readType() == DFPlayerPlayFinished) {
    // mach irgendwas
}

Auf diese Weise ist es möglich, ohne Störgeräusche auf das Beenden der Audiowiedergabe zu reagieren. Ohne die Abfrage der available()-Funktion wird die Wiedergabe in kurzen Zyklen unterbrochen, wodurch sie nicht mehr sauber klingt.

Kommen wir nun zu einem im Internet heiß diskutierten Problem. Die Schaltgeräusche, die entstehen, wenn man den Arduino mit angeschlossenem DFPlayer ein- oder ausschaltet. Auf der Rückseite des Moduls ist ein 0-Ohm-Widerstand aufgelötet. Genau gegenüber befinden sich zwei freie Lötpads. Eine Modifikation auf Hardwareebene ist, den Widerstand ab- und auf die andere Seite aufzulöten. Im Arduino-Forum hat das jemand beschrieben und durchgeführt. Es brachte allerdings nicht das gewünschte Ergebnis.

Die Quelle dafür stammt von hier, ist aber auch schon einige Jahre alt. Im TonUINO-Forum wird ein Lösungsweg mit einer zusätzlichen antiseriellen MOSFET-Schaltung beschrieben. Ich habe das für dieses Projekt nicht weiter verfolgt bzw. verändert.

Störender als die Schaltgeräusche finde ich das Knacken, wenn ein Song gestartet oder angehalten wird. Um das zu verhindern, wird in dem Beispielprojekt AdvancedSettingWithoutReset gezeigt, wie man das lösen kann. Im setup() muss diese Zeile:

if (!myDFPlayer.begin(mySoftwareSerial)) {

folgendermaßen ergänzt werden:

if (!myDFPlayer.begin(mySoftwareSerial, true, false)) {

Dadurch wird ein reset()-Aufruf verhindert, der das Geräusch verursacht. Ich hörte am Ende meiner Startsound-Audiodatei trotzdem noch ein Knackgeräusch. Das lag an der Audiodatei selbst, die scheinbar mit einem Abbruch der Audiowelle endete. Lässt man den Ton ausblenden, ist der Pegel in der Audiodatei am Ende bei Null. Nach dieser Änderung gab es bei mir keine Geräusche dieser Art mehr.

Um weitere Funktionen der Bibliothek kennenzulernen, sollten Sie sich das Beispielprojekt FullFunction ansehen.

Unser eigenes Programm

Zu Beginn soll einfach nur der Startsound abgespielt werden. Dafür verändern wir das GetStarted-Beispiel.

Wir benötigen einige Variablen:

int volume = 20;
int state = 0;
bool ausgegeben = false;

Für den späteren Programmablauf werden wir eine Zustandsmaschine entwickeln, durch die wir uns mit dem Taster durchschalten können. Das realisieren wir mit einer switch-case-Anweisung. Als Argument der Zustände nutze ich hier die variable state. Die Variable ausgegeben sorgt dafür, dass im Seriellen Monitor die Ausgabe nur einmal erscheint. Denn die Hauptschleife läuft dauerhaft durch die statemachine().

Es folgt die Zustandsmaschine selbst:

void statemachine() {
  switch(state) {
    case 0: {
      myDFPlayer.play(1);                           // Startsound abspielen
      Serial.println("Programm wird gestartet.");
      state = 1;
    } break;
    case 1: {                                 // Standby
      if (!ausgegeben) {
        Serial.println("Standby.");
        ausgegeben = true;
      }                                     
    } break;
    default: state = 1; break;
  }
}

Nach dem Einschalten des Arduinos wird der Zustand (case) 0 durchlaufen. Dort wird unser Startsound wiedergegeben und der Text "Programm wird gestartet." ausgegeben. Dann wird in den Zustand 1 gewechselt. Dort wird einmal "Standby." auf dem Bildschirm ausgegeben.

Für die weiteren Durchläufe passiert nichts. Man könnte auch statt der if-Anweisung für das einmalige Abspielen einen weiteren Case einfügen. Da unser Programm allerdings noch größer wird und wir dann leere Cases hätten, lösen wir das auf diese Weise.

Den Text für die Bildschirmausgabe auf dem Seriellen Monitor ändern wir im setup() nach eigenen Bedürfnissen:

void setup() {
  mySoftwareSerial.begin(9600);
  Serial.begin(115200);
  Serial.println(F("Der sprechende Farbdetektor"));
  Serial.println(F("Initialisiere DFPlayer ..."));
  if (!myDFPlayer.begin(mySoftwareSerial, true, false)) {
    Serial.println(F("DFPlayer kann nicht gestartet werden:"));
    Serial.println(F("1. Verbindungen pruefen!"));
    Serial.println(F("2. SD-Karte pruefen!"));
  }
  Serial.println(F("DFPlayer Mini online."));
  Serial.print(F("Lautstaerke: "));
  myDFPlayer.volume(volume);
  Serial.println(volume);
}

In der loop() rufen wir die statemachine() auf:

void loop() {
  statemachine();
}

Laden wir das Programm auf den Arduino, wird der Startsound abgespielt. Danach geschieht nichts weiter.

Kompletter Quellcode: 1.0DFPlayerStartsound.ino

Volume

Um die Lautstärke der Wiedergabe zu ändern, gibt es verschiedene Möglichkeiten. Eine ist der weiter oben genannte Audioverstärker. Eine andere wäre ein Drehencoder, der oft in Audioreceivern verwendet wird. Ich habe mich für die einfachere Variante eines Potentiometers entschieden. Wir dürfen natürlich nicht einfach mit einem veränderbaren Widerstand das Audiosignal am Speaker-Pin beeinflussen. Auf diese Idee könnte der ein oder andere jetzt kommen. Es gibt Potentiometer mit denen das möglich ist. Dabei ist zu beachten, dass es sich bei einem Audiosignal um eine Wechselspannung handelt.

Ich werde das Potentiometer dafür nutzen, um den Wert in der Funktion myDFPlayer.volume(10) zu verändern. Wir ergänzen die Schaltung folgendermaßen:


Die beiden äußeren Pins des Potentiometers an GND und 5V. Der mittlere Kontakt (Schleifer) an einen der analogen Pins des Arduinos, hier A0.

Wir ergänzen unsere Variablen:

int volume_old = 20;

und fügen folgende Funktion hinzu:

void lautstaerke() {
  volume = analogRead(A0);
  volume = map(volume, 0, 1023, 0, 30); 
  if (volume != volume_old) {
    Serial.print("Lautstaerke: ");
    Serial.println(volume);
    myDFPlayer.volume(volume);
  }
  volume_old = volume; 
}

Damit lesen wir den analogen Pin A0 aus. Wir "mappen" die gelieferten Wertebereiche (Eingangswerte 0 bis 1023 auf Lautstärke 0 bis 30). Die Änderung der Lautstärke wollen wir auf dem Monitor ausgeben. Allerdings nur dann, wenn eine Änderung stattgefunden hat. Dafür brauchen wir die if-Abfrage und die Variable volume_old.

In der loop()-Funktion fügen wir nun an den Anfang den Aufruf der oben beschriebenen Funktion ein:

void loop() {
  lautstaerke();
  statemachine();
}

Laden wir das Programm auf den Arduino, hören wir den Startsound, dessen Lautstärke wir direkt ändern können. Im Seriellen Monitor wird diese Änderung ausgegeben. Es ist nun also möglich, zu jeder Zeit die Lautstärke der Audiowiedergabe zu verändern.

Kompletter Quellcode: 1.1DFPlayerStartsound_Poti.ino

Bedienung mit Taster

Wir möchten unseren Farbdetektor auch irgendwie bedienen können. Dafür nutzen wir vorerst nur einen Taster. Damit können wir dann den Abtastvorgang des Farbscanners starten und anhalten. Zunächst ergänzen wir unsere Schaltung durch den besagten Taster:


Wir werden den internen Pullup-Widerstand verwenden. Daher schließen wir den Taster an D12 und GND direkt an. Unseren Quellcode ergänzen wir durch die Definition des Tasterpins:

#define TasterPin 12

Im setup() initialisieren wir ihn als Eingang mit Pullup-Widerstand:

pinMode(TasterPin, INPUT_PULLUP);

Nun ergänzen wir die Zustandsmaschine um die dazugehörigen Cases. Ich möchte, dass man den Taster betätigt, woraufhin ein Hinweissatz zur Bedienung wiedergegeben wird. Man muss den Taster noch einmal loslassen und den Sensor an die Fläche halten, die man scannen möchte. Betätigt man den Taster erneut und hält ihn gedrückt, wird die Farbe gescannt. Lässt man den Taster dann los, wird die letzte erkannte Farbe über die Audiowiedergabe ausgegeben. Man gelangt dann wieder in den Case 3 der Zustandsmaschine, so dass der Hilfehinweis nicht noch einmal wiedergegeben wird, sondern man gleich wieder eine Farbe scannen kann. Diese Funktionalität werden wir nun implementieren. Dabei soll der Taster auch softwareseitig entprellt werden.

void statemachine() {
  switch(state) {
    case 0: {
      myDFPlayer.play(1);                     // Startsound abspielen
      Serial.println("Programm wird gestartet.");
      state = 1;
    } break;
    case 1: {                                 // Standby
      if (!ausgegeben) {
        Serial.println("Standby.");
        ausgegeben = true;
      }                                     
    } break;
    case 2: {                                 // Hilfe abspielen
      myDFPlayer.play(2);
      Serial.println("Taster gedrueckt und Sensor nah an das Objekt halten.");
      state = 3;
      ausgegeben = false;
    } break;
    case 3: {                                 // bereit zum Scannen
      if (!ausgegeben) {
        Serial.println("Warte auf Taster...");
        ausgegeben = true;
      }                                   
    } break;   
    case 4: {                                 // Starte Scan
      myDFPlayer.play(3);
      Serial.println("Scanne...");
      ausgegeben = false;
      state = 5;
    } break;
    case 5: {                                 // Scan
      Serial.println("Farbe: ");
    } break;
    case 6: {                                 // Farbe ausgeben
      myDFPlayer.play(6);
      Serial.println("Farbe: Rot");
      state = 3;
    } break;
    default: state = 1; break;
  }
}

Die Funktion für den Taster sieht folgendermaßen aus:

void taster() {
  taster_status_neu = digitalRead(TasterPin);          //taster ist active low

  // Tasteraenderung erkennen und Prelltimer starten
  if (taster_status_neu != taster_status_alt && !taster_change) {
    start_zeit = millis();
    taster_change = true;
  }
  // wenn Taster gedrueckt
  if (taster_status_neu == LOW && taster_status_alt == LOW && taster_change) {
    // Taster entprellen
    if (millis() - start_zeit > prell_delay) {
      taster_change = false;
      state++;
      if (state > maxStates) {
        state = 1;
      }
    }
  }
  // wenn Taster losgelassen
  else if (taster_status_neu == HIGH && taster_status_alt == HIGH && taster_change) {
    // Taster entprellen
    if (millis() - start_zeit > prell_delay) {
      taster_change = false;
      if (state == 5) {
        state = 6;
      }
    }
  }
  taster_status_alt = taster_status_neu;
}

Sie ist etwas umfangreicher, da wir nicht nur das Drücken des Tasters, sondern auch das Loslassen entprellen. Denn die Farbe soll ausgegeben werden, wenn der Taster nach dem Scanvorgang losgelassen wurde.

Wir lesen den Tasterpin ein. Dieser ist wegen des Pullup-Widerstandes active low (gedrückt ist LOW und losgelassen ist HIGH). Hat eine Veränderung des Tasterzustandes stattgefunden, wird ein Timer gestartet. Damit dieser Befehl nicht immer wieder ausgeführt wird, sperren wir das mit der Variable taster_change (die ich hier mal ausnahmsweise zweisprachig gewählt habe).

Im folgenden Verlauf wird nun geprüft, ob der Taster gedrückt wurde, ob er dann auch gedrückt bleibt und ob das von uns gewählte Zeitintervall für das Entprellen erreicht wurde. Wenn ja, wird die Änderung des Tasters wieder freigegeben und die Variable für die Zustandsmaschine inkrementiert. Dabei müssen wir darauf achten, dass wir die maximale Anzahl an Zuständen nicht überschreiten, damit das Programm nicht ins Leere läuft.

Für den Fall, dass der Taster schon gedrückt war, wieder losgelassen wurde, losgelassen bleibt und die Zeit des Entprellintervalls erreicht wurde, wird ebenfalls die Sperre für den Taster aufgehoben und zusätzlich unsere Zustandsmaschine auf den Zustand gesetzt, der die Farbe wiedergibt.

Wir deklarieren für die beiden Funktionen folgende Variablen:

int maxStates = 6;
bool ausgegeben = false;
unsigned long neue_zeit = 0;
unsigned long start_zeit = 0;
unsigned long prell_delay = 80;
bool taster_status_neu = HIGH;          
bool taster_status_alt = HIGH;
bool taster_change = false;  

Laden wir das Programm auf den Arduino, sollte wie zuvor der Startsound erklingen. Betätigt man den Taster, wird der Hilfetext ausgegeben. Man lässt den Taster los und drückt ihn erneut. Es wird das Wort "Scanne" ausgegeben. Lässt man den Taster irgendwann los, wird eine Farbe ausgegeben. An diesem Punkt ist der Farbsensor noch nicht angeschlossen. Daher habe ich die Farbe Rot gewählt. Den Vorgang kann man dann immer wieder neu starten. Der Programmablauf funktioniert nun also und wir erhalten eine Sprachausgabe.

Kompletter Quellcode: 1.2DFPlayerStartsoundPotiTaster.ino

Vorschau

Im zweiten Teil dieser Blogreihe werden wir den Farbsensor anschließen und in Betrieb nehmen. Ich werde Ihnen zeigen, welche Bibliotheken dafür zur Verfügung stehen und was man bei der Benutzung des Sensors beachten muss.

Bis dahin,

Andreas Wolter

für AZ-Delivery Blog

Für arduinoProjekte für anfängerSensoren

2 Kommentare

Heiko Hogg

Heiko Hogg

Aufbau ist nachgebaut und im standby – und wartet ungeduldig auf den nächsten Teil (oder bin ich das, der es kaum erwarten kann?)
Als ein Mensch, der wie 20% der Männer eine Rot-Grün-Farbsehschwäche hat, ist dieses Thema besonders interessant. Als Normal-Farbsichtiger kann man es sicherlich kaum nachvollziehen, welche Einschränkungen man da hat – und das nicht nur als Pilot oder Lokführer. Wie gesagt: ich bin sehr gespannt, auch darauf, was man daraus noch alles entwickeln und einsetzen kann.
Bis dahin: vielen Dank für die super ausführliche und nachvollziehbare Beschreibung und das sehr, sehr interessante Thema!

Lentner Peter

Lentner Peter

Super Beitrag, ganz ausführlich Beschrieben.
Habe diesen nur aufmerksam Gelesen und nicht getestet.
Die Programmteile mit deutschen Bezeichnungen und nicht nur aus englischen Codes heraus kopiert..

Einen Kommentar hinterlassen

Alle Kommentare werden vor der Veröffentlichung moderiert

Empfohlene Blogbeiträge

  1. ESP32 jetzt über den Boardverwalter installieren
  2. Lüftersteuerung Raspberry Pi
  3. Arduino IDE - Programmieren für Einsteiger - Teil 1
  4. ESP32 - das Multitalent
  5. OTA - Over the Air - ESP Programmieren über WLAN