Använd ett klart microcontrollerpaket för att bygga in Alexa-funktioner i IoT-enheter

Röstassistans har snabbt blivit en viktig funktion i smarta produkter. Bland de molnbaserade lösningarna på marknaden har Amazons Alexa Voice Service (AVS) blivit den främsta röstassistenten. Det hela är en ”nyckelfärdig” lösning som använder Amazons molnresurser för röstigenkänning och bearbetning av naturligt tal.

Men för utvecklarna har prestandakraven och den avancerade strukturen för AVS-systemet blivit ett hinder för att använda det i mikroprocessorbaserade mindre enheter i uppkopplade hem och IoT (Internet of Things). NXP Semiconductors har utvecklat ett paket som ger en färdig lösning och en referensdesign för anpassade tillämpningar, vilket gör det möjligt att använda Amazons AVS i resursbegränsade enheter.

I den här artikeln beskriver vi hur utvecklarna snabbt kan implementera ”inbyggda Alexa-funktioner” med hjälp av den färdiga lösningen från NXP.

Vad är AVS?

Röstassistans dök upp på marknaden för ungefär ett årtionde sedan. Sedan dess har tekniken utvecklats snabbt och blivit en viktig drivkraft på marknaden för smarta högtalare, som enligt marknadsanalytikerna inkluderar ungefär en tredjedel av den amerikanska befolkningen. Exempel på smarta högtalare är Amazon Echo, som har den största andelen av marknaden och innefattar Amazon Web Services-tekniken (AWS) för att kunna leverera molnbaserade resurser som stöd för kompatibla Echo-appar, så kallade Skills.

Med Alexa Skills Kit (ASK) och tillhörande programmeringsgränssnitt (API:er) kan utvecklarna dra fördel av den snabbt växande installerade basen av smarta Echo-högtalare, för att utrusta anslutna enheter med röststyrning. Metoden gör det möjligt för anslutna produkter som ”fungerar med Alexa” – exempelvis smarta tv-apparater eller termostater – att svara på användarens röstkommandon och motsvarande instruktioner som tas emot från Alexa-molnet (figur 1). Ovanstående översiktliga beskrivning av AVS ger en uppfattning om teknikens potential.

Figur 1: Genom att bygga Alexa-appar, s.k. Skills, kan utvecklarna få anslutna produkter att samverka med användarens röstkommandon via Amazons Echo-produkter. (Bildkälla: Amazon Web Services)

Inbyggt Alexa

Vid sidan av produkter som ”fungerar med Alexa” finns produkter med ”inbyggt Alexa” (Alexa Built-in). Inbyggt Alexa ger ett mer sömlöst, fördröjningsfritt gränssnitt mellan enheten och AWS-resurserna. I denna typ av produkter är AVS direkt integrerat i den anslutna enheten. Genom att kombinera AVS med AWS IoT Core-plattformen kan utvecklaren implementera avancerade IoT-tillämpningar som gör det möjligt för användarna att röststyra anslutna enheter och ta emot röstsvar från dem (figur 2).

Figur 2: Alexa-kompatibla enheter med ett röstgränssnitt för att styra enheter (överst) eller ta emot meddelanden från IoT-enheter (längst ner) anslutna till Amazon Web Services-resurser via AWS IoT Core. (Bildkälla: Amazon Web Services)

Tidigare har det krävts betydande insatser bara för att utveckla de Alexa-kompatibla enheter som är förutsättningen för den här typen av IoT-tillämpningar. Det krävdes att enheten körde flera AVS-tjänstbibliotek via AVS-apparatens SDK (software development kit) på en Android- eller Linux-plattform, för att identifiera väckningsord, kommunicera med Alexa-molnet och bearbeta instruktioner för kompatibla funktioner (figur 3).

Figur 3: Komponenterna i AVS-enhetens SDK och hur data flödar mellan dem. (Bildkälla: Amazon Web Services)

För att ge stöd för bibliotekstjänsterna och klara AVS-bearbetningen måste de Alexa-kompatibla enheterna vanligen ha en kraftfull applikationsprocessor och minst 50 Mb minne. Oftast innehöll enheterna dessutom en digital signalbehandlare (DSP) för att köra de avancerade algoritmer som krävdes för att urskilja röstljud i bullriga miljöer och ge stöd för röststyrning på längre avstånd. Systemkraven för att bygga en effektiv Alexa-kompatibel enhet ledde i slutändan till kostnader och komplexitet som var orimliga för normala IoT-enheter.

