Röststyrd FM-radio med arduino och Google Assistent

Numera gillar de flesta av oss att lyssna på musik med våra smartphones. Men för några år tillbaka var detta inte fallet, vid den tidpunkten var FM-radio det första valet för att lyssna på musik, poddsändningar, nyheter och andra. Numera lyssnar ingen på radio för musik, nyheter och andra, mormor och farfar är ett undantag.

Så, för att återuppliva FM-radioens gamla ära lite, i det här projektet ska jag bygga en röststyrd FM-radio med Google Assistance och den populära RDA5870M Superheterodyne Receiver IC.

Kontrollera också våra tidigare FM-radiokretsar:

Arduino-baserad FM-radio
Smart telefonstyrd FM-radio med Arduino
Enkel FM-sändarkrets
Hur man bygger FM-sändarkrets

RDA5807M IC

RDA5807M är en mycket modern FM-stereout tuner med en chip och en helt integrerad synthesizer, IF-selektivitet, RDS / RBDS och MPX-avkodare som stöder frekvensområdet 50MHz till 115MHz. Det är en mycket billig FM-mottagare IC med en chip som kräver mycket få externa komponenter för att fungera funktionellt. Denna IC använder I2C-gränssnittet för att kommunicera med alla huvudenheter, så all denna funktion gör den mycket lämplig för bärbara enheter.

Denna IC har en intern ljudprocessor som är ansvarig för dess fantastiska ljudkvalitet.

Några av de grundläggande funktionerna inkluderar-

Stöd för globala frekvensband
Stöd för RDS / RBDS
Digital låg-IF-tuner
Helt integrerad digital frekvenssynthesizer
Digital automatisk förstärkningskontroll (AGC)
Bass boost
Stöd direkt 32Ω motståndsbelastning
Integrerad LDO-regulator och mer

Du kan lära dig mer om denna IC genom att gå igenom detta projekt Arduino-baserade FM-radio med RDA5807.

IC PT2258

PT2258 är en IC gjord för att användas som en 6-kanals elektronisk volymkontroll, denna IC använder CMOS-teknik speciellt utformad för flerkanaliga ljud-videoapplikationer.

Denna IC ger ett I2C-kontrollgränssnitt med ett dämpningsområde från 0 till -79 dB vid 1 dB / steg och kommer i ett 20-stifts DIP- eller SOP-paket.

Några av de grundläggande funktionerna inkluderar -

6-ingångs- och utgångskanaler (för 5.1-hemljudsystem)
Valbar I2C-adress (för applikation med Daisy-chain)
Högkanalseparation (för applikation med låg ljudnivå)
S / N-förhållande> 100dB
Driftspänningen är 5 till 9V

Vi har tidigare förklarat om denna IC i PT2258 Digital Audio Volume Control Project. Du kan kontrollera det projektet om du vill veta mer om denna IC.

Schematisk

Kretsschema för Google Assistant-kontrollerad FM-radio ges nedan:

Komponenter krävs

NodeMCU Microcontroller - 1
PT2258 Digital volymkontroll - 1
RDA5807 FM-radiomodul - 1
SPDT Relä 6V - 1
1n4007 Diod - 1
Skruvplint 5mmx2 - 1
3,5 mm hörlursuttag - 1
Logisk nivåomvandlare - 1
10K motstånd, 5% - 4
150K motstånd, 5% - 4
100K motstånd, 5% - 2
10uF kondensator - 6
0.1uF kondensator - 1
Bygeltråd - 10

Hur får vi data från Google Assistant?

Ovanstående bild ger dig den grundläggande idén om kommunikationsprocessen mellan Google Assistant och NodeMCU.

Google-assistenten har befogenhet att ändra data på Adafruit IO-servern för att göra det IFTTT med MQTT fungerar som en mäklare.

Om någon dataändring inträffar på serversidan (Adafruit IO) återspeglas den på NodeMCU-sidan. För att uppnå detta måste du följa instruktionerna nedan -

Skapa ett Adafruit-konto för kommunikation

