ჟოლოს ავზი ვებ ინტერფეისით და ვიდეო სტრიმინგით: 8 ნაბიჯი (სურათებით)

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

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

ეს არის გაკვეთილი, რომელიც მოითხოვს ელექტრონული და პროგრამული პროგრამირების ძირითად ცოდნას. ამ მიზეზით, მე ავირჩიე სატანკო შასის ნაკრები (იმის ნაცვლად, რომ დავიბეჭდო იგი 3D პრინტერის გამოყენებით, შეიძლება მოგვიანებით განახლდეს) და სულ 6 კომპონენტი ბატარეების ჩათვლით. პროგრამული უზრუნველყოფის მხრივ შეგიძლიათ ეტაპობრივად მიყვეთ ინსტალაციის პროცესს და პროგრამირება მინიმუმამდეა დაყვანილი, ჟოლოს საგნების ძირითადი ცოდნა დაგეხმარებათ.

მე შევაფასე 12 საათიანი სამუშაო 0 -დან ტანკზე მზაობისთვის. საერთო ღირებულება 70 € ყველა კომპონენტისთვის.

ნაბიჯი 1: BOM

1 - DIY RC Robot Chassis Tank - 32 (€)

www.banggood.com/DIY-RC-Robot-Chassis-Tan…

1 - Dual Channel L298N DC Motor Driver Board - 1, 39 (€)

www.banggood.com/Dual-Channel-L298N-DC-Mo…

1 - Raspberry Pi Zero W Starter Kit - 26 (€)

amzn.eu/1ugAaMP

1 - 16 GB SD ბარათი - 5, 50 (€)

www.gearbest.com/memory-cards/pp_337819.h…

1 - Raspberry Pi 5MP კამერის მოდულის ვებკამერა მოდელის ნულისთვის - 8 (€)

www.gearbest.com/raspberry-pi/pp_612249.h…

1 - დენის ბანკი 5V

1 - 9 ვ ბატარეა

შერეული პურის დაფის კაბელი Dupont კონექტორი

მაუსი, კლავიატურა, მონიტორი ან ტელევიზორი ჟოლოს დასაყენებლად (სურვილისამებრ, მხოლოდ პირველი კონფიგურაციის გასაადვილებლად)

ნაბიჯი 2: ძირითადი კომპონენტების მახასიათებლები

ძრავა

JGA25-370 DC გადაცემათა კოლოფი

ამ ძრავას აქვს D- ფორმის გამომავალი ლილვი.

სპეციფიკაციები

· სამუშაო ძაბვა: 6 V– დან 18 V– მდე

· ნომინალური ძაბვა: 12 ვ

· თავისუფალი გაშვების სიჩქარე 12 V- ზე: 399 RPM

· თავისუფალი გაშვებული დენი 12 V- ზე: 50 mA

· ჩამკეტის დენი 12V: 1200 mA

· ბრუნვის მომენტი 12 ვ -ზე: 2.2 კგ. სმ

· გადაცემის თანაფარდობა: 1:21

· რედუქტორის ზომა: 19 მმ

· წონა: 84 გ

ორმაგი არხი L298N DC საავტომობილო დრაივერის დაფა

ორმაგი H- ხიდის ძრავის მძღოლს, შეუძლია მართოს ორი DC ძრავა ან 4 მავთულის ორფაზიანი სტეპერიანი ძრავა. ჩამონტაჟებული TSD, საავტომობილო სადგომისგან დასაცავად.

სპეციფიკაციები

· მოდულის მიწოდების ძაბვა: DC 2V-10V

· სიგნალის შეყვანის ძაბვა: DC 1.8-7V

· ერთჯერადი სამუშაო დენი: 1.5A

· პიკის დენი 2.5A– მდე

· დაბალი ლოდინის დენი (0.1uA– ზე ნაკლები)

· ჩამონტაჟებული საერთო გამტარობის წრე, შეყვანის ტერმინალი ვაკანტური, ძრავა არ მუშაობს

· ზომა: 24.7 x 21 x 7 მმ

ნაბიჯი 3: გაყვანილობა

ეს იქნება საბოლოო გაყვანილობა, მაგრამ დაელოდეთ, სანამ ჩვენ უნდა დავაინსტალიროთ

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

ჩვენ გვჭირდება ენერგიის ორი განსხვავებული წყარო, ერთი ძრავისთვის და ერთი ჟოლოსთვის.

საავტომობილო დრაივერი Dual Channel L298N DC Motor Driver Board (მაქსიმალური შეყვანის ძაბვა DC 2V-10V) იკვებება 9V ბატარეის გამოყენებით და Raspberry Pi იყენებს სტანდარტების 5V USB აკუმულატორს.