Genom att introducera AVS Integration för AWS IoT Core, sänkte Amazon drastiskt processorbelastningen och den minnesmängd som krävs för produkter med inbyggt Alexa. Tjänsten förflyttar beräknings- och minnesintensiva uppgifter från den Alexa-kompatibla enheten till en virtuell enhet i molnet (figur 4).

Figur 4: Med AVS för AWS IoT Core flyttas minnes- och beräkningsintensiva uppgifter till molnet, vilket gör det möjligt att implementera Alexa-assistentfunktioner i resursbegränsade IoT-enheter. (Bildkälla: Amazon Web Services)

Den fysiska enhetens ”bearbetningsansvar” reduceras till att leverera enklare tjänster, såsom säkra meddelandefunktioner, tillförlitliga ljuddata till och från Alexa, uppgiftshantering och händelsekommunikation inom enheten och med Alexa. Överföring av data, kommandon och meddelanden mellan den fysiska enheten och Alexa sker med hjälp av effektiva MQTT-meddelanden (MQ Telemetry Transport), under ett fåtal reserverade rubriker i publish-subscribe-protokollet MQTT. En tillhörande mobilapp interagerar med Alexa-molnet för enhetsregistrering och annan nödvändig användarinteraktion.

Eftersom AVS för AWS IoT Core flyttar den tunga bearbetningen till molnet, kan utvecklarna skapa produkter med ”inbyggt Alexa” genom att använda plattformar som de förmodligen är mycket mer vana vid. I stället för applikationsprocessorer med 50 Mbyte minne som körs på Linux eller Android, kan utvecklarna använda enklare microcontrollers med mindre än 1 Mbyte RAM som kör RTOS-programvara (realtidsoperativsystem). Komponentlistan för Alexa-kompatibla system byggda med AVS för AWS IoT Core kan bli hälften så lång, jämfört med system som är byggda för att köra hela uppsättningen av AVS-tjänster lokalt.

Att skapa en produkt med inbyggda Alexa-funktioner förblir en komplex uppgift, även om AVS för AWS IoT Core stöder en mycket mer kostnadseffektiv körtidsplattform. Utvecklare som inte är vana vid AVS och IoT Core kan ställas inför en brant inlärningskurva när de ska uppfylla AWS-kraven gällande säkerhet, kommunikation, kontohantering, design av användarupplevelse osv. Bortsett från eventuell vana av AWS-ekosystemet måste alla Alexa-produktutvecklare säkerställa att systemen uppfyller en rad specifikationer och krav om de ska bli godkända för Amazons Alexa-certifiering.

NXP:s microcontrollerbaserade lösning för Alexa erbjuder en färdig systemlösning som implementerar enhetssidans alla maskinvaru- och programvarukrav för Amazons AVS för AWS IoT Core.

Microcontrollerbaserad Alexa-lösning

Microcontrollern NXP i.MX RT106A är centrum i NXP SLN-ALEXA-IOT AVS-paketet, som ger AWS-anslutning, AVS-kvalificerade algoritmer för fjärrljud, ekoutsläckning, Alexa-väckningsord och applikationskod. Paketets i.MX RT106A-microcontroller baseras på en Arm Cortex-M7-kärna och är en del av i.MX RT106x-familjen av crossover-processorer som är specifikt utvecklade för edge computing för IoT. RT106A – byggd för inbäddade rösttillämpningar – adderar specialfunktioner till i.MX RT1060-processorfamiljens breda uppsättning av periferigränssnitt. Den erbjuder också större internminne och brett stöd för externa minnesalternativ (figur 5).

Figur 5: i.MX RT1060 – NXP:s familj av crossover-processorer integrerar en Arm Cortex-M7-microcontrollerkärna med en komplett uppsättning av periferigränssnitt, minne och annan kapacitet som vanligen krävs i en IoT-enhet. (Bildkälla: NXP)

Tack vare all integrerad kapacitet behöver i.MX RT106A-microcontrollern endast ett fåtal ytterligare komponenter för att erbjuda den maskinvara som krävs för att implementera AVS för AWS IoT Core. I sitt SLN-ALEXA-IOT-paketet integrerar NXP en i.MX RT106A-microcontroller i en systemmodul med 256 Mbit flashminne, Murata Electronics Wi-Fi/Bluetooth-transceivermodul LBEE5KL1DX samt Diodes buck-omvandlare AP2202K-3.3TRG1 (figur 6).

