მიკრო: ბიტი Dive-O-Meter: 8 ნაბიჯი (სურათებით)

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

ზაფხული მოვიდა, მისი აუზის დროა!

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

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

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

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

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

განაახლეთ 27 მაისი: ახლა თქვენ შეგიძლიათ იპოვოთ MakeCode HEX სკრიპტი, რომლის ჩატვირთვაც შეგიძლიათ პირდაპირ თქვენს მიკრო: ბიტში. იხილეთ ნაბიჯი 6. განახლება 13 ივნისი: Enviro: ბიტი და დამატებულია საკაბელო ვერსია. იხილეთ ნაბიჯები 7 და 8

ნაბიჯი 1: თეორია მოწყობილობის მიღმა

ჩვენ ვცხოვრობთ ჰაერის ოკეანის ფსკერზე. ზეწოლა აქ არის დაახლოებით 1020 hPa (ჰექტოპასკალი), რადგან ჰაერის სვეტის წონა კოსმოსში აქ არის დაახლოებით 1 კგ კვადრატულ სანტიმეტრზე.

წყლის სიმკვრივე გაცილებით მაღალია, რადგან ერთი ლიტრი ჰაერი იწონის დაახლოებით 1.2 გ და ერთი ლიტრი წყალი 1 კგ, ანუ დაახლოებით 800-ჯერ. ასე რომ, ბარომეტრიული წნევის ვარდნა არის დაახლოებით 1 hPa ყოველ 8 მეტრ სიმაღლეზე, წნევის მომატება არის 1 hPa წყლის ზედაპირზე ქვემოთ ყოველ სანტიმეტრზე. დაახლოებით 10 მ სიღრმეზე წნევაა 2000 hPa, ანუ ორი ატმოსფერო.

აქ გამოყენებული წნევის სენსორს აქვს გაზომვის დიაპაზონი 750 -დან 1500 ცხენის ძაბვის დიაპაზონში, დაახლოებით ერთი ჰპა -ის გარჩევადობით. ეს ნიშნავს, რომ ჩვენ შეგვიძლია გავზომოთ სიღრმე 5 მეტრამდე, დაახლოებით 1 სმ გარჩევადობით.

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

ნაბიჯი 2: მოწყობილობის გამოყენება

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

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

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

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

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

ნაბიჯი 3: საჭირო მასალები

მიკრო: ცოტა. Მაგალითად. 13 GBP/16 ევრო Pimoroni UK/DE– ში.

პირას კონექტორი (კიტრონიკი ან პიმორონი), 5 GBP. მე გამოვიყენე კიტრონიკის ვერსია.

BMP/BME280 სენსორი. მე გამოვიყენე BMP280 სენსორი Banggood– დან, 4.33 ევრო სამი ერთეულისთვის.

Jumper კაბელები სენსორისა და პირას კონექტორის დასაკავშირებლად.

ზღვარზე დამაკავშირებელი/სენსორული კომბინაციის შესანიშნავი ალტერნატივა შეიძლება იყოს Pimoroni enviro: bit (ჯერ არ არის გამოცდილი, იხილეთ ბოლო ნაბიჯი).

ბატარეის პაკეტი ან LiPo მიკრო: ბიტი.

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

ზოგიერთი წონა. მე გამოვიყენე ტყვიის წონის ნაჭრები, რომლებიც გამოიყენება თევზაობისთვის.

Arduino IDE და რამდენიმე ბიბლიოთეკა.

ნაბიჯი 4: შეკრება

დააინსტალირეთ Arduino IDE და საჭირო ბიბლიოთეკები. დეტალები აღწერილია აქ.

