Le détecteur de couleurs parlant avec DFPlayer et TCS3200 - [1ère partie]

Introduction

Dans cette série de blogs, j'aimerais construire avec vous un détecteur de couleurs simple et parlant. Ces dispositifs sont souvent utilisés par des personnes souffrant de limitations visuelles. Il leur est ainsi possible de reconnaître, par exemple, la couleur des vêtements dans l'armoire.

Nous voulons construire un dispositif que l'on tient devant une surface colorée et qui appuie ensuite sur un bouton pour restituer la couleur sous forme de texte parlé. Dans la première partie, nous mettons en service le lecteur MP3 pour la sortie vocale et connectons un bouton pour le changement de mode, ainsi qu'un potentiomètre pour le changement de volume. Allons-y. 

Matériel requis

Nombre	Composant	annotation
1	Module capteur de couleurs TCS3200 (dans la deuxième partie)
1	DFPlayer Mini MP3 Player Modul
1	Carte Micro SD
1	Arduino nano
1	Haut-parleur (max 3W)
1	Bouton
	Résistance variable (potentiomètre)
	Résistance 1 kohm
	Câble de connexion
	Ordinateur avec Arduino IDE et connexion Internet
	Source de tension externe (recommandée), 7 - 12V

La bibliothèque Arduino "Talkie" transforme l'Arduino en un générateur de parole. Je l'ai essayé. Cependant, je ne m'étendrai pas davantage sur le sujet. Je n'étais pas satisfait de la qualité de la voix pour ce projet.

Une autre variante consiste à reproduire des fichiers audio. Pour cela, j'utilise le DFPlayer de DFRobot. Albert Vu et Matthias Kammerer ont déjà montré dans leurs articles de blog comment mettre en place ce composant et le faire fonctionner. L'inconvénient ici est que vous avez besoin d'un haut-parleur pour enregistrer les mots qui seront lus plus tard.
 
De plus, les fichiers audio doivent être édités. J'ai utilisé des générateurs de voix en ligne pour cela. Vous pouvez les trouver, par exemple, sur voicebooking.com ou wideo.com. Vous pouvez y obtenir gratuitement les fichiers nécessaires pour un usage privé. Pour éditer les fichiers audio, vous pouvez utiliser, par exemple, l'éditeur audio gratuit Audacity. Nous aurons besoin d'un son de départ et des textes suivants :

Fichier audio	texte
0001_startsound.wav	[Startsound]
0002_info.wav	Maintenez les boutons enfoncés et gardez le capteur près de l'objet
0003_scanne.wav	Analyse
0004_rot.wav	Rouge
0005_gruen.wav	Vert
0006_blau.wav	Bleu
0007_schwarz.wav	Noir
0008_weiss.wav	Blanc
0009_gelb.wav	Jaune.
0010_orange.wav	Orange
0011_pink.wav	Rose
0012_braun.wav	Marron
0013_kalibriere.wav	Étalonnage
0014_deutsch.wav	Allemand

Visitez l'un des sites web et faites convertir le texte dans son intégralité en un fichier linguistique :

Appuyez sur le bouton et tenez le capteur près de l'objet. Scanning. Rouge. Vert. Bleu. Noir. Blanc. Jaune. Orange. Marron. Calibrer. Allemand.

Ensuite, éditez-les avec un éditeur audio de votre choix pour obtenir des fichiers individuels. Vous pouvez également enregistrer les textes vous-même. La dénomination des fichiers est importante. Au moins les quatre premiers caractères.

Le DFPlayer que nous utilisons recherche sur la carte SD les fichiers portant les numéros 0001.mp3 ou 0001.wav. Pour un meilleur aperçu, n'importe quel texte peut suivre les quatre chiffres. Vous pouvez choisir cette dénomination librement. Nous jouerons des fichiers audio très spécifiques à des moments précis. N'oubliez pas le son de départ. Une fois que vous avez vos fichiers et que vous les avez nommés en conséquence, copiez-les sur la carte micro SD l'un après l'autre. En fait, l'ordre dans lequel les fichiers sont copiés est également important ici. Nous n'aurons pas besoin de sous-dossiers pour l'instant.

Nous allons d'abord démarrer le lecteur et nous assurer que le son de démarrage est émis. Les composants sont connectés comme suit :