Figur 6: I NXP:s SLN-ALEXA-IOT AVS-systemmodul används det enkla maskinvarugränssnittet för att integrera i.MX RT106A-microcontrollern med externt flashminne och en trådlös transceiver. (Bildkälla: NXP)

Ett röstkort i SLN-ALEXA-IOT-paketet innehåller tre Knowles SPH0641LM4H-1 pulsdensitetsmodulerade (PDM) MEMS-mikrofoner, en PUI Audio AS01808AO-högtalare och en NXP TFA9894D-ljudförstärkare av klass D. Utöver en USB Type C-anslutning för att driva paketet och köra ett konsolgränssnitt från en persondator, erbjuder röstkortet stiftlistkontakter för Ethernet, seriellt ansluten kringutrustning och i.MX RT106A-microcontrollerns GPIO (general purpose input/output). Slutligen innefattar kortet switchar för grundläggande hantering av inmatad styrdata, samt lysdioder för visuell återkoppling i enlighet med Amazons krav för AVS UX Attention System, där olika LED-färger och på- och av-cykler används.

Med systemmodulen och röstkortet ger SLN-ALEXA-IOT-maskinvaran en fullständig plattform för att hantera AVS för AWS IoT Core-programvaran på enhetssidan. För Alexa-kompatibla IoT-system är dock optimerad programvara lika viktigt som maskinvaran, vilket har nämnts ovan. Att med Amazons AVS for AWS IoT API skapa programvara från grunden kan förlänga projekttiden kraftigt, eftersom utvecklaren måste bygga nödvändiga dataobjekt och implementera associerade protokoll. Det hela kan ytterligare försvåras om utvecklaren, som kanske siktar på Alexa-certifiering av produkten, försöker efterleva AVS UX Attention System-kraven, AWS-säkerhetsrutinerna och andra krav som måste uppfyllas för att få in Alexa-tjänsterna i konstruktionen. NXP hjälper till med det här, genom att erbjuda en omfattande körtidsmiljö för röststyrning, baserat på Amazons FreeRTOS, byggt på ett lager av programvarudrivrutiner för XIP-flash (execute-in-place), konnektivitet och andra maskinvarukomponenter (figur 7).

Figur 7: NXP:s röststyrningsmiljö, baserad på Amazons FreeRTOS, erbjuder en rad mellanprogramvarutjänster, exempelvis firmware-rutiner för ML-inferens (Machine Learning) och en frontend för ljudbearbetning. (Bildkälla: NXP)

Under programvarumiljöns röststyrningsfunktioner finns NXP:s Intelligent Toolbox-firmware, som ger optimerade funktioner för alla ljuduppgifter, inklusive en ML-inferensmotor och en ML-frontend för konditionering och optimering av ljudsignaler. Andra mellanprogramvarutjänster ger stöd för säker anslutning, AWS-kommunikation och ljudhantering. Över detta omfattande tjänstlager finns programvara för AWS IoT Core, onboarding och andra kontrollfunktioner som startar från en tvåstegs bootloader med stöd för OTA-uppdateringar (over-the-air), baserat på AWS IoT OTA-tjänsten och Amazons FreeRTOS OTA-klient.

Genom att använda den fabriksinstallerade programvaran i denna miljö kan utvecklaren omedelbart få tillgång till SLN-ALEXA-IOT-maskinvarupaketet med en komplett Alexa-kompatibel applikation utformad för att använda ett NXP-demokonto för AWS IoT. NXP-dokumentationen ger en detaljerad genomgång av hur man får tillgång till paketet, distribuerar Wi-Fi-behörighet och utför AWS-enhetsautentisering via demokontot. Under processens gång interagerar utvecklaren med paketet och AWS via en Android-app som ingår i ett programdistributionspaket som man hämtar på NXP-webbplatsen genom att ange den aktiveringskod som medföljer varje SLN-ALEXA-IOT-paket. Efter ett antal enkla åtgärder kan utvecklaren börja interagera med paketet genom att använda samma sorts Alexa-röstkommandon som erbjuds av smarta Echo-högtalare.

