Implementer hurtigt IoT-designs med "Alexa Built-In" ved hjælp af et mikrocontrollerbaseret kit

Stemmeassistenter har hurtigt udviklet sig til at være en vigtig funktion i ethvert smart-produkt. Blandt de nuværende cloudbaserede løsninger på markedet har Amazons Alexa Voice Service (AVS) tilkæmpet sig pladsen som den dominerende stemmeassistent med sin nøglefærdige funktionalitet, der gør brug af Amazon-cloudressourcer til stemmegenkendelse og processering af naturligt sprog.

For udviklere har kravene til ydeevne samt designkompleksiteten i AVS vist sig at være en væsentlig adgangsbarriere for mindre mikroprocessorbaserede enheder til det internetopkoblede hjem og Internet of Things (IoT). Et kit fra NXP Semiconductors er designet som en drop-in-løsning med referencedesign til specialbyggede applikationer og giver en specialdesignet mulighed for anvendelse af Amazon AVS særligt for enheder med begrænsede ressourcer.

I denne artikel kan du se, hvordan udviklere hurtigt kan implementere designs, hvor Alexa er indbygget, ved hjælp af en installationsklar løsning fra NXP.

Hvad er AVS?

Siden den så dagens lys for ti år siden, har stemmeassistentteknologien udviklet sig med lynets hast og har skabt et vækstmarked for smarthøjttalere, som markedsanalytikere vurderer, allerede omfatter omkring en tredjedel af USA's befolkning. Amazon Echo-smarthøjttalere har fået en dominerende markedsandel blandt de konkurrerende løsninger ved at benytte sig af Amazon Web Services (AWS) til levering af cloudbaserede ressourcer til understøttelse af tredjeparts Echo-apps eller Skills.