(არ არის საჭირო MakeCode სკრიპტისთვის.) იმის გათვალისწინებით, რომ თქვენ იყენებთ კიტრონიკის პირას კონექტორს, მიამაგრეთ ქინძისთავები I2C პორტებში 19 და 20. ეს არ არის საჭირო პიმორონის პირას კონექტორზე. შეაერთეთ სათაური სენსორზე და დააკავშირეთ სენსორი და კიდეების კონექტორი ჯუმბერის კაბელების გამოყენებით. შეაერთეთ VCC 3V, GND 0 V, SCL პორტ 19 -ში და SDA 20 პორტში. ალტერნატიულად შეაერთეთ კაბელები უშუალოდ გარღვევაზე. შეაერთეთ მიკრო: ბიტი ჩვენს კომპიუტერს USB კაბელის საშუალებით. გახსენით მოწოდებული სკრიპტი და ჩაუშვით მიკრო: ბიტში. გამოიყენეთ სერიული მონიტორი ან პლოტერი, შეამოწმეთ იძლევა თუ არა სენსორი გონივრულ მონაცემებს. გათიშეთ მიკრო: ბიტი თქვენი კომპიუტერიდან. შეაერთეთ ბატარეა ან LiPo მიკრო: ბიტი. დააჭირეთ ღილაკს B, წაიკითხეთ მნიშვნელობა დააჭირეთ ღილაკს A. დააჭირეთ ღილაკს B, წაიკითხეთ მნიშვნელობა. მოათავსეთ მოწყობილობა ორ ფენაში ჰერმეტულ ჩანთებში, ტოვებს მხოლოდ ძალიან ცოტა ჰაერი ჩანთებში. იმ შემთხვევაში, მოათავსეთ წონა, რომ აანაზღაუროს მცურავი ძალა. შეამოწმეთ არის თუ არა ყველაფერი წყალგაუმტარი. წადი აუზზე და ითამაშე.

ნაბიჯი 5: მიკროპითონის სკრიპტი

სკრიპტი უბრალოდ იღებს წნევის მნიშვნელობას სენსორიდან, ადარებს მას საცნობარო მნიშვნელობას და შემდეგ ითვლის სიღრმეს განსხვავებიდან. სიდიდეების გრაფად გამოსახვისათვის აღებულია სიღრმის მნიშვნელობის მთელი რიცხვი და დარჩენილი ნაწილი. პირველი განსაზღვრავს ხაზის სიმაღლეს. დანარჩენი დაყოფილია ხუთ ურნაში, რომელიც განსაზღვრავს ზოლების სიგრძეს. ზედა დონე არის 0 - 1 მ, ყველაზე დაბალი 4 - 5 მ. როგორც უკვე აღვნიშნეთ, ღილაკზე დაჭერით ადგენს საცნობარო წნევას, ღილაკი B აჩვენებს "ფარდობით სიღრმეს" მეტრებში, ნაჩვენებია რიცხვითი მნიშვნელობით. ჯერჯერობით, უარყოფითი და პოზიტიური მნიშვნელობები წარმოდგენილია როგორც ბარგრაფი LED მატრიცაზე. მოგერიდებათ სკრიპტის ოპტიმიზაცია თქვენი საჭიროებისთვის. თქვენ შეგიძლიათ გააუქმოთ გარკვეული ხაზები, რომ წარმოადგინოთ მნიშვნელობები Arduino IDE– ს სერიულ მონიტორზე ან პლოტერზე. ფუნქციის მიბაძვის მიზნით, თქვენ შეგიძლიათ ააწყოთ მოწყობილობა, რომელიც აღწერილი მაქვს წინა ინსტრუქციაში.

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

#ჩართეთ

