A Micro:bit Dive-O-Meter: 8 ขั้นตอน (พร้อมรูปภาพ)

2024 ผู้เขียน: John Day | [email protected]. แก้ไขล่าสุด: 2024-01-30 13:06

ฤดูร้อนมาถึงแล้ว ถึงเวลาเล่นน้ำแล้ว!

โอกาสที่ดีในการพาตัวเองและไมโครของคุณ: ออกไปข้างนอกและในกรณีนี้แม้แต่ในสระว่ายน้ำ

micro:bit dive-o-meter ที่อธิบายในที่นี้เป็นมาตรวัดความลึกแบบ DIY ง่ายๆ ที่ช่วยให้คุณวัดว่าคุณดำน้ำลึกแค่ไหนหรือกำลังดำน้ำอยู่ ประกอบด้วย micro:bit, ชุดแบตเตอรี่หรือ LiPo, ตัวเชื่อมต่อขอบสำหรับ micro:bit, เซ็นเซอร์ความดันบรรยากาศ BMP280 หรือ BME280 และสายจัมเปอร์บางตัว การใช้ Pimoroni enviro:bit ทำให้สิ่งต่างๆ ง่ายขึ้นกว่าเดิม ทั้งหมดนี้บรรจุในถุงพลาสติกใสหรือซิลิโคนใสกันน้ำสองชั้น โดยมีการเติมตุ้มน้ำหนักเพื่อชดเชยแรงลอยตัว

เป็นแอปพลิเคชันของอุปกรณ์เซ็นเซอร์ความดัน micro:bit ที่ฉันอธิบายไว้ในคำสั่งก่อนหน้านี้

คุณสามารถใช้อุปกรณ์ e. NS. สำหรับการแข่งขันดำน้ำกับเพื่อนๆ และครอบครัว หรือค้นหาความลึกของบ่อน้ำที่แท้จริง ฉันทดสอบโดยใช้สระที่ลึกที่สุดในละแวกบ้านของฉัน และพบว่าใช้งานได้อย่างน้อยที่ความลึก 3.2 เมตร ประมาณห้าเมตรเป็นค่าสูงสุดตามทฤษฎี จนถึงตอนนี้ฉันยังไม่ได้ทดสอบความแม่นยำในรายละเอียดใดๆ แต่อย่างน้อยตัวเลขที่รายงานก็อยู่ในช่วงที่คาดไว้

ข้อสังเกตบางประการ: นี่ไม่ใช่เครื่องมือสำหรับนักดำน้ำตัวจริง micro:bit ของคุณจะเสียหายหากเปียกน้ำ คุณใช้คำแนะนำนี้ด้วยความเสี่ยงของคุณเอง

อัปเดต 27 พฤษภาคม: ขณะนี้คุณสามารถค้นหาสคริปต์ MakeCode HEX ที่คุณสามารถโหลดลงใน micro:bit ได้โดยตรง ดูขั้นตอนที่ 6. อัปเดต 13 มิถุนายน: เพิ่ม Enviro:bit และเวอร์ชันเคเบิล ดูขั้นตอนที่ 7 & 8

ขั้นตอนที่ 1: ทฤษฎีเบื้องหลังอุปกรณ์

เราอาศัยอยู่ใต้ท้องทะเลแห่งอากาศ ความดันด้านล่างอยู่ที่ประมาณ 1,020 เฮกโตปาสกาล (เฮกโตปาสกาล) เนื่องจากน้ำหนักของคอลัมน์อากาศก่อตัวที่นี่สู่อวกาศประมาณ 1 กิโลกรัมต่อตารางเซนติเมตร

ความหนาแน่นของน้ำสูงขึ้นมาก เนื่องจากอากาศหนึ่งลิตรมีน้ำหนักประมาณ 1.2 กรัมและน้ำหนึ่งลิตร 1 กิโลกรัม นั่นคือประมาณ 800 เท่า ดังนั้น เนื่องจากความดันบรรยากาศลดลงประมาณ 1 hPa สำหรับความสูงทุกๆ 8 เมตร แรงดันที่เพิ่มขึ้นคือ 1 hPa สำหรับทุกเซนติเมตรใต้ผิวน้ำ ที่ความลึกประมาณ 10 เมตร ความดันคือ 2,000 hPa หรือสองบรรยากาศ

