Lägg till anpassad Alexa -kontroll till Raspberry Pi -projektet: 5 steg

2024 Författare: John Day | [email protected]. Senast ändrad: 2024-01-30 12:42

Detta projekt är avsett för alla som har ett Raspberry Pi -projekt som använder Python som vill lägga till röststyrning via sina befintliga Amazon Echo -enheter. Du behöver inte vara en erfaren programmerare, men du bör vara bekväm med att använda kommandoraden och anpassa befintlig kod för att passa dina behov.

Jag började med ett projekt för att göra min Raspberry Pi att röststyras med Alexa så att den kunde värma vatten i en vattenkokare till en specifik temperatur. Även om den interaktion jag ville ha var ganska enkel (skicka ett nummer från Alexa till Raspberry Pi), tog det mycket arbete att komma till det tillståndet från de befintliga självstudierna. Jag hoppas att denna handledning kommer att göra processen så snabb som möjligt för andra.

I mitt exempel börjar jag med en Raspberry Pi Zero W med Raspbian. Jag har ett Python3 -program på min Pi som kan skriva text till en SPI -display, och jag har en termometersond som jag kan läsa. För dig kan det här programmet vara nästan vad som helst, men tanken är att du kanske har några inmatningsenheter som du vill läsa via Alexa och/eller några utmatningsenheter som du vill styra med Alexa.

Målet är att gå från ett grundläggande program som det som beskrivs ovan till en enhet som du enkelt kan styra med mitt Echo. Förutsatt att du redan har den här hårdvaran bör detta projekt inte kosta dig några pengar. I slutändan kommer du till den punkt där du kan säga saker som:

Jag: "Alexa, be min gadget att kontrollera temperaturen på sensor 1."

Alexas svar: "Sonden läser 72,31 grader."

eller

Jag: "Alexa, berätta för min pryl att skriva George Washington"

Svar: Displayen som är ansluten till min Raspberry Pi läser nu "George Washington"

I nästa avsnitt kommer jag att beskriva vad som måste hända bakom kulisserna för att få detta att fungera. Om du bara vill få detta att fungera på ditt projekt och inte bryr dig om hur det fungerar, hoppa gärna över det (även om det kan göra det svårare om något går fel).

Steg 1: Bakgrund

