ააშენეთ სიკაშკაშის მოდული AtHome– ით: 7 ნაბიჯი

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

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

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

ეს მოდულები ძირითადად აგებულია Arduino– თან თავსებადი დაფით (ნაწილობრივი Arduino ბირთვი საკმარისი იქნება მანამ, სანამ მას აქვს Stream, Wire და UART ნაკადის მხარდაჭერა), LED (წითელი ერთი ან RGB) წითლდება საკითხის შემთხვევაში, a სენსორი, კვების ბლოკი (კედლის კვების ბლოკი ან ბატარეა) და ლაზერული ჭრა.

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

ნაბიჯი 1: კომპონენტების შეგროვება

ამ პროექტისთვის დაგჭირდებათ რამდენიმე კომპონენტი თქვენი AtHome მოდულის შესაქმნელად:

• 1x Arduino- თავსებადი დაფა: აქ გამოვიყენებ Arduino UNO– ს (მაგრამ ის ასევე მუშაობს სხვა დაფებთან, როგორიცაა TI Launchpads და ESP8266 დაფები)
• 1x სენსორი: მე გამოვიყენებ TSL2561 სიკაშკაშის სენსორს (მხარდაჭერილი სენსორების სია ხელმისაწვდომია ჩვენი ბიბლიოთეკის დოკუმენტაციაში)
• 1x led: მე გამოვიყენებ Grove Chainable RGB LED აქ (მაგრამ ის ასევე შეიძლება იყოს უბრალო წითელი led ან NeoPixel)
• დიუპონის მავთულები

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

ნაბიჯი 2: ჩვენი ბიბლიოთეკის დაყენება

ჩვენი ბიბლიოთეკის დაყენების მიზნით, თქვენ უნდა გადმოწეროთ ჩვენი საცავიდან (ჩვენ მოგვიანებით გამოვაქვეყნებთ მას Arduino IDE სიაში და PlatformIO) ამ ბმულით:

gitlab.com/Woodbox/Framework/-/jobs/artifacts/master/download?job=deploy

შემდეგ, შედით Arduino IDE- ში და აირჩიეთ "ესკიზი> ბიბლიოთეკის ჩართვა>. ZIP ბიბლიოთეკის დამატება …". შემდეგ შეარჩიეთ zip ფაილი სახელწოდებით "artifacts.zip" და დააჭირეთ "OK".

ნაბიჯი 3: საჭირო ბიბლიოთეკების დაყენება

სამუშაოდ, ჩვენს ბიბლიოთეკას სჭირდება სხვა ბიბლიოთეკები თქვენს კომპიუტერში დაინსტალირებისთვის:

• არხიპენკოს დავალების შემდგენელი ბიბლიოთეკა
• ბიბლიოთეკა SEEED Studio Grove Digital Light Sensor
• SEEED Studio Grove Chainable RGB LED ბიბლიოთეკა
• ადაფრუტის ნეოპიქსელის ბიბლიოთეკა

თქვენ შეგიძლიათ დააინსტალიროთ Arduino IDE- ს ბიბლიოთეკის მენეჯერის საშუალებით, გადადით "ესკიზი"> "ბიბლიოთეკის ჩართვა"> "ბიბლიოთეკების მართვა …".

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

ნაბიჯი 4: მოდულის შეკრება

ჩვენ დავიწყებთ სენსორით. მავთულის მეშვეობით დაუკავშირეთ TSL2561– ის VCC პუნქტი Arduino– ს 5V პინთან, სენსორის GND ბუდე Arduino– ს ერთ – ერთ GND პინთან და სენსორის SDA და SCL ქინძისთავებს Arduino– ს SDA და SCL ქინძისთავებთან რა ახლა თქვენ დაასრულეთ!

ახლა დააკავშირეთ GROVE Chainable RGB LED– ის VCC პინი Arduino– ს 5V პინთან და LED– ის GND პინი არდუინოს მეორე GND– თან. თუ თქვენ ხართ Arduino, როგორც მხოლოდ ერთი 5V პინი, შეგიძლიათ გამოიყენოთ პურის დაფა Arduino– ს 5v– ს დასაკავშირებლად პურის დაფის რიგთან და დააკავშიროთ ყველა თქვენი კომპონენტი 5V ქინძისთავებით მასზე, ან დააკავშიროთ ისინი ერთმანეთზე დაფაზე ან გამოიყენეთ wago კონექტორები ან რაც გირჩევნიათ. ახლა, დაუკავშირეთ თქვენი LED- ის CI პინი თქვენი Arduino– ს პინ 7 – ს და თქვენი LED– ის DI pin– ს თქვენი Arduino– ს პინ 8 – თან. თუ თქვენ არ გაქვთ ასეთი LED, არ ინერვიულოთ, შესაძლებელია გამოიყენოთ თქვენი Arduino დაფის ჩაშენებული LED ან კლასიკური, კოდის მცირე ცვლილებით.

