Alexa Voice Controlled Raspberry Pi Drone IoT და AWS: 6 ნაბიჯი (სურათებით)

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

გამარჯობა! მე მქვია არმაანი. მე ვარ 13 წლის ბიჭი მასაჩუსეტიდან. ეს სახელმძღვანელო გვიჩვენებს, როგორც სათაურიდან შეგიძლიათ დაასკვნათ, როგორ ავაშენოთ Raspberry Pi Drone. ეს პროტოტიპი აჩვენებს, თუ როგორ ვითარდება თვითმფრინავები და ასევე რამდენად დიდია მათი როლი მომავალში. მე ნამდვილად შემიძლია დავინახო, რომ ვიღვიძებ 10 წელიწადში და ვთხოვ თვითმფრინავს, რომ საუზმე მომიტანოს. დრონი იყენებს Amazon Alexa- ს, Amazon Web Services- ს, IoT- ს (ნივთების ინტერნეტი) და რაც მთავარია Raspberry Pi- ს გასაშვებად. იგი მიზნად ისახავს დემონსტრირებას და ინფორმირებას თვითმფრინავების შესახებ და როგორ გაუმჯობესდება ისინი ყოველდღე. ვიმედოვნებთ, რომ თქვენ წარმატებული იქნებით და გაეცნობით დრონებს ამ პროცესში. წარმატებებს გისურვებთ და მადლობა რომ კითხულობთ. -არმან

მარაგები

პროტოტიპის შესაქმნელად საჭიროა სხვადასხვა ტექნიკური და პროგრამული უზრუნველყოფა. მე გამოვიყენე Drone Dojo– ს ონლაინ გაკვეთილი თვითმფრინავის ასაშენებლად და ჩამოთვლილი ტექნოლოგიების ინტეგრირებისთვის. დრონისთვის თქვენ შეგიძლიათ იპოვოთ ნაწილების სია აქ:

თვითმფრინავების ნაწილების სია

პროგრამული მოთხოვნები:

• ამაზონის ვებ სერვისები
• Ლეპტოპი
• მისიის დამგეგმავი პროგრამული უზრუნველყოფა
• ბალენა ეჩერი
• MicroSD ბარათი Raspbian ფაილით ნაპოვნია აქ
• Amazon Alexa, ფიზიკური თუ ვირტუალური

ნაბიჯი 1: ნაწილების შეგროვება და გაგება

მიწოდების სიაში ნახსენები ყველა ნაწილი აუცილებელია და ასევე აუცილებელია თითოეული ნაწილის მკაფიო გაგება. თქვენ შეგიძლიათ იპოვოთ ნაწილები ინტერნეტით და შეკრების შემდეგ, განაგრძეთ კითხვა. Drone Dojo- ს პლეილისტი ნაწილების სრული გაგებისთვის შეგიძლიათ იხილოთ აქ. 4 წუთიანი ახსნა ჩემს youtube არხზე შეგიძლიათ იხილოთ აქ. რაც შეეხება თვითმფრინავებს, ერთადერთი ნაწილები, მიუხედავად იმისა, რასაც უმეტესობა ფიქრობს, არ არის მხოლოდ ძრავები და პროპელერები. ქვემოთ მოცემულია თითოეული ნაწილის ძირითადი მიზნები.

ჟოლო პი ემლიდ ნავიოსთან 2

ეს ნაწილი საკმაოდ ცენტრალური პროცესორია და თვითმფრინავის მთავარი წერტილი. Raspberry Pi მოქმედებს როგორც კომპიუტერის პროცესორი, რომელიც უგზავნის ბრძანებებს Navio2– ს, რათა განახორციელოს PWM (პულსის სიგანის მოდულაციის სიგნალები) თვითმფრინავის სხვა ნაწილებზე.

2. ESC (სიჩქარის ელექტრონული კონტროლერები)

ეს ყვითელი ნაწილები ჩარჩოს ქვეშ გვხვდება. ისინი 4 ჩართულია Navio– ში, თითო თითოეული ძრავისთვის. PWM სიგნალების მიღების შემდეგ ისინი ბრუნავს ძრავებს და იწყებენ ფრენას.

3. მოტორსი

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

4. პროპელერები

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

5. ბატარეის და დენის მოდული

LiPo ბატარეა ენერგიის მთელ მოდულს იყენებს მთელ თვითმფრინავზე ჩარჩოში. ის იძლევა დაახლოებით 15-20 წუთის ფრენის დროს და მოქმედებს როგორც ენერგიის წყარო.