เซ็นเซอร์ความดันที่ใช้ในที่นี้มีช่วงการวัดระหว่าง 750 ถึง 1500 hPa ที่ความละเอียดประมาณหนึ่ง hPa ซึ่งหมายความว่าเราสามารถวัดความลึกได้ถึง 5 เมตรที่ความละเอียดประมาณ 1 ซม.

อุปกรณ์ดังกล่าวจะเป็นเกจวัดความลึกประเภท Boyle Marriotte การประกอบนั้นค่อนข้างง่ายและอธิบายไว้ในขั้นตอนต่อไป เซ็นเซอร์ใช้โปรโตคอล I2C ดังนั้นตัวเชื่อมต่อขอบสำหรับ micro:bit จึงสะดวก ส่วนที่สำคัญที่สุดคือถุงกันน้ำ เนื่องจากความชื้นจะทำให้ micro:bit เซ็นเซอร์ หรือแบตเตอรี่เสียหาย เนื่องจากอากาศบางส่วนจะติดอยู่ภายในถุง การเพิ่มน้ำหนักจะช่วยชดเชยแรงลอยตัว

ขั้นตอนที่ 2: การใช้อุปกรณ์

สคริปต์ดังที่แสดงในรายละเอียดในขั้นตอนต่อไป เป็นรูปแบบของสคริปต์ที่ฉันพัฒนาก่อนหน้านี้สำหรับเครื่องวัดความดัน ในการทดสอบอุปกรณ์ คุณอาจใช้ห้องแรงดันแบบธรรมดาที่อธิบายไว้ที่นั่น

สำหรับการดำน้ำ จะแสดงความลึกเป็นเมตร โดยคำนวณจากการวัดแรงดัน ไม่ว่าจะเป็นกราฟแท่งในขั้นตอน 20 ซม. หรือเป็นตัวเลขตามคำขอ

การใช้ปุ่ม A บน micro:bit คุณจะตั้งค่าแรงดันปัจจุบันเป็นค่าแรงดันอ้างอิง เพื่อยืนยันรายการ เมทริกซ์จะกะพริบหนึ่งครั้ง

คุณสามารถใช้สิ่งนี้เพื่อดูว่าคุณดำน้ำได้ลึกแค่ไหน หรือเพื่อบันทึกว่าคุณดำน้ำลึกแค่ไหน

ในกรณีแรกให้ตั้งค่าแรงดันอากาศภายนอกในปัจจุบันเป็นค่าอ้างอิง ในกรณีที่สอง ตั้งค่าแรงกดที่จุดที่ลึกที่สุดที่คุณเป็นการอ้างอิงแรงกด ซึ่งจะทำให้คุณสามารถแสดงให้เห็นว่าคุณไปได้ลึกแค่ไหนเมื่อคุณกลับมาอยู่บนผิวน้ำ ปุ่ม B แสดงความลึก คำนวณจากความแตกต่างของแรงดัน เป็นค่าตัวเลขเป็นเมตร

ขั้นตอนที่ 3: วัสดุที่จำเป็น

ไมโคร:บิต เช่น. ที่ 13 GBP/16 Euro ที่ Pimoroni UK/DE

ตัวเชื่อมต่อขอบ (Kitronic หรือ Pimoroni) 5 GBP ฉันใช้รุ่น Kitronic

เซ็นเซอร์ BMP/BME280 ฉันใช้เซ็นเซอร์ BMP280 จาก Banggood, 4.33 Euro สำหรับสามหน่วย

สายจัมเปอร์สำหรับเชื่อมต่อเซ็นเซอร์และขั้วต่อขอบ

ทางเลือกที่ยอดเยี่ยมสำหรับตัวเชื่อมต่อขอบ/ชุดเซ็นเซอร์ด้านบนอาจเป็น Pimoroni enviro:bit (ยังไม่ได้ทดสอบ ดูขั้นตอนสุดท้าย)

ก้อนแบตเตอรี่หรือ LiPo สำหรับ micro:bit

