გაზომეთ წნევა თქვენი მიკრო საშუალებით: ბიტი: 5 ნაბიჯი (სურათებით)

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

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

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

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

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

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

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

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

დამატება 27-მაი -2018:

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

ნაბიჯი 1: გამოყენებული მასალები

• მიკრო: ბიტი, ნაპოვნია პიმორონიდან - 13.50 გირვანქა სტერლინგი
• Kitronic Edge კონექტორი მიკრო: ბიტისთვის - პიმორონის საშუალებით - 5 გირვანქა სტერლინგი, შენიშვნა: პიმორინი ახლა გვთავაზობს პურის დაფაზე მოსახერხებელ კონექტორს, სახელწოდებით pin: ბიტი ქინძისთავებით I2C პორტებზე.
• 2 x 2 პინიანი სათაურის ზოლები
• ბატარეა ან LiPo მიკრო: ბიტი (არ არის საჭირო, მაგრამ გამოსადეგი), ბატარეის კაბელი გადამრთველით (dito) - პიმორონი
• jumper კაბელები სენსორების Edge კონექტორთან დასაკავშირებლად
• გრძელი (!) ჯუმბერის კაბელები სენსორისთვის, მინიმუმ შპრიცამდე, f/f ან f/m
• BMP280 წნევისა და ტემპერატურის სენსორი - Banggood - 5 აშშ დოლარი სამი ერთეულისთვის ამ სენსორის გაზომვის დიაპაზონი არის 550 - დან 1537 hPa– მდე.
• 150 მლ პლასტმასის კათეტერის შპრიცი რეზინის შუასადებით - ამაზონი ან ტექნიკისა და ბაღის მაღაზიები - დაახლოებით 2 - 3 აშშ დოლარი
• ცხელი წებო/ცხელი წებოს პისტოლეტი
• soldering რკინის
• კომპიუტერი Arduino IDE დაყენებული

ნაბიჯი 2: შეკრების ინსტრუქციები

Solder headers to BMP280 სენსორის გარღვევა.

შეაერთეთ ორი 2 პინიანი სათაური Edge კონექტორის 19 და 20 კონექტორებს (იხ. სურათი).

შეაერთეთ მიკრო: ბიტი Edge კონექტორთან და თქვენს კომპიუტერთან.

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

დააინსტალირეთ საჭირო ბიბლიოთეკები Arduino IDE– ზე.

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

შეაერთეთ სენსორი Edge კონექტორთან. GND 0V, VCC 3V, SCL pin 19 -მდე, SDA 20 pin- მდე.

ატვირთეთ სკრიპტი მიკრო: bit.

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

გამორთეთ მიკრო: ბიტი, ამოიღეთ სენსორი.

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

შეაერთეთ სენსორი ჯუმბერის კაბელებთან. შეამოწმეთ რომ კავშირები სწორი და კარგია. მიკროთან დაკავშირება: ბიტი.

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

ჩადეთ დგუში და გადაიტანეთ იგი ოდნავ შორს, ვიდრე სასურველი დასვენების პოზიცია (100 მლ).

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

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

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

ნაბიჯი 3: ცოტა თეორია და ზოგიერთი პრაქტიკული გაზომვა

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

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

ეს ნიშნავს, რომ თუ შეკუმშავთ გაზის მოცემულ მოცულობას N- ჯერ, ანუ საბოლოო მოცულობა არის ორიგინალის 1/N ჯერ, მისი წნევა გაიზრდება N- ჯერ, როგორც: P0*V0 = P1*V1 = cons t. დაწვრილებითი ინფორმაციისათვის, გთხოვთ, გადახედოთ ვიკიპედიის სტატიას გაზის კანონების შესახებ. ზღვის დონეზე, ბარომეტრიული წნევა ჩვეულებრივ 1010 hPa დიაპაზონშია (ჰექტო პასკალი).

