დაამატეთ პერსონალური Alexa Control ჟოლოს პროექტს: 5 ნაბიჯი

2024 ავტორი: John Day | [email protected]. ბოლოს შეცვლილი: 2024-01-30 10:17

ეს პროექტი განკუთვნილია ყველასთვის, ვისაც აქვს Raspberry Pi პროექტი, რომელიც იყენებს პითონს, რომელსაც სურს დაამატოს ხმის კონტროლი არსებული Amazon Echo მოწყობილობების საშუალებით. თქვენ არ გჭირდებათ იყოთ გამოცდილი პროგრამისტი, მაგრამ კომფორტული უნდა იყოთ ბრძანების ხაზის გამოყენებით და არსებული კოდის მორგება თქვენს საჭიროებებზე.

მე თავდაპირველად დავიწყე პროექტი, რომლის საშუალებითაც შესაძლებელი იქნებოდა ჩემი Raspberry Pi- ს ხმის კონტროლი Alexa– სთან ერთად, რათა მას შეეძლო ქვაბში წყლის გათბობა სპეციფიკურ ტემპერატურაზე. მიუხედავად იმისა, რომ ინტერაქცია, რომელიც მინდოდა, საკმაოდ მარტივი იყო (გადაეცი ერთი ნომერი ალექსიდან ჟოლოს პიზე), ბევრი შრომა დასჭირდა ამ მდგომარეობის მისაღწევად არსებული გაკვეთილებიდან. ვიმედოვნებ, რომ ეს გაკვეთილი სხვებს რაც შეიძლება სწრაფად გახდის ამ პროცესს.

ჩემს მაგალითში, მე ვიწყებ Raspberry Pi Zero W– ით Raspbian– ით. ჩემს Pi– ზე მაქვს Python3 პროგრამა, რომელსაც შეუძლია ტექსტის ჩაწერა SPI ეკრანზე და მაქვს თერმომეტრის ზონდი, რომლის წაკითხვაც შემიძლია. თქვენთვის, ეს პროგრამა შეიძლება იყოს თითქმის არაფერი, მაგრამ იდეა ისაა, რომ თქვენ შეიძლება გქონდეთ შეყვანის მოწყობილობები, რომელთა წაკითხვაც გსურთ Alexa– ს საშუალებით და/ან გამომავალი მოწყობილობები, რომელთა გაკონტროლებაც გსურთ Alexa– ს გამოყენებით.

მიზანია გადავიდეთ ძირითადი პროგრამიდან, როგორიცაა ზემოთ აღწერილი, იმ მოწყობილობაზე, რომლის კონტროლიც მარტივად შეგიძლიათ ჩემი ექოს საშუალებით. დავუშვათ, რომ თქვენ უკვე გაქვთ ეს ტექნიკა, ეს პროექტი არ დაგიჯდებათ ფული. საბოლოო ჯამში, თქვენ მიხვალთ იქამდე, სადაც შეგიძლიათ თქვათ ისეთი რამ, როგორიცაა:

მე: "ალექსა, სთხოვე ჩემს გაჯეტს, რომ შეამოწმოს ტემპერატურა 1 სენსორზე."

ალექსას პასუხი: "ზონდი კითხულობს 72,31 გრადუსს".

ან

მე: "ალექსა, უთხარი ჩემს გაჯეტს, რომ დაწეროს ჯორჯ ვაშინგტონი"

პასუხი: ჩემს Raspberry Pi– სთან დაკავშირებულ ეკრანზე ახლა წერია „ჯორჯ ვაშინგტონი“

მომდევნო ნაწილში, მე აღვწერ რა უნდა მოხდეს კულისებში, რომ ეს ნამუშევარი შეიქმნას. თუ უბრალოდ გსურთ, რომ ეს თქვენს პროექტზე იმუშაოს და არ გაინტერესებთ როგორ მუშაობს, მოგერიდებათ გამოტოვოთ იგი (თუმცა ეს შეიძლება გაართულოს, თუ რამე არასწორედ წავა).