สายไฟพร้อมสวิตช์ (อุปกรณ์เสริม แต่มีประโยชน์) ถุงใสกันน้ำ ฉันใช้กระเป๋าซิลิโคนสำหรับโทรศัพท์มือถือและถุงซิปล็อกขนาดเล็กหนึ่งหรือสองถุง ตรวจสอบให้แน่ใจว่าวัสดุมีความหนาเพียงพอ หมุดที่ขั้วต่อขอบจะไม่ทำให้กระเป๋าเสียหาย

น้ำหนักบาง. ฉันใช้ชิ้นส่วนของน้ำหนักตะกั่วที่ใช้สำหรับการตกปลา

Arduino IDE และไลบรารี่ต่างๆ

ขั้นตอนที่ 4: การประกอบ

ติดตั้ง Arduino IDE และไลบรารีที่จำเป็น รายละเอียดอธิบายไว้ที่นี่

(ไม่จำเป็นสำหรับสคริปต์ MakeCode) เนื่องจากคุณใช้ตัวเชื่อมต่อขอบ Kitronik หมุดบัดกรีกับพอร์ต I2C 19 & 20 ซึ่งไม่จำเป็นสำหรับตัวเชื่อมต่อขอบ Pimoroni บัดกรีส่วนหัวกับเซ็นเซอร์แยกออก และเชื่อมต่อเซ็นเซอร์และขั้วต่อขอบโดยใช้สายจัมเปอร์ เชื่อมต่อ VCC กับ 3V, GND ถึง 0 V, SCL กับพอร์ต 19 และ SDA กับพอร์ต 20 หรือบัดกรีสายเคเบิลโดยตรงกับการฝ่าวงล้อม เชื่อมต่อ micro:bit กับคอมพิวเตอร์ของเราโดยใช้สาย USB เปิดสคริปต์ที่ให้มาและแฟลชไปที่ micro:bit ใช้มอนิเตอร์แบบอนุกรมหรือพล็อตเตอร์ ตรวจสอบว่าเซ็นเซอร์ให้ข้อมูลที่เหมาะสมหรือไม่ ตัดการเชื่อมต่อ micro:bit ออกจากคอมพิวเตอร์ของคุณ ต่อแบตเตอรี่หรือ LiPo เข้ากับ micro:bit กดปุ่ม B อ่านค่า กดปุ่ม A กดปุ่ม B อ่านค่า วางอุปกรณ์ในถุงสุญญากาศสองชั้น โดยเหลืออากาศในถุงเพียงเล็กน้อยเท่านั้น ในกรณีให้วางน้ำหนักเพื่อชดเชยแรงลอยตัว ตรวจสอบว่าทุกอย่างกันน้ำหรือไม่ ไปที่สระว่ายน้ำและเล่น

ขั้นตอนที่ 5: สคริปต์ MicroPython

สคริปต์จะใช้ค่าความดันจากเซ็นเซอร์ เปรียบเทียบกับค่าอ้างอิง แล้วคำนวณความลึกจากความแตกต่าง สำหรับการแสดงค่าเป็นกราฟแท่ง จะใช้จำนวนเต็มและส่วนที่เหลือของค่าความลึก อันแรกจะกำหนดความสูงของเส้น ส่วนที่เหลือแบ่งออกเป็นห้าถัง ซึ่งกำหนดความยาวของแท่ง ระดับบนสุดคือ 0 - 1 ม. ต่ำสุด 4 - 5 ม.ดังที่ได้กล่าวไว้ก่อนหน้านี้ การกดปุ่ม A กำหนดแรงดันอ้างอิง ปุ่ม B จะแสดง "ความลึกสัมพัทธ์" เป็นเมตร โดยแสดงเป็นค่าตัวเลข ถึงตอนนี้ ค่าลบและค่าบวกจะแสดงเป็นกราฟแท่งบนเมทริกซ์ LED ในลักษณะเดียวกัน อย่าลังเลที่จะปรับสคริปต์ให้เหมาะสมตามความต้องการของคุณ คุณสามารถเปิดเสียงบางบรรทัดเพื่อแสดงค่าบนจอภาพอนุกรมหรือพล็อตเตอร์ของ Arduino IDE เพื่อจำลองฟังก์ชัน คุณอาจสร้างอุปกรณ์ที่ฉันอธิบายไว้ในคำสั่งก่อนหน้านี้