Ved hjælp af Alexa Skills Kit (ASK) og de tilknyttede programmeringsgrænsesnit (API'er) kan udviklere benytte sig af den hastigt voksende base af installerede Echo-smarthøjttalere for at give deres forbundne enheder et vist niveau af stemmestyring. Med denne tilgang kan tilsluttede produkter som smart-tv'er eller termostater, som "fungerer sammen med Alexa", reagere på brugerens stemmekommandoer og tilsvarende retningslinjer, der modtages fra Alexas cloud (figur 1). Dette opsummerer AVS og giver et smugkig på dens potentiale.

Figur 1: Ved at bygge Alexa-apps eller Skills kan udviklere gøre tilsluttede produkter i stand til at interagere med brugernes stemmekommandoer via Amazon Echo-produkter. (Billedkilde: Amazon Web Services)

Alexa Built-in-design

I modsætning til produkter, der "fungerer sammen med Alexa", giver smartprodukter, hvor Alexa er indbygget ("Alexa Built-in"), et mere sømløst interface med lav latenstid mellem den stemmeaktiverede Alexa-enhed og AWS-ressourcer. Disse produkter integrerer AVS direkte i designet af en tilsluttet enhed. Ved at bruge AVS i kombination med AWS IoT Core-platformen kan udviklere implementere sofistikerede IoT-applikationer, hvormed brugerne kan bruge stemmekommandoer sammen med Alexa-aktiverede produkter til både at styre tilsluttede enheder og at modtage talte svar fra disse enheder (figur 2).

Figur 2: Alexa-aktiverede enheder giver brugere et stemmeinterface til at styre enheder (øverst) eller modtage meddelelser fra IoT-enheder (nederst), som er forbundet til Amazon Web Services-ressourcer gennem AWS IoT Core. (Billedkilde: Amazon Web Services)

Tidligere har designs til de Alexa-aktiverede enheder, der ligger til grund for denne type IoT-applikation, krævet en større designmæssig indsats i sig selv. For at bruge cloudbaserede Alexa-tjenester skal enheden køre de adskillige AVS-tjenestebiblioteker, der leveres via AVS-enhedens softwareudviklingskit (SDK), der kører på Android- eller Linux-platforme, til at registrere vækkeordet, kommunikere med Alexas cloud og behandle retningslinjer for understøttede funktionaliteter (figur 3).

Figur 3: Dette diagram illustrerer komponenterne i AVS Device SDK, samt hvordan data strømmer mellem dem. (Billedkilde: Amazon Web Services)

For at understøtte disse tjenestebiblioteker skal Alexa-aktiverede enhedsdesigns typisk bruge en højtydende applikationsprocessor og mindst 50 megabyte (MB) hukommelse for at leve op til behandlingskravene for AVS. Derudover vil disse designs ofte inkorporere en digital signal-processor (DSP) til at køre de komplekse algoritmer, der kræves for at udtrække stemmelyd i støjende omgivelser og understøtte den fjernfelt-stemmefunktionalitet, der forventes af enheder med stemmeassistent. Systemkravene, der har været forbundet med at bygge en effektiv Alexa-aktiveret enhed, har i sidste ende ofte været langt mere omkostningstunge og komplekse, end der ellers er behov for i praktiske IoT-enheder.

Med frigivelsen af deres AVS-integration til AWS IoT Core har Amazon drastisk reduceret arbejdsbyrden på processoren samt den mængde hukommelse, der kræves for at implementere "Alexa Built-in"-produkter. Med denne tjeneste flyttes beregnings- og hukommelsesintensive opgaver fra den Alexa-aktiverede enhed til en tilknyttet virtuel enhed i skyen (figur 4).

Figur 4: AVS til AWS IoT Core flytter hukommelses- og behandlingsintensive opgaver til skyen for at gøre det muligt at implementere Alexa-stemmeassistentfunktionalitet på ressourcebegrænsede IoT-enheder. (Billedkilde: Amazon Web Services)

Den fysiske enheds behandlingsopgaver begrænses til mere enkle tjenester som sikre meddelelser, pålidelig levering af lyddata til og fra Alexa, opgaveadministration og hændelsesmeddelelser i enheden og med Alexa. Overførsel af data, kommandoer og meddelelser mellem den fysiske enhed og Alexa foregår via effektive MQTT-meddelelser (MQ Telemetry Transport), hvor der anvendes nogle få reserverede emner i MQTT-publish-subscribe-protokollen. Endelig interagerer en ledsagermobilapp med Alexas cloud for registrere enheden samt eventuel anden nødvendig brugerinteraktion med den Alexa-aktiverede enhed.

Ved at flytte de behandlingstunge opgaver til skyen giver AVS for AWS IoT Core udviklere mulighed for at skabe produkter med "Alexa Built-in" med platforme, som er mere velkendte for udviklere af integrerede systemer. I stedet for at skulle bruge applikationsprocessorer med 50 MB hukommelse, der kører på Linux eller Android, kan udviklere implementere disse designs med mere beskedne mikrocontrollere med mindre end 1 MB RAM, der kører RTOS-software (real-time operating system). Faktisk kan Alexa-aktiverede designs, som er bygget med AVS for AWS IoT Core opnå en 50 % reduktion på materialelisten i sammenligning med designs, der er bygget til at køre hele pakken af AVS-tjenester lokalt.

Selvom AVS for AWS IoT Core understøtter en mere omkostningseffektiv runtime-platform, er det stadig en kompleks opgave at implementere et certificeret Alexa Built-in-produkt. Udviklere, som ikke har forudgående kendskab til AVS og IoT Core, kan komme til at møde en stejl læringskurve i arbejdet med AWS-kravene til sikkerhed, kommunikation, kontoadministration, design af brugeroplevelse (UX) og meget mere. Uanset om de kender til AWS-økosystemet eller ej, skal alle Alexa-produktudviklere sikre sig, at deres designs overholder en længere række specifikationer og krav for at gøre sig fortjent til Amazon Alexa-certificering.

NXP's mikrocontrollerbaserede løsning til Alexa giver en løsning med et nøglefærdigt system, som fuldt ud implementerer kravene til hardware og software på enhedssiden til Amazon AVS for AWS IoT Core.

Mikrocontrollerbaseret Alexa-løsning

NXP SLN-ALEXA-IOT AVS-kittet bygger på NXP i.MX RT106A-mikrocontrolleren og giver brugsklar AWS-forbindelse, AVS-kvalificerede fjernfelts-lydalgoritmer, ekkoannullering, funktionalitet til brug af Alexa-vækkeord og applikationskode. Kittets i.MX RT106A-mikrocontroller, som er baseret på en Arm Cortex-M7-kerne, er en del af NXP's i.MX RT106x-familie af crossover-processorer, der er designet specifikt til IoT-edge computing. RT106A er bygget til integrerede stemmeapplikationer og føjer specialiseret funktionalitet til NXP i.MX RT1060-familien af crossover-processorer og dens basisarkitekturs omfattende sæt af periferiinterfaces, omfattende ekstern hukommelse og bred understøttelse af konfigurationer af ekstern hukommelse (figur 5).

Figur 5: NXP i.MX RT1060-familien af crossover-processorer integrerer en Arm Cortex-M7-mikrocontrollerkerne med et fuldt sæt af periferiinterfaces, hukommelse og andre egenskaber, der typisk kræves i en IoT-enhed. (Billedkilde: NXP)

Med sin integrerede funktionalitet skal i.MX RT106A-mikrocontrolleren kun bruge nogle få yderligere komponenter for at udgøre det hardwarefundament, der er nødvendigt for at implementere AVS for AWS IoT Core. I SLN-ALEXA-IOT-kittet integrerer NXP i.MX RT106A-mikrocontrolleren i et systemmodul med 256 megabit (MB) flashhukommelse, Murata Electronics' LBEE5KL1DX Wi-Fi/Bluetooth-transceivermodul og Diodes' AP2202K-3.3TRG1-buck-konverter (figur 6).

Figur 6: Designet af systemmodulet til NXP SLN-ALEXA-IOT AVS-kittet udnytter det simple hardwareinterface, der kræves for at integrere en NXP i.MX RT106A-mikrocontroller med ekstern flash og en trådløs transceiver. (Billedkilde: NXP)

Som tilføjelse til dette systemmodul giver et stemmekort i SLN-ALEXA-IOT-kittet tre Knowles SPH0641LM4H-1-MEMS-mikrofoner med PDM (pulse-density modulation), en PUI Audio AS01808AO-højttaler og en NXP TFA9894D klasse D-audioforstærker. Sammen med et USB Type C-stik til at levere strøm til kittet og til at køre en shell-konsol fra en pc har stemmekortet headerstik til Ethernet, serielle periferienheder og i.MX RT106A-mikrocontrollerens universelle input/output (GPIO). Endelig har kortet kontakter til grundlæggende kontrolinput samt LED'er til visuel feedback i overensstemmelse med Amazon AVS UX Attention System-kravene med brug af forskellige LED-farver samt on/off-cyklusmønstre.

Med sit systemmodul og stemmekort udgør SLN-ALEXA-IOT-hardwaren en komplet platform til behandling på enhedssiden af AVS for AWS IoT Core-software. Som nævnt tidligere afhænger designet af Alexa-aktiverede enheder lige så meget af optimeret software som hardware. At skulle bygge denne software fra bunden med Amazons AVS for AWS IoT-API kan i væsentlig grad forsinke projekter, når udviklerne arbejder sig gennem processen med at bygge de nødvendige dataobjekter og implementere de tilknyttede protokoller. Der kan opstå yderligere forsinkelse, når udviklere, der arbejder hårdt på at opnå Alexa Built-in-certificering, forsøger at overholde AVS UX Attention System, AWS-sikkerhedspraksis og andre krav til hvert af de forskellige aspekter af brugernes interaktioner med Alexa-tjenester i designet. NXP tager hånd om disse bekymringer med sit omfattende runtime-softwaremiljø til stemmestyring, som er baseret på Amazon FreeRTOS og bygger på et lag af softwaredrivere til execute-in-place (XIP) flash, forbindelse og andre hardwarekomponenter (figur 7).

Figur 7: Systemmiljøet for NXP-stemmestyring, der er bygget på Amazon FreeRTOS, giver et omfattende sæt af middleware-tjenester, herunder firmwarerutiner til inferens med maskinel indlæring og audioprocessering i front-enden. (Billedkilde: NXP)

Til grund for dette softwaremiljøs stemmegenkendelsesegenskaber ligger NXP's Intelligent Toolbox-firmware, som leverer optimerede funktioner til alle audioopgaver, herunder inferensfunktion med maskinel indlæring (ML – machine learning) og ML-audio-front-end til behandling og optimering af audiosignaler. Andre middleware-tjenester understøtter sikker forbindelse, AWS-kommunikation og audiofunktionalitet. Oven på dette omfattende tjenestelag formidler software til AWS IoT Core, onboarding og andre applikationsstyringsfunktioner opstarten fra to-faset bootloader med understøttelse af over-the-air (OTA) opdateringer, der bygger på AWS IoT OTA-tjenesten og Amazon FreeRTOS OTA-klienten.

Ved hjælp af den fabriksinstallerede software, der kører i dette miljø, kan udviklere øjeblikkeligt hente SLN-ALEXA-IOT-hardwarekittet frem med en komplet Alexa-aktiveret applikation, som er designet til at anvende en NXP-demonstrationskonto til AWS IoT. NXP-dokumentationen indeholder en detaljeret gennemgang, der beskriver processerne til at hente kittet frem, provisioning af Wi-Fi-legitimationsoplysninger og fuldførelse af AWS-enhedsgodkendelse med demonstrationskontoen. Som en del af denne proces interagerer udviklere med kittet og AWS ved hjælp af en Android-mobilapp, der medfølger i softwaredistributionspakken, som kan hentes fra NXP-webstedet ved hjælp af en aktiveringskode, der leveres sammen med hvert SLN-ALEXA-IOT-kit. Efter nogle få simple trin kan udviklere øjeblikkeligt begynde at interagere med kittet ved hjælp af den samme slags Alexa-stemmeinteraktioner som med Echo-smarthøjttalere.

SLN-ALEXA-IOT-kittet og den fabriksinstallerede software udgør en parat platform til hurtig prototyping af produkter med Alexa-funktionalitet. Samtidig fungerer kittets hardware og software som en hurtig udviklingsplatform til at bygge Alexa-aktiverede designs baseret på i.MX RT106A-mikrocontrolleren.

Tilpasset udvikling

Software til i.MX RT106A-baserede Alexa-løsninger udnytter egenskaberne i NXP-runtime-miljøet til stemmestyring gennem NXP MCU Alexa Voice IoT-softwareudviklingskittet (SDK), der leveres som en del af softwaredistributionspakken, som fås efter aktivering af produktet. Dette SDK, der er designet som en tilføjelse til NXP's Eclipse-baserede integrerede udviklingsmiljø MCUXpresso (IDE), kombinerer fuld kildekode til eksempelapplikationer, drivere og middleware med headerstik til binær-distribution af specialiserede firmwareegenskaber såsom NXP Intelligent Toolbox, inferensfunktion med maskinel indlæring og audio-front-end med maskinel indlæring.

Udviklere, som har brug for hurtigt at udrulle et Alexa-aktiveret produkt, kan i princippet benytte den komplette Alexa-demonstrationsapplikation med mindre modifikationer. I det enkleste tilfælde vil disse modifikationer blot ændre applikationens målretning til udviklerens egen AWS-konto ved hjælp af dennes egne sikkerhedslegitimationsoplysninger. NXP leverer en trinvis beskrivelse til at gennemføre denne proces.

Hvis der er brug for tilpasset udvikling, viser de medfølgende eksempelapplikationer i softwaredistributionspakken eksekverbare eksempler på, hvordan man arbejder med NXP MCU Alexa Voice IoT SDK. I stedet for at springe direkte ind i den komplette Alexa-demonstrationsapplikation kan udviklere udforske eksempelsapplikationer, som giver dem mulighed for at have et mere stramt fokus på specifikke egenskaber, herunder audio-front-end, Wi-Fi og Bluetooth-forbindelse, bootloading med mere. Eksempelvis illustrerer eksempelapplikationen til audio front-end de grundlæggende designmønstre til at køre registrering af vækkeord ved hjælp af Amazon FreeRTOS-opgaver.

I eksempelapplikationen til audio-front-end demonstrerer hovedrutinen, hvordan udviklere kan initialisere hardware- og softwaredelsystemer og derefter bruge FreeRTOS xTaskCreate-funktionen til at starte hovedapplikationsopgaven (appTask) og en konsol-shell-opgave (sln_shell_task), før de overgiver kontrollen til FreeRTOS-scheduleren (post 1). (Bemærk: vTaskStartScheduler-kaldet til start af FreeRTOS-scheduleren returneres kun, hvis scheduleren ikke har tilstrækkelig hukommelse).

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();
.
.
.
}