ასე რომ, დაწყებული დასვენების წერტილებიდან მაგ. V0 = 100 მლ და P0 = 1000 hPa, ჰაერის შეკუმშვა დაახლოებით 66 მლ -მდე (ანუ V1 = 2/3 * V0) გამოიწვევს წნევას დაახლოებით 1500 hPa (P1 = 3/2 P0). დგუში 125 მლ -მდე (მოცულობის 5/4 ჯერ) იწვევს წნევას დაახლოებით 800 hPa (4/5 წნევა). გაზომვები საოცრად ზუსტია ასეთი მარტივი მოწყობილობისთვის.

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

ჩვენ ასევე შეგვიძლია გამოვთვალოთ და გამოვთვალოთ ისინი ექსპერიმენტულად. დავუშვათ, ჩვენ შეკუმშავს ჰაერი 1500 hPa– მდე, ბაზალური ბარომეტრული წნევით 1000 hPa. ასე რომ, წნევის სხვაობა არის 500 hPa, ან 50, 000 პა. ჩემი შპრიცისთვის, დგუშის დიამეტრი (დ) არის დაახლოებით 4 სმ ან 0.04 მეტრი.

ახლა თქვენ შეგიძლიათ გამოთვალოთ ძალა, რომელიც საჭიროა დგუშის ამ პოზიციაზე შესანარჩუნებლად. მოცემულია P = F/A (წნევა არის ძალა გაყოფილი ფართობის მიხედვით), ან გარდაიქმნება F = P*A. SI ერთეული ძალისთვის არის "ნიუტონი" N, სიგრძით "მეტრი" მ და 1 Pa არის 1N კვადრატულ მეტრზე. მრგვალი დგუშისთვის ფართობი შეიძლება გამოითვალოს A = ((d/2)^2)*pi გამოყენებით, რაც 0.00125 კვადრატულ მეტრს იძლევა ჩემი შპრიცისათვის. Ისე

50, 000 Pa * 0.00125 მ^2 = 63 ნ.

დედამიწაზე, 1 N კორელაციას უწევს 100 გრ წონას, ამიტომ 63 N უდრის წონას 6.3 კგ.

ეს შეიძლება ადვილად შემოწმდეს მასშტაბის გამოყენებით. დააყენეთ შპრიცი დგუშით სასწორზე, სანამ არ მიაღწევს წნევას 1500 hPa, შემდეგ წაიკითხეთ მასშტაბი. ან დააჭირეთ სანამ მასშტაბი არ აჩვენებს დაახლოებით 6-7 კგ, შემდეგ დააჭირეთ ღილაკს "A" და წაიკითხეთ მიკრო: ბიტის LED მატრიცაზე ნაჩვენები მნიშვნელობა. როგორც გაირკვა, ზემოაღნიშნული გათვლების საფუძველზე შეფასება არ იყო ცუდი. წნევა ოდნავ აღემატება 1500 hPa– ს, რომელიც დაკავშირებულია სხეულის მასშტაბით დაახლოებით 7 კგ ნაჩვენები „წონით“(იხილეთ სურათები). თქვენ ასევე შეგიძლიათ შეცვალოთ ეს კონცეფცია და გამოიყენოთ მოწყობილობა წნევის გაზომვების საფუძველზე მარტივი ციფრული მასშტაბის შესაქმნელად.

გთხოვთ გაითვალისწინოთ, რომ სენსორის ზედა ზღვარია დაახლოებით 1540 hPa, ასე რომ ზემოაღნიშნული წნევის გაზომვა შეუძლებელია და შეიძლება დააზიანოს სენსორი.

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

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

მიმაგრებული ნახავთ ჩემს BMP280 სკრიპტს მიკრო: ბიტისთვის. ეს არის BMP/BME280 სკრიპტის წარმოებული, რომელიც მე ვიპოვე სადღაც Banggood ვებსაიტზე, ადაფრუტის მიკრობიტის ბიბლიოთეკასთან ერთად. პირველი საშუალებას გაძლევთ გამოიყენოთ Banggood სენსორი, მეორე ამარტივებს 5x5 LED ეკრანის მართვას. მადლობას ვუხდი ორივე დეველოპერს.