6. GPS

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

7. ტელემეტრიის მოდული

ტელემეტრიის მოდული აკავშირებს ჩვენს თვითმფრინავს სახმელეთო კონტროლის სადგურთან, ჩვენს შემთხვევაში მისიის დამგეგმავი, მონიტორინგისთვის.

8. RC კონტროლერი და მოდული PPM კოდირებით

RC კონტროლერი იყენებს რადიოს სიგნალებისა და ბრძანებების გადასატანად RC მოდულში, რათა დრონი ხელით მართოს. PPM Encoder თარგმნის ამ სიგნალებს Navio + RPI დამუშავებისა და შესასრულებლად.

9. ჩარჩო

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

ახლა თითოეული ნაწილის ცოდნით, ჩვენ საბოლოოდ შეგვიძლია ავაშენოთ დრონი! გადადით შემდეგ საფეხურზე!

ნაბიჯი 2: თვითმფრინავის აწყობა

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

Raspberry Pi Drone– ის მშენებლობა

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

1. მოაწყეთ თქვენი მარაგი - შეაგროვეთ ჩვენი მასალები და დარწმუნდით, რომ ისინი ადვილად მისაწვდომია

2. დაგეგმეთ თქვენი მშენებლობა - მოაწყეთ თქვენი ნაწილები ჩარჩოზე, რათა შეიმუშაოთ გეგმა იმისა, რასაც თქვენ ააშენებთ

3. შედუღების სამუშაო - ეს არის სამუშაო, რომლის გაკეთებაც ცოტათი ძნელია მარტო. თქვენ უნდა შეკრათ ოქროს ტყვიის კონექტორები, რომლებიც მოყვება ძრავებს ESC– ს. შემდეგი, თქვენ უნდა აიღოთ ჩარჩოს ქვედა ნაწილი და შეაერთოთ ESC ის ქვედა ჩარჩოზე ან ენერგიის განაწილების დაფაზე. ბატარეის მოდული ასევე გაიყიდება ელექტროენერგიის განაწილების დაფაზე

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

5. RC კონტროლერის მიმღებთან მიბმა - სცადეთ მიჰყევით ზემოთ მოცემულ ჩამონათვალში მითითებებს, რომ დაუკავშიროთ RC კონტროლერი ESC– ს გამოყენებით.

6. ნაწილების დასრულება ჩარჩოზე - ფირზე ან სამაჯური ტელემეტრიული მოდულის ჩარჩოზე. მიამაგრეთ PPM დამშიფრავი მკლავზე. ახლა თქვენ შეგიძლიათ მიაბათ ESC და PPM კოდირება Navio– ში.

7. GPS მთა + ბატარეა - შეიკრიბეთ GPS მთა სხვადასხვა ხრახნებითა და ნაჭრებით. სამაგრების გამოყენებით მიამაგრეთ GPS ჩარჩოზე. მე არ გამომიყენებია GPS მთა მისი სისუსტის გამო, მაგრამ ეს თქვენზეა დამოკიდებული. შემდეგი, თქვენ შეგიძლიათ ჩადოთ ბატარეა Power Dist. დაფა. ჩამონტაჟებული და ჩამონტაჟებული ჩავწერე დენის მოდული ჩარჩოზეც. ახლა თქვენი აპარატურა საკმაოდ დაყენებულია. ახლა იმ ნაწილს, რომელსაც ჩვენ ველოდებით!

8. პროპელერების დაყენება !!! - შეგიძლიათ გამკაცრდეს პროპელერები დასაკრავი სიაში მითითებული სქემის გამოყენებით. შემდეგ შეგიძლიათ ჩართოთ ESC- ის ძრავები და ჩვენ საბოლოოდ დავასრულეთ თვითმფრინავის მშენებლობა.

პროგრამული უზრუნველყოფა არის შემდეგი, ასე შემდეგ!

ნაბიჯი 3: Raspberry Pi და GCS (მისიის დამგეგმავი) კონფიგურაცია