Gör först ett Adafruit IO-konto. Logga in på Adafruit IO med dina uppgifter eller Registrera dig om du inte har ett konto. Vi använde tidigare Adafruit IO för att bygga Alexa-styrd LED, Raspberry Pi-hemautomation och många andra IoT-baserade projekt.

Efter att ha loggat in på Adafruit-kontot, Klicka på Dashboards och klicka sedan på Action> Skapa en ny Dashboard .

Därefter ska vi lägga till ett nytt namn och en kort beskrivning av vår nya instrumentpanel.

När du har skapat instrumentpanelen måste du hämta användarnamnet och den aktiva nyckeln från ditt konto så som det krävs i Arduino-koden. Du kan få det genom att klicka på KEY-ikonen.

Därefter gör du tre block; ett växlingsblock, ett mätblock, ett textblock.

Blocken är mycket viktiga, eftersom dessa block ansvarar för kommunikationen mellan google-hjälp och NodeMCU.

För att skapa ett block måste du klicka på + -tecknet i det övre högra hörnet.

Därefter ska vi göra blocken.

Därefter måste du ställa in varje block, för det måste du kryssa för ett visst block och klicka på Nästa steg.

För detta projekt finns det inget behov av att ändra några inställningar förutom växlingsknappen.

Texten i växlingsknappen är med stora bokstäver, du måste göra det till en liten bokstav och uppdatera ändringarna.

Det är allt, det är alla saker du behöver för att ställa in i Adafruit IO.

Min sista skärm ser ut så här-

Ställa in en IFTTT-mäklare för FM-radio

Som alltid, Registrera dig om du inte har ett konto eller Logga in om du redan har ett konto.

Nu måste du skapa en applet. Följ stegen nedan för det:

För att skapa en applet, klicka på din kontoikon och klicka på Skapa.

Klicka på + -ikonen efter if på skärmen skapa.

Därefter måste du tillåta åtkomst till ditt Google-konto.

För det måste du söka efter Google Assistant i sökfältet och klicka på Google Assistant-ikonen.

I nästa skärm måste vi välja en trigger, Kom ihåg att vi skapade tre block i Adafruit IO-servern, vi måste göra triggers för de tre blocken.

Först, Radio Station Block, för det måste vi välja Säg en fras med en textingrediens .

I nästa skärm måste vi skriva vad vill du säga och vad google-assistenten ska svara dig med.

Klicka sedan på knappen Skapa utlösare.

Nästa skärm ser ut ungefär så här, eftersom du har slutfört om en del, det är dags för den då delen genom att klicka på + tecknet efter då .

Du får en skärm som bilden nedan, sök efter Adafruit och klicka på Adafruit-ikonen.

Därefter auktoriserar du ditt Adafruit-konto med IFTTT och klickar sedan på Anslut.

Därefter måste du klicka på Skicka data till Adafruit IO.

Då får du en rullgardinsmeny med flöden som du har skapat tidigare i Adafruit-kontot.

Välj vilken som helst och klicka på skapa åtgärder, du måste göra detta för alla tre.

Och med det, markerar slutet på IFTTT-processen, ser min sista appletskärm ut så här,

Arduino-kod och förklaring

Arduino-koden finns för att hantera all kommunikation mellan IC och kommunikationen mellan Adafruit IO IFTTT och WIFI. Komplett kod för denna Arduino Nano FM-radio ges i slutet av denna handledning. Koden är lite lång och komplex, här har vi förklarat hela koden rad för rad.

Först måste vi inkludera alla obligatoriska bibliotek, de är:

#omfatta // Bibliotek för ESP8266 NodeMCU Board #include // Trådbibliotek behövs för I2C-kommunikation #include // PT2258-biblioteket behövs för att kommunicera med IC # inkludera // RDA5807M-biblioteket används för att kommunicera med RDA-modulen # inkludera // Adafruit MQTT är behov av MQTT # inkludera // Adafruit MQTT är för MQTT-klienten

Definiera sedan SSID och lösenord för WI-FI, detta är SSID och LÖSENORD för din router.