ฉันไม่ได้เขียนส่วนของสคริปต์ที่อ่านเซ็นเซอร์ ฉันไม่แน่ใจเกี่ยวกับแหล่งที่มา แต่ฉันชอบที่จะขอบคุณรถยนต์ ยินดีต้อนรับการแก้ไขหรือคำแนะนำสำหรับการเพิ่มประสิทธิภาพ

#รวม

#รวม Adafruit_Microbit_Matrix microbit; #define BME280_ADDRESS 0x76 ไม่ได้ลงนาม int แบบยาว hum_raw, temp_raw, pres_raw; ลงนาม 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 dig_H1; int16_t dig_H2; int8_t dig_H3; int16_t dig_H4; int16_t dig_H5; int8_t dig_H6; กดสองครั้ง = 1,015; // ค่าเริ่มต้นความลึกสองเท่า; // คำนวณความลึก //------------------------------------------ -------------------------------------------------- ---------------------- การตั้งค่าเป็นโมฆะ () { 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 filter = 0; //กรองออก uint8_t spi3w_en = 0; ///3-wire 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; โหมดพิน (PIN_BUTTON_A, อินพุต); โหมดพิน (PIN_BUTTON_B, INPUT); Serial.begin(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"); ล่าช้า (1,000); } //---------------------------------------------------------- ---------------------------------------------- วงเป็นโมฆะ () { double temp_act = 0.0, press_act = 0.0, hum_act=0.0; ลงนาม int แบบยาว temp_cal; ไม่ได้ลงนาม int ยาว press_cal, hum_cal; อินท์ N; อินท์เอ็ม; ดับเบิล press_delta; // ความดันสัมพัทธ์ indeep_m; // ความลึกเป็นเมตร ส่วนจำนวนเต็ม double depth_cm; // ส่วนที่เหลือเป็น cm readData(); // temp_cal = calibration_T (temp_raw); press_cal = calibration_P(pres_raw); // hum_cal = การสอบเทียบ_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(""); }อื่น{ // คำนวณความลึกจากความแตกต่างของแรงดัน press_delta = (press_act - press_norm); // คำนวณความลึกของความดันสัมพัทธ์ = (press_delta/100); // ความลึกเป็นเมตร depth_m = int(abs(ความลึก)); // ความลึก im เมตร depth_cm = (abs(ความลึก) - depth_m); // ส่วนที่เหลือ /* // ใช้สำหรับการพัฒนา Serial.println (ความลึก); Serial.println(deep_m); Serial.println(deep_cm); */ // ขั้นตอนสำหรับกราฟแท่งถ้า (deep_cm> 0.8) { // กำหนดความยาวของแท่ง (N=4); } อื่น ๆ ถ้า (deep_cm > 0.6){ (N=3); } อื่น ๆ ถ้า (deep_cm > 0.4){ (N=2); } อื่น ๆ ถ้า (deep_cm > 0.2){ (N=1); } อื่น ๆ { (N=0); }