Post 1: Inkluderet i NXP MCU Alexa Voice IoT SDK-distributionen demonstrerer en eksempelapplikation for audio-front-end de grundlæggende initialiseringskrav og oprettelsen af FreeRTOS-opgaver til hovedapplikationsopgaven og en konsol-shell-opgave. (Kodekilde: NXP)

Efter initialisering af audioundersystemet starter hovedapplikationsopgaven appTask til gengæld et par FreeRTOS-opgaver. Én opgave kører en tjenesterutine, audio_processing_task, som behandler audioinput, mens den anden håndterer konverteringen af mikrofonens PDM-output til pulskodemodulation (PCM). Efter yderligere housekeeping lægger appTask sig fast i en uendelig sløjfe og venter på en RTOS-meddelelse, der betyder, at vækkeordet blev registreret (post 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;
    }
}

Post 2: I eksempelapplikationen for audio-front-end starter hovedapplikationsopgaven, appTask, den opgave, der håndterer audioprocessering og konvertering af mikrofondata og venter derefter på en FreeRTOS-meddelelse (taskNotification) om, at vækkeordet blev registreret (kWakeWordDetected). (Kodekilde: NXP)

Audioprocesseringsopgaven i denne eksempelapplikation initialiserer firmwarens vækkeordsfunktion og initialiserer parametre for vækkeordsregistrering, før den også lægger sig i en uendelig sløjfe, hvor den venter på en FreeRTOS-meddelelse fra opgaven til konvertering af mikrofondata om, at der er behandlede mikrofondata tilgængelige. På dette tidspunkt kalder audioprocesseringsopgaven Intelligent Toolbox-firmwarefunktioner, der behandler audiodataene og udfører vækkeordsregistrering ved hjælp af inferensfunktionen med maskinel indlæring (post 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);
        }
    }
}