ნაბიჯი 1: ფონი

ამ სურათზე (კრედიტი: https://developer.amazon.com/en-US/docs/alexa/alex…) ჩვენ შეგვიძლია დავინახოთ Alexa გაჯეტების ზოგადი არქიტექტურა.

როდესაც თქვენ ამბობთ რამეს თქვენს Echo მოწყობილობაზე, ის აგზავნის აუდიოს Alexa Cloud– ში, სადაც დამუშავდება და სადაც წარმოიქმნება პასუხი თქვენზე პასუხის გასაცემად. როდესაც ჰკითხავთ რა ამინდია, ეს მხოლოდ ეს ორია კომუნიკაციაში. ახლა დავუშვათ, რომ გსურთ დაამატოთ ხმოვანი კონტროლი თქვენს ერთ – ერთ მცირე პროექტზე Raspberry Pi– ზე. ბორტზე ყველაფრის დამუშავება მოითხოვს მნიშვნელოვან აპარატურას და ძალიან დახვეწილ კოდის ბაზას, რომ საქმეები წავიდეს. უკეთესი გამოსავალი იქნებოდა Alexa Cloud– ის ბერკეტი, რომელიც ძალიან დახვეწილია და ძალიან კარგად გაართვა თავი მეტყველების რთულ შაბლონებს. Alexa Gadgets გთავაზობთ კარგ გზას ამის გასაკეთებლად.

Alexa Gadget აკავშირებს Echo მოწყობილობას bluetooth- ის გამოყენებით. როდესაც ეს კავშირი დამყარდება, ორივე გადასცემს ერთმანეთს შეტყობინებებს UTF-8 კოდირების გამოყენებით. როდესაც ექო რაღაცას გადასცემს გაჯეტს, მას დირექტივა ეწოდება. სხვა მიმართულება მოიხსენიება როგორც მოვლენა. ამ ყველაფრის ზუსტ ნაკადში შესვლამდე, ჩვენ უნდა შემოვიღოთ კიდევ ერთი ძირითადი ელემენტი: პერსონალური Alexa უნარები.

Alexa საშუალებას აძლევს დეველოპერებს შექმნან საკუთარი ჩვევები, რაც მათ საშუალებას აძლევს შექმნან საკუთარი ურთიერთქმედებები და ქცევები Echo ყველა მოწყობილობაზე გამოსაყენებლად. მაგალითად, დეველოპერს შეუძლია შექმნას ჩვეული უნარი, რომ გითხრათ მანძილი აშშ -ს ორ აეროპორტს შორის. მომხმარებელი იტყოდა: "ალექსა, მკითხე ჩემი დისტანციის გამომთვლელი, რა მანძილია LAX- სა და JFK- ს შორის" და მას შეუძლია უპასუხოს "2475 მილს". როგორ აკეთებს ამას? როდესაც დეველოპერი აყალიბებს სპეციალურ უნარებს, ისინი განსაზღვრავენ იმას, რასაც ეწოდება "საბაჟო მიზნები", "გამონათქვამების ნიმუში", რომელიც შეიცავს "სლოტებს". მაგალითად, ამ უნარში შეიძლება მქონდეს განზრახვა "calc_dist" გამოვთვალო მანძილი ორ წერტილს შორის. ნიმუშის გამოთქმა იქნება "რა მანძილია {slot1} - სა და {slot2}" - ს შორის ან "რამდენად შორს არის {slot1} - სა და {slot2} - ს შორის". ფრჩხილებში ნაჩვენები სლოტები აქვს სპეციფიკურ ტიპებს. ამ შემთხვევაში, ეს იქნება აეროპორტის კოდები, როგორიცაა LAX, JFK, BOS, ATL. როდესაც მომხმარებელი ითხოვს მორგებულ უნარს, Alexa Cloud ცდილობს შეადაროს ის, რასაც მომხმარებელი ამბობს მორგებულ განზრახვაზე, მოწოდებული ნიმუშის გამოყენებით და ცდილობს იპოვოს სლოტის სწორი მნიშვნელობები ამ მოთხოვნისათვის. ამ მაგალითში ის აღმოაჩენს, რომ მომხმარებელს სურდა "calc_dist" განზრახვა და რომ slot1 არის LAX და slot2 არის JFK. ამ დროს, Alexa Cloud გადადის მუშაობას დეველოპერის საკუთარ კოდზე. ძირითადად, ის ეუბნება დეველოპერების კოდს, თუ რა განზრახვა მიიღო მან და რა იყო სლოტის ყველა მნიშვნელობა, სხვა დეტალებთან ერთად.

დეველოპერი იღებს გადაწყვეტილებას სად ცხოვრობს მათი კოდი, მაგრამ ძალიან პოპულარული ვარიანტია გამოიყენოთ AWS Lambda ფუნქცია. თუ არ იცით რა არის ეს, ეს არის სერვისი, რომელიც საშუალებას გაძლევთ ატვირთოთ კოდი, რომლის გაშვებაც შესაძლებელია ნებისმიერ დროს და შემდეგ გადაგიხდით მხოლოდ იმ დროის განმავლობაში, როდესაც თქვენი კოდი მუშაობს. თუ ჩვენ გავაგრძელებთ ჩვენს მაგალითს, დეველოპერის კოდი შეიძლება იყოს პითონის ფუნქცია, რომელიც იღებს აეროპორტის ორ კოდს, ეძებს მათ ადგილს, ითვლის დისტანციებს და შემდეგ აგზავნის პასუხს Alexa Cloud– ზე, რომ ისაუბროს მომხმარებელზე. Alexa Cloud აგზავნის ამ სიტყვის ინფორმაციას მომხმარებლის მოწყობილობაში და ისინი მიიღებენ პასუხს.

ახლა ჩვენ შეგვიძლია დავუბრუნდეთ გაჯეტს. ჩვენ შეგვიძლია შევქმნათ ჩვევები, რომლებიც შექმნილია სპეციალურად გაჯეტებთან მუშაობისთვის. დეველოპერს შეუძლია დაწეროს უნარი, რომელიც აგზავნის დირექტივას დაკავშირებულ გაჯეტზე. ამ დირექტივას აქვს დატვირთვა, რომელიც შეიძლება გამოყენებულ იქნას, როგორც ეს გაჯეტს სჭირდება. ამ უნარს ასევე შეუძლია გაგზავნოს დირექტივა და შემდეგ მოუსმინოს მოვლენას გაჯეტიდან, რათა უნარის კოდს ჰქონდეს წვდომა გაჯეტიდან გაგზავნილ ინფორმაციაზე.

ამ ნაკადის დამკვიდრება საშუალებას გაძლევთ შექმნათ ძალიან მძლავრი ინსტრუმენტი, რადგან იაფ აპარატებს შეუძლიათ ღრუბელში კოდთან კომუნიკაციისა და ხმოვან ბრძანებებზე რეაგირების საუკეთესო ხმოვანი ამოცნობის გამოყენებით.

უნდა აღინიშნოს, რომ უნარების უმეტესობა მათთან ურთიერთობის სხვადასხვა გზას იძლევა. მაგალითად, მომხმარებელმა შეიძლება პირდაპირ გადაინაცვლოს სიტყვით "ალექსა, ჰკითხე ჩემს დისტანციურ კალკულატორს რა მანძილია LAX- სა და JFK- ს შორის" (ეწოდება ერთჯერადი გამოძახება) ან უბრალოდ გამოიყენოს გაშვების განზრახვა: "ალექსა, გახსენით ჩემი დისტანციური კალკულატორი ". ამ ბოლო მაგალითს, როგორც წესი, მოჰყვება Alexa, რომელიც პასუხობს მოთხოვნით დამატებითი ინფორმაციისთვის. ეს სახელმძღვანელო განზრახ გამოტოვებს ამ უკანასკნელის მხარდაჭერას. უფრო კონკრეტულად, ლამბდას ფუნქციის შეცვლის გარეშე, თქვენ შეგიძლიათ გამოიყენოთ უნარი მხოლოდ ერთი გასროლის გამოყენებით. დიზაინის ეს არჩევანი საშუალებას იძლევა მოდელი იყოს უფრო მარტივი (არ უნდა იყოს მხარდაჭერილი გაშვების მიზნებისა და საუბრის მიმდინარეობისას) და მე აღმოვაჩინე, რომ მე, როგორც წესი, მსურს ურთიერთქმედება ჩემს გაჯეტებთან ერთჯერადი მოწოდებების გამოყენებით, რადგან ისინი, როგორც წესი, უფრო სწრაფია.

ნაბიჯი 2: დაარეგისტრირეთ გაჯეტი Alexa Voice Service Developer Console– ზე

ქვემოთ მოცემულია საჭირო ნაბიჯების აღწერა. მე შევქმენი ექვივალენტი ვიდეო, რომელიც გვიჩვენებს, თუ როგორ უნდა გავაკეთოთ ყველა ეს ნაბიჯი. თქვენ შეგიძლიათ გამოიყენოთ ორივე, ან ორივე, ამ ნაბიჯის დასასრულებლად.

1. გადადით
2. თუ ჯერ არ გაქვთ უფასო ანგარიში, შექმენით ერთი
3. დააწკაპუნეთ "პროდუქტზე"
4. შეავსეთ ეტიკეტები და აირჩიეთ "Alexa Gadget"
5. შეავსეთ რაც გსურთ დანარჩენი ველებისთვის
6. დააწკაპუნეთ დასრულება

ნაბიჯი 3: შექმენით AWS Lambda ფუნქცია და პერსონალური უნარი

შექმენით პერსონალური უნარი Alexa Skills Kit დეველოპერის კონსოლზე

ამ გაკვეთილის კოდი შეგიძლიათ იხილოთ აქ

ამ ნაბიჯის დასრულებამდე, თქვენ უნდა შექმნათ.zip ფაილი, რომელიც შეიცავს AWS Lambda ფუნქციის განლაგების პაკეტს, როგორც ეს ნაჩვენებია აქ გაკვეთილში.

1. ჩამოტვირთეთ საქაღალდე "lambda" ჩემი Github– დან, რომელიც შეიცავს "lambda_function.py" და "მოთხოვნები. Txt"
2. გახსენით ტერმინალი და შეცვალეთ მიმდინარე დირექტორია ამ საქაღალდის შიგნით.
3. გაუშვით შემდეგი თანმიმდევრობა:

pip install -r მოთხოვნები. txt -t skill_env

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

თქვენი.zip ფაილი ახლა განთავსდება იმ დირექტორიაში, სადაც lambda საქაღალდე იყო და ეწოდება "skill-code.zip".

შენიშვნა AWS– ზე მასპინძლობის ღირებულების შესახებ: ეს გაკვეთილი მოითხოვს, რომ გქონდეთ AWS ანგარიში (შექმნა უფასო). ლამბდას ფუნქციები ფულს ხარჯავს, თუმცა მათი ამჟამინდელი ფასი ნ ვირჯინიის რეგიონში 0.000000208 აშშ დოლარია 100 მგ გამოყენებაზე 128 მბ მეხსიერებით. ცნობისთვის, ჩემი უნარ -ჩვევების გამოძახება ითვალისწინებს ამ დონეზე დაახლოებით 800 მმ გამოყენებას. $ 1.00 აშშ დოლარის გადასახდელად, თქვენ უნდა გამოიძახოთ ეს ფუნქცია დაახლოებით 600, 000 -ჯერ, რაც (თუ თქვენ დაგჭირდებათ 5 წამი თითო ინვოისზე) დაგჭირდებათ 34 დღე უწყვეტი თქვენი ფუნქციის გამოძახებით. ღირებულება არ უნდა იყოს მნიშვნელოვანი საკითხი, სანამ არ გამოაქვეყნებთ თქვენს უნარს და უამრავი ადამიანი დაიწყებს მის გამოყენებას. თუ თქვენ შეშფოთებული ხართ AWS– ით გადასახადების მიღებით, განიხილეთ გამოყენების სიგნალიზაციის დაყენება, რომელიც შეგატყობინებთ, თუ გამოყენება გადალახავს განსაზღვრულ ზღვარს.

ქვემოთ მოცემულია საჭირო ნაბიჯების აღწერა. მე შევქმენი ექვივალენტი ვიდეო, რომელიც გვიჩვენებს, თუ როგორ უნდა გავაკეთოთ ყველა ეს ნაბიჯი. თქვენ შეგიძლიათ გამოიყენოთ ორივე, ან ორივე ამ ნაბიჯის დასასრულებლად.

1. გადადით https://aws.amazon.com/ და შედით კონსოლში ან შექმენით უფასო ანგარიში, თუ არ გაქვთ
2. მოძებნეთ და დააწკაპუნეთ ლამბდაზე მომსახურების ქვეშ
3. დააჭირეთ ღილაკს "შექმენით ფუნქცია"
4. აირჩიეთ "ავტორი ნულიდან", დაარქვით მას სახელი და შეარჩიეთ Python 3 -ის უახლესი ვერსია გაშვებისთვის
5. შეცვალეთ "inline code inline" ("ატვირთეთ.zip ფაილი") და შეარჩიეთ.zip ფაილი, რომელიც შეიქმნა ზემოთ
6. ახალ ფანჯარაში გადადით https://developer.amazon.com/alexa/console/ask და შედით სისტემაში
7. დააწკაპუნეთ "შექმენით უნარი"
8. მონიშნეთ იგი, შეარჩიეთ "მორგებული" მოდელი და "უზრუნველყეთ თქვენი საკუთარი" და დააჭირეთ "შექმენით უნარი"
9. დააჭირეთ ღილაკს "დაწყება ნაკაწრიდან" და დააჭირეთ "არჩევა"
10. "განზრახვების" განყოფილებაში დააჭირეთ ღილაკს "დამატება"
11. შექმენით მორგებული განზრახვა სახელწოდებით "alexa_to_pi" და შეავსეთ "ჩაწერეთ {person}" როგორც გამოთქმის მაგალითი
12. გააკეთეთ განზრახვის სლოტი სახელწოდებით "პირი" ტიპი "AMAZON. Person"
13. შექმენით მორგებული განზრახვა სახელწოდებით "pi_to_alexa" და შეავსეთ "შეამოწმეთ ტემპერატურა სენსორიდან {sensor_num}
14. გააკეთეთ განზრახვის სლოტი სახელწოდებით "sensor_num" ტიპი "AMAZON. NUMBER"
15. ინტერფეისების ქვეშ ჩართეთ "პერსონალური ინტერფეისის კონტროლერი"
16. Endpoint– ის ქვეშ აირჩიეთ „AWS Lambda ARN“და დააკოპირეთ „Your Skill ID“
17. დაუბრუნდით AWS კონსოლს
18. დააწკაპუნეთ "ტრიგერის დამატება"
19. აირჩიეთ "Alexa Skills Kit", შეამოწმეთ "Enable" Skill ID verification, ჩასვით ახლახან გადაწერილი Skill ID და დააწკაპუნეთ დამატებაზე
20. დააკოპირეთ Lambda ARN ზედა მარჯვენა კუთხეში
21. ნავიგაცია უკან Alexa დეველოპერის კონსოლში და ჩასვით Lambda ARN "ნაგულისხმევი რეგიონის" ველში
22. Invocation- ში დააყენეთ Skill Invocation Name, როგორც "ჩემი გაჯეტი"
23. დააჭირეთ ღილაკს "მოდელის შენახვა" და შემდეგ "მოდელის შექმნა"
24. დააწკაპუნეთ "გამოცდაზე" ზედა ჩანართებში და შეცვალეთ ამომრჩევი "გამორთულიდან" "განვითარებაზე"
25. გაითვალისწინეთ, რომ ლამბდა ფუნქციის ჟურნალები ნაპოვნია AWS- ის "CloudWatch" სერვისში.

ნაბიჯი 4: შექმენით კოდი თქვენს ჟოლოს პიზე

იმისათვის, რომ თქვენი Raspberry Pi დაუკავშირდეს Alexa მოწყობილობას, მას სჭირდება გარკვეული კოდი Bluetooth– ზე ინფორმაციის გადაცემის გასაადვილებლად და ამ კავშირის შესანარჩუნებლად, სხვა რამდენიმე ფაილის გარდა. ყველაზე მარტივი გზა ამაზონის ყველაზე თანამედროვე ფაილების დასაწყებად არის მათი Raspberry Pi გაჯეტების საცავის კლონირება. გადადით თქვენი მიმდინარე პროექტის დირექტორიაში და გაუშვით

git კლონი

ეს დატვირთავს მათ საცავს ყველა საჭირო კოდით თქვენს Pi- ზე. მას აქვს რამდენიმე მაგალითი პროექტი, რომელიც აჩვენებს Alexa Gadgets– ის ზოგიერთ შესაძლებლობებს. თუ გსურთ მეტი ინფორმაცია, იხილეთ readme მათ Github გვერდზე.

გაუშვით მათი დაყენების ფუნქცია, რომ ყველაფერი კონფიგურირებული იყოს.

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

sudo python3 გაშვება. py -დაყენება

მიჰყევით მოთხოვნებს და უპასუხეთ "y" - ს როდესაც გკითხავთ, გსურთ თუ არა თქვენი Gadget სერთიფიკატების გამოყენებით კონფიგურაცია. გაიხსენეთ Amazon ID და Gadget Secret დეველოპერის კონსოლზე თქვენი გაჯეტის დაყენებიდან, ვინაიდან აქ იქნება მოთხოვნილი. მე ავირჩიე "bt" გადაცემის რეჟიმი ჩემი Raspberry Pi Zero W. BLE არ არის მხარდაჭერილი ყველა ძველი Echo მოწყობილობით, მაგრამ თქვენ შეგიძლიათ ნახოთ რა შეუძლია თქვენს აპარატურას. თუ თქვენ იყენებთ თქვენს Pi- ს დესკტოპის რეჟიმში, Amazon გირჩევთ მარჯვენა ღილაკით დააწკაპუნოთ bluetooth ხატზე ზედა მარჯვენა კუთხეში და დააწკაპუნოთ "ამოიღეთ" Bluetooth "პანელიდან" დაკავშირების პრობლემების თავიდან ასაცილებლად.

შენიშვნა: ამ ნაბიჯს შეიძლება გარკვეული დრო დასჭირდეს იმისდა მიხედვით, თუ რამდენი უნდა იყოს დაინსტალირებული.

ახლა თქვენ გექნებათ ყველა საჭირო დამხმარე ფაილი, რომ დაუბრუნდეთ თქვენს პროექტს და დაიწყოთ იმ ფუნქციების დამატება, რაც თქვენს ექოსთან კომუნიკაციის საშუალებას მისცემს.

თუ აირჩევთ, შეგიძლიათ წაშალოთ საქაღალდე "მაგალითები" "Alexa-Gadgets-Raspberry-Pi-Samples/src"

თქვენ შეგიძლიათ გქონდეთ თქვენი პროექტის კოდი სადაც გსურთ, მაგრამ მე გავაკეთებ საქაღალდეს სახლის დირექტორიაში, ალტერნატიულად შეგიძლიათ გადმოწეროთ საქაღალდე კოდით ჩემი Github– დან, უბრალოდ დარწმუნდით, რომ დაარედაქტირეთ.ini ფაილები ქვემოთ აღწერილი.

cd /home /pi

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

მე ახლა შევქმენი ორი ფაილი საქაღალდეში სახელწოდებით "my_project".. Ini ფაილი მნიშვნელოვანია. დარწმუნდით, რომ იგი შეიცავს შემდეგს და შემცვლელს თქვენს Amazon ID- სა და Gadget Secret- ში:

[GadgetSettings]

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

ახლა მოდით შევხედოთ პითონის ფაილს დეტალებში შესვლამდე:

json იმპორტი

agt იმპორტიდან AlexaGadget

კლასი MyGadget (AlexaGadget):

def _ დაწყება _ (საკუთარი თავი):

სუპერ ()._ init _ ()

def on_custom_mygadget_alexatopi (თვითმმართველობის, დირექტივა):

payload = json.loads (directive.payload.decode ("utf-8")) print ("მიღებული მონაცემები:" + str (payload)) write_text (str (payload ['data'] ['person'] ['value ']))

def on_custom_mygadget_pitoalexa (თვითმმართველობის, დირექტივა):

payload = json.loads (directive.payload.decode ("utf-8")) print ("მიღებული მონაცემები:" + str (payload)) payload = {'data': "ზონდი კითხულობს" + str (get_temp (payload ['data'] ['sensor_num'] ['value'])) + "grad."} self.send_custom_event ("Custom. MyGadget", "PiToAlexa", payload) MyGadget (). main ()

პირველ რიგში შეამჩნევთ, რომ ის ორ ფუნქციას იძახებს: write_text () და get_temp (). ჩემს კოდში, მე განვსაზღვრავ ამ ფუნქციებს ერთ ფაილში, მაგრამ ისინი დამოკიდებულია ჩემს აპარატურაზე, ამიტომ მე მათი გამოტოვება ავირჩიე. მე დავამატე ეს ფაილი იმ ფუნქციებით, რომლებიც განსაზღვრულია მხოლოდ დაბეჭდვისა და დასაბრუნებელი მონაცემების დასაბრუნებლად იმ შემთხვევაში, თუ გსურთ ამ ზუსტი კოდის გაშვება. მე გირჩევთ შეამოწმოთ ზუსტად ეს კოდი, სანამ შეცვლით მას თქვენს პროექტთან მუშაობისთვის. მე ასევე დავამატე.ini ფაილი, მაგრამ დარწმუნდით, რომ შედიხართ და შეცვლით პირადობის მოწმობას და გაჯეტის საიდუმლოებას. ზედა ფუნქცია იღებს მონაცემებს Alexa– დან. ქვედა ფუნქცია იღებს მონაცემებს იმავე ფორმატში, მაგრამ Alexa მოწყობილობა დაელოდება ხუთ წამს, სანამ მოვლენა უკან დააბრუნებს საკუთარ დატვირთვას. ეს დატვირთვა განსაკუთრებულია იმით, რომ Alexa მოწყობილობა ისაუბრებს მის შინაარსზე.

ამ ფაილების მიღების შემდეგ გადადით "my_project" საქაღალდეში და გაუშვით პითონის ფაილი.

sudo გადატვირთვა

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

თუ თქვენ პირველად მართავთ პროგრამას, დაგჭირდებათ მისი დაწყვილება Echo მოწყობილობასთან. დარწმუნდით, რომ თქვენი Echo მოწყობილობა არის Raspberry Pi– სთან ახლოს, რადგან ჩვენ უნდა დავუშვათ bluetooth კავშირი.

თქვენს მობილურ მოწყობილობაზე Alexa აპლიკაციაში დააწკაპუნეთ "მოწყობილობები" ქვედა მარჯვენა კუთხეში.

დააწკაპუნეთ "Echo & Alexa" ზედა მარცხენა კუთხეში.

დააწკაპუნეთ თქვენს Echo მოწყობილობაზე.

"უკაბელო" განყოფილებაში, შეეხეთ "Bluetooth მოწყობილობებს".

შეეხეთ „დააწყვილე ახალი მოწყობილობა“და სიაში უნდა ნახო შენი გაჯეტი.

შეეხეთ თქვენს გაჯეტს. თქვენ უნდა ნახოთ Pi მოხსენება, რომელიც წარმატებით დაწყვილდა.

თქვენი Pi- ს გამომუშავების ყურებისას, სცადეთ ხმოვანი ბრძანება Echo- ს:

თქვენ: "ალექსა, სთხოვე ჩემს გაჯეტს, რომ შეამოწმოს ტემპერატურა ერთი სენსორიდან"

თუ ყველაფერი სწორად მუშაობს, თქვენ უნდა მოისმინოთ:

ექო: "ზონდი კითხულობს 120.505 გრადუსს."

შენ: "ალექსა, უთხარი ჩემს გაჯეტს, რომ დაწეროს ჯორჯ ვაშინგტონი."

Pi უნდა დაბეჭდოს:

მიღებული მონაცემები: {'მონაცემები': {'პირი': {'სახელი': 'პირი', 'მნიშვნელობა': 'ჯორჯ ვაშინგტონი', 'confirmationStatus': 'NONE'}}}

Ჯორჯ ვაშინგტონი"

ნაბიჯი 5: შეფუთვა

აქ ნაჩვენები ვიდეო არის გაჯეტის მაგალითი, რომელიც მუშაობს ტემპერატურის კითხვაზე (იგივე ზონდი F– ში C) და სახელების ჩაწერა უბრალო ჩვენებაზე.

ახლა, როდესაც თქვენ იმედია რაიმე მუშაობს, თქვენ უნდა შეეცადოთ წახვიდეთ და დააკონფიგურიროთ ის, რომ გახადოთ თქვენი პროექტი უფრო ქმედუნარიანი. გახსოვდეთ, რომ თქვენ შეგიძლიათ მარტივად შეცვალოთ განზრახვები Alexa დეველოპერის კონსოლში და რომ გამოყენებული ყველა სლოტი გადაეცემა თქვენს Pi- ს დატვირთვაში. გარდა ამისა, თქვენ შეგიძლიათ ალექსას უთხრათ ყველაფერი, რაც გსურთ, მხოლოდ იმ დატვირთვის რედაქტირებით, რომელსაც თქვენ უკან დააბრუნებთ ღონისძიებაზე თქვენი Raspberry Pi კოდიდან.

გთხოვთ გაითვალისწინოთ, რომ ეს გაკვეთილი არ არის გამიზნული იყოს საბოლოო გადაწყვეტა ყველა იმ შესაძლებლობისთვის, რაც გსურთ გქონდეთ Alexa Gadget– ით. მიზანმიმართულად შემოიფარგლება, რომ მოგცეთ ორი მარტივი ფუნქცია მონაცემების გადასაცემად თითოეული მიმართულებით Alexa- სა და Gadget- ს შორის. თუ თქვენ დაინტერესებული ხართ უფრო დახვეწილი ურთიერთქმედების მოდელების შექმნით, მე გირჩევთ წაიკითხოთ ყველა წაკითხული ფაილი https://github.com/alexa/Alexa-Gadgets-Raspberry-P… და სცადოთ მათ მიერ მოყვანილი ყველა მაგალითი. რა მე ასევე გირჩევთ წაიკითხოთ დოკუმენტაცია Alexa Gadgets Toolkit და Alexa Skills Kit.