- RDA5807M IC
- IC PT2258
- Schematico
- Componenti richiesti
- Come riceviamo i dati dall'Assistente Google?
- Impostazione di un account Adafruit per la comunicazione
- Impostazione di un broker IFTTT per la radio FM
- Codice e spiegazione di Arduino
- Testare la radio FM a controllo vocale utilizzando Arduino
- Ulteriore miglioramento
Oggigiorno, alla maggior parte di noi piace ascoltare la musica, con i nostri smartphone. Ma alcuni anni fa, non era così, in quel momento, le radio FM erano la prima scelta per ascoltare musica, podcast, notizie e altro. Al giorno d'oggi nessuno ascolta la radio per musica, notizie e altro, la nonna e il nonno fanno eccezione.
Quindi, per far rivivere un po 'la vecchia gloria della radio FM, in questo progetto, costruirò una radio FM a controllo vocale utilizzando Google Assistance e il popolare IC ricevitore supereterodina RDA5870M.
Inoltre, controlla i nostri precedenti circuiti radio FM:
- Radio FM basata su Arduino
- Radio FM controllata da smartphone utilizzando Arduino
- Circuito trasmettitore FM semplice
- Come costruire un circuito trasmettitore FM
RDA5807M IC
L'RDA5807M è un sintonizzatore radio stereo FM a chip singolo molto moderno con un sintetizzatore completamente integrato, selettività IF, RDS / RBDS e decodificatore MPX che supporta la gamma di frequenza da 50 MHz a 115 MHz. È un IC ricevitore FM a chip singolo molto economico che richiede pochissimi componenti esterni per funzionare in modo funzionale. Questo IC utilizza l'interfaccia I2C per comunicare con qualsiasi dispositivo master, quindi tutta questa caratteristica lo rende molto adatto per i dispositivi portatili.
Questo IC ha un processore audio interno che è responsabile della sua ottima qualità audio.
Alcune delle caratteristiche di base includono:
- Supporto per bande di frequenza in tutto il mondo
- Supporto per RDS / RBDS
- Sintonizzatore digitale a bassa frequenza IF
- Sintetizzatore di frequenza digitale completamente integrato
- Controllo automatico del guadagno digitale (AGC)
- Aumento dei bassi
- Supporta direttamente il caricamento della resistenza da 32Ω
- Regolatore LDO integrato e altro
Puoi saperne di più su questo IC passando attraverso questo progetto Radio FM basata su Arduino utilizzando RDA5807.
IC PT2258
Il PT2258 è un circuito integrato realizzato per essere utilizzato come un regolatore di volume elettronico a 6 canali, questo circuito integrato utilizza la tecnologia CMOS appositamente progettata per applicazioni audio-video multicanale.
Questo CI fornisce un'interfaccia di controllo I2C con un intervallo di attenuazione da 0 a -79 dB a 1 dB / passo ed è disponibile in un pacchetto DIP o SOP a 20 pin.
Alcune delle funzionalità di base includono:
- 6 canali di ingresso e uscita (per sistemi home audio 5.1)
- Indirizzo I2C selezionabile (per applicazione daisy-chain)
- Alta separazione dei canali (per applicazioni a basso rumore)
- Rapporto S / N di> 100 dB
- La tensione di esercizio è compresa tra 5 e 9 V.
Abbiamo già spiegato questo circuito integrato nel progetto di controllo del volume audio digitale PT2258. Puoi controllare quel progetto se vuoi saperne di più su questo IC.
Schematico
Di seguito è riportato lo schema del circuito per la radio FM controllata da Google Assistant:
Componenti richiesti
- Microcontrollore NodeMCU - 1
- PT2258 Controller volume digitale - 1
- Modulo radio FM RDA5807 - 1
- Relè SPDT 6V - 1
- Diodo 1n4007 - 1
- Terminale a vite 5mmx2 - 1
- Jack per cuffie da 3,5 mm - 1
- Convertitore di livello logico - 1
- Resistenza 10K, 5% - 4
- Resistore 150K, 5% - 4
- Resistenza 100K, 5% - 2
- Condensatore 10uF - 6
- Condensatore 0.1uF - 1
- Cavo del ponticello - 10
Come riceviamo i dati dall'Assistente Google?
L'immagine sopra ti dà l'idea di base del processo di comunicazione tra l'Assistente Google e NodeMCU.
L'Assistente Google ha l'autorità di modificare i dati nel server IO di Adafruit per fare in modo che IFTTT con MQTT funzioni come broker.
Se si verifica una modifica dei dati sul lato server (Adafruit IO), ciò si riflette sul lato NodeMCU. Per ottenere ciò, è necessario seguire le istruzioni fornite di seguito:
Impostazione di un account Adafruit per la comunicazione
Innanzitutto, crea un account IO Adafruit. Accedi ad Adafruit IO con le tue credenziali o registrati se non hai un account. In precedenza abbiamo utilizzato Adafruit IO per costruire LED controllati da Alexa, automazione domestica Raspberry Pi e molti altri progetti basati su IoT.
Dopo aver effettuato l'accesso all'account Adafruit, Fare clic su Dashboard, quindi su Azione> Crea un nuovo dashboard .
Successivamente, aggiungeremo un nuovo nome e una breve descrizione della nostra nuova dashboard.
Dopo aver creato la dashboard, devi ottenere il nome utente e la chiave attiva dal tuo account come richiesto nel codice Arduino. Puoi ottenerlo facendo clic sull'icona CHIAVE.
Dopodiché, fai tre blocchi; un blocco di commutazione, un blocco indicatore, un blocco di testo.
I blocchi sono molto importanti, in quanto questi blocchi sono responsabili della comunicazione tra l'assistenza google e il NodeMCU.
Per creare un blocco, è necessario fare clic sul segno + nell'angolo in alto a destra.
Successivamente, creeremo i blocchi.
Successivamente, è necessario impostare ogni blocco, per questo, è necessario selezionare un blocco particolare e fare clic su Passaggio successivo.
Per questo progetto, non è necessario modificare alcuna impostazione ad eccezione del pulsante di attivazione / disattivazione.
Il testo nel pulsante di attivazione / disattivazione è in lettere maiuscole, è necessario renderlo una lettera minuscola e aggiornare le modifiche.
Questo è tutto, è tutto ciò di cui hai bisogno per configurare in adafruit IO.
La mia schermata finale è simile a questa
Impostazione di un broker IFTTT per la radio FM
Come sempre, Iscriversi se non si dispone di un account o Accedi se hai già un account.
Ora devi creare un'applet. Per questo, segui i passaggi seguenti:
Per creare un'applet, fai clic sull'icona del tuo account e fai clic su Crea.
Nella schermata di creazione, fare clic sull'icona + dopo if.
Dopodiché, devi consentire l'accesso al tuo account Google.
Per questo, devi cercare l'Assistente Google nella barra di ricerca e fare clic sull'icona dell'Assistente Google.
Nella schermata successiva, dobbiamo scegliere un trigger, Ricorda, abbiamo creato tre blocchi nell'Adafruit IO Server, dobbiamo creare trigger per quei tre blocchi.
Per prima cosa, il Blocco stazione radio, per questo, dobbiamo selezionare Pronuncia una frase con un ingrediente di testo .
Nella schermata successiva, dobbiamo digitare cosa vuoi dire e con cosa dovrebbe rispondere l'Assistente Google.
Quindi fare clic sul pulsante Crea trigger.
La schermata successiva simile a questa, come avete completato la Se parte, è il momento per l' allora parte, fare clic sul + segno dopo allora .
Ti verrà presentata una schermata come l'immagine qui sotto, cerca Adafruit e fai clic sull'icona Adafruit.
Quindi, autorizza il tuo account Adafruit con IFTTT, quindi fai clic su Connetti.
Successivamente, devi fare clic su Invia dati a Adafruit IO.
Quindi ti verrà presentato un menu a discesa dei feed che hai creato in precedenza nell'account Adafruit.
Scegline uno e fai clic su Crea azione, devi farlo per tutti e tre.
E con questo, segna la fine del processo IFTTT, la mia schermata finale dell'applet è simile a questa,
Codice e spiegazione di Arduino
Il codice Arduino è lì per gestire tutta la comunicazione tra l'IC e la comunicazione tra Adafruit IO IFTTT e WIFI. Il codice completo per questa Arduino Nano FM Radio è fornito alla fine di questo tutorial. Il codice è un po 'lungo e complesso, qui abbiamo spiegato il codice completo riga per riga.
Innanzitutto, dobbiamo includere tutte le librerie richieste, sono:
#includere
Quindi, definisci l'SSID e la password per il WI-FI, questo è l'SSID e la PASSWORD del tuo router.
const char * ssid = "Android"; // SSID del tuo router const char * password = "12345678"; // Password del tuo router
Quindi definiamo due booleani e una variabile, i booleani vengono utilizzati per contenere lo stato di comunicazione degli IC e la variabile volume viene utilizzata per impostare il livello del volume.
bool potStatus; // 1 quando viene stabilita la comunicazione tra l'MCU e l'IC bool radioStatus; // 1 quando viene stabilita la comunicazione tra l'MCU e l'IC int volume = 15; // il livello di volume predefinito con l'IC inizia con
Quindi, abbiamo impostato un pin GPIO chiamato Relay_Pin per accendere o spegnere l'amplificatore.
#define Relay_Pin D7 // Questo pin viene utilizzato per accendere e spegnere la radio
Successivamente, dobbiamo definire tutte le definizioni necessarie per comunicare con Adafruit IO.
#define AIO_SERVER "io.adafruit.com" #define AIO_SERVERPORT 1883 // usa 8883 per SSL #define AIO_USERNAME "debashis13" // Sostituiscilo con il tuo nome utente #define AIO_KEY "aio_Qyal47xo1fYhc55QB1lEPEirnoFp Sostituisci con la tua chiave di progetto" //
Le seguenti definizioni FIX_BAND è una definizione proprietaria utilizzata dalla libreria.
La successiva istruzione definita imposta il volume interno del modulo.
#define FIX_BAND RADIO_BAND_FM // <La band sarà sintonizzata da questo sketch è FM. #define FIX_RADIO_VOLUME 6 /// <Volume predefinito del modulo.
Quindi, crea gli oggetti richiesti per PT2258, RDA5807M e WiFiClient.
PT2258 digitalPot; // PT2258 Radio Object RDA5807M; // Client WiFiClient oggetto RDA5807M; // Oggetto WiFiClient
Quindi configurare la classe client MQTT passando il client WiFi e il server MQTT e i dettagli di accesso.
Adafruit_MQTT_Client mqtt (& client, AIO_SERVER, AIO_SERVERPORT, AIO_USERNAME, AIO_KEY);
// Imposta la classe client MQTT passando il client WiFi e il server MQTT e i dettagli di accesso.
Quindi dobbiamo iscriverci a un feed. Cosa ti fa chiedere?
Se alcuni valori, alcuni parametri cambiano nel server Adafruit, le modifiche si rifletteranno qui.
Adafruit_MQTT_Subscribe Radio_Station = Adafruit_MQTT_Subscribe (& mqtt, AIO_USERNAME "/ feeds / Radio_Station"); // Metodi utilizzati per iscriversi a un feed Adafruit_MQTT_Subscribe Toggle_FM = Adafruit_MQTT_Subscribe (& mqtt, AIO_USERNAME "/ feeds / Toggle_FM"); // Metodi utilizzati per iscriversi a un feed Adafruit_MQTT_Subscribe Volume = Adafruit_MQTT_Subscribe (& mqtt, AIO_USERNAME "/ feeds / Volume"); // Metodi utilizzati per iscriversi a un feed
Di seguito è riportato il prototipo della funzione per la funzione MQTT_connect () .
void MQTT_connect (); // Prototipo di funzione per MQTT Connect
Quindi iniziamo il nostro processo di configurazione. Inizialmente, iniziamo la comunicazione UART con il metodo di inizio.
Serial.begin (9600); // UART inizia Serial.println (); // aggiunge una riga extra per la spaziatura Serial.println (); // aggiunge una riga extra per la spaziatura Successivamente, facciamo la solita cosa per connetterci al WiFI **************** tutte le solite cose necessarie per una connessione WiFi *********************** / Serial.print ("connessione a"); Serial.println (ssid); WiFi.mode (WIFI_STA); WiFi.begin (ssid, password); while (WiFi.status ()! = WL_CONNECTED) {ritardo (500); Serial.print ("."); } Serial.println (""); Serial.println ("WiFi connesso"); Serial.println ("indirizzo IP:"); Serial.println (WiFi.localIP ()); / **************** tutte le solite cose necessarie per una connessione WiFi *********************** /
Successivamente, chiama il metodo Wire.begin () per creare un'istanza di una connessione I2C e chiamiamo il metodo Wire.setClock () per fissare la frequenza I2C a 100 KHz poiché è la velocità massima del PT2258 IC.
Wire.begin (); // inizia la sequenza di avvio I2C Wire.setClock (100000); // imposta il clock I2C a 100KHz
Successivamente, chiama il metodo init () sia per il PT2258 che per l'IC RDA5807 e mantieni lo stato di ritorno nei valori booleani precedentemente definiti.
potStatus = digitalPot.init (); radioStatus = radio.init ();
Quindi, controlla se l'MCU è stato in grado di comunicare con l'IC o meno. Lo facciamo con due dichiarazioni if else .
if (potStatus) {Serial.println ("Found PT2258 Device!"); } else {Serial.println ("Impossibile avviare PT2258"); } if (radioStatus) {Serial.println ("Found RDA5807M Device!"); } else {Serial.println ("Impossibile avviare RDA5807M"); }
Quindi, chiama il metodo di sottoscrizione dalla libreria MQTT. Saremo avvisati dal server MQTT in caso di modifiche ai nostri feed sottoscritti.
mqtt.subscribe (& Radio_Station); // Configurazione dell'abbonamento MQTT per il feed Radio_Station mqtt.subscribe (& Toggle_FM); // Imposta l'abbonamento MQTT per Toggle_FM feed mqtt.subscribe (& Volume); // Imposta la sottoscrizione MQTT per il feed del volume
Successivamente, impostiamo il pin Relay come output e lo stato del pin su LOW
pinMode (D7, OUTPUT); digitalWrite (D7, LOW);
Quindi, imposta un volume radio predeterminato, questo parametro imposta il volume interno dell'IC RDA5807, che segna la fine del nostro processo di configurazione.
radio.setVolume (FIX_RADIO_VOLUME); // successivamente impostiamo il volume della radio normalize radio.setMono (false); // non vogliamo che il chip dia un'uscita mono radio.setMute (false); // non vogliamo che il chip vada in mute all'inizio
Iniziamo il ciclo chiamando la funzione MQTT_connect () che stabilisce una connessione al server MQTT.
Nella funzione di connessione MQTT, proviamo tre volte a stabilire una connessione al server MQTT.
Se ha esito positivo, viene visualizzato un messaggio di successo, altrimenti verrà visualizzato un messaggio di errore.
void MQTT_connect () {int8_t ret; // Intero a 8 bit per memorizzare i tentativi // Interrompi se già connesso. if (mqtt.connected ()) {return; } Serial.print ("Connessione a MQTT…"); uint8_t retries = 3; while ((ret = mqtt.connect ())! = 0) {// connect restituirà 0 per Serial.println connesso (mqtt.connectErrorString (ret)); Serial.println ("Nuovo tentativo di connessione MQTT in 5 secondi…"); mqtt.disconnect (); ritardo (5000); // attendi 5 secondi tentativi--; if (retries == 0) {// fondamentalmente muori e aspetta che WDT mi resetti mentre (1); }} Serial.println ("MQTT Connected!"); }
Successivamente, inizia creando un puntatore a un oggetto Adafruit_MQTT_Subscribe . Lo useremo per determinare quale abbonamento è stato ricevuto.
Abbonamento Adafruit_MQTT_Subscribe *;
Successivamente, attendiamo un messaggio di iscrizione.
mqtt.readSubscription (timeInMilliseconds) ascolterà per un certo tempo, per qualsiasi messaggio proveniente dal server MQTT.
Se riceve un messaggio prima del timeout, risponderà con un puntatore all'abbonamento o scadrà e restituirà 0. In tal caso, attenderà 2 secondi.
while ((subscription = mqtt.readSubscription (20000)))
Se si verifica un timeout, il riempimento del ciclo while non riesce. In caso contrario, confrontiamo quale abbonamento e otterremo i nostri abbonamenti noti.
In questo codice, lo facciamo per tutti e tre i nostri feed sottoscritti.
if (abbonamento == & Toggle_FM) if (abbonamento == & Radio_Station) if (abbonamento == & Volume)
Questi erano i tre parametri principali che devi capire nella sezione del ciclo.
Questa sezione del codice viene utilizzata per monitorare e impostare il feed Toggle_FM .
if (subscription == & Toggle_FM) // è un messaggio dal feed Toggle_FM {Serial.print (F ("Got:")); Serial.println ((char *) Toggle_FM.lastread); // stampa i dati del feed solo per il debug if (String ((char *) Toggle_FM.lastread) == String ("on")) // confrontiamo i dati ricevuti con un parametro noto, in questo caso ci aspettiamo che "on "proviene dal server {// ma prima di farlo dobbiamo renderlo una stringa che renda il confronto super facile digitalWrite (D7, HIGH); // se otteniamo una stringa" on "dal server che stiamo creando il pin D7 ALTO} if (String ((char *) Toggle_FM.lastread) == String ("off")) // di nuovo stiamo controllando la stringa {digitalWrite (D7, LOW); // se otteniamo un stringa "off" dal server stiamo rendendo il pin D7 BASSO}}
Questa sezione del codice viene utilizzata per monitorare e impostare il feed Radio_Station .
if (subscription == & Radio_Station) {Serial.print (F ("Got:")); Serial.println ((char *) Radio_Station.lastread); if (String ((char *) Radio_Station.lastread) == String ("Big FM")) // sentiamo che stiamo controllando la stringa Big FM {radio.setBandFrequency (FIX_BAND, 9270); // se la condizione di cui sopra è vera, stiamo impostando il canale radoi su 92.7MHz} // Il processo sopra menzionato continua di seguito 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); }}
Questa sezione del codice viene utilizzata per monitorare e impostare il feed del volume.
if (subscription == & Volume) // // senti che stiamo controllando la stringa Volume ed è un valore intero in un formato stringa // Dobbiamo riconvertirlo in un numero intero per cambiare il volume con l'aiuto del PT2258 IC Serial.print (F ("Got:")); Serial.println ((char *) Volume.lastread); volume = atoi ((char *) Volume.lastread); // Stiamo usando il metodo atoi () per convertire un puntatore a caratteri in un intero volume = map (volume, 0,100,79,0); // map (value, fromLow, fromHigh, toLow, toHigh) // poiché la pt2258 comprende solo valori interi in dB // stiamo mappando il valore 0dB - 79dB su 0% - 100%. digitalPot.setChannelVolume (volume, 0); // dopotutto stiamo impostando il volume per il canale 0 del PT2258 IC digitalPot.setChannelVolume (volume, 1); // dopotutto stiamo impostando il volume per il canale 1 del PT2258 IC}}
Testare la radio FM a controllo vocale utilizzando Arduino
Per testare il circuito, è stato utilizzato il seguente apparato:
- Un trasformatore che ha un Tap 13-0-13
- Due altoparlanti da 4Ω 20W come carico.
- Telefono per utilizzare l'Assistente Google.
In un precedente articolo, ti ho mostrato come realizzare un semplice amplificatore audio 2x32 Watt con IC TDA2050, lo userò anche per questa dimostrazione, Ho disordinato il potenziometro meccanico e ho cortocircuitato due cavi con due piccoli cavi jumper. Ora, con l'aiuto di due pulsanti, sono stato in grado di modificare il volume dell'amplificatore.
Ulteriore miglioramento
Ci sono molti ulteriori miglioramenti che possono essere apportati a questo circuito.
- Esistono vari problemi di rumore perché una sorgente audio funziona accanto al NodeMCU, quindi è necessario implementare una schermatura aggiuntiva per migliorare l'immunità al rumore.
- Costruire il circuito generale su un PCB migliorerà l'immunità al rumore.
- È possibile aggiungere filtri aggiuntivi a questo IC per eliminare il rumore.
Spero che questo articolo ti sia piaciuto e che abbia imparato qualcosa di nuovo da esso. Se hai qualche dubbio, puoi chiedere nei commenti qui sotto o puoi usare i nostri forum per una discussione dettagliata.