if (deep_m == 4) { // ตั้งค่าระดับ == meter

(ม=4); } อื่น ๆ ถ้า (deep_m == 3){ (M=3); } อื่น ๆ ถ้า (deep_m == 2){ (M=2); } อื่น ๆ ถ้า (deep_m == 1){ (M=1); } อื่นๆ { (M=0); // แถวบน } /* // ใช้เพื่อการพัฒนา Serial.print("m: "); Serial.println(deep_m); Serial.print("ซม.:"); Serial.println(deep_cm); 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"); Serial.print(-500); Serial.print("\t"); Serial.println(500); ล่าช้า (500); // วัดสองครั้งต่อวินาที } //--------------------------------------------------- -------------------------------------------------- -------------------------------------------------- -------- // สิ่งต่อไปนี้จำเป็นสำหรับเซ็นเซอร์ bmp/bme280 เก็บไว้เป็นโมฆะ readTrim() { uint8_t data[32], i=0; // แก้ไข 2014/Wire.beginTransmission (BME280_ADDRESS); Wire.write(0x88); Wire.endTransmission(); Wire.requestFrom(BME280_ADDRESS, 24); // แก้ไข 2014/while(Wire.available()){ data = Wire.read(); ผม++; } Wire.beginTransmission (BME280_ADDRESS); // เพิ่ม 2014/Wire.write(0xA1); // เพิ่ม 2014/Wire.endTransmission(); // เพิ่ม 2014/Wire.requestFrom(BME280_ADDRESS, 1); // เพิ่ม 2014/data = Wire.read(); // เพิ่ม 2014/i++; // เพิ่ม 2014/Wire.beginTransmission(BME280_ADDRESS); Wire.write(0xE1); Wire.endTransmission(); Wire.requestFrom(BME280_ADDRESS, 7); // แก้ไข 2014/while(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/} เป็นโมฆะ writeReg (uint8_t reg_address, ข้อมูล uint8_t) { Wire.beginTransmission (BME280_ADDRESS); Wire.write(reg_address); Wire.write (ข้อมูล); Wire.endTransmission(); } เป็นโมฆะ readData () { int i = 0; ข้อมูล uint32_t[8]; Wire.beginTransmission (BME280_ADDRESS); Wire.write(0xF7); Wire.endTransmission(); Wire.requestFrom(BME280_ADDRESS, 8); ในขณะที่(Wire.available()){ data = Wire.read(); ผม++; } pres_raw = (data[0] << 12) | (ข้อมูล[1] 4); temp_raw = (ข้อมูล[3] << 12) | (ข้อมูล[4] 4); hum_raw = (data[6] 3) - ((ลงนาม int แบบยาว)dig_T1 11; var2 = (((((adc_T >> 4) - ((ลงนาม int แบบยาว)dig_T1)) * ((adc_T>>4) - ((ลงนาม int แบบยาว)dig_T1))) >> 12) * ((ลงนาม int แบบยาว) dig_T3)) >> 14; t_fine = var1 + var2; T = (t_fine * 5 + 128) >> 8; ส่งคืน T; } unsigned long int calibration_P(signed long int adc_P) { ลงนาม int ยาว int var1, var2; unsigned long int P; var1 = (((ลงนาม int แบบยาว) t_fine)>>1) - (ลงนาม int แบบยาว)64000; var2 = (((var1>>2) * (var1>>2)) >> 11) * ((ลงนาม int แบบยาว)dig_P6); var2 = var2 + ((var1*((ลงนาม int แบบยาว)dig_P5))2)+(((ลงนาม int แบบยาว)dig_P4)2)*(var1>>2)) >> 13)) >>3) + (((ลงนาม int แบบยาว)dig_P2) * var1)>>1))>>18; var1 = ((((32768+var1))*((ลงนาม int แบบยาว) dig_P1))>>15); ถ้า (var1 == 0) { กลับ 0; } P = (((unsigned long int)(((signed long int)1048576)-adc_P)-(var2>>12)))*3125; if(P<0x80000000) { P = (P <<1) / ((unsigned long int) var1); } อื่น ๆ { P = (P / (int ยาวที่ไม่ได้ลงนาม) var1) * 2; } var1 = (((ลงนาม int แบบยาว)dig_P9) * ((ลงนาม int แบบยาว)(((P>>3) * (P>>3))>>13)))>>12; var2 = (((ลงนาม int แบบยาว)(P>>2)) * ((ลงนาม int แบบยาว) dig_P8))>>13; P = (unsigned long int)((ลงนาม int แบบยาว)P + ((var1 + var2 + dig_P7) >> 4)); กลับ P; } unsigned long int calibration_H (ลงนาม int แบบยาว adc_H) { ลงนาม int แบบยาว v_x1; v_x1 = (t_fine - ((ลงนาม int แบบยาว)76800)); v_x1 = (((((adc_H << 14)) -(((ลงนาม int แบบยาว)dig_H4) 15) * (((((((v_x1 * ((ลงนาม int แบบยาว)dig_H6)) >> 10) * (((v_x1 * ((ลงนาม int แบบยาว) dig_H3)) >> 11) + ((ลงนาม int แบบยาว) 32768))) >> 10) + ((ลงนาม int แบบยาว)2097152)) * ((ลงนาม int แบบยาว) dig_H2) +8192 >> 14)); v_x1 = (v_x1 - (((((v_x1 >> 15)) * (v_x1 >> 15)) >> 7) * ((ลงนาม int แบบยาว)dig_H1)) >> 4)); v_x1 = (v_x1 419430400 ? 419430400: v_x1); ผลตอบแทน (unsigned long int)(v_x1 >> 12);

ขั้นตอนที่ 6: การทำให้เข้าใจง่ายขึ้น: MakeCode/JavaScript Code

ในเดือนพฤษภาคม 2018 Pimoroni ได้เปิดตัว enviro:bit ซึ่งมาพร้อมกับเซ็นเซอร์ความดัน/ความชื้น/อุณหภูมิ BME280 เซ็นเซอร์แสงและสี TCS3472 และไมโครโฟน MEMS นอกจากนี้ พวกเขายังเสนอไลบรารี JavaScript สำหรับตัวแก้ไข MakeCode และไลบรารี MicroPython สำหรับเซ็นเซอร์เหล่านี้

ฉันใช้ไลบรารี MakeCode เพื่อพัฒนาสคริปต์สำหรับอุปกรณ์ของฉัน คุณพบไฟล์ hex ที่แนบมาซึ่งคุณสามารถคัดลอกไปยัง micro:bit ของคุณได้โดยตรง

ด้านล่างนี้คุณจะพบโค้ด JavaScript ที่เกี่ยวข้อง การทดสอบในพูลทำงานได้ดีกับสคริปต์เวอร์ชันก่อนหน้า ดังนั้นฉันคิดว่ามันจะทำงานได้ดีเช่นกัน นอกจากเวอร์ชันพื้นฐานสำหรับกราฟแท่งแล้ว ยังมีเวอร์ชันเล็งเป้า (X) และเวอร์ชัน L ซึ่งออกแบบมาเพื่อให้การอ่านง่ายขึ้น โดยเฉพาะอย่างยิ่งในสภาพแสงน้อย เลือกหนึ่งที่คุณต้องการ

ให้คอลัมน์ = 0

ให้ Meter = 0 ปล่อยให้คงอยู่ = 0 ให้ Row = 0 ให้ Delta = 0 ให้ Ref = 0 ให้ Is = 0 Is = 1012 basic.showLeds(` # # # # # # #… # #. #. # #.. # # # # # # `) Ref = 1180 basic.clearScreen() basic.forever (() => { basic.clearScreen() if (input.buttonIsPressed (Button. A)) { Ref = envirobit.getPressure () basic.showLeds(` #. #. #. #. #. # # # # #. #. #. #. #. # `) basic.pause(1000) } else if (input.buttonIsPressed(Button. B)) { basic.showString ("" + Row + "." + เหลือ + " m") basic.pause (200) basic.clearScreen () } อื่น { Is = envirobit.getPressure () Delta = Is - Ref Meter = คณิตศาสตร์.abs(Delta) if (Meter >= 400) { Row = 4 } else if (Meter >= 300) { Row = 3 } else if (Meter >= 200) { Row = 2 } else if (Meter >= 100)) { แถว = 1 } อื่น ๆ { แถว = 0 } เหลือ = เมตร - แถว * 100 ถ้า (คง >= 80) { คอลัมน์ = 4 } อื่น ๆ ถ้า (คง >= 60) { คอลัมน์ = 3 } อื่น ๆ ถ้า (คง >= 40) { คอลัมน์ = 2 } อื่น ๆ ถ้า (คง >= 20) { คอลัมน์ = 1 } อื่น { คอลัมน์ = 0 } สำหรับ (ให้ ColA = 0; ColA <= คอลัมน์; ColA ++) { led.plot (C olA, แถว) } basic.pause(500) } })

