एक माइक्रो: बिट डाइव-ओ-मीटर: 8 कदम (चित्रों के साथ)

2024 लेखक: John Day | [email protected]. अंतिम बार संशोधित: 2024-01-30 09:22

गर्मी आ गई है, इसके पूल का समय!

अपने आप को और अपने सूक्ष्म को ले जाने का एक अच्छा अवसर: थोड़ा बाहर, और इस मामले में भी, स्विमिंग पूल में।

यहां वर्णित सूक्ष्म: बिट डाइव-ओ-मीटर एक साधारण DIY गहराई नापने का यंत्र है जो आपको यह मापने की अनुमति देता है कि आप कितने गहरे हैं, या गोताखोरी कर रहे थे। इसमें केवल एक माइक्रो: बिट, एक बैटरी पैक या लीपो, माइक्रो: बिट के लिए एक एज कनेक्टर, एक बीएमपी280 या बीएमई280 बैरोमेट्रिक प्रेशर सेंसर और कुछ जम्पर केबल होते हैं। पिमोरोनी एनविरो का उपयोग करना: बिट चीजों को हमेशा आसान बनाता है। यह सब जलरोधी स्पष्ट प्लास्टिक या सिलिकॉन बैग की दो परतों में पैक किया जाता है, कुछ भार के साथ उछाल बल की भरपाई के लिए जोड़ा जाता है।

यह माइक्रो: बिट प्रेशर सेंसर डिवाइस का एक अनुप्रयोग है जिसका मैंने पिछले निर्देश में वर्णन किया था।

आप डिवाइस ई का उपयोग कर सकते हैं। जी। दोस्तों और परिवार के साथ डाइविंग प्रतियोगिताओं के लिए, या यह पता लगाने के लिए कि वह तालाब वास्तव में कितना गहरा है। मैंने अपने पड़ोस में सबसे गहरे पूल का उपयोग करके इसका परीक्षण किया, और पाया कि यह कम से कम 3.2 मीटर की गहराई तक काम करता है। लगभग पांच मीटर सैद्धांतिक अधिकतम है। अब तक मैंने किसी भी विवरण में इसकी सटीकता का परीक्षण नहीं किया है, लेकिन रिपोर्ट की गई संख्या कम से कम अपेक्षित सीमा में थी।

कुछ टिप्पणियाँ: यह वास्तविक गोताखोरों के लिए एक उपकरण होने के लिए नहीं है। आपका माइक्रो: बिट गीला होने पर क्षतिग्रस्त हो जाएगा। आप इस निर्देश का उपयोग अपने जोखिम पर करते हैं।

27 मई को अपडेट करें: अब आप एक मेककोड हेक्स-स्क्रिप्ट पा सकते हैं जिसे आप सीधे अपने माइक्रो: बिट पर लोड कर सकते हैं। चरण 6 देखें। 13 जून को अपडेट करें: एक एनवायरो: बिट और एक केबल संस्करण जोड़ा गया। चरण 7 और 8 देखें

चरण 1: डिवाइस के पीछे का सिद्धांत

हम हवा के एक महासागर के तल पर रह रहे हैं। यहाँ नीचे का दबाव लगभग १०२० hPa (हेक्टोपास्कल) है क्योंकि यहाँ वायु स्तंभ का भार अंतरिक्ष में लगभग १ किलो प्रति वर्ग सेंटीमीटर है।

पानी का घनत्व बहुत अधिक होता है, क्योंकि एक लीटर हवा का वजन लगभग 1.2 ग्राम और एक लीटर पानी का 1 किलो, यानी लगभग 800 गुना होता है। इसलिए चूंकि बैरोमेट्रिक दबाव में गिरावट प्रत्येक 8 मीटर ऊंचाई के लिए लगभग 1 hPa है, पानी की सतह के नीचे प्रत्येक सेंटीमीटर के लिए दबाव लाभ 1 hPa है। लगभग 10 मीटर की गहराई पर, दबाव 2000 hPa या दो वायुमंडल है।