const char * ssid = "Android"; // SSID för din router const char * password = "12345678"; // Lösenord för din router

Sedan definierar vi två booleaner och en variabel, booleanerna används för att hålla kommunikationsstatus för IC: erna, och volymvariabeln används för att ställa in volymnivån.

bool pottenStatus; // 1 när kommunikation upprättas mellan MCU och IC bool radioStatus; // 1 när kommunikation upprättas mellan MCU och IC int volym = 15; // standard volymnivå med IC börjar med

Sedan satte vi upp en GPIO-stift med namnet Relay_Pin för att slå på eller stänga av förstärkaren.

#define Relay_Pin D7 // Denna stift används för att slå på och av radion

Därefter måste vi definiera alla nödvändiga definitioner för att kommunicera med Adafruit IO.

#define AIO_SERVER "io.adafruit.com" #define AIO_SERVERPORT 1883 // use 8883 for SSL #define AIO_USERNAME "debashis13" // Byt ut det med ditt användarnamn #define AIO_KEY "aio_Qyal47xo1fYhc55QB1lEPEirnoFp"

Nedanstående definitioner FIX_BAND är en egen definition som används av biblioteket.

Nästa definierade uttalande ställer in modulens interna volym.

#define FIX_BAND RADIO_BAND_FM // <Bandet stäms av denna skiss är FM. #define FIX_RADIO_VOLUME 6 /// <Modulens standardvolym.

Gör sedan de objekt som krävs för PT2258, RDA5807M och WiFiClient.

PT2258 digitalPot; // PT2258 Objekt RDA5807M-radio; // RDA5807M Object WiFiClient-klient; // WiFiClient-objekt

Ställ sedan in MQTT-klientklassen genom att skicka in WiFi-klienten och MQTT-servern och inloggningsinformation.

Adafruit_MQTT_Client mqtt (& klient, AIO_SERVER, AIO_SERVERPORT, AIO_USERNAME, AIO_KEY);

// Ställ in MQTT-klientklassen genom att skicka in WiFi-klienten och MQTT-servern och inloggningsinformation.

Då måste vi prenumerera på ett flöde. Vad får det dig att fråga?

Om vissa värden, vissa parametrar ändras på Adafruit-servern, kommer ändringarna att återspeglas här.

Adafruit_MQTT_Subscribe Radio_Station = Adafruit_MQTT_Subscribe (& mqtt, AIO_USERNAME "/ feeds / Radio_Station"); // Metoder som används för att prenumerera på ett flöde Adafruit_MQTT_Subscribe Toggle_FM = Adafruit_MQTT_Subscribe (& mqtt, AIO_USERNAME "/ feeds / Toggle_FM"); // Metoder som används för att prenumerera på en Feed Adafruit_MQTT_Subscribe Volume = Adafruit_MQTT_Subscribe (& mqtt, AIO_USERNAME "/ feeds / Volume"); // Metoder som används för att prenumerera på ett flöde

Nedan är funktionsprototypen för MQTT_connect () -funktionen.

ogiltig MQTT_connect (); // Funktionsprototyp för MQTT Connect

Sedan börjar vi vår installationsprocess. Först startar vi UART-kommunikationen med startmetoden.

Serial.begin (9600); // UART börjar Serial.println (); // lägger till en extra rad för avstånd Serial.println (); // lägger till en extra rad för avstånd Därefter gör vi allt det vanliga för att ansluta till WiFI **************** alla vanliga saker som krävs för en WiFi-anslutning ********************** / Serial.print ("anslutning till"); Serial.println (ssid); WiFi-läge (WIFI_STA); WiFi.begin (ssid, lösenord); medan (WiFi.status ()! = WL_CONNECTED) {fördröjning (500); Serial.print ("."); } Serial.println (""); Serial.println ("WiFi-ansluten"); Serial.println ("IP-adress:"); Serial.println (WiFi.localIP ()); / **************** alla vanliga saker som krävs för en WiFi-anslutning **********************