#მოიცავს Adafruit_Microbit_Matrix microbit; #განსაზღვრეთ BME280_ADDRESS 0x76 ხელმოუწერელი ხანგრძლივი int hum_raw, temp_raw, pres_raw; ხელმოწერილი long int t_fine; uint16_t dig_T1; int16_t dig_T2; int16_t dig_T3; uint16_t dig_P1; int16_t dig_P2; int16_t dig_P3; int16_t dig_P4; int16_t dig_P5; int16_t dig_P6; int16_t dig_P7; int16_t dig_P8; int16_t dig_P9; int8_t იჭრება_H1; int16_t dig_H2; int8_t dig_H3; int16_t dig_H4; int16_t dig_H5; int8_t იჭრება_H6; ორმაგი პრესა_ორმონი = 1015; // საწყისი მნიშვნელობა ორმაგი სიღრმე; // გამოთვლილი სიღრმე // ------------------------------------------------ ------------------------------------------------------ ---------------------- ბათილად დაყენება () {uint8_t osrs_t = 1; // ტემპერატურის გადაჭარბებული აღება x 1 uint8_t osrs_p = 1; // წნევის გადაჭარბებული აღება x 1 uint8_t osrs_h = 1; // ტენიანობის ჭარბი შერჩევა x 1 uint8_t რეჟიმი = 3; // ნორმალური რეჟიმი uint8_t t_sb = 5; // Tstandby 1000ms uint8_t ფილტრი = 0; // გაფილტვრა uint8_t spi3w_en = 0; // 3 მავთულის SPI გამორთვა uint8_t ctrl_meas_reg = (osrs_t << 5) | (osrs_p << 2) | რეჟიმი; uint8_t config_reg = (t_sb << 5) | (ფილტრი << 2) | spi3w_en; uint8_t ctrl_hum_reg = osrs_h; pinMode (PIN_BUTTON_A, INPUT); pinMode (PIN_BUTTON_B, INPUT); სერიული.დაწყება (9600); // სერიული პორტის სიჩქარის დაყენება Serial.print ("წნევა [hPa]"); // სათაური სერიული გამომავალი Wire.begin (); writeReg (0xF2, ctrl_hum_reg); writeReg (0xF4, ctrl_meas_reg); writeReg (0xF5, config_reg); readTrim (); // microbit.begin (); // microbit.print ("x"); დაგვიანება (1000); } // -------------------------------------------------- ------------------------------------------------ ბათილი მარყუჟი () {ორმაგი temp_act = 0.0, press_act = 0.0, hum_act = 0.0; ხელმოწერილი long int temp_cal; ხელმოუწერელი ხანგრძლივი int press_cal, hum_cal; int N; int M; ორმაგი პრესა_ დელტა; // ფარდობითი წნევა int სიღრმე_მ; // სიღრმე მეტრებში, მთელი ნაწილი ორმაგი სიღრმე_ სმ; // დარჩენილი სმ readData (); // temp_cal = calibration_T (temp_raw); press_cal = calibration_P (pres_raw); // hum_cal = calibration_H (hum_raw); // temp_act = (ორმაგი) temp_cal / 100.0; press_act = (ორმაგი) press_cal / 100.0; // hum_act = (ორმაგი) hum_cal / 1024.0; microbit.clear (); // LED მატრიცის გადატვირთვა // ღილაკი A ადგენს რეალურ მნიშვნელობას მითითებად (P ნულოვანი) // ღილაკი B აჩვენებს მიმდინარე მნიშვნელობას სიღრმეში მეტრებში (გამოითვლება წნევის სხვაობიდან) თუ (! digitalRead (PIN_BUTTON_A)) {// დააყენეთ ჰაერის ნორმალური წნევა როგორც ნულოვანი press_norm = press_act; // microbit.print ("P0:"); // microbit.print (press_norm, 0); // microbit.print ("hPa"); microbit.fillScreen (LED_ON); // ერთხელ დახუჭე დაგვიანების დასადასტურებლად (100); } else if (! digitalRead (PIN_BUTTON_B)) {// სიღრმის ჩვენება მეტრით microbit.print (სიღრმე, 2); microbit.print ("მ"); // Serial.println (""); } else {// გამოთვალეთ სიღრმე წნევის სხვაობისგან press_delta = (press_act - press_norm); // გამოთვალეთ ფარდობითი წნევის სიღრმე = (press_delta/100); // სიღრმე მეტრებში სიღრმე_მ = ინტ (აბს (სიღრმე)); // სიღრმე im მეტრი სიღრმე_ სმ = (აბს (სიღრმე) - სიღრმე_მ); // დარჩენილი /* // გამოიყენება განვითარებისათვის Serial.println (სიღრმე); Serial.println (სიღრმე_მ); Serial.println (სიღრმე_ სმ); */ // ბარგრაფიის საფეხურები თუ (სიღრმე_ სმ> 0.8) {// ბარის სიგრძის დადგენა (N = 4); } else if (სიღრმე_ სმ> 0.6) {(N = 3); } else if (სიღრმე_ სმ> 0.4) {(N = 2); } else if (სიღრმე_ სმ> 0.2) {(N = 1); } სხვა {(N = 0); }