यहां इस्तेमाल किए गए प्रेशर सेंसर की माप सीमा 750 और 1500 hPa के बीच लगभग एक hPa के रिज़ॉल्यूशन पर होती है। इसका मतलब है कि हम लगभग 1 सेमी के संकल्प पर 5 मीटर तक की गहराई माप सकते हैं।

डिवाइस एक बॉयल मैरियट टाइप डेप्थ गेज होगा। इसकी असेंबली काफी सरल है और बाद के चरण में वर्णित है। सेंसर I2C प्रोटोकॉल का उपयोग करता है, इसलिए माइक्रो: बिट के लिए एक एज कनेक्टर काम आता है। सबसे महत्वपूर्ण हिस्सा वाटरटाइट बैग हैं, क्योंकि कोई भी नमी माइक्रो: बिट, सेंसर या बैटरी को नुकसान पहुंचाएगी। चूंकि थैलियों के अंदर कुछ हवा फंस जाएगी, वजन जोड़ने से उत्प्लावक बल की भरपाई करने में मदद मिलती है।

चरण 2: डिवाइस का उपयोग करना

स्क्रिप्ट, जैसा कि बाद के चरण में विस्तार से दिखाया गया है, एक स्क्रिप्ट का रूपांतर है जिसे मैंने पहले एक दबाव मीटर के लिए विकसित किया था। डिवाइस का परीक्षण करने के लिए, आप वहां वर्णित साधारण दबाव कक्ष का उपयोग कर सकते हैं।

डाइविंग उद्देश्यों के लिए यह मीटर में गहराई दिखाता है, जैसा कि दबाव माप से गणना की जाती है, या तो 20 सेमी चरणों में बार ग्राफ के रूप में या अनुरोध पर, संख्याओं में।

माइक्रो: बिट पर बटन ए का उपयोग करके, आप वर्तमान दबाव को संदर्भ दबाव मान के रूप में सेट करेंगे। प्रविष्टि की पुष्टि करने के लिए, मैट्रिक्स एक बार झपकाता है।

आप इसका उपयोग या तो देख सकते हैं कि आप कितनी गहराई में गोता लगा रहे हैं, या यह रिकॉर्ड करने के लिए कि आप कितनी गहराई में गोता लगा रहे थे।

पहले मामले में वर्तमान बाहरी वायु दाब को संदर्भ के रूप में सेट करें। दूसरे मामले में दबाव को सबसे गहरे बिंदु पर सेट करें जहां आप दबाव संदर्भ के रूप में हैं, जो तब आपको यह दिखाने की अनुमति देता है कि जब आप सतह पर वापस आए तो आप कितने गहरे थे। बटन बी मीटर में संख्यात्मक मान के रूप में, दबाव अंतर से गणना की गई गहराई को प्रदर्शित करता है।

चरण 3: आवश्यक सामग्री

एक माइक्रो: बिट। उदा. पिमोरोनी यूके/डीई में 13 जीबीपी/16 यूरो पर।

एक एज कनेक्टर (किट्रोनिक या पिमोरोनी), 5 जीबीपी। मैंने किट्रोनिक संस्करण का उपयोग किया।

एक BMP/BME280 सेंसर। मैंने बैंगगूड से BMP280 सेंसर का इस्तेमाल किया, तीन इकाइयों के लिए 4.33 यूरो।

सेंसर और एज कनेक्टर को जोड़ने के लिए जम्पर केबल।

एज कनेक्टर/सेंसर संयोजन का एक उत्कृष्ट विकल्प पिमोरोनी एनविरो हो सकता है: बिट (अभी तक परीक्षण नहीं किया गया है, अंतिम चरण देखें)।

माइक्रो: बिट के लिए बैटरी पैक या लीपो।

एक स्विच के साथ एक पावर केबल (वैकल्पिक लेकिन सहायक)। वाटरटाइट बैग साफ़ करें। मैंने एक मोबाइल फोन के लिए एक सिलिकॉन पाउच और एक या दो छोटे ज़िपलॉक बैग का इस्तेमाल किया। सुनिश्चित करें कि सामग्री काफी मोटी है, इसलिए किनारे के कनेक्टर पर पिन बैग को नुकसान नहीं पहुंचाएंगे।