სტანდარტულად, სკრიპტი აჩვენებს წნევის გაზომვის შედეგებს 5 საფეხურზე მიკრო: ბიტის 5x5 LED ეკრანზე, რაც მცირე ზომის დაყოვნების საშუალებას იძლევა. ზუსტი მნიშვნელობები შეიძლება პარალელურად იყოს ნაჩვენები Arduino IDE სერიულ მონიტორზე, ან უფრო დეტალური დიაგრამა შეიძლება გამოისახოს Arduino IDE– ს სერალური ამსახველი.

თუ დააჭერთ A ღილაკს, გაზომილი წნევის მნიშვნელობები ნაჩვენებია მიკრო: ბიტის 5x5 LED მასივზე. თუ დააჭერთ B ღილაკს, გამოჩნდება ტემპერატურის მნიშვნელობები. მიუხედავად იმისა, რომ ეს იძლევა ზუსტი მონაცემების წაკითხვის საშუალებას, მნიშვნელოვნად ანელებს გაზომვის ციკლს.

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

#მოიცავს xxx

#მოიცავს 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; // კონტეინერები გაზომილი მნიშვნელობებისთვის int value0; int მნიშვნელობა 1; int მნიშვნელობა 2; int ღირებულება 3; int ღირებულება 4; // ---------------------------------------------------- ------------------------------------------------------ ------------------ void setup () {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.println ("ტემპერატურა [გრადუსი C]"); // Serial.print ("\ t"); 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; // დააყენეთ ბარიერის მნიშვნელობები LED მატრიცის ჩვენებისთვის, hPa- ში ორმაგი max_0 = 1100; ორმაგი max_1 = 1230; ორმაგი max_2 = 1360; ორმაგი max_3 = 1490; 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 მატრიცის გადატვირთვა /* Serial.print ("PRESS:"); Serial.println (press_act); Serial.print ("hPa"); Serial.print ("TEMP:"); Serial.print ("\ t"); Serial.println (temp_act); */ if (! digitalRead (PIN_BUTTON_B)) {// რიცხვების მნიშვნელობების ჩვენება აფერხებს microbit.print წრეების გაზომვას ("T:"); microbit.print (temp_act, 1); microbit.print ("'C"); // Serial.println (""); } else if (! digitalRead (PIN_BUTTON_A)) {microbit.print ("P:"); microbit.print (press_act, 0); microbit.print ("hPa"); } else {// წნევის მნიშვნელობების ჩვენება პიქსელებად ან ხაზებად გარკვეულ დონეზე // 5 ნაბიჯი: 1490 hPa // max_n მნიშვნელობებით განსაზღვრული ბარიერები, თუ (press_act> max_3) {(N = 0); // ზედა სტრიქონი} else if (press_act> max_2) {(N = 1); } else if (press_act> max_1) {(N = 2); } else if (press_act> max_0) {(N = 3); } სხვა {(N = 4); // საბაზისო რიგი} // Serial.println (N); // განვითარების მიზნით // microbit.print (N); // როგორც ხაზი // microbit.drawLine (N, 0, 0, 4, LED_ON); // მნიშვნელობების გადატანა მომდევნო ხაზზე მნიშვნელობა 4 = მნიშვნელობა 3; მნიშვნელობა 3 = მნიშვნელობა 2; მნიშვნელობა 2 = მნიშვნელობა 1; მნიშვნელობა 1 = მნიშვნელობა 0; მნიშვნელობა 0 = N; // სურათის დახაზვა, სვეტი სვეტი microbit.drawPixel (0, მნიშვნელობა 0, LED_ON); // როგორც პიქსელი: სვეტი, მწკრივი. 0, 0 მარცხენა ზედა კუთხის microbit.drawPixel (1, მნიშვნელობა 1, LED_ON); microbit.drawPixel (2, მნიშვნელობა 2, LED_ON); microbit.drawPixel (3, მნიშვნელობა 3, LED_ON); microbit.drawPixel (4, მნიშვნელობა 4, LED_ON); } // მონაცემების გაგზავნა სერიულ მონიტორზე და სერიულ პლოტერზე // Serial.println (press_act); // რიცხვითი ჩვენებისათვის სერიულ პორტში ღირებულების (ების) გაგზავნა, სურვილისამებრ