Därefter ring Wire.begin () -metoden för att starta en I2C-anslutning och vi kallar Wire.setClock () -metoden för att fixa I2C-frekvensen till 100 KHz eftersom det är full hastighet för PT2258 IC.

Wire.begin (); // starta I2C-startsekvensen Wire.setClock (100000); // ställer I2C-klockan till 100KHz

Därefter ringer du init () -metoden för både PT2258 och RDA5807 IC och håller returstatusen i de tidigare definierade booléerna.

potStatus = digitalPot.init (); radioStatus = radio.init ();

Kontrollera sedan om MCU kunde kommunicera med IC eller inte. Vi gör detta med två om annars uttalanden.

if (potStatus) {Serial.println ("Hittade PT2258-enhet!"); } annat {Serial.println ("Det gick inte att initiera PT2258"); } if (radioStatus) {Serial.println ("Hittade RDA5807M-enhet!"); } annat {Serial.println ("Det gick inte att initiera RDA5807M"); }

Ring sedan prenumerationsmetoden från MQTT-biblioteket. Vi kommer att meddelas av MQTT-servern om några ändringar inträffar i våra prenumerationer.

mqtt.subscribe (& Radio_Station); // Ställ in MQTT-prenumeration för Radio_Station-flöde mqtt.subscribe (& Toggle_FM); // Ställ in MQTT-prenumeration för Toggle_FM-flöde mqtt.subscribe (& Volym); // Ställ in MQTT-prenumeration för volymflöde

Därefter sätter vi relästiftet som utgång och stiftstatusen till LÅG

pinMode (D7, OUTPUT); digitalWrite (D7, LOW);

Ställ sedan in en förutbestämd radiovolym, den här parametern ställer in den interna volymen på RDA5807 IC, vilket markerar slutet på vår installationsprocess.

radio.setVolume (FIX_RADIO_VOLUME); // nästa ställer vi in normalisera radiovolymen radio.setMono (falsk); // vi vill inte att chipet ger mono-utgång radio.setMute (false); // vi vill inte att chipet ska stängas av i början

Vi startar slingan genom att anropa MQTT_connect () -funktionen som skapar en anslutning till MQTT-servern.

I MQTT-anslutningsfunktionen försöker vi tre gånger skapa en anslutning till MQTT-servern.

Om det lyckas får vi ett framgångsmeddelande annars får vi ett felmeddelande.