För snabb prototypkonstruktion av produkter med Alexa-funktioner ger SLN-ALEXA-IOT-paketet och den fabriksinstallerade programvaran en färdig plattform. Paketets maskinvara och programvara fungerar samtidigt som effektiv utvecklingsplattform för att skapa anpassade Alexa-kompatibla system baserat på microcontrollern i.MX RT106A.

Anpassad utveckling

Programvara för i.MX RT106A-baserade Alexa-lösningar nyttjar funktionerna i NXP-körtidsmiljön för röststyrning. Det sker via NXP:s MCU Alexa Voice IoT-SDK, som tillhandahålls som del av det programdistributionspaket som blir tillgängligt vid produktaktiveringen. SDK-paketet – ett tillägg till NXP:s Eclipse-baserade MCUXpresso-IDE (integrated development environment) – innehåller komplett källkod för demoapplikationer, kombinerat med drivrutiner och mellanprogramvara med headers för binära distributioner av specialiserad firmwarekapacitet såsom NXP Intelligent Toolbox, ML-inferensmotor och ML-ljud-frontend.

Utvecklare som vill distribuera en Alexa-kompatibel produkt snabbt kan i princip använda hela Alexa-demoapplikationen med några mindre modifieringar. En sådan modifiering kan, i det enklaste scenariot, innebära att utvecklaren riktar om applikationen till sitt eget AWS-konto, med de egna inloggningsuppgifterna. NXP ger en steg-för-stegbeskrivning av hur det utförs.

För anpassad utveckling kan man använda de demoapplikationer som ingår i distributionspaketet. De är körbara exempel på hur man arbetar med NXP MCU Alexa Voice IoT SDK. I stället för att direkt börja använda den kompletta Alexa-applikationen kan utvecklaren utforska enskilda demoapplikationer för specifika funktioner, såsom en ljud-frontend, Wi-Fi- och Bluetooth-anslutning, bootloading osv. Till exempel kan demoapplikationen för en ljud-frontend ge information om den grundläggande strukturen för att detektera väckningsord med hjälp av Amazons FreeRTOS-uppgifter.

Huvudrutinen i demoapplikationen för en ljud-frontend visar hur utvecklaren kan initiera maskinvaru- och programvarusystem och sedan använda FreeRTOS xTaskCreate-funktion för att starta huvudprogrammet (appTask) och en konsolgränssnittsuppgift (sln_shell_task), innan kontrollen överförs till FreeRTOS-schemaläggaren (program 1). (Obs: vTaskStartSchedulers anrop för att starta FreeRTOS-schemaläggaren returneras endast om schemaläggaren inte har tillräckligt med minne.)

Copy void main(void) {     /* Enable additional fault handlers */     SCB->SHCSR |= (SCB_SHCSR_BUSFAULTENA_Msk | /*SCB_SHCSR_USGFAULTENA_Msk |*/ SCB_SHCSR_MEMFAULTENA_Msk);       /* Init board hardware. */     BOARD_ConfigMPU();     BOARD_InitBootPins();     BOARD_BootClockRUN(); .
.
.
RGB_LED_Init();     RGB_LED_SetColor(LED_COLOR_GREEN);       sln_shell_init();       xTaskCreate(appTask, "APP_Task", 512, NULL, configMAX_PRIORITIES - 1, &appTaskHandle);     xTaskCreate(sln_shell_task, "Shell_Task", 1024, NULL, tskIDLE_PRIORITY + 1, NULL);       /* Run RTOS */     vTaskStartScheduler(); .
.
.
\}

Program 1: NXP MCU Alexa Voice IoT SDK-distributionen innehåller en demoapplikation för en ljud-frontend. Den visar hur man initierar och skapar FreeRTOS-uppgifter för huvudprogrammet, och en konsolgränssnittsuppgift. (Kodkälla: NXP)

När ljuddelsystemet har initierats startar appTask (huvudprogrammet) två FreeRTOS-uppgifter. En uppgift kör en tjänstrutin, audio_processing_task, som bearbetar ljud-indata. Den andra uppgiften konverterar mikrofonens PDM-utdata till pulskodsmodulering (PCM). Efter ytterligare lite ”hushållsgöra” stannar appTask i en loop, medan den väntar på ett RTOS-meddelande som säger att väckningsordet har upptäckts (program 2).