ნაბიჯი 5: Luminosity მოდულის ესკიზის დაწერა

მოდით შევქმნათ ახალი ესკიზი და დავწეროთ კოდი ჩვენი მოდულისთვის.

თუ ესკიზის ახსნა არ გაინტერესებთ, შეგიძლიათ დააკოპიროთ და ჩასვათ თქვენს Arduino IDE– ში:

#ჩართეთ

LightModule = AtHomeModule- ის გამოყენებით; ნაკადი *ნაკადები = {& სერიული, nullptr}; GroveChainableLED:: ქინძისთავები grovePins = {7, 8}; GroveChainableLED led (& grovePins); LightModule *მოდული = LightModule:: getInstance (); void setup () {// განათავსეთ თქვენი დაყენების კოდი აქ, ერთხელ გასაშვებად: Serial.begin (9600); მოდული-> setStreams (ნაკადები); GroveDigitalLightSensor *lightSensor = new GroveDigitalLightSensor (); მოდული-> setSensor (lightSensor); მოდული-> setDisplay (& led); მოდული-> კონფიგურაცია (); } void loop () {// განათავსეთ თქვენი მთავარი კოდი აქ, განმეორებით გასაშვებად: module-> run (); }

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

დასაწყისისთვის, ჩვენ უნდა შევიტანოთ ჩვენი ბიბლიოთეკა ჩვენს ესკიზში, ესკიზის ზედა ნაწილში ჩაწერეთ ეს სტრიქონი:

#ჩართეთ

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

ვთქვათ, მაგალითად, მე მინდა, რომ ამ ყუთს დაერქვას სახელი "LightModule", რადგან ის გამოყენებული იქნება სიკაშკაშის მონიტორინგის მოდულის განსახორციელებლად და მინდა შევინარჩუნო მხოლოდ 1 მნიშვნელობა ერთდროულად. სიკაშკაშე წარმოდგენილია ლუქსში, როგორც განუყოფელი ტიპი ჩვენი TSL2561 სენსორით, რომელიც წარმოდგენილია როგორც uint16_t კომპიუტერებით. ჩვენი მეტსახელი ასე გამოიყურება:

LightModule = AtHomeModule- ის გამოყენებით;

საკვანძო სიტყვა "გამოყენება" ნიშნავს იმას, რომ ჩვენ ვქმნით მეტსახელს და სახელი, რომელსაც ჩვენ მას ვაძლევთ შემდეგ შეესაბამება "=" სიმბოლოს მიმდევრობას.

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

ახლა, როდესაც ჩვენ მოგვიანებით გამოვიყენებთ სახელს "AtHomeModule", არდუინომ იცის, რომ ეს ეხება სრულ სახელს "AtHomeModule".

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

შემდეგი, ჩვენ უნდა შევქმნათ მითითებების მასივი Arduino ნაკადებზე, რომლებიც გამოიყენება მოდულის მიერ კომუნიკაციისთვის, ყოველთვის მთავრდება keyworkd "nullptr" - ით. აქ, მე ვიყენებ მხოლოდ Arduino- ს "სერიულ" ნაკადს, რომელიც კომპიუტერთან დაკავშირებულია USB პორტით, ასე რომ მასივი ასე გამოიყურება:

ნაკადი *ნაკადები = {& სერიული, nullptr};

"*" სიმბოლო ნიშნავს, რომ ტიპი არის მაჩვენებელი (ელემენტის ადგილმდებარეობა და არა თავად ელემენტი) და "" ფრჩხილები ნიშნავს არდუინოში, ეს არის მასივი, ასე რომ ჩვენ შეგვიძლია დავაყენოთ მრავალი მნიშვნელობა.

შემდეგი, ჩვენ უნდა შევქმნათ ჩვენი LED. ამისათვის ჩვენ უნდა დავწეროთ შემდეგი ორი სტრიქონი;

GroveChainableLED:: ქინძისთავები grovePins = {7, 8};

GroveChainableLED led (& grovePins);

თუ თქვენ არ გაქვთ Grove RGB LED, მაგრამ მაინც გინდათ ვიზუალური გამოხმაურება, ამის გაკეთება შეგიძლიათ ესკიზის მარტივი ცვლილებით. შეცვალეთ ორი წინა ხაზი ამ ხაზით:

მონოქრომატული LED განათება (LED_BUILTIN);

ამ კონფიგურაციაში მწვანე ჩაშენებული LED ჩართული იქნება მანამ, სანამ მონიტორინგის მნიშვნელობა ნორმალურია ჯანმრთელობისთვის და გამორთულია, როდესაც ის კავშირის გარეშეა. თუ გირჩევნიათ ჩართოთ ის, როდესაც კავშირი არ არის (რადგან თქვენ იყენებთ მაგალითად წითელ LED- ს ნაცვლად მწვანე შუქზე 13 – ზე) შეგიძლიათ გამოიყენოთ ეს ხაზი ნაცვლად:

მონოქრომატული LED განათება (LED_BUILTIN, ჭეშმარიტი);

შემდეგი ნაბიჯი არის ჩვენი მოდულის შექმნა. ეს გაკეთდა პირველად ჩვენ ვიღებთ მის ადგილმდებარეობას მეხსიერებაში "getInstance" მეთოდის გამოძახებით, მაგალითად:

LightModule *მოდული = LightModule:: getInstance ();

შემდეგ, ჩვენ უნდა დავაყენოთ პარამეტრები Arduino- ს "setup ()" ფუნქციაში, დაწყებული "Serial" პორტის ინიციალიზაციით, როგორც ყოველთვის Arduino სკეტჩებში:

სერიული.დაწყება (9600);

ჩვენ ვქმნით სინათლის სენსორს ამ ხაზის ჩაწერით:

GroveDigitalLightSensor *lightSensor = new GroveDigitalLightSensor ();

შემდეგ, ჩვენ ვეუბნებით ჩვენს მოდულს, რომ გამოიყენოს Arduino Stream– ის მითითებების მასივი მათი მეშვეობით:

მოდული-> setStreams (ნაკადები);

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

მოდული-> setSensor (lightSensor);

ჩვენ ვეუბნებით ჩვენს მოდულს გამოიყენოს ჩვენი LED, რომ მოგვცეს ვიზუალური კავშირი:

მოდული-> setDisplay (& led);

დაბოლოს, ჩვენ ვეუბნებით ჩვენს მოდულს, რომ ის მზად არის განახორციელოს ნებისმიერი შიდა კონფიგურაცია, რომელიც საჭიროა საკუთარი "setup" ფუნქციის გამოძახებით:

მოდული-> კონფიგურაცია ();

ჩვენი ბოლო ნაბიჯი არის ჩვენი მოდულის "გაშვება ()" ფუნქციის გამოძახება, რომელიც შექმნილია Arduino- ს "მარყუჟის" ფუნქციის ყოველ გამეორებაზე ამ ხაზის "მარყუჟის" ფუნქციის ჩაწერისას:

მოდული-> გაშვება ();

ახლა, ჩვენი ესკიზი საბოლოოდ მზად არის ატვირთოს Arduino– ში და შეამოწმოთ ჩვენი მოდული!

ნაბიჯი 6: ჩვენი AtHome მოდულის ტესტირება

ესკიზის არდუინოზე ასატვირთად, შეარჩიეთ თქვენი Arduino UNO დაფა, გადადით "ინსტრუმენტები"> "პორტი"> "[COMx ან/dev/x] (Arduino/Genuino UNO)".

და ბოლოს, უბრალოდ დააწკაპუნეთ ღილაკზე "ატვირთვა" (წრის ღილაკი ისრით მარჯვნივ მიმართული, ინსტრუმენტის ზოლის მეორე ხატი), რომ ატვირთოთ ესკიზი თქვენს დაფაზე.

Შესრულებულია! ახლა თქვენ მოდული უნდა იმუშაოთ და გაგზავნოთ ღირებულებები თქვენს კომპიუტერში, რომელიც ჩანს Arduino– ს სერიულ მონიტორზე. ამის შემოწმება შეგიძლიათ Arduino- ს "სერიული მონიტორის" გახსნით "Tools" მენიუში და უნდა გქონდეთ გამომავალი ამ ნაბიჯის მეორე სათაურის სურათის მსგავსი:)

ნაბიჯი 7: მოდულის საქმის შექმნა

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

ყუთის ყუთების გასაკეთებლად, ჩვენ ვიყენებთ makercase– ს, რათა მოვამზადოთ შაბლონი სასურველ ზომებზე, რომელსაც მოგვიანებით შევაკეთებთ. თქვენ ნახავთ luminosity მოდულის svg ფაილს, რომელიც ერთვის ამ ნაბიჯს.

შემდეგ უბრალოდ შეაერთეთ სახეები ერთის გარდა, ასე რომ თქვენ შეგიძლიათ გახსნათ იგი მოგვიანებით, განათავსეთ თქვენი წრე შიგნით და ჩადეთ LED საქმის ხვრელში (ჩვენ ვიყენებთ გამჭვირვალე ლენტს, რომ შეავსოთ ხვრელი და გავავრცელოთ სინათლე, გარდა იმისა, რომ LED წინა მხარეს ჩავდოთ მისგან).

ახლა უბრალოდ დაამატეთ ბატარეა თქვენი Arduino– ს გასაძლიერებლად, დახურეთ საქმე და თქვენი მოდული მზად არის და კარგად უნდა გამოიყურებოდეს:)