საავტომობილო დრაივერის GND პინი უკავშირდება ბატარეას მინუს და ჟოლოს Pi (GND). Raspberry Pi– ის GPIO ქინძისთავები დაკავშირებულია ძრავის მძღოლთან, როგორც მაგიდა.

ნაბიჯი 4: RASPBERRY O. S.- ის მომზადება

ეს არის სტანდარტული ინსტალაცია Raspbian ოპერაციული სისტემისთვის, შეგიძლიათ იპოვოთ

ბევრი დეტალური სამეურვეო ძიება ინტერნეტში, ძირითადად ნაბიჯებია:

1. ჩამოტვირთეთ iso RASPBIAN STRETCH WESKTOP– ით

2. 16 GB SD ბარათის ფორმატირება, მე გამოვიყენე SD ფორმატი

3. დაწვით. IMG ფაილი, მე გამოვიყენე Win32DiskImager

ახლა თქვენი ჟოლო მზადაა ჩატვირთვისას, დაუკავშიროთ იგი USB დენის წყაროს (5V, 2A) და მოემზადეთ პირველი ჩატვირთვის დაყენებისთვის. ამის გაკეთება შეგიძლიათ ორი გზით, გარე მოწყობილობების გამოყენებით, როგორიცაა მაუსი, კლავიატურა და მონიტორი, ან თქვენი კომპიუტერი და დისტანციური კავშირი ჟოლოსთან. ამის შესახებ ბევრი სასწავლო მასალაა, ერთი არის:

ნაბიჯი 5: როგორ გავაკონტროლოთ ჩვენი WIFI ტანკი NODE. JS და WEBSOCKET. IO

ახლა ჩვენ გვაქვს ჟოლოს მიკრო კომპიუტერის ახალი ინსტალაცია, რომელიც მზად არის ჩვენი სამუშაოს გასაშვებად, ასე რომ … რას ვიყენებთ სატანკოზე ბრძანებების გასაცემად?

პითონი არის ძალიან მარტივი ენა, რომელიც ჩვეულებრივ გამოიყენება Rapsberry პროექტის ქვიშის გასაშვებად, ასევე მარტივად შეიძლება გამოყენებულ იქნას Rapsberry შეყვანისა და გამომავალი ქინძისთავებისთვის (GPIO)

მაგრამ, ჩემი მიზანი იყო ჩემი სატანკო wi-fi დაკავშირება ნებისმიერი მოწყობილობიდან (კომპიუტერი, მობილური ტელეფონი, ტაბლეტი …) საერთო ბრაუზერის გამოყენებით და ასევე ვიდეოს სტრიმინგი მისგან. ასე რომ, დაივიწყეთ პითონი ახლავე და მოდით გადავიდეთ NODE. JS და SOCKET. IO.

NODE.js