Une résistance de 1 KOhm doit être connectée entre la broche RX du DFPlayer et la broche TX de l'Arduino. Il est également conseillé de connecter une source de tension externe qui fournit entre 7 et 12V à la broche VIN de l'Arduino.

DFPLayer Mini Pins	Arduino Nano Pins
VCC	5V
Gnd	Gnd
Rx	Plus de 1 kohm à D11 (TX)
Tx	D10 (RX)
	Haut-parleur
SPK_1	Rouge (plus)
SPK_2	Noir (moins)

Après avoir tout connecté, nous devons maintenant écrire un programme. Il y a quelques bibliothèques disponibles dans la gestion des bibliothèques de l'IDE Arduino. Nous utilisons la bibliothèque DFRobot fournie par le créateur DFRobotDFPlayerMini.

J'ai également testé la bibliothèque DFPlayerMini_Fast. Il est bien décrit et un peu plus fin. Cependant, lorsque j'ai eu besoin de savoir si le lecteur était en train de reproduire un fichier audio, je n'ai rien pu faire. Il est possible de récupérer ces informations, mais la commande constamment répétée génère des erreurs dans la lecture. Dans la bibliothèque DFRobot, la même chose se produit.

Toutefois, vous pouvez également y demander si le statut a été modifié et avec quel paramètre. Vous pouvez ensuite demander si la lecture a été arrêtée et quel est le dernier fichier audio lu. Je n'ai pas trouvé cette possibilité dans la bibliothèque-Fast.

Après avoir installé la bibliothèque, quelques exemples sont à leur disposition. Ouvrez le projet GetStarded et transférez-le sur l'Arduino.

Bien entendu, il ne faut pas oublier d'insérer la carte SD, qui contient les fichiers audio. Si tout s'est déroulé correctement, vous devriez entendre le son de démarrage pendant trois secondes. Si ce n'est pas le cas, la cause peut être diverses sources d'erreur.