Copy
void appTask(void *arg)
{
.
.
.
    // Create audio processing task
    if (xTaskCreate(audio_processing_task, "Audio_processing_task", 1536U, NULL, audio_processing_task_PRIORITY,
                    &xAudioProcessingTaskHandle) != pdPASS)
.
.
.
    // Create pdm to pcm task
    if (xTaskCreate(pdm_to_pcm_task, "pdm_to_pcm_task", 1024U, NULL, pdm_to_pcm_task_PRIORITY, &xPdmToPcmTaskHandle) !=
        pdPASS)
.
.
.
    RGB_LED_SetColor(LED_COLOR_OFF);
 
    SLN_AMP_WriteDefault();
 
    uint32_t taskNotification = 0;
    while (1)
    {
        xTaskNotifyWait(0xffffffffU, 0xffffffffU, &taskNotification, portMAX_DELAY);
 
        switch (taskNotification)
        {
            case kWakeWordDetected:
            {
                RGB_LED_SetColor(LED_COLOR_BLUE);
                vTaskDelay(100);
                RGB_LED_SetColor(LED_COLOR_OFF);
 
                break;
            }
 
            default:
                break;
        }
 
        taskNotification = 0;
    }
}

Program 2: I demoapplikationen för en ljud-frontend startar huvudprogrammet, appTask, uppgifter för att hantera ljudbearbetning och datakonvertering, och väntar sedan på ett FreeRTOS-meddelande (taskNotification) om att väckningsordet har upptäckts (kWakeWordDetected). (Kodkälla: NXP)

Ljudbearbetningsuppgiften i demoapplikationen initierar väckningsordets firmware-funktion och detekteringsparametrar innan den (liksom appTask) går in i en loop, där den väntar på ett FreeRTOS-meddelande (från mikrofondatakonverteringsuppgiften) om att bearbetade mikrofondata är tillgängliga. Ljudbearbetningsuppgiften anropar i det här skedet Intelligent Toolbox-firmwarefunktioner som bearbetar ljuddata och detekterar väckningsord med hjälp av ML-inferensmotorn (program 3).

Copy void audio_processing_task(void *pvParameters) { .
.
.
    SLN_AMAZON_WAKE_Initialize();
    SLN_AMAZON_WAKE_SetWakeupDetectedParams(&wakeWordActive, &wwLen);
 
    while (1)
    {
        // Suspend waiting to be activated when receiving PDM mic data after Decimation
        xTaskNotifyWait(0U, ULONG_MAX, &taskNotification, portMAX_DELAY);
 
.
.
.
        // Process microphone streams
        int16_t *pcmIn = (int16_t *)((*s_micInputStream)[pingPongIdx]);
        SLN_Voice_Process_Audio(g_externallyAllocatedMem, pcmIn,
                                &s_ampInputStream[pingPongAmpIdx * PCM_SINGLE_CH_SMPL_COUNT], &cleanAudioBuff, NULL,
                                NULL);
 
        // Pass output of AFE to wake word
        SLN_AMAZON_WAKE_ProcessWakeWord(cleanAudioBuff, 320);
        taskNotification &= ~currentEvent;
 
        if (wakeWordActive)
        {
            wakeWordActive = 0U;
 
            // Notify App Task Wake Word Detected
            xTaskNotify(s_appTask, kWakeWordDetected, eSetBits);
        }
    }
}

Program 3: Ljudbearbetningsuppgiften i demoapplikationen för en ljud-frontend initeriar firmwaremotorn för väckningsordet, väntar på ett FreeRTOS-meddelande om att mikrofondata är tillgänglig och anropar slutligen en analog Intelligent Toolbox-frontend (SLN_Voice_Process_Audio) och ML-inferensmotor (SLN_AMAZON_WAKE_ProcessWakeWord) för detektering av väckningsord. (Kodkälla: NXP)

När väckningsordet har detekterats, utfärdar ljudbearbetningsuppgiften ett FreeRTOS-meddelande för att upplysa huvudprogrammet, appTask, om händelsen. När appTask har tagit emot meddelandet blinkar den blåa LED-lampan en gång (se program 2 igen).

Den kompletta Alexa-demoapplikationen har samma struktur som frontend-applikationen, men är mycket längre och utförligare, för att stödja Alexa-funktionerna fullt ut. Till exempel, efter att ML-inferensmotorn upptäcker väckningsordet i Alexa-demoapplikationen, utför ljudbearbetningsuppgiften en sekvens av FreeRTOS-meddelanden motsvarande varje skede av Alexa-bearbetningssekvensen (program 4).