კიდევ ერთხელ, თქვენ შეგიძლიათ იპოვოთ უფრო დეტალური ინსტრუქციები დასაკრავი სიიდან ბოლო საფეხურიდან. თუმცა, თქვენ ალბათ იცით როგორ დააინსტალიროთ RasPi. მაგრამ ამჯერად ჩვენ ამას თავდაუზოგავად ვაკეთებთ. გამოიყენეთ Balena Etcher, რომ ჩაწეროთ ოპერაციული სისტემა Navio OS ვებ გვერდიდან MicroSD ბარათში. სანამ ის თქვენს კომპიუტერშია ჩართული, შედით wpa პროგრამაში, notepad ++ - ის გამოყენებით. ამის შემდეგ, შეიყვანეთ ssid და პაროლი Raspberry Pi– სთვის, რათა დაუკავშირდეთ თქვენს WiFi– ს. შემდეგ თქვენ უნდა დაამატოთ ფაილი სახელწოდებით SSH. ეს შეიძლება იყოს ბრძანების ხაზის ან სხვა მეთოდის საშუალებით. ახლა ჩვენ შეგვიძლია SSH. თქვენ შეგიძლიათ გამოიყენოთ ბრძანების სტრიქონი ან Putty. მე გამოვიყენე ბრძანების სტრიქონი და დავწერე "ssh pi@navio" ჩემს შემთხვევაში დასაკავშირებლად, ან შეგიძლიათ იპოვოთ IP მისამართი და ssh ამ გზით. დაკავშირებისას გამოიყენეთ ეს ვიდეო Navio– ს დასაყენებლად და კონფიგურაციისთვის. ტელემეტრიის დასაყენებლად ჯერ უნდა შეცვალოთ ჟოლოს პიზე. მიჰყევით ამას, რათა განახორციელოთ ცვლილებები და სცადოთ დაკავშირება მისიის დამგეგმავთან. თუ ტელემეტრია არ მუშაობს, შეგიძლიათ გააუქმოთ რედაქტირება და დაუკავშიროთ UDB კავშირის გამოყენებით თქვენი GCS (სახმელეთო კონტროლის სადგური, როგორიცაა ლეპტოპი) IP. მისიის დამგეგმავთან დაკავშირების შემდეგ, თქვენ შეგიძლიათ გამოიყენოთ დაყენების ოსტატი დრონის ყველა ნაწილის დაკალიბრებისთვის. თუ დახმარება გჭირდებათ, კვლავ მიმართეთ დასაკრავ სიას. ჩვეულებრივ, როდესაც თქვენ შექმნით, თითქმის ყოველთვის არის შეცდომა. პრობლემების მოგვარება არის ამ პროექტის ერთ -ერთი უდიდესი ნაწილი. მე ნამდვილად არ შემიძლია დაგეხმაროთ იქ, რადგან არ ვიცი თქვენი შეცდომების შესახებ, მაგრამ შეცდომების უმეტესობა შეიძლება გამოსწორდეს ინტერნეტის დახმარებით. მას შემდეგ რაც ყველაფერი მზად არის, მაშინ დრონი მზად არის ფრენისთვის! თქვენ შეგიძლიათ დააყენოთ თქვენი RC კონტროლერი და ფრენის რეჟიმები Mission Planner– ზე. ეცადეთ, მარცხენა ჯოხი დაიჭიროთ ქვედა მარჯვენა მხარეს ხუთი წამის განმავლობაში, რათა დრონი შეიარაღდეს. მე არ გირჩევთ ფრენას გაკვეთილის გარეშე, რადგან დრონი ძალიან მყიფეა და ადვილად იშლება. ჩემთვის, პირველად რომ დავფრინავდი, გავტეხე GPS მთა და რამდენიმე პროპელერი. თუ თქვენ არ გჭირდებათ ხმის კონტროლი, მაშინ შეგიძლიათ აქ გაჩერდეთ. იმისათვის, რომ გაეცნოთ AWS- ს და დრონის პროგრამირებას, განაგრძეთ!

ნაბიჯი 4: დრონის დაპროგრამება პითონთან გასაფრენად

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

1. ჯერ მოდით გადმოწეროთ ArduPilot წყაროს კოდი Raspberry Pi- ის კატალოგში

mkdir src

შემდეგ, მიიღეთ ფაილები GitHub– დან git კლონის გამოყენებით

git clone -b Copter -3.6.11

ახლა მოდით გადავიდეთ /src /ardupilot– ზე

cd src

cd ardupilot

ახლა მოდით, საწყისი ფაილების ინიციალიზაცია

git ქვემოდულის განახლება -init -რეკურსიული

2. შემდეგი, ჩვენ უნდა შევადგინოთ firmware Raspberry Pi– ზე

დარწმუნდით, რომ გადახვალთ/src/ardupilot/cd– ით შემდეგი ნაბიჯების გადადგმამდე

შემდეგ სპეციალურად Navio– ს კოფიგურაციისთვის

./waf კონფიგურაცია --board = navio2

შემდეგ შეგიძლიათ შეადგინოთ