Serial.print (press_act); // მნიშვნელობის გაგზავნა სერიულ პორტში პლოტერისთვის

// ინდიკატორის ხაზების დახაზვა და ნაჩვენები დიაპაზონის დაფიქსირება Serial.print ("\ t"); სერიული. ბეჭდვა (600); Serial.print ("\ t"); Serial.print (1100), Serial.print ("\ t"); Serial.println (1600); დაგვიანება (200); // გაზომე წამში სამჯერ} // -------------------------------------------- ------------------------------------------------------ ------------------------------------------------------ - // 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] << 8) | მონაცემები [7]; }

ხელმოწერილი long int calibration_T (ხელმოწერილი ხანგრძლივი int adc_T)

{ხელმოწერილი long int var1, var2, T; var1 = ((((adc_T >> 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;} ხელმოუწერელი ხანგრძლივი int calibration_P (ხელმოწერილი long int adc_P) {ხელმოწერილი long int var1, var2; ხელმოუწერელი გრძელი int P; var1 = (((ხელმოწერილია long int) t_fine) >> 1) - (ხელმოწერილი long int) 64000; var2 = (((var1 >> 2) * (var1 >> 2)) >> 11) * ((ხელმოწერილია გრძელი int) dig_P6); var2 = var2 + ((var1 * ((ხელმოწერილია ხანგრძლივი 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);}

ნაბიჯი 5: MakeCode/JavaScript სკრიპტები

პიმორონმა ახლახანს გამოუშვა გარემო: ბიტი, რომელსაც გააჩნია BMP280 წნევის სენსორი, სინათლის/ფერის სენსორი და MEMS მიკროფონი.ისინი ასევე გვთავაზობენ მიკროპითონს და MakeCode/JavaScript ბიბლიოთეკას.

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

ეს არის სკრიპტის ვარიაცია მიკრო: bit dive-o-meter. სტანდარტულად ის აჩვენებს წნევის სხვაობას ბარის დიაგრამის სახით. ღილაკზე დაჭერით ადგენს საცნობარო წნევას, ღილაკზე დაჭერით აჩვენებს სხვაობას hPa– ს რეალურ და საცნობარო წნევას შორის.

გარდა შტრიხკოდის ძირითადი ვერსიისა, თქვენ ასევე იპოვით "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 ("" + Delta + "hPa") basic.pause (200) basic.clearScreen ()} else {Is = envirobit.getPressure () Delta = Is - Ref Meter = Math.abs (Delta) თუ (მეტრი> = 400) {მწკრივი = 4} სხვა თუ (მეტრი> = 300) {მწკრივი = 3} სხვა თუ (მეტრი> = 200) {რიგი = 2} სხვა შემთხვევაში თუ (მეტრი> = 100) {რიგი = 1} else {Row = 0} რჩება = მეტრი - Row * 100 თუ (დარჩება> = 80) {სვეტი = 4} სხვა თუ (დარჩება> = 60) {სვეტი = 3} სხვაგან თუ (დარჩება> = 40) {სვეტი = 2 } else if (რჩება> = 20) {Column = 1} else {Column = 0} for (let ColA = 0; ColA <= Column; ColA ++) {led.plot (ColA, Row)} ძირითადი. პაუზა (500)}})