Copy void audio_processing_task(void *pvParameters) { .
.
.
    SLN_AMAZON_WAKE_Initialize();
    SLN_AMAZON_WAKE_SetWakeupDetectedParams(&u8WakeWordActive, &wwLen);
 
    while (1)
    {
        // Suspend waiting to be activated when receiving PDM mic data after Decimation
        xTaskNotifyWait(0U, ULONG_MAX, &taskNotification, portMAX_DELAY);
.
.
.
        int16_t *pcmIn = (int16_t *)((*s_micInputStream)[pingPongIdx]);
        SLN_Voice_Process_Audio(g_w8ExternallyAllocatedMem, pcmIn,
                                &s_ampInputStream[pingPongAmpIdx * PCM_SINGLE_CH_SMPL_COUNT], &pu8CleanAudioBuff, NULL,
                                NULL);
              SLN_AMAZON_WAKE_ProcessWakeWord((int16_t*)pu8CleanAudioBuff, 320);
        taskNotification &= ~currentEvent;
 
        // If devices is muted, then skip over state machine
        if (s_micMuteMode)
        {
            if (u8WakeWordActive)
            {
                u8WakeWordActive = 0U;
            }
 
            memset(pu8CleanAudioBuff, 0x00, AUDIO_QUEUE_ITEM_LEN_BYTES);
        }
 
        if (u8WakeWordActive)
        {
            configPRINTF(("Wake word detected locally\r\n"));
        }
 
        // Execute intended state
        switch (s_audioProcessingState)
        {
            case kIdle:
 
                /* add clean buff to cloud wake word ring buffer */
                continuous_utterance_samples_add(pu8CleanAudioBuff, PCM_SINGLE_CH_SMPL_COUNT * PCM_SAMPLE_SIZE_BYTES);
                if (u8WakeWordActive)
                {
                    continuous_utterance_buffer_set(&cloud_buffer, &cloud_buffer_len, wwLen);
 
                    u8WakeWordActive = 0U;
                    wwLen = 0;
                    // Notify App Task Wake Word Detected
                    xTaskNotify(s_appTask, kWakeWordDetected, eSetBits);
 
                    // App Task will now determine if we begin recording/publishing data
                }
 
                break;
.
.
.
            case kWakeWordDetected:
 
                audio_processing_reset_mic_capture_buffers();
                // Notify App_Task to indicate recording
                xTaskNotify(s_appTask, kMicRecording, eSetBits);
 
                if (s_audioProcessingState != kMicRecording)
                {
                    s_audioProcessingState = kMicCloudWakeVerifier;
                }
 
                configPRINTF(("[audio processing] Mic Recording Start.\r\n"));
                // Roll into next state
 
            case kMicCloudWakeVerifier:
            case kMicRecording:
 
                micRecordingLen = AUDIO_QUEUE_ITEM_LEN_BYTES;
                if (u8WakeWordActive)
                {
                    u8WakeWordActive = 0U;
                }
 
                // Push data into buffer for consumption by AIS task
                status = audio_processing_push_mic_data(&pu8CleanAudioBuff, &micRecordingLen);
.
.
.
    \}
\}

Program 4: Den fullständiga Alexa-applikationen innehåller ytterligare kod för de bearbetningssteg som utförs i ljud-frontend-applikationen, för hantering av efterföljande steg i Alexa-sekvensen. (Kodkälla: NXP)

Den fullständiga Alexa-applikationens ljudbearbetningsuppgift meddelar huvudprogrammet vid lokal ML-detekering av väckningsord, så som beskrivs ovan. Det måste nu dessutom hantera ljudbearbetningstillstånd där mikrofonen hålls öppen för att inhämta fullständig ljuddata för talbearbetning i Alexa-molnet, utan att förlora den ursprungliga dataström som innehåller det lokalt detekterade väckningsordet. Den fullständiga dataströmmen skickas till Alexa-molnet för verifiering av väckningsordet och för ytterligare talbearbetning.

I varje skede av den här bearbetningssekvensen skickar ljudbearbetningsuppgiften motsvarande FreeRTOS-meddelanden till huvudprogrammet. Precis som för ljudbearbetningsuppgiften, utökar den kompletta Alexa-applikationen det huvudprogram som presenteras i en förenklad version i ljud-frontend-applikationen. Den kompletta Alexa-applikationens huvudprogram, appTask, genererar nu händelser både för överföring till Alexa-molnet och för hantering av modulens lysdioder, i enlighet med kraven för Amazon AVS UX Attention System. När till exempel mikrofonen hålls öppen efter detektering av väckningsordet, meddelar ljudbearbetningsuppgiften huvudprogrammet, som aktiverar rätt UX-varningsstatus (lila LED-lampa med fast sken) (se de gulmarkerade segmenten i program 5 och motsvarande markering i program 4).

Copy
void appTask(void *arg)
{
.
.
.
// Create audio processing task if (xTaskCreate(audio_processing_task, "Audio_proc_task", 1536U, NULL, audio_processing_task_PRIORITY, &xAudioProcessingTaskHandle) != pdPASS) .
.
.
// Create pdm to pcm task if (xTaskCreate(pdm_to_pcm_task, "pdm_to_pcm_task", 512U, NULL, pdm_to_pcm_task_PRIORITY, &xPdmToPcmTaskHandle) != pdPASS) .
.
.
    while(1)
    {
 
        xTaskNotifyWait( ULONG_MAX, ULONG_MAX, &taskNotification, portMAX_DELAY );
 
        if (kIdle & taskNotification)
        {
            // Set UX attention state
            ux_attention_set_state(uxIdle);
 
            taskNotification &= ~kIdle;
        }
 
        if (kWakeWordDetected & taskNotification)
        {
            if (reconnection_task_get_state() == kStartState)
            {
                if (!AIS_CheckState(&aisHandle, AIS_TASK_STATE_MICROPHONE))
                {
                    // Set UX attention state
                    ux_attention_set_state(uxListeningStart);
.
.
.
// Begin sending speech micOpen.wwStart = aisHandle.micStream.audio.audioData.offset + 16000; micOpen.wwEnd = aisHandle.micStream.audio.audioData.offset + audio_processing_get_wake_word_end(); micOpen.initiator = AIS_INITIATOR_WAKEWORD; AIS_EventMicrophoneOpened(&aisHandle, &micOpen); // We are now recording audio_processing_set_state(kWakeWordDetected); } } else { ux_attention_set_state(uxDisconnected); audio_processing_set_state(kReconnect); } taskNotification &= ~kWakeWordDetected; } .
.
.
 
        if (kMicRecording & taskNotification)
        {
            // Set UX attention state and check if mute is active
            // so we don't confuse the user
            if (audio_processing_get_mic_mute())
            {
                ux_attention_set_state(uxMicOntoOff);
            }
            else
            {
                ux_attention_set_state(uxListeningActive);
            }
 
            taskNotification &= ~kMicRecording;
        }
.
.
.

Program 5: I den kompletta Alexa-applikationen är det huvudprogrammet som dirigerar Alexa-bearbetningssekvensen, inklusive lysdioderna, i enlighet med kraven för Alexa-certifiering. (Kodkälla: NXP)

Huvudprogrammet i den kompletta Alexa-applikationen utökar den struktur som används i ljud-frontend-applikationen. I det här fallet skapar huvudprogrammet också ytterligare FreeRTOS-uppgifter för utförligare initiering, samt uppgifter för att hantera paketets knappar och stöd för OTA-uppdateringar.

Genom att vidareutveckla demoapplikationerna kan utvecklaren implementera tillförlitliga inbyggda Alexa-funktioner med hjälp av NXP:s MCU Alexa Voice IoT-SDK i egna i.MX RT106A-baserade system. Plattformen använder AVS för AWS IoT och gör det därmed möjligt för utvecklaren att i högre grad distribuera Alexa-kompatibla lösningar i resursbegränsade lågkostnadsenheter som är grunden för avancerade IoT-tillämpningar.

Slutsats

Amazon Alexa Voice Service har gjort det möjligt för utvecklarna att implementera samma röstassistentfunktioner som driver på marknadsutvecklingen för smarta Echo-högtalare. Körningsplattformar med stora lokala minnesresurser och hög bearbetningskapacitet var tidigare en förutsättning för att bygga en produkt som skulle bli godkänd för den åtråvärda Alexa-certifieringen. NXP erbjuder ett paket, byggt med AVS för AWS IoT Core, som ger en färdig lösning för att tillföra inbyggda Alexa-funktioner med endast en microcontroller och en tillhörande programkörningsmiljö.