თუ (სიღრმე_მ == 4) {// დონის დაყენება == მეტრი

(M = 4); } else if (სიღრმე_მ == 3) {(მ = 3); } else if (სიღრმე_მ == 2) {(მ = 2); } else if (სიღრმე_მ == 1) {(მ = 1); } სხვა {(M = 0); // ზედა რიგი} /* // გამოიყენება განვითარების მიზნით Serial.print ("m:"); Serial.println (სიღრმე_მ); Serial.print ("სმ:"); Serial.println (სიღრმე_ სმ); Serial.print ("M:"); Serial.println (M); // განვითარების მიზნით Serial.print ("N:"); Serial.println (N); // განვითარების მიზნით დაგვიანება (500); */ // დახაზეთ ბარგრაფი microbit.drawLine (0, M, N, M, LED_ON); }

// მნიშვნელობის გაგზავნა სერიულ პორტში პლოტერისთვის

Serial.print (press_delta); // ინდიკატორის ხაზების დახაზვა და ნაჩვენები დიაპაზონის დაფიქსირება Serial.print ("\ t"); Serial.print (0); Serial.print ("\ t"); სერიული. ბეჭდვა (-500); Serial.print ("\ t"); Serial.println (500); დაგვიანება (500); // გაზომეთ წამში ორჯერ} // --------------------------------------------- ------------------------------------------------------ ------------------------------------------------------ -------- // bmp/bme280 სენსორისთვის საჭიროა შემდეგი, შეინარჩუნოს როგორც ბათილი readTrim () {uint8_t მონაცემები [32], i = 0; // დაფიქსირება 2014/Wire.beginTransmission (BME280_ADDRESS); Wire.write (0x88); Wire.endTransmission (); მავთული. მოთხოვნა (BME280_ADDRESS, 24); // დაფიქსირება 2014/ხოლო (Wire.available ()) {data = Wire.read (); მე ++; } Wire.beginTransmission (BME280_ADDRESS); // დამატება 2014/Wire.write (0xA1); // დამატება 2014/Wire.endTransmission (); // დამატება 2014/მავთული. მოთხოვნა (BME280_ADDRESS, 1); // დაამატეთ 2014/მონაცემები = Wire.read (); // დამატება 2014/i ++; // დამატება 2014/Wire.beginTransmission (BME280_ADDRESS); Wire.write (0xE1); Wire.endTransmission (); მავთული. მოთხოვნა (BME280_ADDRESS, 7); // დაფიქსირება 2014/ხოლო (Wire.available ()) {data = Wire.read (); მე ++; } dig_T1 = (მონაცემები [1] << 8) | მონაცემები [0]; dig_P1 = (მონაცემები [7] << 8) | მონაცემები [6]; dig_P2 = (მონაცემები [9] << 8) | მონაცემები [8]; dig_P3 = (მონაცემები [11] << 8) | მონაცემები [10]; dig_P4 = (მონაცემები [13] << 8) | მონაცემები [12]; dig_P5 = (მონაცემები [15] << 8) | მონაცემები [14]; dig_P6 = (მონაცემები [17] << 8) | მონაცემები [16]; dig_P7 = (მონაცემები [19] << 8) | მონაცემები [18]; dig_T2 = (მონაცემები [3] << 8) | მონაცემები [2]; dig_T3 = (მონაცემები [5] << 8) | მონაცემები [4]; dig_P8 = (მონაცემები [21] << 8) | მონაცემები [20]; dig_P9 = (მონაცემები [23] << 8) | მონაცემები [22]; dig_H1 = მონაცემები [24]; dig_H2 = (მონაცემები [26] << 8) | მონაცემები [25]; dig_H3 = მონაცემები [27]; dig_H4 = (მონაცემები [28] << 4) | (0x0F & მონაცემები [29]); dig_H5 = (მონაცემები [30] 4) & 0x0F); // დაფიქსირება 2014/dig_H6 = მონაცემები [31]; // დაფიქსირება 2014/} void writeReg (uint8_t reg_address, uint8_t data) {Wire.beginTransmission (BME280_ADDRESS); Wire.write (reg_address); Wire.write (მონაცემები); Wire.endTransmission (); } void readData () {int i = 0; uint32_t მონაცემები [8]; Wire.beginTransmission (BME280_ADDRESS); Wire.write (0xF7); Wire.endTransmission (); მავთული. მოთხოვნა (BME280_ADDRESS, 8); while (Wire.available ()) {data = Wire.read (); მე ++; } pres_raw = (მონაცემები [0] << 12) | (მონაცემები [1] 4); temp_raw = (მონაცემები [3] << 12) | (მონაცემები [4] 4); hum_raw = (მონაცემი [6] 3) - ((ხელმოწერილია გრძელი int) dig_T1 11; var2 = (((((adc_T >> 4) - ((ხელმოწერილია ხანგრძლივი int) dig_T1)) * ((adc_T >> 4) - ((ხელმოწერილია long int) dig_T1))) >> 12) * ((ხელმოწერილია long int) dig_T3)) >> 14; t_fine = var1 + var2; T = (t_fine * 5 + 128) >> 8; დაბრუნება T; } ხელმოუწერელი long int calibration_P (ხელმოწერილი int int adc_P) {ხელმოწერილი long int var1, var2; ხელმოუწერელი გრძელი int P; var1 = (((ხელმოწერილი long int) t_fine) >> 1) - (ხელმოწერილი long int) 64000; var2 = (((var1 >> 2) * (var1 >> 2)) >> 11) * ((ხელმოწერილია long int) dig_P6); var2 = var2 + ((var1 * ((ხელმოწერილია long int) dig_P5)) 2) + (((ხელმოწერილია long int) dig_P4) 2) * (var1 >> 2)) >> 13)) >> 3) + ((((ხელმოწერილია long int) dig_P2) * var1) >> 1)) >> 18; var1 = (((((32768+var1))*((ხელმოწერილია გრძელი int) dig_P1)) >> 15); if (var1 == 0) {დაბრუნება 0; } P = (((ხელმოუწერელი გრძელი int) (((ხელმოწერილი გრძელი ინტერ) 1048576) -adc_P)-(var2 >> 12)))*3125; თუ (P <0x80000000) {P = (P << 1) / ((ხელმოუწერელი გრძელი int) var1); } else {P = (P / (unsigned long int) var1) * 2; } var1 = (((ხელმოწერილია long int) dig_P9) * ((ხელმოწერილია long int) (((P >> 3) * (P >> 3)) >> 13))) >> 12; var2 = (((ხელმოწერილია long int) (P >> 2)) * ((ხელმოწერილია long int) dig_P8)) >> 13; P = (ხელმოუწერელი გრძელი int) ((ხელმოწერილი გრძელი int) P + ((var1 + var2 + dig_P7) >> 4)); დაბრუნება P; } ხელმოუწერელი long int calibration_H (ხელმოწერილი long int adc_H) {ხელმოწერილი long int v_x1; v_x1 = (t_fine - ((ხელმოწერილია long int) 76800)); v_x1 = ((((((adc_H << 14) -(((ხელმოწერილია ხანგრძლივი int) dig_H4) 15) *) ((((((v_x1 * ((ხელმოწერილია ხანგრძლივი int) dig_H6)) >> 10) * (((v_x1 * ((ხელმოწერილი გრძელი ინტ) dig_H3)) >> 11) + ((ხელმოწერილი გრძელი ინტ) 32768))) >> 10) + ((ხელმოწერილი გრძელი ინტ) 2097152)) * ((ხელმოწერილი გრძელი ინტერ) dig_H2) + 8192) >> 14)); v_x1 = (v_x1 - ((((((v_x1 >> 15) * (v_x1 >> 15)) >> 7) * ((ხელმოწერილია გრძელი ინტერ) dig_H1)) >> 4)); v_x1 = (v_x1 419430400? 419430400: v_x1); დაბრუნება (ხელმოუწერელი გრძელი ინტერ) (v_x1 >> 12);

ნაბიჯი 6: ძირითადი გამარტივება: MakeCode/JavaScript კოდი

2018 წლის მაისში, პიმორონმა გამოუშვა გარემო: ბიტი, რომელსაც მოყვება BME280 წნევის/ტენიანობის/ტემპერატურის სენსორი, TCS3472 სინათლისა და ფერის სენსორი და MEMS მიკროფონი. გარდა ამისა, ისინი გვთავაზობენ JavaScript ბიბლიოთეკას MakeCode რედაქტორისთვის და MicroPython ბიბლიოთეკას ამ სენსორებისთვის.

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

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

მოდით სვეტი = 0

ნება მეტრი = 0 ნება დარჩება = 0 ნება რიგი = 0 ნება დელტა = 0 ნება Ref = 0 ნება Is = 0 არის = 1012 ძირითადი. showLeds (` # # # # # # #. # # # # # # # #.. # # # # # # `) Ref = 1180 basic.clearScreen () basic.forever (() => {basic.clearScreen () if (input.buttonIsPressed (Button. A)) {Ref = envirobit.getPressure () Basic.showLeds (` #. #. #. #. #. # # # # #. #. #. #. #. #`) ძირითადი. პაუზა (1000)} სხვა შემთხვევაში) {Basic.showString ("" + Row + "." + რჩება + "m") basic.pause (200) basic.clearScreen ()} else {Is = envirobit.getPressure () Delta = Is - Ref Meter = Math.abs (Delta) if (Meter> = 400) {Row = 4} else if (Meter> = 300) {Row = 3} else if (Meter> = 200) {Row = 2} else if (Meter> = 100) {Row = 1} სხვა {Row = 0} რჩება = მეტრი - Row * 100 თუ (დარჩება> = 80) {სვეტი = 4} სხვა თუ (დარჩება> = 60) {სვეტი = 3} სხვა თუ (დარჩება> = 40) {სვეტი = 2} სხვა თუ (დარჩება> = 20) {სვეტი = 1} სხვა {სვეტი = 0} for (let ColA = 0; ColA <= Column; ColA ++) {led.plot (C olA, Row)} Basic.pause (500)}})