./waf -სამიზნეების ბინ/არდიკოპტერი

3. ახლა ჩვენ შეგვიძლია დავაინსტალიროთ წყაროს კოდი Navio– ში

პირველი ნავიგაციის უფლება დირექტორია.

cd/etc/systemd/system

შემდეგ შეცვალეთ ფაილი

sudo vi arducopter.service

სადაც ნათქვამია ExecStart, ჩაწერეთ შემდეგი იმის ნაცვლად, რაც უკვე არსებობს

ExecStart =/bin/sh -c "/home/pi/src/arducopter/build/navio2/bin/arducopter $ {ARDUPILOT_OPTS}"

ახლა, ardupilot წყაროს კოდის ამოქმედების მიზნით, ჩვენ შეგვიძლია გამოვიყენოთ

sudo systemctl daemon-reload

შემდეგ ჩვენ შეგვიძლია გადატვირთვა

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

ბოლო ნაბიჯით, ჩვენ საბოლოოდ დავასრულეთ ArduPilot– ის დაყენება ჩვენს თვითმფრინავზე

4. DroneKit– ის დაყენება

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

ჩვენ შეგვიძლია დავაინსტალიროთ პითონის პაკეტი

pip install dronekit == 2.9.1

ეს შეიძლება იყოს, ან არ იყოს უახლესი ვერსია, მაგრამ ის არის ის, რაც მე გამოვიყენე, რათა დავეხმარო პრობლემების მოგვარებაში.

ინსტალაციის შემოწმების მიზნით, ჩვენ შეგვიძლია გავაკეთოთ ა

პიპის გაყინვა | grep dronekit

ახლა ჩვენ საბოლოოდ მზად ვართ გავაკეთოთ ჩვენი პირველი პითონის სკრიპტი

5. ასაფრენი და მიწა. Py

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

## ჯერ არ შევქმნათ დირექტორია ამ კოდის შესანახად

cd dk ## თუ გსურთ ამის გაკეთება, გამოიყენეთ vi takeoff_and_land.py ## პროგრამის შესაქმნელად

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

chmod +x ასაფრენი_და_ მიწა. py

შემდეგ, სცადეთ გამოიყენოთ შემდეგი კოდი გასაშვებად

პითონი takeoff_and_land.py -დაკავშირება 127.0.0.1:14550

პირველად ეს არც მე გამომივიდა. თუ არსებობს ბმულის ვადა, მაშინ არ ინერვიულოთ, რომ რისი გაკეთებაც შეგიძლიათ. გახსენით სხვა მოთხოვნა და ssh. შეგიძლიათ სცადოთ რაღაცის დაყენება, სახელწოდებით mavproxy და სცადოთ მისი გაშვება. ამის შემდეგ შეგიძლიათ ორივე ერთდროულად გაუშვათ. ეს უნდა დაეხმაროს თვითმფრინავის დაკავშირებას. ამის დასრულების შემდეგ, მე მაქვს გამოწვევა თქვენთვის. შეეცადეთ გაარკვიოთ რას აკეთებს სხვა პროგრამა (set_velocity_body.py) და როგორ უნდა იმუშაოს იგი. თუ ასეა, კარგი სამუშაო.

6. წინ!

ჩვენ ახლა შეგვიძლია გამოვიყენოთ ეს ცოდნა იმისათვის, რომ ჩვენი დრონი ხმის კონტროლირებადი იყოს. Alexa თვითმფრინავების კონტროლი იყენებს ბევრ ამ მახასიათებელს და სხვა. წარმატებები და წინსვლა!

ნაბიჯი 5: Amazon Alexa და Amazon ვებ სერვისების გამოყენება ხმის კონტროლის ინტეგრირებისთვის

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

1. Raspberry Pi- ის დარეგისტრირება როგორც ნივთი AWS IoT- ზე