कुछ वजन। मैंने सीसे के वजन के टुकड़ों का इस्तेमाल किया जो मछली पकड़ने के लिए उपयोग किए जाते हैं।

Arduino IDE, और कई पुस्तकालय।

चरण 4: विधानसभा

Arduino IDE और आवश्यक लाइब्रेरी स्थापित करें। विवरण यहाँ वर्णित हैं।

(मेककोड स्क्रिप्ट के लिए आवश्यक नहीं है।) यह देखते हुए कि आप किट्रोनिक एज कनेक्टर का उपयोग करते हैं, I2C पोर्ट 19 और 20 के लिए सोल्डर पिन। पिमोरोनी एज कनेक्टर के लिए यह आवश्यक नहीं है। हेडर को सेंसर से मिलाएं और जम्पर केबल का उपयोग करके सेंसर और एज कनेक्टर को कनेक्ट करें। VCC को 3V, GND को 0 V, SCL को पोर्ट 19 और SDA को पोर्ट 20 से कनेक्ट करें। वैकल्पिक रूप से केबल को सीधे ब्रेकआउट से मिलाएं। USB केबल द्वारा माइक्रो: बिट को हमारे कंप्यूटर से कनेक्ट करें। दी गई स्क्रिप्ट को खोलें और इसे माइक्रो: बिट पर फ्लैश करें। सीरियल मॉनिटर या प्लॉटर का उपयोग करें, जांचें कि सेंसर उचित डेटा देता है या नहीं। अपने कंप्यूटर से माइक्रो: बिट को डिस्कनेक्ट करें। बैटरी या लीपो को माइक्रो: बिट से कनेक्ट करें। बटन बी दबाएं, मूल्य पढ़ें बटन ए दबाएं। बटन बी दबाएं, मूल्य पढ़ें। डिवाइस को एयरटाइट बैग की दो परतों में रखें, बैग में केवल बहुत कम हवा छोड़े। मामले में, उछाल बल की भरपाई के लिए एक भार रखें। जांचें कि क्या सब कुछ जलरोधक है। पूल में जाओ और खेलो।

चरण 5: माइक्रोपायथन स्क्रिप्ट

स्क्रिप्ट केवल सेंसर से दबाव मान लेती है, इसकी तुलना संदर्भ मान से करती है, और फिर अंतर से गहराई की गणना करती है। मानों को बार ग्राफ के रूप में प्रदर्शित करने के लिए, गहराई मान का पूर्णांक और शेष भाग लिया जाता है। पहला लाइन की ऊंचाई को परिभाषित करता है। शेष पांच डिब्बे में टूट गया है, जो सलाखों की लंबाई को परिभाषित करता है। शीर्ष स्तर 0 - 1 मीटर, निम्नतम 4 - 5 मीटर है। जैसा कि पहले उल्लेख किया गया है, बटन ए दबाने से संदर्भ दबाव सेट होता है, बटन बी मीटर में "सापेक्ष गहराई" प्रदर्शित करता है, जो संख्यात्मक मान के रूप में प्रदर्शित होता है। अब तक, नकारात्मक और सकारात्मक मान एलईडी मैट्रिक्स पर उसी तरह बारग्राफ के रूप में प्रस्तुत किए जाते हैं। अपनी आवश्यकताओं के लिए स्क्रिप्ट को अनुकूलित करने के लिए स्वतंत्र महसूस करें। आप Arduino IDE के सीरियल मॉनिटर या प्लॉटर पर मान प्रस्तुत करने के लिए कुछ पंक्तियों को अनम्यूट कर सकते हैं। फ़ंक्शन का अनुकरण करने के लिए, आप मेरे द्वारा पिछले निर्देश में वर्णित डिवाइस का निर्माण कर सकते हैं।

मैंने स्क्रिप्ट का वह हिस्सा नहीं लिखा है जो सेंसर को पढ़ता है। मैं स्रोत के बारे में निश्चित नहीं हूं, लेकिन मैं ऑटोर्स को धन्यवाद देना चाहता हूं। अनुकूलन के लिए किसी भी सुधार या संकेत का स्वागत है।

