Arduino Datalogger: 8 ნაბიჯი (სურათებით)

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

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

დასაწყებად:

თქვენ დაგჭირდებათ Tinkercad (www.tinkercad.com) ანგარიში. გაემართეთ და დარეგისტრირდით თქვენი ელ.ფოსტის ან სოციალური მედიის ანგარიშით.

შესვლა მიგიყვანთ Tinkercad Dashboard– ში. დააჭირეთ ღილაკს "სქემები" მარცხნივ და აირჩიეთ "ახალი წრის შექმნა". Დავიწყოთ!

თქვენ შეგიძლიათ იპოვოთ სრული ფაილი TInkercad სქემებზე - გმადლობთ მისი შემოწმებისთვის!

ნაბიჯი 1: დაამატეთ რამდენიმე კომპონენტი

თქვენ დაგჭირდებათ რამდენიმე ძირითადი კომპონენტი. Ესენი მოიცავს:

• არდუინოს დაფა
• პურის დაფა

დაამატეთ ისინი, მოძებნეთ ისინი და დააწკაპუნეთ-გადაიტანეთ ისინი შუა არეზე.

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

ნაბიჯი 2: შენიშვნა პურის დაფების შესახებ

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

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

ნაბიჯი 3: დაამატეთ ორი სენსორი

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

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

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

ნაბიჯი 4: ფოტომგრძნობიარე სენსორი

1. ფოტომგრძნობიარე სენსორისთვის, დაამატეთ მავთული არდუინოს 5V პინიდან იმავე სვეტში, როგორც მარჯვენა ფეხი პურის დაფაზე. შეცვალეთ მავთულის ფერი წითელში.
2. შეაერთეთ მარცხენა ფეხი იმავე სვეტის პინის მეშვეობით Arduino- ზე A0 (A-zero) პინთან. ეს არის ანალოგური პინი, რომელსაც ჩვენ გამოვიყენებთ სენსორის მნიშვნელობის წასაკითხად. შეღებეთ ეს მავთული ყვითლად ან სხვაგვარად, ვიდრე წითელი ან შავი.

3. მოათავსეთ რეზისტორი (მოძებნეთ და დააწკაპუნეთ-გადაიტანეთ) დაფაზე. ეს ასრულებს წრეს და იცავს სენსორს და პინს.

   • გადააბრუნეთ ისე, რომ სვეტების გასწვრივ გაიაროს.
   • შეაერთეთ ერთი ფეხი პურის დაფაზე მარჯვენა ფეხის სვეტთან

   • მოათავსეთ მავთული რეზისტორის მეორე ბოლოდან მიწამდე

     შეცვალეთ მავთულის ფერი შავზე

4. ორჯერ შეამოწმეთ ყველა კავშირი. თუ რამე არ არის სწორ ადგილას, ის არ იმუშავებს სწორად.

ნაბიჯი 5: დაიწყეთ კოდი

მოდით შევხედოთ ამ კომპონენტის კოდს.

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

ბათილად დაყენება ()

ბათილი მარყუჟი ()

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

დაყენების ფუნქცია მუშაობს ერთხელ Arduino– ს ჩატვირთვისას (როდესაც მას აერთებთ ან ბატარეებს აერთებთ).

მარყუჟის ფუნქცია გადის მუდმივ მარყუჟში მილიწამიდან დაყენების ფუნქცია სრულდება.

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

ამოცანა

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

ცვლადები

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

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

int someVar = A0;

ასე რომ, ჩვენ მივანიჭეთ ცვლადი და მივეცით ტიპი int. Int არის მთელი რიცხვი ან მთელი რიცხვი.

"მაგრამ თქვენ არ გამოგიყენებიათ მთელი რიცხვი!", მესმის თქვენი ნათქვამი. Მართალია.

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

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

თქვენი კოდი ასე უნდა გამოიყურებოდეს:

int lightSensor = A0;

void setup () {} void loop () {}

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

int lightSensor = A0;

void setup () {pinMode (lightSensor, INPUT); } void loop () {}

pinMode ფუნქცია ეუბნება არდუინოს, რომ pin (A0) გამოყენებული იქნება როგორც INPUT pin. შენიშვნა camelCaseUsed (იხ. თითოეული პირველი ასო არის დიდი, რადგან მასში აქვს მუწუკები, შესაბამისად… აქლემი…!) ცვლადებისა და ფუნქციის სახელებისთვის. ეს არის კონვენცია და კარგია შეჩვევა.

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

int lightSensor = A0;

void setup () {pinMode (lightSensor, INPUT); } void loop () {int კითხვა = analogRead (lightSensor); }

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

int lightSensor = A0;