I den här bilden (kredit: https://developer.amazon.com/en-US/docs/alexa/alex … kan vi se den allmänna arkitekturen för Alexa Gadgets.

När du säger något till din Echo -enhet skickar det ljudet till Alexa Cloud, där det bearbetas och där ett svar genereras för att svara på dig. När du frågar vad vädret är är det bara dessa två i kommunikation. Antag nu att du vill lägga till röststyrning till ett av dina små projekt på en Raspberry Pi. Att bearbeta allt ombord skulle kräva betydande hårdvara och en mycket sofistikerad kodbas för att få saker att gå. En bättre lösning skulle vara att utnyttja Alexa Cloud, som är mycket sofistikerat och har blivit mycket bra på att hantera komplexa talmönster. Alexa Gadgets ger ett bra sätt för dig att göra detta.

En Alexa Gadget kommunicerar med en Echo -enhet med bluetooth. När denna anslutning upprättats skickar de två meddelandena till varandra med hjälp av UTF-8-kodning. När Echo skickar något till prylen kallas det ett direktiv. Den andra riktningen kallas en händelse. Innan vi går in på det exakta flödet av allt detta, bör vi introducera ett annat nyckelelement: anpassade Alexa Skills.

Alexa tillåter utvecklare att skapa sina egna anpassade färdigheter, vilket gör att de kan designa sina egna interaktioner och beteenden för användning på alla Echo -enheter. Till exempel kan en utvecklare skapa en anpassad färdighet för att berätta avståndet mellan två flygplatser i USA. En användare skulle säga: "Alexa, fråga min anpassade avståndskalkylator vad avståndet är mellan LAX och JFK" och det kan svara med "2475 miles". Hur gör det här? När en utvecklare gör en anpassad färdighet definierar de vad som kallas "anpassade avsikter" med "provuttryck" som innehåller "slots". Till exempel, i denna färdighet kan jag ha avsikten "calc_dist" att beräkna avståndet mellan två punkter. Ett exempel är "vad avståndet är mellan {slot1} och {slot2}" eller "hur långt mellan {slot1} och {slot2}". Spåren som visas inom parentes har specifika typer. I detta fall skulle dessa typer vara flygplatskoder som LAX, JFK, BOS, ATL. När en användare frågar efter den anpassade färdigheten försöker Alexa Cloud att matcha vad användaren säger till en anpassad avsikt med hjälp av de medföljande exempeluttrycken och försöker hitta giltiga platsvärden för den begäran. I det här exemplet skulle det upptäcka att användaren ville ha "calc_dist" -avsikten och att slot1 är LAX och slot2 är JFK. Vid denna tidpunkt skickar Alexa Cloud arbetet vidare till utvecklarens egen kod. I grunden berättar det för utvecklarens kod vilken avsikt den fick och vad alla slotvärden var, bland annat.

Utvecklaren får bestämma var deras kod bor, men ett mycket populärt alternativ är att använda en AWS Lambda -funktion. Om du inte vet vad det är, är det i huvudsak en tjänst som låter dig ladda upp kod som kan köras när som helst och sedan debiterar dig bara för den tid som din kod körs. Om vi fortsätter med vårt exempel kan utvecklarens kod vara en Python -funktion som tar emot de två flygplatskoderna, letar upp deras platser, beräknar avstånden och sedan skickar ett svar tillbaka till Alexa Cloud för att tala ut något till användaren. Alexa Cloud skickade sedan tillbaka talinformationen till användarens enhet, och de skulle få svaret.

Nu kan vi komma tillbaka till prylen. Vi kan skapa anpassade färdigheter som är utformade för att fungera specifikt med prylar. En utvecklare kan skriva en färdighet som skickar ut ett direktiv till en ansluten gadget. Det direktivet har en nyttolast som kan användas men det behövs av gadgeten. Den färdigheten kan också skicka ett direktiv och sedan lyssna efter en händelse från gadgeten så att skicklighetskoden kan ha tillgång till information som skickas från gadgeten.

Att etablera detta flöde tillåter skapar ett mycket kraftfullt verktyg eftersom billiga prylar kan ha förmågan att kommunicera med kod i molnet och svara på röstkommandon med några av de bästa röstigenkänningar som finns.

Det bör noteras att de flesta färdigheter tillåter olika sätt att interagera med dem. Till exempel kan en användare hoppa rakt in i en avsikt genom att säga "Alexa, fråga min anpassade avståndsberäknare vad avståndet är mellan LAX och JFK" (kallas en one-shot-anrop) eller så kan de helt enkelt använda en lanseringsavsikt: "Alexa, öppna min anpassade avståndsräknare ". Detta sista exempel följs vanligtvis av att Alexa svarar med en uppmaning om mer information. Denna handledning utesluter avsiktligt stöd för den senare. Mer specifikt, utan att modifiera Lambda-funktionen, kan du bara åkalla färdigheten med hjälp av ett enda skott. Det här designvalet gör att modellen kan vara enklare (behöver inte stödja lanseringsavsikter eller konversationsflöde), och jag har funnit att jag vanligtvis vill interagera med mina prylar med hjälp av one-shot-påkallelser ändå eftersom de vanligtvis är snabbare.

Steg 2: Registrera gadgeten på Alexa Voice Service Developer Console

Följande är en beskrivning av de steg som behövs. Jag har skapat en likvärdig video som visar hur man gör alla dessa steg. Du kan använda antingen eller båda för att slutföra detta steg.

1. Navigera till
2. Om du inte redan har ett gratis konto, gör ett
3. Klicka på "Produkter"
4. Fyll i etiketter och välj "Alexa Gadget"
5. Fyll i vad du vill för resten av fälten
6. Klicka på Slutför

Steg 3: Skapa AWS Lambda -funktion och anpassad skicklighet

Skapa anpassad skicklighet på utvecklarkonsolen för Alexa Skills Kit

Kod för denna handledning hittar du här

Innan du slutför detta steg måste du skapa en.zip -fil som innehåller distributionspaketet för AWS Lambda -funktionen som visas i självstudien här.

1. Ladda ner mappen "lambda" från min Github som innehåller "lambda_function.py" och "requirements.txt"
2. Öppna terminalen och ändra den aktuella katalogen så att den finns i den här mappen.
3. Kör följande sekvens:

pip installera -r krav.txt -t skill_env

cp lambda_function.py skill_env cd skill_env zip -r../../skill-code.zip

Din.zip-fil kommer nu att finnas i katalogen där lambda-mappen var och kommer att kallas "skill-code.zip".

En anteckning om kostnaden för hosting på AWS: Denna handledning kräver att du har ett AWS -konto (gratis att skapa). Lambda -funktioner kostar dock pengar, men deras nuvarande prissättning i N. Virginia -regionen är $ 0.000000208 per 100 ms användning med 128 MB minne. För referens, varje anrop av min skicklighet räknar cirka 800 ms användning på denna nivå. För att få en räkning på $ 1,00USD måste du åberopa den här funktionen cirka 600 000 gånger vilket (om det tar dig 5 sekunder per anrop) skulle ta dig över 34 dagar utan att behöva ringa din funktion. Kostnaden bör inte vara en betydande fråga om du inte publicerar din skicklighet och ett stort antal människor börjar använda den. Om du är orolig för att få räkningar på AWS, överväg att konfigurera användarlarm som meddelar dig om användningen passerar ett definierat tröskelvärde.

Följande är en beskrivning av de steg som behövs. Jag har skapat en likvärdig video som visar hur man gör alla dessa steg. Du kan använda antingen eller båda för att slutföra detta steg.

1. Navigera till https://aws.amazon.com/ och logga in på konsolen eller skapa ett gratis konto om du inte har ett
2. Sök efter och klicka på Lambda under tjänster
3. Klicka på "Skapa funktion"
4. Välj "Author from scratch", ge det ett namn och välj den senaste Python 3 -versionen för körning
5. Ändra "redigera kod inline" till "ladda upp en.zip -fil" och välj den.zip -fil som skapats ovan
6. I ett nytt fönster navigerar du till https://developer.amazon.com/alexa/console/ask och loggar in
7. Klicka på "Skapa skicklighet"
8. Märk den, välj "Anpassad" modell och "Tillhandahåll din egen" och klicka på "Skapa skicklighet"
9. Klicka på "Starta från början" och klicka på "Välj"
10. Klicka på "Lägg till" under "Avsikter"
11. Skapa en anpassad avsikt som kallas "alexa_to_pi" och fyll i "skriv {person}" som ett exempeluttalande
12. Gör en avsiktsplats som heter "person" med typen "AMAZON. Person"
13. Skapa en anpassad avsikt som heter "pi_to_alexa" och fyll i "kontrollera temperaturen från sensorn {sensor_num}
14. Gör en avsiktsplats som heter "sensor_num" med typen "AMAZON. NUMBER"
15. Under gränssnitt, aktivera "Custom Interface Controller"
16. Under Endpoint väljer du "AWS Lambda ARN" och kopierar "Ditt skicklighets -ID"
17. Navigera tillbaka till AWS -konsolen
18. Klicka på "Lägg till utlösare"
19. Välj "Alexa Skills Kit", markera "Aktivera" under Skill ID -verifiering, klistra in Skill ID som du just kopierade och klicka på lägg till
20. Kopiera Lambda ARN i det övre högra hörnet
21. Navigera tillbaka till Alexa Developer Console och klistra in Lambda ARN i fältet "Standardregion"
22. Under kallelse, ställ in Skill Invocation Name till "min gadget"
23. Klicka på "Spara modell" och sedan "Bygg modell"
24. Klicka på "Testa" i de översta flikarna och ändra väljaren från "Av" till "Utveckling"
25. Observera att loggar för Lambda -funktionen finns i "CloudWatch" -tjänsten på AWS.

Steg 4: Ställ in koden på din Raspberry Pi

För att din Raspberry Pi ska kunna kommunicera med Alexa -enheten behöver den lite kod för att underlätta överföring av information via bluetooth och bibehålla den anslutningen, förutom några andra filer. Det enklaste sättet att komma igång med de mest uppdaterade filerna från Amazon är att klona deras Raspberry Pi Gadgets-arkiv. Navigera till katalogen för ditt nuvarande projekt och kör

git-klon

Detta kommer att ladda hela deras förråd med all nödvändig kod på din Pi. Den har några exempelprojekt som visar upp några av funktionerna hos Alexa Gadgets. Om du vill ha mer information kan du läsa mer på deras Github -sida.

Kör deras installationsfunktion för att få allt konfigurerat.

cd/home/pi/Alexa-Gadgets-Raspberry-Pi-Samples

sudo python3 launch.py --setup

Följ anvisningarna och svara "y" när du blir tillfrågad om du vill konfigurera med hjälp av dina gadgetuppgifter. Kom ihåg Amazon -ID och Gadget Secret från att konfigurera din gadget på utvecklarkonsolen eftersom det kommer att bli ombedd här. Jag valde "bt" överföringsläge för min Raspberry Pi Zero W. BLE stöds inte av alla äldre Echo -enheter, men du kan leta upp vad din hårdvara kan. Om du använder din Pi i skrivbordsläge rekommenderar Amazon att högerklicka på Bluetooth-ikonen högst upp till höger och klicka på "Ta bort" Bluetooth "från panelen" för att undvika anslutningsproblem.

Obs! Det här steget kan ta ett tag beroende på hur mycket som måste installeras.

Nu har du alla nödvändiga supportfiler för att gå tillbaka till ditt projekt och börja lägga till funktioner för att möjliggöra kommunikation med ditt eko.

Om du väljer kan du ta bort mappen "exempel" i "Alexa-Gadgets-Raspberry-Pi-Samples/src"

Du kan ha din projektkod var du vill, men jag gör en mapp i hemkatalogen för den, alternativt kan du ladda ner mappen med koden från min Github, var noga med att redigera.ini -filerna enligt beskrivningen nedan.

cd /home /pi

mkdir my_project cd my_project touch my_gadget.py touch my_gadget.ini

Jag har nu skapat två filer i en mapp som heter "mitt_projekt".. Ini -filen är viktig. Var säker på att den innehåller följande och ersätt i ditt Amazon -ID och Gadget Secret:

[GadgetSettings]

amazonId = INSERT_AMAZON_ID_HERE alexaGadgetSecret = INSERT_ALEXA_GADGET_SECRET_HERE [GadgetCapabilities] Custom. MyGadget = 1.0

Låt oss nu titta på python -filen innan vi går in på detaljerna:

importera json

från agt importera AlexaGadget

klass MyGadget (AlexaGadget):

def _init _ (själv):

super ()._ init _ ()

def on_custom_mygadget_alexatopi (själv, direktiv):

nyttolast = json.loads (directive.payload.decode ("utf-8")) print ("Mottagna data:" + str (nyttolast)) write_text (str (nyttolast ['data'] ['person'] ['värde '])))