Node.js (https://github.com/nodejs/node/wiki) არის ღია კოდის სერვერის ჩარჩო სამუშაო, რომელიც დაფუძნებულია js ენაზე. ვინაიდან მე ვიყენებ Raspberry Pi Zero- ს (ARMv6 CPU) ჩვენ არ შეგვიძლია გამოვიყენოთ ავტომატური ინსტალაციის პროცესი (განკუთვნილია ARMv7 CPU– სთვის) და ჩვენ ეს უნდა გავაკეთოთ ხელით:

ჩამოტვირთეთ Nodejs ადგილობრივად, (მე გამოვიყენე 7.7.2 ვერსია ARMv6– ისთვის, შეამოწმეთ სხვა ვერსიები აქ

pi@ჟოლო: ~ $ wget

nodejs.org/dist/v7.7.2/node-v7.7.2-linux-…

დასრულების შემდეგ, ამოიღეთ შეკუმშული ფაილი:

pi@ჟოლო: ~ $ tar -xzf node-v7.7.2-linux-armv6l.tar.gz

დააკოპირეთ და დააინსტალირეთ ფაილები /user /local

pi@ჟოლო: ~ $ sudo cp -R node-v7.7.2-linux-armv6l/*/usr/local/

დაამატეთ ადგილი, სადაც ჩვენ დავაინსტალირებთ nodejs- ს ბილიკზე, შეცვალეთ ".profile" ფაილი:

pi@ჟოლო: ~ $ nano ~/.პროფილი

დაამატეთ შემდეგი სტრიქონი ფაილის ბოლოს, შეინახეთ და გამოდით

PATH = $ PATH:/usr/local/bin

წაშალეთ გადმოწერილი ფაილი:.

pi@ჟოლო: ~ $ rm ~/node-v7.7.2-linux-armv6l.tar.gz

pi@ჟოლო: ~ $ rm -r ~/node-v7.7.2-linux-armv6l

ჩაწერეთ შემდეგი ბრძანებები nodejs– ის ინსტალაციის შესამოწმებლად:

pi@ჟოლო: ~ $ node -v

pi@ჟოლო: ~ $ npm -v

თქვენ უნდა წაიკითხოთ v7.7.2 და v4.1.2, როგორც პასუხი.

თუ ყველაფერი კარგად წავიდა, შექმენით ახალი საქაღალდე თქვენი nodejs ფაილების გასანათებლად:

pi@ჟოლო: ~ $ mkdir nodehome

ახალი საქაღალდის შიგნით გადატანა:

pi@ჟოლო: ~ $ cd nodehome

დააინსტალირეთ დამატებითი მოდული, რომელიც საჭიროა GPIO- ს მართვისათვის ყველაზე ძირითადი გზით, ჩართული და გამორთული:

pi@ჟოლო: n $ npm ინსტალაცია გამორთულია

ახლა დროა შევამოწმოთ ჩვენი პირველი პროექტი "Blink.js", შედეგი იქნება … მოციმციმე LED

pi@ჟოლო: ~ $ nano blink.js

ჩასვით შემდეგი კოდი, შეინახეთ და გამოდით:

var Gpio = მოითხოვს ("გამორთვა"). Gpio; // ჩართვა ჩართვა

var LED = ახალი Gpio (3, 'out'); // გამოიყენეთ GPIO 3

var blinkInterval = setInterval (მოციმციმე LED, 250);

// მოციმციმე LED ყოველ 250 წმ

ფუნქცია blinkLED () {// ფუნქცია ციმციმის დასაწყებად

თუ

(LED.readSync () === 0) {// შეამოწმეთ პინის მდგომარეობა, თუ მდგომარეობა არის 0 (ან გამორთული)

LED.writeSync (1);

// დააყენეთ პინის მდგომარეობა 1 -ზე (ჩართეთ LED)

} სხვა {

LED.writeSync (0);

// დააყენეთ პინის მდგომარეობა 0 -ზე (გამორთეთ LED)

}

}

ფუნქცია endBlink () {// ფუნქცია აციმციმებლად

გამჭვირვალე ინტერვალი (მოციმციმე ინტერვალი); // შეწყვიტეთ დახუჭვის ინტერვალი

LED.writeSync (0); // გამორთეთ LED

LED.unexport (); // გამოაქვეყნეთ GPIO უფასო რესურსებზე

}

setTimeout (endBlink, 5000); // შეწყვიტე მოციმციმე 5 წამის შემდეგ

მავთულის LED, Resistor (200ohms) როგორც ნაჩვენებია სქემაში და გაუშვით პროექტი:

pi@ჟოლო: ~ $ კვანძი blink.js

კვანძი მზად არის.

SOCKET. IO

WebSocket არის კომპიუტერული საკომუნიკაციო პროტოკოლი, რომელიც დაფუძნებულია TCP კავშირზე, ის უზრუნველყოფს პროგრამისტს სერვერისა და კლიენტის შესაქმნელად. კლიენტი უკავშირდება სერვერს და ასხივებს და იღებს შეტყობინებებს სერვერზე და მისგან. Node.js– ისთვის WebSocket განხორციელებას ეწოდება Socket.io (https://socket.io/).

დააინსტალირეთ socket.io:

pi@ჟოლო: ~ $ npm დააინსტალირეთ socket.io -შენახვა

გადაადგილდით nodejs სახლში, რომელიც შეიქმნა წინათ:

pi@ჟოლო: ~ $ cd nodehome

და შექმენით ახალი საქაღალდე "საჯარო":

pi@ჟოლო: m $ mkdir საჯარო

შექმენით ახალი სერვერის ნიმუში, დაარქვით მას "webserver.js"

pi@ჟოლო: $ nano webserver.js

ჩასვით შემდეგი კოდი, შეინახეთ და გამოდით:

var http = მოითხოვს ('http'). createServer (დამმუშავებელი); // მოითხოვეთ http სერვერი და შექმენით სერვერი ფუნქციის დამმუშავებლით ()

var fs = მოითხოვს ('fs'); // მოითხოვს ფაილური სისტემის მოდულს

http.listen (8080); // მოუსმინეთ პორტს 8080

ფუნქციის დამმუშავებელი (req, res) {// სერვერის შექმნა

fs.readFile (_ dirname + '/public/index.html', ფუნქცია (შეცდომა, მონაცემები) {// წაკითხვა

ფაილის index.html საჯარო საქაღალდეში

თუ (შეცდომა) {

res.writeHead (404, {'Content-Type': 'text/html'}); // შეცდომის ჩვენება 404

დაბრუნება res.end ( 404 არა

ნაპოვნია );

}

res.writeHead (200, {'Content-Type': 'text/html'}); // დაწერე HTML

res.write (მონაცემები); // მონაცემების ჩაწერა

ინდექსიდან. html

დაბრუნება res.end ();

});

}

ეს ვებ სერვერი მოუსმენს თქვენს ჟოლოს პორტს 8080 და მოგაწვდით ფაილს ნებისმიერი ვებ კლიენტისთვის, რომელიც დააკავშირებს მას. ახლა ჩვენ უნდა შევქმნათ რაიმე მასპინძელი და მივაწოდოთ ჩვენს კლიენტებს: გადადით "საჯარო" საქაღალდეში: pi@raspberry: ~ $ cd public

შექმენით ახალი html ფაილი "index.html":

pi@ჟოლო: ~ $ nano index.html

ჩასვით კოდი თანდართული "HelloWorld.txt" - დან, შეინახეთ და გამოდით.

გადაიტანეთ nodejs საქაღალდეში "nodehome":

pi@ჟოლო: ~ $ cd nodehome

დაიწყეთ HTTP ვებ სერვერი:

pi@ჟოლო: ~ $ node webserver.js

გახსენით ვებ – გვერდი ბრაუზერში https:// Raspberry_IP: 8080/(შეცვალეთ Raspberry_IP თქვენი IP– ით)

ნაბიჯი 6: ვიდეოს გაძლიერების შესაძლებლობების დამატება

ჟოლოს ვიდეო ნაკადის განსახორციელებლად სხვადასხვა გზა არსებობს, უადვილესი

როგორც მე აღმოვაჩინე აქამდე, რომ როგორც შესანიშნავი შესრულება და შეიძლება ინტეგრირება ვებ ინტერფეისში არის საფუძველი მიგელ მოტას პროექტზე:

miguelmota.com/blog/raspberry-pi-camera-bo…

მადლობა მიგელ! მისი ბლოგიდან ეს არის ნაბიჯები:

დააინსტალირეთ libjpeg8 და cmake კომპონენტები:

pi@ჟოლო: $ sudo apt-get install libjpeg8

pi@ჟოლო: $ sudo apt-get install libjpeg8-dev

pi@ჟოლო: $ sudo apt-get install cmake

ჩამოტვირთეთ mjpg-streamer raspicam მოდულით:

pi@ჟოლო: g $ git კლონი

github.com/jacksonliam/mjpg-streamer.git/mjpg-streamer

შეცვალეთ დირექტორია:

pi@ჟოლო: ~ $ cd ~/mjpg-streamer/mjpg-streamer-experimental

შედგენა:

პი@ჟოლო: ~ $ გაწმინდე ყველაფერი

შეცვალეთ ძველი mjpg-streamer:

pi@ჟოლო: ~ $ sudo rm -rf /opt /-j.webp

pi@ჟოლო: ~ $ sudo mv ~/mjpg-streamer/mjpg-streamer-experimental

/opt/mjpg-streamer

pi@ჟოლო: ~ $ sudo rm -rf ~/mjpg -streamer

შექმენით ახალი "start_stream.sh" ფაილი, დააკოპირეთ და ჩასვით თანდართული "start_stream.txt" ფაილიდან.

გახადე ის შესრულებადი (შექმენი shell სკრიპტები):

pi@ჟოლო: ~ $ chmod +x start_stream.sh

დაიწყეთ სერვერის ნაკადი:

pi@ჟოლო: ~ $./start_stream.sh

გახსენით ვებ – გვერდი ბრაუზერში https:// Raspberry_IP: 9000 (შეცვალეთ Raspberry_IP თქვენი IP– ით)

ნაბიჯი 7: სატანკო პროგრამა

ყველაფერი მზადაა, ახლა ჩვენ უნდა შევქმნათ ჩვენი ვებ გვერდი ტანკის გასაკონტროლებლად (index.html) და ჩვენი ვებ სერვერი ჩვენი ბრძანებების მოსასმენად (webserver.js). ასე რომ, უბრალოდ შეცვალეთ აქამდე ნანახი ფაილები (მხოლოდ მაგალითები სისტემის შესამოწმებლად) თანდართული webserver.txt და index.txt.

ნაბიჯი 8: დაწყება კონტროლის ინტერფეისი და STREAMING სერვერი

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

კვანძის nodehome/webserver.js

./nodehome/start_stream.sh

გახსენით ვებ – გვერდი ბრაუზერში https:// Raspberry_IP: 8080 (შეცვალეთ Raspberry_IP თქვენი IP– ით)