IoT (ნივთების ინტერნეტი) გამოსაყენებლად, ჩვენ გვჭირდება რაღაც. ასე რომ, ჩვენ უნდა შეხვიდეთ AWS კონსოლში, რათა პირველად გამოვიყენოთ AWS IoT. შემდეგ გადადით IoT Core– ზე. იქ ყოფნისას თქვენ უნდა დააწკაპუნოთ მართვაზე და შემდეგ შექმნათ ნივთი. სახელის დამატების შემდეგ, დასაკავშირებლად, ჩვენ გვჭირდება სერთიფიკატი. მე გირჩევთ დააწკაპუნოთ ერთი დაწკაპუნების სერტიფიკატზე. შემდეგ სერთიფიკატის ეკრანის ნახვის შემდეგ, დარწმუნდით, რომ ჩამოტვირთეთ თითოეული გასაღები, მათ შორის, ძირეული CA. შემდეგ შეგიძლია წახვიდე და დაასრულო ნივთის შექმნა. შემდეგ ჩვენ უნდა შევქმნათ პოლიტიკა. დაბრუნდით IoT Core– ში. შემდეგ დააჭირეთ უსაფრთხო და დააწკაპუნეთ პოლიტიკაზე. შემდეგ დააჭირეთ პოლიტიკის შექმნას. ამის შემდეგ შეგიძლიათ შექმნათ სახელი და დაამატოთ რესურსები. მოქმედებისას აკრიფეთ iot * და ტიპი * რესურსის ქვეშ და დააჭირეთ ეფექტს. შემდეგ დაუბრუნდით თქვენს ნივთს და გადადით თქვენს სერთიფიკატზე. ერთხელ აქ, დააწკაპუნეთ პოლიტიკაზე. ამის შემდეგ შეგიძლიათ მიამაგროთ თქვენი პოლიტიკა ნივთზე და ყველაფერი მზად არის!

2. Raspberry Pi– ზე კოდის დაყენება და IoT– სთან ურთიერთობა

ამ ნაწილისთვის, თქვენ დაგჭირდებათ SFTP კლიენტი (მე გამოვიყენე WinSCP) ფაილის გადასატანად. ჩვენს Raspberry Pi– სთან დაკავშირებისას, ჩვენ გვჭირდება სერტიფიკატის გასაღებები ხელთ. თქვენ უნდა გადაიტანოთ ძირითადი ფაილები Raspberry Pi– ში. თქვენ ასევე უნდა დააინსტალიროთ AWSIoTPythonSDK Raspberry Pi– ზე. შემდეგ შედით dk დირექტორიაში Raspberry Pi– ზე. თქვენ იყენებთ Alexa Drone Control ფაილს, რომელიც მე მივეცი IoT– თან კომუნიკაციისთვის. ამ ფაილის გამოსაყენებლად მე გამოვიყენე Shell Script დასაწყებად. მე ვაჩვენებ კოდს ქვემოთ, რადგან რატომღაც არ შემიძლია ფაილის ატვირთვა. თუ პროგრამა ტესტირებისას არ იღებს შეტყობინებებს AWS IoT– დან, არ ინერვიულოთ! ეს შეიძლება იყოს ჩემი ბრალი, რადგან Alexa Drone საკონტროლო ფაილი შეიძლება არ მოერგოს თქვენს ნივთს. ასე რომ, მისი გამოსასწორებლად, დაბრუნდით AWS IoT– ზე და დააჭირეთ მარცხენა პანელზე Learn. მიჰყევით ინსტრუქციას და შეიძლება დაგჭირდეთ გადატვირთვა. Ვწუხვარ ამის გამო. მას შემდეგ რაც თქვენი IoT იწყებს მუშაობას RasPi– ს პროგრამასთან, შეგიძლიათ დააკავშიროთ dronekit კოდი Alexa Drone Control ფაილიდან, რომელიც მე მომეცა. ამის შემდეგ გამოიყენეთ Shell Script, რომელიც მე მომეცი თქვენი სერთიფიკატებით და დანარჩენი API Endpoint IoT– დან.

# გაჩერების სკრიპტი erroret -e # შეამოწმეთ თუ არსებობს root CA ფაილი, გადმოწერეთ თუ არა [! -ფ./root-CA.crt]; შემდეგ printf "\ n ჩამოტვირთეთ AWS IoT Root CA სერთიფიკატი AWS– დან … / n" curl https://www.amazontrust.com/repository/AmazonRoot…>> root-CA.crt fi # დააინსტალირეთ AWS მოწყობილობის SDK პითონისთვის, თუ უკვე არ არის დაინსტალირებული თუ [! -დ./aws-iot-device-sdk-python]; შემდეგ printf "\ nAWS SDK … / n" git clone https://www.amazontrust.com/repository/AmazonRoot…> pushd aws-iot-device-sdk-python python setup.py დააინსტალირეთ popd fi

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

printf "\ n გაშვებული პაბი/ქვე ნიმუში პროგრამა… / n" python dk/AlexaDroneControl.py -დაკავშირება 127.0.0.1:14550 -e "Your IoT ARN" -r root -CA.crt -c PiGroundStation01.cert.pem -k PiGroundStation01.private.key

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

3. შექმენით თქვენი Alexa უნარი

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

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