Post 3: I eksempelapplikationen for audio-front-end initialiserer audioprocesseringsopgaven firmwarens vækkeordsfunktion, venter på en FreeRTOS-meddelelse om, at der er mikrofondata tilgængelige, og kalder til sidst NXP Intelligent Toolbox-firmwarens analoge front-end (SLN_Voice_Process_Audio) og inferensfunktionen med maskinel indlæring (SLN_AMAZON_WAKE_ProcessWakeWord) for vækkeordsregistrering. (Kodekilde: NXP)

Efter registrering af vækkeord udsteder audioprocesseringsopgaven en FreeRTOS-opgavemeddelelse om at give besked til hovedapplikationsopgaven, appTask, for den pågældende hændelse. Ved modtagelse af denne meddelelse blinker appTask et kort øjeblik med den blå LED (se post 2 igen).

Den komplette Alexa-eksempelapplikation er afhængig af de samme mønstre, der er beskrevet for den mere simple audio-front-end-applikation, men udvider den grundlæggende kodebase til at understøtte fuld Alexa-funktionalitet. Efter at inferensfunktionen med maskinel indlæring registrerer vækkeordet i Alexa-eksempelapplikationen, udfører audioprocesseringsopgaven en række FreeRTOS-meddelelser, som er knyttet til hver fase i Alexa-behandlingssekvensen (post 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);
.
.
.
    }
}