Vérifiez que le voyant du DFPlayer est allumé. Si c'est le cas, le fichier audio est en cours de lecture. Si tel est le cas, l'enceinte n'est peut-être pas connectée correctement. Vous pourriez mélanger les sorties des haut-parleurs sur le DFPlayer. Il ne doit pas être connecté à SPK1 et GND comme vous le soupçonnez. C'est une sortie mono et elle doit être connectée à SPK1 et SPK2. Si vous disposez d'un amplificateur audio, le signal audio peut également être prélevé sur le convertisseur numérique-analogique situé sur le module. Pour ce faire, utilisez les connecteurs DACL et DACR. Dans ce cas, le signal est un signal stéréo. Si le voyant du module DFPlayer ne s'allume pas, il se peut que le courant ne soit pas assez fort. Ouvrez le moniteur série et regardez la sortie de l'écran. La ligne "DFPlayer Mini online." devrait y apparaître. Si ce n'est pas le cas, vous verrez apparaître un message d'erreur. Il se peut que les lignes RX et TX soient inversées. Il s'agit d'une erreur courante. Cela m'est arrivé aussi. C'est un peu déroutant quand on initialise les broches. Vous ne spécifiez pas à quelle broche du DFPlayer la broche de l'Arduino est connectée, mais vous créez vos propres broches RX et TX. Ensuite, vous devez les interconnecter entre les deux composants. Une autre possibilité est que la carte SD ne soit pas reconnue. Celle-ci ne doit pas être supérieure à 32 Go. Assurez-vous qu'il ne peut être formaté qu'avec le système de fichiers FAT16 ou FAT32. Si le voyant du module DFPlayer s'allume et que vous n'entendez toujours rien, vérifiez que le format des fichiers audio est correct. Reportez-vous à la [Fiche technique] (https://cdn.shopify.com/s/files/1/1509/1638/files/MP3PlayerModulDatenblatt.pdf?10537896017176417241) de la couche DFP pour les spécifications appropriées. Le niveau audio du fichier est peut-être trop faible. Par défaut, le niveau de volume dans le programme d'exemple est réglé sur 10. Le maximum est la valeur 30.

Je suppose maintenant que le fichier audio sera lu. À ce stade, je voudrais expliquer brièvement comment fonctionne le code source de l'exemple, afin que nous puissions mieux l'utiliser pour notre projet :

#include "Softwaresérial.h"
#include "DFROBOTDFPLAYERMINI.H"

Pour la communication série, la bibliothèque SoftSerial est nécessaire. Il est donc possible d'obtenir une sortie sur le moniteur série en même temps, car il utilise l'interface matérielle, qui peut également être utilisée. La bibliothèque DFRobot nous fournit les fonctions nécessaires pour faire fonctionner le lecteur MP3.

Softwaresérial MySoftwareserial (10, 11); // rx, tx
Dfrobotdfplayermini myDFplayer;

L'interface SoftSerial nous permet d'attribuer nos propres broches pour la communication. Comme déjà mentionné, nous créons nos propres broches RX et TX. La broche RX de l'Arduino (ici 10) doit ensuite être connectée à la broche TX de la DFPlayer. La broche TX #11 de l'Arduino via la résistance de 1 KOhm à la broche RX de la DFPlayer. L'objet myDFPlayer sera utilisé plus tard pour la lecture audio.

Dans le setup(), on démarre la communication avec :

mysoftwaresérial.begin (9600);
Sérial.begin (115200);

Par défaut, le DFPlayer communique avec une vitesse de transmission de 9600 bauds via l'interface SoftSerial. La sortie sur le moniteur série est spécifiée ici avec 115200. Assurez-vous que la même valeur est définie dans le moniteur série.

  SI (! mydfplayer.begin (mysoftwaresérial) {}

Cette commande dans la requête démarre la communication du DFPlayer via l'interface SoftSerial avec l'Arduino. Si cette opération n'a pas abouti, un message d'erreur s'affiche.

mydfplayer.volume (10);  // Définir la valeur du volume. De 0 à 30
mydfplayer.play (1);     // jouer le premier mp3

Ces deux appels de fonction vous permettent de régler le volume et de lire une piste audio spécifique à partir de la carte SD. Si le son est trop faible, augmentez la valeur jusqu'à un maximum de 30. Notre son de démarrage est 0001_Startsound.wav. Appuyez sur play(1) pour lire ce fichier. Il est important qu'il ait d'abord été copié sur la carte SD et qu'il soit situé dans le répertoire racine. Le nom après 0001 n'est pas pertinent.

Dans la fonction loop(), un timer est d'abord lancé. Cela garantit que la lecture est relancée toutes les trois secondes.

mydfplayer.next ();

Cette fonction permet de lire le fichier audio suivant. Ainsi, tous les fichiers de la carte SD doivent être lus pendant trois secondes.

SI mydfplayer.Available ()) {
Imprimerdetail (mydfplayer.readtype (), mydfplayer.read ());
}

Avec la fonction available(), il est possible de réagir aux changements ou aux erreurs. Le DFPlayer renvoie le type de changement avec readType() et un paramètre approprié avec la fonction read().

Pour la sortie des informations associées, la fonction printDetail() a été écrite plus bas dans le code source. Par exemple, si la lecture est arrêtée, le type renvoyé est DFPlayerPlayFinished et le paramètre associé est le numéro du dernier fichier audio lu.

Ainsi, par exemple, si vous voulez réagir au fait que la lecture est terminée, vous pouvez l'interroger. Voici un court exemple de code :

SI (mydfplayer.Available () && mydfplayer.readtype () == dfplayerplayFinished) {
    // Faire quelque chose
}

De cette manière, il est possible de réagir à la fin de la lecture audio sans aucun bruit. Sans l'interrogation de la fonction available(), la lecture sera interrompue par cycles courts, ce qui rendra le son impropre.

Nous en arrivons maintenant à un problème très discuté sur l'internet. Les bruits de commutation qui se produisent lorsque vous allumez ou éteignez l'Arduino avec le DFPlayer connecté. Une résistance de 0 ohm est soudée à l'arrière du module. Exactement en face, il y a deux points de soudure libres. Une modification au niveau du matériel consiste à dessouder la résistance et à la souder de l'autre côté. Quelqu'un sur le forum Arduino a décrit et réalisé ceci. Cependant, cela n'a pas donné le résultat souhaité.

La source de cette information vient d'ici, mais elle est également vieille de plusieurs années. Dans le forum TonUINO, une solution avec un circuit MOSFET antisérieux supplémentaire est décrite. Je n'ai pas approfondi cette question dans le cadre de ce projet ou de sa modification.

Plus inquiétant que les bruits de commutation, je trouve le grésillement lorsqu'un morceau est lancé ou arrêté. Pour éviter cela, le projet d'exemple AdvancedSettingWithoutReset montre comment résoudre ce problème. Dans le setup() doit se trouver cette ligne :

SI (! mydfplayer.begin (mysoftwaresérial) {

être complétée comme suit :

SI (! mydfplayer.begin (mysoftwaresérial, vrai, faux)) {

Cela empêche un appel à reset() de provoquer le bruit. J'ai encore entendu un grésillement à la fin de mon fichier audio de démarrage. Cela était dû au fait que le fichier audio lui-même semblait se terminer par une rupture de l'onde audio. Si vous laissez le son s'estomper, le niveau du fichier audio est nul à la fin. Après ce changement, je n'ai plus eu aucun bruit de cette nature.

Pour connaître d'autres fonctions de la bibliothèque, vous pouvez consulter le projet d'exemple FullFunction.

Notre propre programme

Au début, nous voulons juste jouer le son de démarrage. Pour cela, nous modifions l'exemple GetStarted.

Il nous faut des variables :

int volume = 20;
int État = 0;
démarrage passé = faux;

Pour le déroulement ultérieur du programme, nous développerons une machine à états, par laquelle nous pourrons commuter avec le bouton. Nous réalisons cela avec une déclaration de type "switch-case". Comme argument des états j'utilise ici l'état variable. La sortie variable permet de s'assurer que la sortie n'apparaît qu'une seule fois dans le moniteur série. Parce que la boucle principale passe en permanence par le statemachine().

Vient ensuite la machine à états elle-même :

annuler Stemachine () {
  changer(État) {
    cube 0: {
mydfplayer.play (1);                           // joue Sound Sound
Série.println ("Le programme est lancé.");
État = 1;
    } Pause;
    cube 1: {                                 // Etre prêt
      SI (! Publié) {
Série.println ("Etre prêt.");
passé = vrai;
      }                                     
    } Pause;
    défaut: état = 1; Pause;
  }
}

Après avoir allumé l'Arduino, l'état (case) 0 est parcouru. Là, notre son de démarrage est joué et le texte "Programme démarré." est affiché. Ensuite, nous passons à l'état 1. Là, "Standby." s'affiche une fois à l'écran.

Rien ne se passe pour les cycles suivants. Vous pourriez également insérer un autre cas à la place de l'énoncé if pour la lecture unique. Cependant, comme notre programme va devenir encore plus grand et que nous aurions alors des cas vides, nous le résolvons de cette façon.

Nous modifions le texte de la sortie écran sur le moniteur série dans setup() en fonction de nos propres besoins :

annuler installer() {
mysoftwaresérial.begin (9600);
Sérial.begin (115200);
Série.println (F (F (F ("Le détecteur de couleur parlante"));
Série.println (F (F (F ("Initialiser dfplayer ..."));
  SI (! mydfplayer.begin (mysoftwaresérial, vrai, faux)) {
Série.println (F (F (F ("DFPlayer ne peut pas être démarré:"));
Série.println (F (F (F ("1. confirme Prüfen!"));
Série.println (F (F (F ("2. Carte SD Prüfen!"));
  }
Série.println (F (F (F ("DFPLayer Mini en ligne."));
Serial.Print (F (F (F (F (F)"Le volume: "));
mydfplayer.volume (volume);
Série.println (volume);
}

Dans le Boucle () Nous appelons le Stemachine () sur:

annuler Boucle () {
Stemachine ();
}

Si nous chargeons le programme sur l'Arduino, le son de démarrage est joué. Après cela, rien d'autre ne se passe.

Complete source code: 1.0DfplayerStartsound.ino

Le volume

Il existe plusieurs façons de modifier le volume de la lecture. Le premier est l'amplificateur audio mentionné ci-dessus. Un autre exemple serait un encodeur rotatif, souvent utilisé dans les récepteurs audio. J'ai choisi l'option plus simple d'un potentiomètre. Bien entendu, il ne faut pas se limiter à utiliser une résistance variable pour influencer le signal audio au niveau de la broche du haut-parleur. L'un ou l'autre pourrait avoir cette idée maintenant. Il existe des potentiomètres avec lesquels cela est possible. Il convient de noter qu'un signal audio est une tension alternative.

Je vais utiliser le potentiomètre pour modifier la valeur dans la fonction myDFPlayer.volume(10). Nous complétons le circuit comme suit :

Les deux broches extérieures du potentiomètre à GND et 5V. Le contact du milieu (wiper) à l'une des broches analogiques de l'Arduino, ici A0.

Nous ajoutons à nos variables :

int Volume_old = 20;

et ajoutez la fonction suivante :

annuler le volume() {
Volume = analogogread (A0);
Volume = carte (volume, 0, 1023, 0, 30); 
  SI (Volume! = Volume_old) {
Serial.Print ("Le volume: ");
Série.println (volume);
mydfplayer.volume (volume);
  }
Volume_old = volume;
}

Avec cela, nous lisons la broche analogique A0. Nous "mappons" les plages de valeurs fournies (valeurs d'entrée de 0 à 1023 à un volume de 0 à 30). Nous voulons afficher le changement de volume sur le moniteur. Mais seulement si un changement a eu lieu. Pour cela, nous avons besoin du if-query et de la variable volume_old.

Dans la fonction loop(), nous insérons maintenant l'appel de la fonction décrite ci-dessus au début :

annuler Boucle () {
le volume();
Stemachine ();
}

Si nous chargeons le programme sur l'Arduino, nous entendons le son de démarrage, dont nous pouvons modifier le volume directement. Cette modification est affichée dans le moniteur série. Il est donc désormais possible de modifier le volume de la lecture audio à tout moment.

Code source complet: 1.1DfplayerStartsound_poti.ino

Opération avec bouton

Nous aimerions pouvoir faire fonctionner notre détecteur de couleurs d'une manière ou d'une autre. Pour l'instant, nous n'utilisons qu'un seul bouton. Avec elle, nous pouvons démarrer et arrêter le processus de numérisation du scanner couleur. Tout d'abord, nous ajoutons ledit bouton à notre circuit :

Nous allons utiliser la résistance pullup interne. Nous connectons donc le bouton poussoir à D12 et à GND directement. Nous complétons notre code source en définissant la broche du bouton poussoir :

#define TasterPin 12

Dans setup() nous l'initialisons comme entrée avec une résistance pullup :

Pinmode (Tastonpin, Input_Pullup);

Maintenant, nous ajoutons les cas correspondants à la machine à états. J'aimerais que vous appuyiez sur le bouton, après quoi une indication de l'opération est diffusée. Vous devez à nouveau relâcher le bouton et maintenir le capteur contre la surface que vous souhaitez scanner. Si vous appuyez à nouveau sur le bouton et que vous le maintenez enfoncé, la couleur sera numérisée. Si vous relâchez ensuite le bouton, la dernière couleur détectée est restituée par la lecture audio. Vous revenez alors au cas 3 de la machine à états, de sorte que la note d'aide n'est pas jouée à nouveau, mais vous pouvez immédiatement balayer à nouveau une couleur. Nous allons maintenant mettre en œuvre cette fonctionnalité. Dans le processus, le bouton doit également être débloqué du côté logiciel.

annuler Stemachine () {
  changer(État) {
    cube 0: {
mydfplayer.play (1);                     // joue Sound Sound
Série.println ("Le programme est lancé.");
État = 1;
    } Pause;
    cube 1: {                                 // Etre prêt
      SI (! Publié) {
Série.println ("Etre prêt.");
passé = vrai;
      }                                     
    } Pause;
    cube 2: {                                 // Jouer de l'aide
mydfplayer.play (2);
Série.println ("Bouton rogné et garde le capteur près de l'objet.");
État = 3;
passé = faux;
    } Pause;
    cube 3: {                                 // prêt à numériser
      SI (! Publié) {
Série.println ("En attente de bouton ...");
passé = vrai;
      }                                   
    } Pause;   
    cube 4: {                                 // START SCAN
mydfplayer.play (3);
Série.println ("Analyse ...");
passé = faux;
État = 5;
    } Pause;
    cube 5: {                                 // analyse
Série.println ("Couleur: ");
    } Pause;
    cube 6: {                                 // couleur de sortie
mydfplayer.play (6);
Série.println ("Couleur rouge");
État = 3;
    } Pause;
    défaut: état = 1; Pause;
  }
}

La fonction de ce bouton est la suivante :

annuler Bouton () {
Taston_status_neu = digitalRead (Tastonpin); // bouton est actif bas

  // reconnaît le bouton endurer et démarrer les minuteries de rebond
  SI (TASTON_STATUS_NEU! = TASTON_STATUS_ALT &&! TASTON_Change) {
Start_zeit = millis ();
TASTON_CHANGE = vrai;
  }
  // si bouton-poussoir
  SI (TASTON_STATUS_NEU == LOW && TASTON_STATUS_ALT == LOW && TASTON_CHANGE) {
    // bouton de démembrement
    SI (Millis () - Heure de départ> Prell_Delay) {
TASTON_CHANGE = faux;
État ++;
      SI (État> maxate) {
État = 1;
      }
    }
  }
  // si le bouton est sorti
  Autre SI (Bouton_status_neu == High && tatus_alt == High && tatus_change) {
    // bouton de démembrement
    SI (Millis () - Heure de départ> Prell_Delay) {
TASTON_CHANGE = faux;
      SI (État == 5) {
État = 6;
      }
    }
  }
TASTON_STATUS_ALT = TASTON_STATUS_NEU;
}

Elle est un peu plus étendue, car nous déboussolons non seulement l'enfoncement de la sonde, mais aussi son relâchement. En effet, la couleur doit être émise lorsque la sonde est relâchée après la numérisation.

Nous lisons la broche du bouton poussoir. Il s'agit d'un niveau bas actif en raison de la résistance pullup (appuyé est BAS et relâché est HAUT). Si un changement d'état du bouton-poussoir s'est produit, une temporisation est lancée. Pour éviter que cette commande ne soit exécutée encore et encore, nous la verrouillons avec la variable taster_change (que j'ai choisi d'être bilingue ici pour une fois).

Dans le processus suivant, on vérifie maintenant si le bouton-poussoir a été enfoncé, s'il reste enfoncé et si l'intervalle de temps que nous avons choisi pour le déblocage a été atteint. Si c'est le cas, la modification du bouton-poussoir est à nouveau relâchée et la variable de la machine à états est incrémentée. Nous devons faire attention à ne pas dépasser le nombre maximum d'États, afin que le programme ne tombe pas à l'eau.

Si le bouton-poussoir a déjà été enfoncé, relâché à nouveau, reste relâché et que le temps de l'intervalle de débordement a été atteint, le verrouillage du bouton-poussoir est également libéré et notre machine à états est en outre placée dans l'état qui reflète la couleur.

Nous déclarons les variables suivantes pour les deux fonctions :

int Maxstates = 6;
démarrage passé = faux;
non signé longue New_zeit = 0;
non signé longue Start_zeit = 0;
non signé longue Prell_delay = 80;
démarrage Taston_status_neu = haut;
démarrage Taston_status_alt = haut;
démarrage TASTON_CHANGE = faux;  

Si nous chargeons le programme sur l'Arduino, le son de démarrage devrait apparaître comme avant. Si vous appuyez sur le bouton, le texte d'aide s'affiche. Relâchez le bouton et appuyez de nouveau. Le mot "Scan" est émis. Si vous relâchez le bouton à un moment donné, une couleur est émise. A ce stade, le capteur de couleur n'est pas encore connecté. J'ai donc choisi la couleur rouge. Le processus peut ensuite être redémarré encore et encore. Maintenant, la séquence de programme fonctionne et nous obtenons une sortie vocale.

Code source complet: 1.2DfplayerSon de départPotionTaster.ino

Aperçu

Dans la deuxième partie de cette série de blogs, nous allons connecter le capteur de couleurs et le mettre en service. Je vous montrerai quelles sont les bibliothèques disponibles pour cela et ce qu'il faut prendre en compte lors de l'utilisation du capteur.

En attendant,

Andreas Wolter

pour AZ-Delivery Blog