ნაბიჯი 4: შექმენით თქვენი ლამბდა ფუნქცია

ახლა, ეს ნაბიჯი არის ის, რაც თქვენ თავად უნდა გაარკვიოთ. მე გეტყვით, თუ როგორ უნდა დააკავშიროთ იგი Alexa Skill– თან, მაგრამ თქვენ თვითონ მოგიწევთ მისი კოდირება. ასე რომ, ჯერ გადადით AWS მენეჯმენტის კონსოლზე. შემდეგ წადი ლამბდაში. ამის შემდეგ თქვენ შეგიძლიათ შექმნათ ფუნქცია და დაასახელოთ ის რაც გსურთ. დარწმუნდით, რომ დაწერეთ იგი ნულიდან და გახადეთ გაშვებული დრო, რომელი პროგრამირების ენა გსურთ. მე გამოვიყენე Node.js. Alexa უნარის დასამატებლად დაამატეთ გამომწვევი და შეარჩიეთ Alexa Skills Kit (ASK). დააკოპირეთ თქვენი Lambda ARN და დაუბრუნდით Alexa უნარს. ახლა გადადით საბოლოო წერტილზე. თქვენ შეგიძლიათ ჩასვათ თქვენი ARN, შეინახოთ და შექმნათ ახალი მოდელი. შემდეგ აიღეთ Alexa Skill ID და ჩასვით იგი ტრიგერის განყოფილებაში, სადაც ის მოგთხოვთ ლამბდაზე. შემდეგი, გადაახვიეთ ქვემოთ ლამბდაზე და იპოვეთ ძირითადი პარამეტრები და გააკეთეთ დრო 10 წამი. ახლა თქვენზეა დამოკიდებული, რომ გაარკვიოთ კოდი. მინიშნებისთვის, შეგიძლიათ ქვემოთ მოყვანილი ვებსაიტები.

github.com/aws/aws-iot-device-sdk-js

www.hackster.io/veggiebenz/voice-controlle…

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

/ *** აკონტროლეთ თქვენი APM / Pixhawk ოთხკუთხედი თქვენი ხმით, Amazon Alexa, Lambda, 2lemetry MQTT გამოყენებით.*/ var awsIot = მოითხოვს ('aws-iot-device-sdk'); var config = მოითხოვს ("./ კონფიგურაცია"); var deviceName = "EchoDroneControl"; // ეს მოწყობილობა ნამდვილად არის კონტროლერი var mqtt_config = {"keyPath": config.privateKey, "certPath": config.certificate, "caPath": config.rootCA, "host": config.host, "port": 8883, "clientId": "Lambda-" + მოწყობილობის სახელი, // + "-Lambda-" + (ახალი თარიღი (). getTime ()), "region": "us-east-1", "debug": true}; var ctx = null; var კლიენტი = null; // გააგზავნეთ შემომავალი მოთხოვნა ტიპის მიხედვით (LaunchRequest, IntentRequest და ა.შ.) მოთხოვნის JSON ძირითადი ნაწილი მოცემულია მოვლენის პარამეტრში. export.handler = ფუნქცია (მოვლენა, კონტექსტი) {try {console.log ("event.session.application.applicationId =" + event.session.application.applicationId); ctx = კონტექსტი; if (event.session.application.applicationId! == app_id) {ctx.fail ("აპლიკაციის არასწორი ID"); } კლიენტი = awsIot.device (mqtt_config); client.on ("დაკავშირება", ფუნქცია () {console.log ("დაკავშირებულია AWS IoT"); // callback ();});

if (event.session.new) {

onSessionStarted ({requestId: event.request.requestId}, event.session); } if (event.request.type === "LaunchRequest") {onLaunch (event.quest, event.session); } else if (event.request.type === "IntentRequest") {onIntent (event.quest, event.session); } else if (event.request.type === "SessionEndedRequest") {onSessionEnded (event.quest, event.session); ctx. წარმატება (); }} catch (e) {console.log ("გამონაკლისი დამმუშავებელში:" + e); ctx.fail ("გამონაკლისი:" + ე); }}; /*** იძახება სესიის დაწყებისას. */ function onSessionStarted (sessionStartedRequest, session) {console.log ("onSessionStarted requestId =" + sessionStartedRequest.requestId + ", sessionId =" + session.sessionId); }