#शामिल

#include Adafruit_Microbit_Matrix microbit; # परिभाषित करें 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; डबल प्रेस_नॉर्म = १०१५; // एक प्रारंभिक मूल्य डबल गहराई; // परिकलित गहराई //------------------------------------------ -------------------------------------------------- ----------------------- शून्य सेटअप () {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; // स्टैंडबाय 1000ms uint8_t फ़िल्टर = 0; // uint8_t spi3w_en = 0 को फ़िल्टर करें; //-तार 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; पिनमोड (पिन_बटन_ए, इनपुट); पिनमोड (पिन_बटन_बी, इनपुट); सीरियल.बेगिन (९६००); // सीरियल पोर्ट स्पीड सेट करें Serial.print ("दबाव [hPa]"); // सीरियल आउटपुट के लिए हेडर Wire.begin (); राइटरेग (0xF2, ctrl_hum_reg); राइटरेग (0xF4, ctrl_meas_reg); राइटरेग (0xF5, config_reg); रीडट्रिम (); // माइक्रोबिट.बेगिन (); // माइक्रोबिट.प्रिंट ("एक्स"); देरी (1000); }//------------------------------------------- ------------------------------------------ शून्य लूप () {डबल टेम्प_एक्ट = ०.०, प्रेस_एक्ट = ०.०, hum_act = ०.०; लंबे int temp_cal पर हस्ताक्षर किए; अहस्ताक्षरित लंबा int press_cal, hum_cal; इंट एन; इंट एम; डबल प्रेस_डेल्टा; // सापेक्ष दबाव int गहराई_एम; // मीटर में गहराई, पूर्णांक भाग डबल गहराई_ सेमी; // सेमी रीडडेटा में शेष (); // temp_cal = अंशांकन_T (temp_raw); प्रेस_काल = अंशांकन_पी (pres_raw); // hum_cal = अंशांकन_H (hum_raw); // temp_act = (डबल) temp_cal / 100.0; प्रेस_एक्ट = (डबल)press_cal / १००.०; // hum_act = (डबल) hum_cal / 1024.0; माइक्रोबिट.क्लियर (); // रीसेट एलईडी मैट्रिक्स // बटन ए संदर्भ के रूप में वास्तविक मूल्य सेट करता है (पी शून्य) // बटन बी मीटर में गहराई के रूप में वर्तमान मूल्य प्रदर्शित करता है (दबाव अंतर से गणना) अगर (! digitalRead (PIN_BUTTON_A)) {// सामान्य वायु दबाव सेट करें शून्य के रूप में प्रेस_नॉर्म = प्रेस_एक्ट; // माइक्रोबिट.प्रिंट ("P0:"); // माइक्रोबिट.प्रिंट (प्रेस_नॉर्म, 0); // माइक्रोबिट.प्रिंट ("एचपीए"); माइक्रोबिट.फिलस्क्रीन (LED_ON); // देरी की पुष्टि करने के लिए एक बार झपकाएं (100); }else if (! digitalRead(PIN_BUTTON_B)) {// मीटर माइक्रोबिट में गहराई प्रदर्शित करें।प्रिंट (गहराई, 2); माइक्रोबिट.प्रिंट ("एम"); // सीरियल.प्रिंट्लन (""); } और {// दबाव अंतर से गहराई की गणना करें प्रेस_डेल्टा = (प्रेस_एक्ट - प्रेस_नॉर्म); // सापेक्ष दबाव गहराई की गणना करें = (press_delta/100); // मीटर में गहराई गहराई_एम = इंट (एब्स (गहराई)); // गहराई im मीटर गहराई_cm = (abs(गहराई) - गहराई_m); // शेष / * // विकास के लिए उपयोग किया जाता है Serial.println (गहराई); सीरियल.प्रिंट्लन (गहराई_एम); सीरियल.प्रिंट्लन (गहराई_सेमी); *//बारग्राफ के लिए कदम अगर (गहराई_सेमी> 0.8) {// बार की लंबाई निर्धारित करें (एन = 4); } और अगर (गहराई_सेमी> ०.६) {(एन = ३); } और अगर (गहराई_सेमी> 0.4) {(एन = 2); } और अगर (गहराई_सेमी> 0.2){ (एन = 1); } और { (एन = 0); }