ნაბიჯი 7: Enviro: bit ვერსია

ამასობაში მე მივიღე გარემო: ბიტი (20 GBP) და სიმძლავრე: bit (6 GBP), ორივე პიმორონისგან.

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

სიმძლავრე: ბიტი არის მშვენიერი გადაწყვეტა მიკრო: ბიტის კვებისათვის და გააჩნია ჩართვა/გამორთვა.

დიდი ის არის, რომ ორივე უბრალოდ დაჭერით და გამოყენებულია, არ არის შედუღება, კაბელები, დაფები. დაამატეთ enviro: bit მიკრო: bit, ჩატვირთეთ თქვენი კოდი micro: bit, გამოიყენეთ იგი.

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

ის წყალში გამოსცადეს, კარგად მუშაობდა. დაახლოებით 1,8 მ სიღრმეზე გაზომილი მნიშვნელობა იყო დაახლოებით 1,7 მ. არც ისე ცუდია სწრაფი და იაფი გადაწყვეტისთვის, მაგრამ შორს არის სრულყოფილებისგან.ადაპტირებას გარკვეული დრო სჭირდება, ასე რომ თქვენ შეიძლება დაგჭირდეთ დარჩენა გარკვეულ სიღრმეზე დაახლოებით 10-15 წამის განმავლობაში.

ნაბიჯი 8: საკაბელო და სენსორული ზონდის ვერსია

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

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

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

შედეგები:

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

პოტენციური პროგრამები:

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

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

მეორე ადგილი გარე ფიტნეს გამოწვევაში