Post 4: I den fulde Alexa-applikation udvider audioprocesseringsopgaven de behandlingstrin, der udføres i audio-front-end-applikationen, med yderligere kode til administration af de efterfølgende audioprocesseringsfaser i Alexa-sekvensen. (Kodekilde: NXP)

Efter lokal registrering af vækkeord med maskinel indlæring giver den fulde Alexa-applikations audioprocesseringsopgave besked til hovedapplikationsopgaven, som det blev beskrevet tidligere. Derudover skal den nu administrere audioprocesseringstilstande, hvor mikrofonen forbliver åben for at indfange det fuldstændige audioinput til talebehandling i Alexas cloud uden at miste den oprindelige datastrøm, der indeholder det lokalt registrerede vækkeord. Denne komplette datastrøm videregives til Alexas cloud for at få bekræftet vækkeordet samt for yderligere talebehandling.

I hver fase af denne behandlingssekvens udsteder audioprocesseringsopgaven tilsvarende FreeRTOS-meddelelser til hovedapplikationsopgaven. Lige som med audioprocesseringsopgaven udvider den fulde Alexa-applikation mønstret fra hovedapplikationsopgaven i en mere enkel form i audio-front-end-applikationen. Her genererer den fulde Alexa-applikations hovedapplikationsopgave, appTask, både hændelser til transmission til Alexas cloud og til administration af kittets LED'er i overensstemmelse med kravene i Amazon AVS UX Attention System. Eksempelvis giver audioprocesseringsopgaven, når mikrofonen holdes åben efter registrering af vækkeord, besked til hovedapplikationsopgaven, som angiver den rette UX-opmærksomhedstilstand (konstant lysende cyan LED) (se gule fremhævninger i post 5 og tilsvarende fremhævning i post 4 igen).

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;
        }