अगर (गहराई_एम == 4) {// सेट स्तर == मीटर

(एम = 4); } और अगर (गहराई_एम == 3){ (एम = 3); } और अगर (गहराई_एम == 2){ (एम = 2); } और अगर (गहराई_एम == 1){ (एम = 1); } और { (एम = 0); // ऊपरी पंक्ति } /* // विकास उद्देश्यों के लिए उपयोग किया जाता है Serial.print("m:"); सीरियल.प्रिंट्लन (गहराई_एम); सीरियल.प्रिंट ("सेमी:"); सीरियल.प्रिंट्लन (गहराई_सेमी); सीरियल.प्रिंट ("एम:"); सीरियल.प्रिंट्लन (एम); // विकास के उद्देश्यों के लिए सीरियल.प्रिंट ("एन:"); सीरियल.प्रिंट्लन (एन); // विकास के उद्देश्यों के लिए देरी (500); *//ड्रा बारग्राफ microbit.drawLine(0, M, N, M, LED_ON); }

// प्लॉटर के सीरियल पोर्ट को वैल्यू भेजें

सीरियल.प्रिंट (प्रेस_डेल्टा); // संकेतक रेखाएं बनाएं और प्रदर्शित सीमा को ठीक करें Serial.print("\t"); सीरियल.प्रिंट (0); सीरियल.प्रिंट ("\ t"); सीरियल.प्रिंट (-500); सीरियल.प्रिंट ("\ t"); सीरियल.प्रिंट्लन (500); देरी (500); // एक सेकंड में दो बार मापें } //----------------------------------------------- -------------------------------------------------- -------------------------------------------------- -------- // bmp/bme280 सेंसर के लिए निम्नलिखित की आवश्यकता होती है, इसे शून्य रीडट्रिम () {uint8_t डेटा [32], i = 0 के रूप में रखें; // फिक्स 2014/वायर.बेगिनट्रांसमिशन (BME280_ADDRESS); वायर.राइट (0x88); वायर.एंडट्रांसमिशन (); Wire.requestFrom (BME280_ADDRESS, 24); // फिक्स 2014/जबकि (वायर.उपलब्ध ()) {डेटा = वायर.रीड (); मैं++; } Wire.beginTransmission(BME280_ADDRESS); // 2014 जोड़ें/वायर.राइट (0xA1); // 2014 जोड़ें/वायर.एंडट्रांसमिशन (); // 2014/Wire.requestFrom (BME280_ADDRESS, 1) जोड़ें; // 2014/डेटा जोड़ें = वायर.रीड (); // 2014/i++ जोड़ें; // 2014/Wire.beginTransmission (BME280_ADDRESS) जोड़ें; वायर.राइट (0xE1); वायर.एंडट्रांसमिशन (); Wire.requestFrom (BME280_ADDRESS, 7); // फिक्स 2014/जबकि (वायर.उपलब्ध ()) {डेटा = वायर.रीड (); मैं++; } 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 = डेटा [२४]; dig_H2 = (डेटा [26] << 8) | डेटा [25]; dig_H3 = डेटा [27]; dig_H4 = (डेटा [२८]<< ४) | (0x0F और डेटा [29]); dig_H5 = (डेटा [30] 4) और 0x0F); // फिक्स २०१४/dig_H6 = डेटा [३१]; // फिक्स 2014/} शून्य राइटरेग (uint8_t reg_address, uint8_t डेटा) { Wire.beginTransmission (BME280_ADDRESS); वायर.राइट (reg_address); वायर.राइट (डेटा); वायर.एंडट्रांसमिशन (); } शून्य रीडडेटा () {int i = 0; uint32_t डेटा [8]; Wire.beginTransmission (BME280_ADDRESS); वायर.राइट (0xF7); वायर.एंडट्रांसमिशन (); Wire.requestFrom (BME280_ADDRESS, 8); जबकि (वायर.उपलब्ध ()) {डेटा = वायर.रीड (); मैं++; } pres_raw = (डेटा [0] << 12) | (डेटा [1] 4); temp_raw = (डेटा [3] << 12) | (डेटा [4] 4); hum_raw = (डेटा [६] ३) - ((लंबे इंट पर हस्ताक्षर किए गए) dig_T1 11; var2 = (((((adc_T >> 4) - ((लंबे इंट पर हस्ताक्षर किए गए) dig_T1)) * ((adc_T>>4) - (((लंबे इंट पर हस्ताक्षर किए गए) dig_T1))) >> 12) * ((लंबे इंट पर हस्ताक्षर किए गए) dig_T3)) >> 14; t_fine = var1 + var2; T = (t_fine * 5 + 128) >> 8; रिटर्न टी; } अहस्ताक्षरित लंबी इंट कैलिब्रेशन_पी (हस्ताक्षरित लंबी इंट एडीसी_पी) { लंबे इंट var1, var2 पर हस्ताक्षर किए; अहस्ताक्षरित लंबे इंट पी; var1 = ((((((हस्ताक्षरित लंबे इंट) t_fine)>> 1) - (लंबे इंट पर हस्ताक्षर किए गए) 64000; var2 = (((var1>>2) * (var1>>2)) >> 11) * (((लांग इंट पर हस्ताक्षर किए गए) dig_P6); var2 = var2 + ((var1*((long int पर हस्ताक्षर किए)dig_P5))2)+((((लंबे इंट पर हस्ताक्षर किए गए) dig_P4)2)*(var1>>2)) >> 13)) >>3) + ((((((((लॉन्ग इंट पर हस्ताक्षर किए गए)) dig_P2) * var1)>>1))>>18; var1 = ((((32768+var1))*(((लंबे इंट पर हस्ताक्षर किए गए) dig_P1))>>15); अगर (var1 == 0) {वापसी 0; } पी = (((अहस्ताक्षरित लंबी इंट) (((((((हस्ताक्षरित लंबे इंट) 1048576) -adc_P)-(var2>>12)) * 3125; अगर (पी <0x80000000) {पी = (पी <<1) / ((अहस्ताक्षरित लंबी इंट) var1); } और { पी = (पी / (अहस्ताक्षरित लंबी इंट) var1) * 2; } var1 = ((((लंबे इंट पर हस्ताक्षर किए गए) dig_P9) * (((लंबे इंट पर हस्ताक्षर किए) (((पी>> 3) * (पी>> 3))>> 13))>>12; var2 = ((((लंबे इंट पर हस्ताक्षर किए गए) (पी>> 2)) * ((लंबे इंट पर हस्ताक्षर किए गए) dig_P8))>>13; पी = (अहस्ताक्षरित लंबी इंट) ((हस्ताक्षरित लंबी इंट) पी + ((var1 + var2 + dig_P7) >> 4)); वापसी पी; } अहस्ताक्षरित लंबी इंट कैलिब्रेशन_एच (हस्ताक्षरित लंबी इंट adc_H) { लंबे इंट v_x1 पर हस्ताक्षर किए; v_x1 = (t_fine - ((हस्ताक्षरित लंबी इंट) 76800)); v_x1 = (((((adc_H << 14) -((((((लंबे इंट पर हस्ताक्षर किए गए) dig_H4) 15) * ((((((v_x1 * ((लंबे इंट पर हस्ताक्षर किए गए)) dig_H6)) * (((v_x1 * (((लांग इंट पर हस्ताक्षर किए गए) dig_H3)) >> 11) + (((लॉन्ग इंट पर हस्ताक्षर किए गए) ३२७६८)) >> १०) + ((लॉन्ग इंट पर हस्ताक्षर किए गए) २०९७१५२)) * ((लॉन्ग इंट पर हस्ताक्षर किए गए) 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: एक प्रमुख सरलीकरण: मेककोड/जावास्क्रिप्ट कोड

मई 2018 में, पिमोरोनी ने एनवायरो: बिट जारी किया है, जो बीएमई२८० दबाव/आर्द्रता/तापमान सेंसर, एक टीसीएस३४७२ प्रकाश और रंग सेंसर और एक एमईएमएस माइक्रोफोन के साथ आता है। इसके अलावा वे मेककोड संपादक के लिए एक जावास्क्रिप्ट पुस्तकालय और इन सेंसर के लिए एक माइक्रोपायथन पुस्तकालय की पेशकश कर रहे हैं।

मैं अपने डिवाइस के लिए स्क्रिप्ट विकसित करने के लिए उनकी मेककोड लाइब्रेरी का उपयोग कर रहा हूं। संलग्न आपको हेक्स फाइलें मिलती हैं, जिन्हें आप सीधे अपने माइक्रो: बिट पर कॉपी कर सकते हैं।

नीचे आपको संबंधित JavaScript कोड मिलता है। पूल में परीक्षण ने स्क्रिप्ट के पुराने संस्करण के साथ अच्छा काम किया, इसलिए मुझे लगता है कि वे भी काम करेंगे। मूल, बारग्राफ संस्करण के अलावा, एक क्रॉसहेयर संस्करण (एक्स) और एक एल-संस्करण भी है, जिसका उद्देश्य पढ़ने को आसान बनाना है, खासकर कम रोशनी की स्थिति में। जिसे आप पसंद करते हैं उसे चुनें।

मान लीजिए कॉलम = 0

लेट मीटर = 0 लेट स्टे = 0 लेट रो = 0 लेट डेल्टा = 0 लेट रेफ = 0 लेट आईएस = 0 आईएस = 1012 बेसिक। शो एलईडी (` # # # # # #। । # # # # # # `) रेफरी = ११८० बेसिक। क्लियरस्क्रीन () बेसिक। फॉरएवर (() => {बेसिक.क्लियरस्क्रीन () अगर (इनपुट। बटनIsPressed (बटन। ए)) { रेफरी = envirobit.getPressure () basic.showLeds(`#.#.#.#.#.####.#.#.#.#.#`) basic.pause(1000) } और अगर (input.buttonIsPressed(Button. B)) {basic.showString("" + Row + "।" + Stay + "m") basic.pause(200) basic.clearScreen() } else { Is = envirobit.getPressure() Delta = Is - Ref Meter = Math.abs (डेल्टा) अगर (मीटर> = 400) {पंक्ति = 4} और अगर (मीटर> = 300) {पंक्ति = 3} और अगर (मीटर> = 200) {पंक्ति = 2} और अगर (मीटर> = 100) {पंक्ति = १} अन्य {पंक्ति = ०} बने रहना = मीटर-पंक्ति * १०० यदि (रहना> = ८०) {स्तंभ = ४} और यदि (रहना> = ६०) {स्तंभ = ३} और यदि (रहना >= ४०) {कॉलम = २} और अगर (रहे> = २०) {कॉलम = १} और {कॉलम = ०} के लिए (कोला = 0; कोला <= कॉलम; कोला ++) {led.प्लॉट (सी OLA, Row) } basic.pause(500) } })

चरण 7: पर्यावरण: बिट संस्करण

इस बीच मुझे एनविरो: बिट (20 जीबीपी) और पावर: बिट (6 जीबीपी), दोनों पिमोरोनी से प्राप्त हुए।

जैसा कि पहले उल्लेख किया गया है, एनवायरो: बिट बीएमई280 दबाव, आर्द्रता और तापमान सेंसर के साथ आता है, लेकिन एक प्रकाश और रंग सेंसर (यहां एक एप्लिकेशन देखें) और एक एमईएमएस माइक्रोफोन भी आता है।

पावर: बिट माइक्रो: बिट को पावर देने के लिए एक अच्छा समाधान है और ऑन/ऑफ स्विच के साथ आता है।

बड़ी बात यह है कि यह दोनों सिर्फ क्लिक और उपयोग हैं, कोई सोल्डरिंग, केबल, ब्रेडबोर्ड नहीं। एनवायरो: बिट को माइक्रो: बिट में जोड़ें, आप कोड को माइक्रो: बिट में लोड करें, इसका उपयोग करें।

इस मामले में मैंने माइक्रो, पावर और एनवायरो: बिट का इस्तेमाल किया, उन्हें एक ज़ीप्लोक बैग में रखा, इसे मोबाइल फोन के लिए एक साफ पानी से तंग प्लास्टिक बैग में रखा, तैयार। एक बहुत तेज़ और सुव्यवस्थित समाधान। तस्वीरें देखें। सुरक्षा परतों के माध्यम से इसका उपयोग करने के लिए स्विच काफी बड़ा है।

यह पानी में परीक्षण किया गया है, अच्छी तरह से काम कर रहा था। लगभग १.८ मीटर की गहराई पर मापा गया मान लगभग १.७ मीटर था। तेज़ और सस्ते समाधान के लिए बहुत बुरा नहीं है, लेकिन परिपूर्ण होने से बहुत दूर है।समायोजित होने में कुछ समय लगता है, इसलिए आपको लगभग 10-15 सेकंड के लिए एक निश्चित गहराई पर रहने की आवश्यकता हो सकती है।

चरण 8: केबल और सेंसर जांच संस्करण

यह वास्तव में पहला विचार था जो एक माइक्रो: बिट गहराई मीटर के लिए था, जो आखिरी बार बनाया जाना था।

यहाँ मैंने BMP280 सेंसर को 4-तार केबल के 5m में मिलाया और दूसरे छोर पर महिला जम्पर रखा। सेंसर को पानी से बचाने के लिए, केबल को इस्तेमाल किए गए वाइन कॉर्क के माध्यम से चलाया जाता था। कॉर्क के सिरों को गर्म गोंद से सील कर दिया गया था। इससे पहले कि मैं कॉर्क में दो पायदान काटता, दोनों उसके चारों ओर जा रहे थे। फिर मैंने सेंसर को स्पंज बॉल में पैक किया, उसके चारों ओर एक गुब्बारा रखा और गुब्बारे के सिरे को कॉर्क (निचले पायदान) पर लगा दिया। फिर मैंने एक दूसरे गुब्बारे में सीसे के ३ ४० ग्राम टुकड़े रखे, इसे पहले एक के चारों ओर लपेटा, बाहरी तरफ रखा वजन, और दूसरे पायदान पर गुब्बारे का अंत तय किया। दूसरे गुब्बारे से हवा निकाली गई, फिर डक्ट टेप से सब कुछ ठीक कर दिया गया। चित्र देखें, अधिक विस्तृत लोग अनुसरण कर सकते हैं।

जंपर्स माइक्रो: बिट से एक एज कनेक्टर के माध्यम से जुड़े थे, डिवाइस चालू था और संदर्भ दबाव सेट किया गया था। फिर सेंसर हेड को धीरे-धीरे पूल के नीचे (10 मीटर जंपिंग टॉवर, लगभग 4.5 मीटर गहरा) छोड़ा गया।

परिणाम:

मेरे आश्चर्य के लिए, इसने इस लंबी केबल के साथ भी काम किया। दूसरी ओर, लेकिन आश्चर्य की बात नहीं है, उच्च दबाव में माप त्रुटि बड़ी हो गई थी, और 4 मीटर की अनुमानित गहराई लगभग 3 मीटर बताई गई थी।

संभावित अनुप्रयोग:

कुछ त्रुटि सुधारों के साथ, डिवाइस का उपयोग लगभग 4 मीटर की गहराई को मापने के लिए किया जा सकता है।

एक Arduino या रास्पबेरी पाई के संयोजन के साथ, इसका उपयोग पूल या पानी की टंकी, ई, जी के भरने के बिंदु को मापने और नियंत्रित करने के लिए किया जा सकता है। जल स्तर निश्चित सीमा से ऊपर या नीचे जाने पर चेतावनी देने के लिए।

आउटडोर फिटनेस चैलेंज में उपविजेता