def on_custom_mygadget_pitoalexa (själv, direktiv):

nyttolast = json.loads (directive.payload.decode ("utf-8")) print ("Mottagna data:" + str (nyttolast)) nyttolast = {'data': "Sonden läser" + str (get_temp (nyttolast) ['data'] ['sensor_num'] ['värde'])) + "grader."} self.send_custom_event ('Custom. MyGadget', 'PiToAlexa', nyttolast) MyGadget (). main ()

Först kommer du att märka att det kallar två funktioner: write_text () och get_temp (). I min kod definierar jag dessa funktioner i samma fil, men de är beroende av min hårdvara så jag har valt att utelämna dem. Jag har bifogat den här filen med de funktionerna definierade för att bara skriva ut och returnera dummy -data om du vill köra den exakta koden. Jag föreslår att du testar med denna exakta kod innan du ändrar den för att fungera med ditt projekt. Jag har också bifogat.ini -filen, men se till att du går in och ändrar ID och gadgethemlighet. Den översta funktionen tar emot data som skickas in från Alexa. Den nedre funktionen tar emot data i samma format, men Alexa -enheten väntar i fem sekunder på att en händelse ska skickas tillbaka med sin egen nyttolast. Denna nyttolast är speciell genom att Alexa -enheten talar innehållet.