.
.
.

Post 5: I den fulde Alexa-applikation orkestrerer hovedapplikationsopgaven Alexa-behandlingssekvensen med styring af LED-indikatorer i overensstemmelse med kravene til Alexa-certificering. (Kodekilde: NXP)

Hovedrutinen i den fulde Alexa-applikation udvider på samme måde det mønster, der er demonstreret i enklere form i audio-front-end-applikationen. I dette tilfælde opretter hovedapplikationen også yderligere FreeRTOS-opgaver til en mere omfattende initialiseringsprocedure samt opgaver til at håndtere kittets knapper og understøtte OTA-opdateringer.

Ved at bygge på disse samme applikationer kan udviklere med sindsro implementere Alexa Built-in-funktionalitet ved hjælp af NXP MCU Alexa Voice IoT SDK i deres egne i.MX RT106A-baserede designs. Fordi den udnytter AVS for AWS IoT Core fuldt ud, gør denne eksekveringsplatform det muligt for udviklere at udrulle Alexa-aktiverede løsninger bredere på billige enheder med begrænsede ressourcer på grundlag af hele tiden mere sofistikerede IoT-applikationer.

Konklusion

Amazon Alexa Voice Service har givet udviklere mulighed for at implementere den samme stemmeassistentfunktionalitet, der driver den hastige udbredelse af Echo-smarthøjttalere. Tidligere krævede produkter, der kunne gøre sig fortjent til den eftertragtede Alexa Built-in-certificering, eksekveringsplatforme med betydelig lokal hukommelse og højtydende processor. Et kit fra NXP, som er bygget med AVS for AWS IoT Core, giver en drop-in-løsning til Alexa Built-in-funktionalitet ved hjælp af en mikrocontroller og et tilknyttet sofistikeret softwareeksekveringsmiljø.