- IC RDA5807M
- IC PT2258
- Schématique
- Composants requis
- Comment obtenons-nous des données de l'Assistant Google?
- Créer un compte Adafruit pour la communication
- Configuration d'un courtier IFTTT pour la radio FM
- Code Arduino et explication
- Test de la radio FM à commande vocale à l'aide d'Arduino
- Amélioration supplémentaire
De nos jours, la plupart d'entre nous aiment écouter de la musique, avec nos smartphones. Mais il y a quelques années, ce n'était pas le cas, à ce moment-là, les radios FM étaient le premier choix pour écouter de la musique, des podcasts, des nouvelles et autres. De nos jours, personne n'écoute la radio pour écouter de la musique, des nouvelles et autres, grand-mère et grand-père étant une exception.
Donc, pour faire revivre un peu l'ancienne gloire de la radio FM, dans ce projet, je vais construire une radio FM à commande vocale en utilisant Google Assistance et le populaire RDA5870M Superheterodyne Receiver IC.
Consultez également nos précédents circuits radio FM:
- Radio FM basée sur Arduino
- Radio FM contrôlée par téléphone intelligent utilisant Arduino
- Circuit émetteur FM simple
- Comment construire un circuit d'émetteur FM
IC RDA5807M
Le RDA5807M est un tuner radio FM stéréo à puce unique très moderne avec un synthétiseur entièrement intégré, une sélectivité IF, un décodeur RDS / RBDS et MPX qui prend en charge la gamme de fréquences de 50 MHz à 115 MHz. C'est un circuit intégré de récepteur FM à puce unique très bon marché qui nécessite très peu de composants externes pour fonctionner correctement. Cet IC utilise l'interface I2C pour communiquer avec n'importe quel appareil maître, donc toute cette fonctionnalité le rend très approprié pour les appareils portables.
Ce circuit intégré a un processeur audio interne qui est responsable de sa grande qualité audio.
Certaines des fonctionnalités de base comprennent:
- Prise en charge des bandes de fréquences mondiales
- Prise en charge de RDS / RBDS
- Tuner numérique à faible IF
- Synthétiseur de fréquence numérique entièrement intégré
- Contrôle de gain automatique numérique (AGC)
- Renforcement des basses
- Soutenir directement le chargement de résistance de 32Ω
- Régulateur LDO intégré et plus
Vous pouvez en savoir plus sur cet IC en parcourant ce projet Radio FM basée sur Arduino utilisant RDA5807.
IC PT2258
Le PT2258 est un circuit intégré conçu pour être utilisé comme contrôleur de volume électronique à 6 canaux, ce circuit intégré utilise la technologie CMOS spécialement conçue pour les applications audio-vidéo multicanaux.
Ce circuit intégré fournit une interface de contrôle I2C avec une plage d'atténuation de 0 à -79 dB à 1 dB / pas et est livré dans un boîtier DIP ou SOP à 20 broches.
Certaines des fonctionnalités de base comprennent:
- 6 canaux d'entrée et de sortie (pour les systèmes audio à domicile 5.1)
- Adresse I2C sélectionnable (pour les applications en guirlande)
- Séparation des canaux élevés (pour les applications à faible bruit)
- Rapport S / N> 100 dB
- La tension de fonctionnement est de 5 à 9 V
Nous avons déjà expliqué ce circuit intégré dans le projet de contrôle du volume audio numérique PT2258. Vous pouvez vérifier ce projet si vous souhaitez en savoir plus sur ce CI.
Schématique
Le schéma de circuit de la radio FM contrôlée par Google Assistant est donné ci-dessous:
Composants requis
- Microcontrôleur NodeMCU - 1
- Contrôleur de volume numérique PT2258 - 1
- Module radio FM RDA5807 - 1
- Relais SPDT 6V - 1
- Diode 1n4007 - 1
- Borne à vis 5mmx2 - 1
- Prise casque 3,5 mm - 1
- Convertisseur de niveau logique - 1
- Résistance 10K, 5% - 4
- Résistance 150K, 5% - 4
- Résistance 100K, 5% - 2
- Condensateur 10uF - 6
- Condensateur 0.1uF - 1
- Fil de cavalier - 10
Comment obtenons-nous des données de l'Assistant Google?
L'image ci-dessus vous donne une idée de base du processus de communication entre l'Assistant Google et le NodeMCU.
L'Assistant Google a le pouvoir de modifier les données du serveur Adafruit IO pour que IFTTT avec MQTT travaille en tant que courtier.
Si une modification de données se produit du côté serveur (Adafruit IO), cela se reflète du côté NodeMCU. Pour y parvenir, vous devez suivre les instructions ci-dessous.
Créer un compte Adafruit pour la communication
Commencez par créer un compte Adafruit IO. Connectez-vous à Adafruit IO avec vos identifiants ou inscrivez-vous si vous n'avez pas de compte. Nous avons précédemment utilisé Adafruit IO pour créer des LED contrôlées par Alexa, la domotique Raspberry Pi et de nombreux autres projets basés sur l'IoT.
Après vous être connecté au compte Adafruit, Cliquez sur Tableaux de bord, puis sur Action> Créer un nouveau tableau de bord .
Ensuite, nous allons ajouter un nouveau nom et une brève description de notre nouveau tableau de bord.
Après avoir créé le tableau de bord, vous devez obtenir le nom d'utilisateur et la clé active de votre compte, comme requis dans le code Arduino. Vous pouvez l'obtenir en cliquant sur l'icône CLÉ.
Après cela, faites trois blocs; un bloc bascule, un bloc jauge, un bloc texte.
Les blocs sont très importants, car ces blocs sont responsables de la communication entre l'assistance google et le NodeMCU.
Pour créer un bloc, vous devez cliquer sur le signe + dans le coin supérieur droit.
Ensuite, nous allons faire les blocs.
Ensuite, vous devez configurer chaque bloc, pour cela, vous devez cocher un bloc particulier et cliquer sur Étape suivante.
Pour ce projet, il n'est pas nécessaire de modifier les paramètres à l'exception du bouton bascule.
Le texte du bouton bascule est en majuscules, vous devez en faire une petite lettre et mettre à jour les modifications.
C'est tout, c'est tout ce que vous devez configurer dans adafruit IO.
Mon écran final ressemble à ceci-
Configuration d'un courtier IFTTT pour la radio FM
Comme toujours, inscrivez -vous si vous n'avez pas de compte ou connectez -vous si vous avez déjà un compte.
Maintenant, vous devez créer une applet. Pour cela, suivez les étapes ci-dessous:
Pour créer une applet, cliquez sur l' icône de votre compte et cliquez sur Créer.
Dans l'écran de création, cliquez sur l' icône + après si.
Après cela, vous devez autoriser l'accès à votre compte Google.
Pour cela, vous devez rechercher Google Assistant dans la barre de recherche et cliquer sur l'icône Assistant Google.
Dans l'écran suivant, nous devons choisir un déclencheur, N'oubliez pas que nous avons créé trois blocs dans le serveur Adafruit IO, nous devons y créer des déclencheurs pour ces trois blocs.
Tout d'abord, le bloc Radio Station, pour cela, nous devons sélectionner Dites une phrase avec un ingrédient de texte .
Dans l'écran suivant, nous devons taper ce que vous voulez dire et ce que l'assistant Google devrait vous répondre.
Cliquez ensuite sur le bouton Créer un déclencheur.
L'écran suivant ressemble à quelque chose comme ça, comme vous avez terminé la Si une partie, il est temps pour la ensuite partie, cliquez sur le + signe après alors .
Un écran comme l'image ci-dessous vous sera présenté, recherchez Adafruit et cliquez sur l'icône Adafruit.
Ensuite, autorisez votre compte Adafruit avec IFTTT, puis cliquez sur Se connecter.
Ensuite, vous devez cliquer sur Envoyer les données à Adafruit IO.
Ensuite, une liste déroulante des flux que vous avez créés précédemment dans le compte Adafruit vous sera présentée .
Choisissez-en un et cliquez sur créer une action, vous devez le faire pour les trois.
Et avec cela, marque la fin du processus IFTTT, mon écran final d'applet ressemble à ceci,
Code Arduino et explication
Le code Arduino est là pour gérer toute la communication entre l'IC et la communication entre Adafruit IO IFTTT et WIFI. Le code complet de cette radio Arduino Nano FM est donné à la fin de ce tutoriel. Le code est un peu long et complexe, ici nous avons expliqué le code complet ligne par ligne.
Tout d'abord, nous devons inclure toutes les bibliothèques requises, ce sont:
#comprendre
Ensuite, définissez le SSID et le mot de passe pour le WI-FI, c'est le SSID et le MOT DE PASSE de votre routeur.
const char * ssid = "Android"; // SSID de votre routeur const char * password = "12345678"; // Mot de passe de votre routeur
Ensuite, nous définissons deux booléens et une variable, les booléens sont utilisés pour maintenir l'état de communication des circuits intégrés et la variable de volume est utilisée pour régler le niveau de volume.
bool potStatus; // 1 lorsque la communication est établie entre le MCU et l'IC bool radioStatus; // 1 lorsque la communication est établie entre le MCU et l'IC int volume = 15; // niveau de volume par défaut avec l'IC commence par
Ensuite, nous avons configuré une broche GPIO nommée Relay_Pin pour allumer ou éteindre l'amplificateur.
#define Relay_Pin D7 // Cette broche est utilisée pour allumer et éteindre la radio
Ensuite, nous devons définir toutes les définitions nécessaires pour communiquer avec Adafruit IO.
#define AIO_SERVER "io.adafruit.com" #define AIO_SERVERPORT 1883 // utilise 8883 pour SSL #define AIO_USERNAME "debashis13" // Remplacez-le par votre nom d'utilisateur #define AIO_KEY "aio_Qyal47xo1fYhc55QB1lEPEirno1fYhc55QB1lEPEirF
Les définitions ci-dessous FIX_BAND est une définition propriétaire utilisée par la bibliothèque.
L'instruction définie suivante définit le volume interne du module.
#define FIX_BAND RADIO_BAND_FM // <La bande qui sera accordée par ce croquis est FM. #define FIX_RADIO_VOLUME 6 /// <Volume par défaut du module.
Ensuite, créez les objets requis pour le PT2258, le RDA5807M et le WiFiClient.
PT2258 digitalPot; // Objet PT2258 Radio RDA5807M; // RDA5807M Object Client WiFiClient; // Objet WiFiClient
Configurez ensuite la classe client MQTT en transmettant le client WiFi et le serveur MQTT et les informations de connexion.
Adafruit_MQTT_Client mqtt (& client, AIO_SERVER, AIO_SERVERPORT, AIO_USERNAME, AIO_KEY);
// Configurez la classe client MQTT en transmettant le client WiFi et le serveur MQTT et les informations de connexion.
Ensuite, nous devons nous abonner à un flux. Qu'est-ce que cela vous fait demander?
Si certaines valeurs, certains paramètres changent dans le serveur Adafruit, les changements seront reflétés ici.
Adafruit_MQTT_Subscribe Radio_Station = Adafruit_MQTT_Subscribe (& mqtt, AIO_USERNAME "/ feeds / Radio_Station"); // Méthodes utilisées pour s'abonner à un flux Adafruit_MQTT_Subscribe Toggle_FM = Adafruit_MQTT_Subscribe (& mqtt, AIO_USERNAME "/ feeds / Toggle_FM"); // Méthodes utilisées pour s'abonner à un flux Adafruit_MQTT_Subscribe Volume = Adafruit_MQTT_Subscribe (& mqtt, AIO_USERNAME "/ feeds / Volume"); // Méthodes utilisées pour s'abonner à un flux
Voici le prototype de fonction pour la fonction MQTT_connect () .
void MQTT_connect (); // Prototype de fonction pour MQTT Connect
Ensuite, nous commençons notre processus de configuration. Dans un premier temps, nous commençons la communication UART avec la méthode begin.
Serial.begin (9600); // UART commence Serial.println (); // ajoute une ligne supplémentaire pour l'espacement Serial.println (); // ajoute une ligne supplémentaire pour l'espacement Ensuite, nous faisons tout ce qui est habituel pour nous connecter au WiFI **************** toutes les choses habituelles requises pour une connexion WiFi *********************** / Serial.print ("se connecter à"); Serial.println (ssid); WiFi.mode (WIFI_STA); WiFi.begin (ssid, mot de passe); while (WiFi.status ()! = WL_CONNECTED) {délai (500); Serial.print ("."); } Serial.println (""); Serial.println ("WiFi connecté"); Serial.println ("Adresse IP:"); Serial.println (WiFi.localIP ()); / **************** toutes les choses habituelles requises pour une connexion WiFi *********************** /
Ensuite, appelez la méthode Wire.begin () pour instancier une connexion I2C et nous appelons la méthode Wire.setClock () pour fixer la fréquence I2C à 100 KHz car c'est la pleine vitesse du PT2258 IC.
Wire.begin (); // commence la séquence de démarrage I2C Wire.setClock (100000); // réglage de l'horloge I2C à 100 KHz
Ensuite, appelez la méthode init () pour le PT2258 et le RDA5807 IC et maintenez l'état de retour dans les booléens précédemment définis.
potStatus = digitalPot.init (); radioStatus = radio.init ();
Ensuite, vérifiez si le MCU a pu communiquer avec l'IC ou non. Nous faisons cela avec deux instructions if else .
if (potStatus) {Serial.println ("Périphérique PT2258 trouvé!"); } else {Serial.println ("Impossible de lancer PT2258"); } if (radioStatus) {Serial.println ("Périphérique RDA5807M trouvé!"); } else {Serial.println ("Impossible de lancer RDA5807M"); }
Ensuite, appelez la méthode subscribe à partir de la bibliothèque MQTT. Nous serons informés par le serveur MQTT si des changements se sont produits dans nos flux abonnés.
mqtt.subscribe (& Radio_Station); // Configuration de l'abonnement MQTT pour le flux Radio_Station mqtt.subscribe (& Toggle_FM); // Configuration de l'abonnement MQTT pour le flux Toggle_FM mqtt.subscribe (& Volume); // Configurer l'abonnement MQTT pour le flux de volume
Ensuite, nous définissons la broche du relais comme sortie et l'état de la broche sur LOW
pinMode (D7, SORTIE); DigitalWrite (D7, LOW);
Ensuite, définissez un volume radio prédéterminé, ce paramètre règle le volume interne du RDA5807 IC, ce qui marque la fin de notre processus de configuration.
radio.setVolume (FIX_RADIO_VOLUME); // ensuite nous réglons le volume radio normalize radio.setMono (false); // nous ne voulons pas que la puce donne une sortie mono radio.setMute (false); // nous ne voulons pas que la puce se mette en sourdine au début
Nous démarrons la boucle en appelant la fonction MQTT_connect () qui établit une connexion avec le serveur MQTT.
Dans la fonction de connexion MQTT, nous essayons trois fois d'établir une connexion au serveur MQTT.
S'il réussit, nous recevons un message de réussite, sinon nous recevrons un message d'erreur.
void MQTT_connect () {int8_t ret; // Entier 8 bits pour stocker les tentatives // Arrêter si déjà connecté. if (mqtt.connected ()) {return; } Serial.print ("Connexion à MQTT…"); uint8_t retries = 3; while ((ret = mqtt.connect ())! = 0) {// connect renverra 0 pour Serial.println connecté (mqtt.connectErrorString (ret)); Serial.println ("Nouvelle tentative de connexion MQTT dans 5 secondes…"); mqtt.disconnect (); retard (5000); // attendez 5 secondes de nouvelles tentatives--; if (retries == 0) {// essentiellement mourir et attendre que WDT me réinitialise while (1); }} Serial.println ("MQTT connecté!"); }
Ensuite, commencez par créer un pointeur vers un objet Adafruit_MQTT_Subscribe . Nous allons l'utiliser pour déterminer quel abonnement a été reçu.
Abonnement Adafruit_MQTT_Subscribe *;
Ensuite, nous attendons un message d'abonnement.
mqtt.readSubscription (timeInMilliseconds) écoutera pendant un certain temps, tous les messages provenant du serveur MQTT.
S'il reçoit un message avant l'expiration du délai, il répondra avec un pointeur vers l'abonnement ou il expirera simplement et retournera 0. Dans ce cas, il attendra 2 secondes.
while ((abonnement = mqtt.readSubscription (20000)))
Si un délai d' attente se produit, le tout remplissage de la boucle échoue. Sinon, nous comparons quel abonnement et obtiendrons nos abonnements connus.
Dans ce code, nous faisons cela pour les trois de nos flux abonnés.
if (abonnement == & Toggle_FM) if (abonnement == & Radio_Station) if (abonnement == & Volume)
Ce sont les trois principaux paramètres que vous devez comprendre dans la section boucle.
Cette section du code est utilisée pour surveiller et définir le flux Toggle_FM .
if (subscription == & Toggle_FM) // est-ce un message du flux Toggle_FM {Serial.print (F ("Got:")); Serial.println ((char *) Toggle_FM.lastread); // imprimer les données du flux juste pour le débogage if (String ((char *) Toggle_FM.lastread) == String ("on")) // nous comparons les données reçues à un paramètre connu dans ce cas, nous attendons que "on "vient du serveur {// mais avant de faire cela, nous devons en faire une chaîne qui rend la comparaison super facile digitalWrite (D7, HIGH); // si nous obtenons une chaîne" on "du serveur que nous créons la broche D7 HIGH} if (String ((char *) Toggle_FM.lastread) == String ("off")) // encore une fois, nous vérifions la chaîne off {digitalWrite (D7, LOW); // si nous obtenons un "off" chaîne du serveur sur lequel nous mettons la broche D7 à LOW}}
Cette section du code est utilisée pour surveiller et définir le flux Radio_Station .
if (abonnement == & Radio_Station) {Serial.print (F ("Got:")); Serial.println ((char *) Radio_Station.lastread); if (String ((char *) Radio_Station.lastread) == String ("Big FM")) // entendre que nous vérifions la chaîne Big FM {radio.setBandFrequency (FIX_BAND, 9270); // si la condition ci-dessus est vraie, nous définissons le canal radoi sur 92,7 MHz} // Le processus mentionné ci-dessus se poursuit ci-dessous if (String ((char *) Radio_Station.lastread) == String ("Red FM")) { radio.setBandFrequency (FIX_BAND, 9350); } if (String ((char *) Radio_Station.lastread) == String ("Radio Mirchi")) {radio.setBandFrequency (FIX_BAND, 9830); }}
Cette section du code est utilisée pour surveiller et régler l'alimentation en volume.
if (subscription == & Volume) // // entend que nous vérifions la chaîne Volume et c'est une valeur entière au format chaîne // Nous devons la reconvertir en entier pour changer le volume à l'aide du PT2258 IC Serial.print (F ("Got:")); Serial.println ((char *) Volume.lastread); volume = atoi ((char *) Volume.lastread); // Nous utilisons la méthode atoi () pour convertir un pointeur de caractère en un entier volume = map (volume, 0,100,79,0); // map (value, fromLow, fromHigh, toLow, toHigh) // car le pt2258 ne comprend que les valeurs entières en dB // nous mappons la valeur 0dB - 79dB à 0% - 100%. digitalPot.setChannelVolume (volume, 0); // après tout, nous réglons le volume du canal 0 du PT2258 IC digitalPot.setChannelVolume (volume, 1); // après tout, nous réglons le volume du canal 1 du PT2258 IC}}
Test de la radio FM à commande vocale à l'aide d'Arduino
Pour tester le circuit, l'appareil suivant a été utilisé:
- Un transformateur qui a un 13-0-13 Tap
- Deux haut-parleurs 4Ω 20W en tant que charge.
- Téléphone pour utiliser l'Assistant Google.
Dans un article précédent, je vous ai montré comment créer un amplificateur audio simple 2x32 Watt avec TDA2050 IC, je vais également l'utiliser pour cette démonstration, J'ai désordonné le potentiomètre mécanique et court-circuité deux fils avec deux petits câbles volants. Maintenant, à l'aide de deux boutons poussoirs, j'ai pu modifier le volume de l'amplificateur.
Amélioration supplémentaire
De nombreuses autres améliorations peuvent être apportées à ce circuit.
- Il existe divers problèmes de bruit car une source audio fonctionne à côté du NodeMCU, nous devons donc implémenter un blindage supplémentaire pour améliorer l'immunité au bruit.
- Construire le circuit global sur un PCB améliorera l'immunité au bruit.
- Des filtres supplémentaires peuvent être ajoutés à ce circuit intégré pour éliminer le bruit.
J'espère que vous avez aimé cet article et en avez appris quelque chose de nouveau. Si vous avez le moindre doute, vous pouvez demander dans les commentaires ci-dessous ou utiliser nos forums pour une discussion détaillée.