void setup () {// დააყენეთ pin რეჟიმები pinMode (lightSensor, INPUT); // სერიული ბიბლიოთეკის დამატება Serial.begin (9600); } void loop () {// სენსორის წაკითხვა int reading = analogRead (lightSensor); // დაბეჭდეთ მნიშვნელობა მონიტორზე Serial.print ("Light:"); Serial.println (კითხვა); // შემდეგი მარყუჟის გადადება 3 წამიანი დაგვიანებით (3000); }

რამდენიმე ახალი რამ! პირველ რიგში, თქვენ ნახავთ ამას:

// ეს არის კომენტარი

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

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

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

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

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

// ეს ბეჭდავს სერიალს ხაზის შესვენების გარეშე (ბოლოში შეიყვანეთ)

Serial.print ("სინათლე:"); // ეს ხაზს წყვეტს, ასე რომ ყოველ ჯერზე, როდესაც ვკითხულობთ და ვწერთ, ის მიდის ახალ სტრიქონზე Serial.println (კითხვა);

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

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

დიდი! მივდივართ!

ნაბიჯი 6: სიმულაცია

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

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

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

ნაბიჯი 7: შეაერთეთ ტემპერატურის სენსორი

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

ახლა მოდით განვაახლოთ კოდი.

ტემპერატურის სენსორის კოდი

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

int lightSensor = A0;

int tempSensor = A1; void setup () {// დააყენეთ pin რეჟიმები pinMode (lightSensor, INPUT); // სერიული ბიბლიოთეკის დამატება Serial.begin (9600); } void loop () {// ტემპერატურის სენსორი // ორი ცვლადის შექმნა ერთ ხაზზე - ოჰ ეფექტურობა! // Float var შესანახად ათწილადის მცურავი ძაბვა, გრადუსი C; // წაიკითხეთ ქინძის მნიშვნელობა და გადააკეთეთ ის 0 - 5 – ის მაჩვენებლად // არსებითად ძაბვა = (5/1023 = 0.004882814); ძაბვა = (analogRead (tempSensor) * 0.004882814); // გადააკეთეთ ხარისხი C გრადუსი C = (ძაბვა - 0.5) * 100; // ბეჭდვა სერიულ მონიტორზე Serial.print ("ტემპი:"); სერიული. ბეჭდვა (გრადუსი C); Serial.println ("oC"); // სენსორის წაკითხვა int reading = analogRead (lightSensor); // დაბეჭდეთ მნიშვნელობა მონიტორზე Serial.print ("Light:"); Serial.println (კითხვა); // შემდეგი მარყუჟის გადადება 3 წამიანი დაგვიანებით (3000); }

მე რამდენიმე განახლება გავაკეთე კოდზე. მოდით განვიხილოთ ისინი ინდივიდუალურად.

პირველ რიგში, მე დავამატე ხაზი

int tempSensor = A1;

ისევე, როგორც lightSensor, უნდა შევინახო მნიშვნელობა ცვლადში, რათა შემდგომში გავადვილო. თუ მომიწევს ამ სენსორის ადგილმდებარეობის შეცვლა (მაგალითად, დაფის ხელახლა დაყენება), მაშინ მე მხოლოდ კოდის ერთი ხაზი უნდა შევცვალო, არა ძიება მთელ კოდის ბაზაზე, რომ შევცვალო A0 ან A1 და ა.

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

მცურავი ძაბვა, გრადუსი C;

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

ახლა ჩვენ გავაკეთებთ კითხვას და ვინახავთ მას, შემდეგ გადავიყვანთ ჩვენს გამომავალ მნიშვნელობას.

ძაბვა = (analogRead (tempSensor) * 0.004882814);

გრადუსი C = (ძაბვა - 0.5) * 100;

ეს ორი სტრიქონი რთულად გამოიყურება, მაგრამ პირველში ჩვენ ვიღებთ კითხვას და ვამრავლებთ მას 0.004 -ზე … რადგან ის გარდაქმნის 1023 -ს (ანალოგური კითხვა ამ მნიშვნელობას აბრუნებს) 5 -დან.

მეორე სტრიქონი ამრავლებს ამ კითხვას 100 -ზე ათწილადის გადასაყვანად. ეს გვაძლევს ტემპერატურას. სისუფთავე!

ნაბიჯი 8: ტესტირება და შემოწმება

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

Გააკეთე? გაგვიზიარე და გვითხარი შენი ამბავი!

ეს არის თქვენთვის ჩართული ბოლო წრე, ასე რომ თქვენ შეგიძლიათ ითამაშოთ/გამოსცადოთ საბოლოო ქმნილება. მადლობა სწავლების დასრულებისთვის!