När du har dessa filer navigerar du till "my_project" -mappen och kör pythonfilen.

sudo starta om

cd/home/pi/my_project sudo python3./my_gadget.py

Om det här är första gången du kör programmet måste du koppla det till din Echo -enhet. Se till att din Echo -enhet är nära Raspberry Pi, eftersom vi måste tillåta en Bluetooth -anslutning.

Klicka på "enheter" i nedre högra hörnet i Alexa -appen på din mobila enhet.

Klicka på "Echo & Alexa" längst upp till vänster.

Klicka på din Echo -enhet.

Under "TRÅDLÖS" trycker du på "Bluetooth -enheter".

Tryck på "KOPPLA EN NY ENHET" så ska du se din gadget på listan.

Klicka på din gadget. Du bör se Pi -rapporten att den lyckades para ihop.

Medan du tittar på utmatningen på din Pi, försök ge ett röstkommando till Echo:

Du: "Alexa, be min gadget att kontrollera temperaturen från sensor ett"

Om allt fungerade korrekt borde du höra:

Eko: "Sonden läser 120.505 grader."

Du: "Alexa, berätta för min pryl att skriva George Washington."

Pi ska skriva ut:

Mottagna data: {'data': {'person': {'name': 'person', 'value': 'George Washington', 'confirmStatus': 'NONE'}}}

George Washington"

Steg 5: Förpackning

Videon som visas här är ett exempel på gadgeten som arbetar med att läsa temperaturen (samma sond i F mot C) och skriva namn till en enkel display.

Nu när du förhoppningsvis har något som fungerar, bör du försöka gå och anpassa detta för att göra ditt eget projekt mer kapabelt. Kom ihåg att du enkelt kan redigera avsikterna i Alexa Developer Console och att alla platser du använder kommer att skickas till din Pi i nyttolasten. Dessutom kan du få Alexa att säga vad du vill genom att bara redigera nyttolasten du skickar tillbaka i händelsen från din Raspberry Pi -kod.

Observera att denna handledning inte är avsedd att vara en slutlig lösning för alla funktioner du kan önska dig med en Alexa Gadget. Det är avsiktligt begränsat att ge dig två enkla funktioner för att skicka data i varje riktning mellan Alexa och en gadget. Om du är intresserad av att bygga mer sofistikerade interaktionsmodeller, skulle jag uppmuntra dig att läsa alla readme-filer i https://github.com/alexa/Alexa-Gadgets-Raspberry-P… och prova alla exempel de ger. Jag skulle också föreslå att du läser dokumentationen för Alexa Gadgets Toolkit och Alexa Skills Kit.