/**

* დარეკილია, როდესაც მომხმარებელი იწყებს უნარ -ჩვევებს ისე, რომ არ დააკონკრეტოს რა სურს. */ ფუნქცია onLaunch (startRequest, session, callback) {console.log ("onLaunch requestId =" + launRequest.requestId + ", sessionId =" + session.sessionId); // გაგზავნეთ თქვენი უნარების გაშვებაზე. getWelcomeResponse (გამოძახება); } /*** იძახება, როდესაც მომხმარებელი განსაზღვრავს ამ უნარის განზრახვას. */ფუნქცია onIntent (განზრახვის მოთხოვნა, სესია) {//, გამოძახება) {console.log ("onIntent requestId =" + purposeRequest.requestId + ", sessionId =" + session.sessionId); var განზრახვა = განზრახვა. განზრახვა, განზრახვა სახელი = განზრახვა. console.log ("REQUEST to string =" + JSON.stringify (purposeRequest)); var callback = null; // გაგზავნეთ თქვენი უნარების განზრახვის დამმუშავებლებში, თუ ("GoIntent" === purposeName) {doGoIntent (განზრახვა, სესია); } else if ("CommandIntent" === purposeName) {doCommandIntent (განზრახვა, სესია); } else if ("TurnIntent" === purposeName) {doTurnIntent (განზრახვა, სესია); } else if ("HelpIntent" === purposeName) {getWelcomeResponse (); } else {ჩააგდე "არასწორი განზრახვა"; }} /*** იძახება, როდესაც მომხმარებელი ამთავრებს სესიას. * არ იძახება, როდესაც უნარი ბრუნდება shouldEndSession = true. */ ფუნქცია onSessionEnded (sessionEndedRequest, session) {console.log ("onSessionEnded requestId =" + sessionEndedRequest.requestId + ", sessionId =" + session.sessionId); // დაამატეთ გასუფთავების ლოგიკა აქ} // --------------- ფუნქციები, რომლებიც აკონტროლებენ უნარის ქცევას -------------------- --- ფუნქცია getWelcomeResponse () {// თუ გვინდოდა სესიის ინიციალიზაცია, რომ ჰქონოდა გარკვეული ატრიბუტები, ჩვენ შეგვიძლია აქ დავამატოთ ისინი. var sessionAttributes = {}; var cardTitle = "მოგესალმებით"; var speechOutput = "კეთილი იყოს თქვენი მობრძანება DRONE CONTROL- ში."; // TODO: თვითმფრინავი არის ონლაინ თუ ოფლაინში? თუ ონლაინ არის, შეიარაღებულია? var repromptText = "დრონი მზად არის ბრძანებისთვის."; var shouldEndSession = false; ctx.succcess (buildResponse (sessionAttributes, buildSpeechletResponse (cardTitle, speechOutput, repromptText, shouldEndSession))); } /*** ამუშავებს GO განზრახვას. */ ფუნქცია doGoIntent (განზრახვა, სესია, გამოძახება) {// var cardTitle = "თვითმფრინავი GO …"; var repromptText = ""; var sessionAttributes = {}; var shouldEndSession = false; var speechOutput = ""; var მიმართულება = განზრახვა. slots.direction.value; var მანძილი = განზრახვა. ადგილები. მანძილი. მნიშვნელობა; var ერთეული = purpose.slots. Unit.value; var validDirections = ["წინ", "წინ", "უკან", "უკან", "მარჯვნივ", "მარცხნივ", "ზემოთ", "ქვემოთ", "პირდაპირ", "წინ", "პირდაპირ წინ"]; var validUnits = ["ფეხი", "ფეხები", "მეტრი", "მეტრი", "ეზო", "ეზოები"]; repromptText = "მითხარი რამდენად შორს უნდა წავიდე და რა მიმართულებით."; var fail = false; // შეაფასეთ შეყვანა, თუ (! (parseInt (მანძილი)> = 1)) {speechOutput = "მე ვერ გავიგე მანძილი, რომლის გავლაც გსურთ."; მარცხი = ჭეშმარიტი; ctx.succcess (buildResponse (sessionAttributes, buildSpeechletResponse (cardTitle, speechOutput, repromptText, shouldEndSession))); } if (validDirections.indexOf (მიმართულება) == -1) {speechOutput = "მე ვერ გავიგე ის მიმართულება, საიდანაც გსურთ რომ ვიმოგზაურო."; მარცხი = ჭეშმარიტი; ctx.succcess (buildResponse (sessionAttributes, buildSpeechletResponse (cardTitle, speechOutput, repromptText, shouldEndSession))); } if (validUnits.indexOf (unit) == -1) {speechOutput = "მე ვერ გავიგე ის ერთეული, რომლის გამგზავრებაც გსურთ."; მარცხი = ჭეშმარიტი; ctx.succcess (buildResponse (sessionAttributes, buildSpeechletResponse (cardTitle, speechOutput, repromptText, shouldEndSession))); } if (! fail) {var cardTitle = "დრონი მიდის" + მიმართულება + "" + მანძილი + "" + ერთეული; speechOutput = "მიდის" + მიმართულება + "" + მანძილი + "" + ერთეული; mqttPublish (განზრახვა, სესიის ატრიბუტები, ბარათის სათაური, მეტყველების გამოსავალი, საყურადღებო ტექსტი, უნდა დაასრულოს სესია); }}

ფუნქცია doCommandIntent (განზრახვა, სესია, გამოძახება) {

// var cardTitle = "დრონის ბრძანება …"; var repromptText = null; var sessionAttributes = {}; var shouldEndSession = false; var speechOutput = ""; repromptText = "მითხარი რა არის ბრძანება დრონისთვის."; var ამოცანა = purpose.slots. Task.value; var validTasks = ["გაშვება", "მიწა", "რ. ტ. ლ.", "გამართვა", "დარჩენა", "გაჩერება", "დაბრუნება დასაწყებად", "შეწყვეტა"]; if (validTasks.indexOf (ამოცანა) == -1) {speechOutput = "მე ვერ გავიგე ბრძანება."; ctx.succcess (buildResponse (sessionAttributes, buildSpeechletResponse (cardTitle, speechOutput, repromptText, shouldEndSession))); } else {var cardTitle = "დრონის ბრძანების შესრულება" + ამოცანა; speechOutput = "ბრძანების შესრულება" + ამოცანა; mqttPublish (განზრახვა, სესიის ატრიბუტები, ბარათის სათაური, მეტყველების გამოსავალი, საყურადღებო ტექსტი, უნდა დაასრულოს სესია); }}

ფუნქცია doTurnIntent (განზრახვა, სესია, გამოძახება) {

// var cardTitle = "დრონის შემობრუნება …"; var repromptText = null; var sessionAttributes = {}; var shouldEndSession = false; var speechOutput = ""; repromptText = "მითხარი, როგორ გინდა დრონის გადაბრუნება."; var მიმართულება = განზრახვა. slots.direction.value; var validDirections = ["მარჯვნივ", "მარცხნივ", "გარშემო"]; if (validDirections.indexOf (მიმართულება) == -1) {speechOutput = "მე ვერ გავიგე შემობრუნების მიმართულება."; ctx.succcess (buildResponse (sessionAttributes, buildSpeechletResponse (cardTitle, speechOutput, repromptText, shouldEndSession))); } else {var cardTitle = "თვითმფრინავის ბრუნვა" + მიმართულება; speechOutput = "შემობრუნება" + მიმართულება; mqttPublish (განზრახვა, სესიის ატრიბუტები, ბარათის სათაური, მეტყველების გამოსავალი, საყურადღებო ტექსტი, უნდა დაასრულოს სესია); }}

ფუნქცია mqttPublish (განზრახვა, სესია ატრიბუტები, ბარათი სათაური, მეტყველება

{var strIntent = JSON.stringify (განზრახვა); console.log ("mqttPublish: INTENT text =" + strIntent); // client.publish ("ikw1zr46p50f81z/drone/echo", strIntent, false); client.publish (config.topic, strIntent, false); client.end (); client.on ("დახურვა", (ფუნქცია () {console.log ("MQTT CLIENT CLOSE - ფიქრობს, რომ ეს წარმატებით გაკეთდა."); ctx.succeed (buildResponse (sessionAttributes, buildSpeechletResponse (cardTitle, speechOutput, repromptText, shouldEndSession)));})); client.on ("შეცდომა", (ფუნქცია (შეცდომა, მინიჭებული) {console.log ("MQTT კლიენტის შეცდომა !!" + შეცდომა);})); }

// --------------- დამხმარეები, რომლებიც აგებენ ყველა პასუხს -----------------------

ფუნქცია buildSpeechletResponse (სათაური, გამომავალი, repromptText, shouldEndSession) {return {outputSpeech: {type: "PlainText", text: output}, card: {type: "Simple", title: title, content: output}, reprompt: {outputSpeech: {type: "PlainText", text: repromptText}}, shouldEndSession: shouldEndSession}} ფუნქცია buildResponse (sessionAttributes, speechletResponse) {return {version: "1.0", sessionAttributes: sessionAttributes, answer: speechletResponse}}