ogiltig MQTT_connect () {int8_t ret; // 8-bitars heltal för att lagra försöken // Stopp om det redan är anslutet. if (mqtt.connected ()) {return; } Serial.print ("Ansluter till MQTT…"); uint8_t försöker igen = 3; medan ((ret = mqtt.connect ())! = 0) {// connect returnerar 0 för ansluten Serial.println (mqtt.connectErrorString (ret)); Serial.println ("Försöker igen MQTT-anslutning på 5 sekunder…"); mqtt.disconnect (); fördröjning (5000); // vänta 5 sekunder på nytt--; if (försöker == 0) {// dör i princip och vänta på att WDT återställer mig medan (1); }} Serial.println ("MQTT Connected!"); }

Börja sedan med att skapa en pekare till ett Adafruit_MQTT_Subscribe- objekt. Vi använder detta för att avgöra vilken prenumeration som mottogs.

Adafruit_MQTT_Prenumerera * prenumeration;

Därefter väntar vi på ett prenumerationsmeddelande.

mqtt.readSubscription (timeInMilliseconds) lyssnar på en viss tid för alla meddelanden som kommer från MQTT-servern.

Om det får ett meddelande före timeout, svarar det med en pekare till prenumerationen eller så tar det bara timeout och returnerar 0. I så fall väntar den i 2 sekunder.

medan ((prenumeration = mqtt.readSubscription (20000)))

Om en timeout inträffar misslyckas while loop-fyllningen. Om inte, jämför vi vilken prenumeration och får våra kända prenumerationer.

I den här koden gör vi detta för alla tre av våra prenumerationer.

if (prenumeration == & Toggle_FM) if (prenumeration == & Radio_Station) if (prenumeration == & Volym)

Dessa var de tre viktigaste parametrarna som du behöver förstå i loop-avsnittet.

Detta avsnitt av koden används för att övervaka och ställa in Toggle_FM- flödet.

if (abonnemang == & Toggle_FM) // är det ett meddelande från Toggle_FM-flödet {Serial.print (F ("Got:")); Serial.println ((char *) Toggle_FM.lastread); // skriv ut matningsdata bara för felsökning om (String ((char *) Toggle_FM.lastread) == String ("on")) // vi jämför de mottagna data med en känd parameter i det här fallet förväntar vi oss att "on "kommer från sever {// men innan vi gör det måste vi göra det till en sträng som gör jämförelsen super enkel digitalWrite (D7, HIGH); // om vi får en" on "sträng från servern vi gör D7-stiftet HIGH} om (String ((char *) Toggle_FM.lastread) == String ("off")) // igen söker vi efter strängen från {digitalWrite (D7, LOW); // om vi får en "off" -sträng från servern vi gör D7-stift LOW}}

Detta avsnitt av koden används för att övervaka och ställa in Radio_Station- flödet.

if (abonnemang == & Radio_Station) {Serial.print (F ("Got:")); Serial.println ((char *) Radio_Station.lastread); om (String ((char *) Radio_Station.lastread) == String ("Big FM")) // hör vi efter strängen Big FM {radio.setBandFrequency (FIX_BAND, 9270); // om ovanstående villkor är sanna sätter vi radoi-kanalen till 92,7MHz} // Ovan nämnda process fortsätter nedan om (String ((char *) Radio_Station.lastread) == String ("Red FM")) { radio.setBandFrequency (FIX_BAND, 9350); } om (String ((char *) Radio_Station.lastread) == String ("Radio Mirchi")) {radio.setBandFrequency (FIX_BAND, 9830); }}

Detta avsnitt av koden används för att övervaka och ställa in volymflödet.

om (prenumeration == & Volym) // // hör vi söker efter strängvolym och det är ett heltal i strängformat // Vi måste konvertera tillbaka det till ett heltal för att ändra volymen med hjälp av PT2258 IC Serial.print (F ("Got:")); Serial.println ((char *) Volume.lastread); volume = atoi ((char *) Volume.lastread); // Vi använder metoden atoi () för att konvertera en teckenpekare till en heltalsvolym = karta (volym, 0,100,79,0); // map (value, fromLow, fromHigh, toLow, toHigh) // eftersom pt2258 bara förstår heltalsvärden i dB // kartar vi 0dB - 79dB-värdet till 0% - 100%. digitalPot.setChannelVolume (volym, 0); // trots allt ställer vi in volymen för kanal 0 för PT2258 IC digitalPot.setChannelVolume (volym, 1); // trots allt ställer vi in volymen för kanal 1 på PT2258 IC}}

Testa röststyrd FM-radio med Arduino

För att testa kretsen användes följande apparat-

En transformator som har en 13-0-13 Tap
Två 4Ω 20W högtalare som belastning.
Telefon för att använda Google Assistant.

I en tidigare artikel har jag visat dig hur man gör en enkel 2x32 Watt ljudförstärkare med TDA2050 IC, jag kommer att använda det för denna demonstration, också, Jag har stört den mekaniska potentiometern och kortslutit två ledningar med två små bygelkablar. Nu, med hjälp av två tryckknappar, kunde jag ändra volymen på förstärkaren.

Ytterligare förbättring

Det finns många ytterligare förbättringar av denna krets.

Det finns olika bullerproblem eftersom en ljudkälla fungerar bredvid NodeMCU, så vi måste implementera ytterligare skärmning för att förbättra bullerimmuniteten.
Att bygga den övergripande kretsen till ett kretskort kommer att förbättra bullerimmuniteten.
Ytterligare filter kan läggas till denna IC för att eliminera brus.

Jag hoppas att du gillade den här artikeln och lärde dig något nytt av den. Om du är osäker kan du fråga i kommentarerna nedan eller använda våra forum för detaljerad diskussion.