ขั้นตอนที่ 7: เวอร์ชัน Enviro:bit

ในระหว่างนี้ ฉันได้รับ enviro:bit (20 GBP) และ power:bit (6 GBP) ทั้งคู่จาก Pimoroni

ตามที่กล่าวไว้ก่อนหน้านี้ enviro:bit มาพร้อมกับเซ็นเซอร์ความดัน ความชื้นและอุณหภูมิ BME280 แต่ยังเซ็นเซอร์แสงและสี (ดูแอปพลิเคชันที่นี่) และไมโครโฟน MEMS

power:bit เป็นทางออกที่ดีในการจ่ายไฟให้กับ micro:bit และมาพร้อมกับสวิตช์เปิด/ปิด

สิ่งที่ยอดเยี่ยมคือมันทั้งสองแบบเพียงแค่คลิกและใช้งาน ไม่มีการบัดกรี สายเคเบิล เขียงหั่นขนม เพิ่ม enviro:bit ลงใน micro:bit โหลดโค้ดของคุณลงใน micro:bit ใช้งาน

ในกรณีนี้ ฉันใช้ micro, power และ enviro:bit วางไว้ในถุง Ziploc วางไว้ในถุงพลาสติกใสกันน้ำสำหรับโทรศัพท์มือถือ พร้อม วิธีแก้ปัญหาที่รวดเร็วและเป็นระเบียบเรียบร้อย ดูภาพ สวิตช์มีขนาดใหญ่พอที่จะใช้ผ่านชั้นป้องกันได้

ผ่านการทดสอบในน้ำ ใช้งานได้ดี ที่ความลึกประมาณ 1.8 ม. ค่าที่วัดได้คือ 1.7 ม. ไม่เลวสำหรับโซลูชันที่รวดเร็วและราคาถูก แต่ยังห่างไกลจากความสมบูรณ์แบบต้องใช้เวลาสักครู่ในการปรับ ดังนั้นคุณอาจต้องอยู่ที่ระดับความลึกประมาณ 10-15 วินาที

ขั้นตอนที่ 8: เวอร์ชันของหัววัดสายเคเบิลและเซนเซอร์

นี่เป็นแนวคิดแรกสำหรับเครื่องวัดความลึกแบบ micro:bit ซึ่งเป็นแนวคิดสุดท้ายที่จะสร้าง

ที่นี่ฉันบัดกรีเซ็นเซอร์ BMP280 ถึง 5 ม. ของสายเคเบิล 4 สายแล้ววางจัมเปอร์ตัวเมียที่ปลายอีกด้านหนึ่ง เพื่อป้องกันเซ็นเซอร์จากน้ำ สายไฟต้องร้อยผ่านจุกไวน์ที่ใช้แล้ว ปลายก๊อกถูกปิดผนึกด้วยกาวร้อน ก่อนที่ฉันจะตัดรอยหยักสองอันลงในจุกไม้ก๊อก ทั้งสองก็วนไปรอบๆ จากนั้นฉันก็บรรจุเซ็นเซอร์ลงในลูกบอลฟองน้ำ วางบอลลูนไว้รอบๆ และยึดปลายบอลลูนไว้ที่จุก (รอยบากด้านล่าง) จากนั้นฉันวางตุ้มน้ำหนักตะกั่ว 3 40 กรัม 3 ชิ้นลงในบอลลูนลูกที่สอง พันรอบบอลลูนแรก ตุ้มน้ำหนักที่ด้านนอก และตรึงปลายบอลลูนไว้ที่รอยบากที่สอง อากาศถูกลบออกจากบอลลูนที่สอง จากนั้นทุกอย่างก็ยึดด้วยเทปพันสายไฟ ดูภาพ รายละเอียดเพิ่มเติมอาจตามมา

จัมเปอร์เชื่อมต่อกับ micro:bit ผ่านขั้วต่อขอบ อุปกรณ์เปิดอยู่ และตั้งค่าแรงดันอ้างอิง จากนั้นหัวเซนเซอร์ก็ค่อยๆ ปล่อยลงสู่ก้นสระ (หอกระโดด 10 ม. ลึกประมาณ 4.5 ม.)

ผลลัพธ์:

ด้วยความประหลาดใจของฉัน มันใช้งานได้แม้กับสายเคเบิลยาวนี้ ในทางกลับกัน แต่ไม่น่าแปลกใจเลยที่ข้อผิดพลาดในการวัดดูเหมือนจะใหญ่ขึ้นเมื่อใช้แรงดันที่สูงขึ้น และรายงานความลึกประมาณ 4 ม. ที่ประมาณ 3 ม.

การใช้งานที่เป็นไปได้:

ด้วยการแก้ไขข้อผิดพลาดบางอย่าง อุปกรณ์อาจใช้เพื่อวัดความลึกประมาณ 4 เมตร

ร่วมกับ Arduino หรือ Raspberry Pi สามารถใช้วัดและควบคุมจุดเติมน้ำในสระหรือถังเก็บน้ำ เช่น เพื่อเตือนหากระดับน้ำสูงกว่าหรือต่ำกว่าเกณฑ์ที่กำหนด

รองชนะเลิศในการแข่งขันฟิตเนสกลางแจ้ง