Miernik indeksu Warmte: 11 kroków

2024 Autor: John Day | [email protected]. Ostatnio zmodyfikowany: 2024-01-30 11:29

Met deze instructable kun je je eigen warmte index meter maken.

Een warmte index meter geeft de gevoelstemperatuur aan op basis van de omgevingstemperatuur en de luchtvochtigheid.

Deze meter is bedoeld voor binnen maar kan buiten worden gebruikt mits er geen neerslag valt en er een windvrij plekje wordt gebruikt.

Kieszonkowe dzieci

- Particle Photon spotkał się z płytą stykową

- Czujnik temperatury (TMP36)

- Afstandssensor voor afstanden tussen 10 en 20 cm.

- Powerbank

- Stojak na 220 Ohm

- Chlebak draadjes, 9+

- Telefon komórkowy + komputer

- Paardenhaar

- Hout en houtlijm

- Gereedschap: Boormachine/schroevendraaier, zaag en vijl

- Zeep

- 2 potloden- Kurk

- Kartonnen plaatje + wit papier

- Gewichtjes, denk aan kleine loodjes of metalen plaatjes

Optionel:

- Schemat LCD + potencjometr 10k Ohm + zworka męska/żeńska, 12

- Luchtvochtigheidsmeter

- Temperaturometr - Rolmaat

Krok 1: De Photon Instellen

Benodigdheden: - telefon komórkowy Mobiele

- foton

- Komputer

Pobierz aplikację cząstek op je telefoon en maak een konta cząstek.

Zatrzymaj de usb-kabel van de photon in je computer, claim de photon en stel de wifi in.

Dit kan przez setup.particle.io.

Krok 2: Paardenhaar

Benodigdheden: - Paard

Voor het maken van de haar-hydrometer heb je een ontvette paardenhaar nodig van bij voorkeur minimaal 60 cm

De haren kunnen worden afgeknipt, of uit de staart/manen worden getrokken (op eigen risico).

Krok 3: Maak Een Horizontale Opstelling Met Daaraan Een Kastje

Benodigdheden: - Zeep

- Hout + lijm

- Gereedschap

Maak een ombouw waarbij de paardenhaar horyzonttaal kan worden gespannen en die tegelijkertijd enige bescherming biedt

Ontvet de paardenhaar

Span de haar horizontaltaal, bij voorkeur minimum 50 cm. Zorg dat er genoeg haar over is om de hefboom en het gewicht te bevestigen (zie volgende stap)

Krok 4: Maak Een Kastje Voor De Photon En LCD-scherm

Benodigdheden:- Hout en houtlijm

- Gereedschap: zaag

Maak een simpele houten bak zonder deksel met een houten plank die in het midden staat als een divider. Op deze plank moet het breadboard met de photon passen als de bak op zijn zijkant wordt gezet. Daarnaa kan aan de onderkant van de bak een gat worden gemaakt voor het LCD-scherm. Dit gat moet parallel zijn met het plankje dat in de bak is gezet. Als de bak klaar is kan deze op zijn zijkant naast de haar worden gezet aan de kant waar de gewichtjes aan de haar hangen.

Krok 5: Maak Een Hefboom

Benodigdheden: - 2 potloden

- Kurku

- Kartonnen plaatje + wit papier

- Gewichtjes

- Gereedschap: vijl en boor

Boor een gat in het kastje en plaats het korte potlood. Het lange potlood dient uitgevijld te worden zodat deze op het korte potlood kan balanceren.

Plak een wit velletje papier onder een plaatje (w dit geval karton) en plaats deze aan het uiteinde van de hefboom.

Verbind de paardenhaar aan de hefboom en balanceer deze uit met een gewichtje (zie afbeelding 3 ringen).

Krok 6: Plaats De Afstandmeter Onder Het (kartonnen) Plaatje

Benodigdheden:

- Czujnik odległości

- Opzetstukje (opcja)

- Dodatkowy zestaw draad en soldeer (opcja)

Bij voorkeur met een afstand van minimaal 12 cm bij een relatieve luchtvochtigheid van +- 60%.

Indien nodig op een opzetstukje.

Als de bedrading van de afstandssensor niet de houten bak halen zullen deze eerst verlengd moeten worden.

Krok 7: Kod Schrijven

Benodigdheden: - Komputer spotkał rachunek cząstek

Nie można budować.particle.io i może mieć nieuwe app aan. Noem deze bijvoorbeeld HeatIndex.

Dostępne biblioteki, zoek LiquidCrystal pl import deze in de app.

Dan kan de volgende code gekopieerd worden in de app:

Lees de komentarze goed door als je wilt begrijpen wat elk stukje code precies doet.

Ook als er een probleem optreedt is het goed om de comments te raadplegen.

// Dołącz następujące biblioteki:#include #include

// Piny odczytu analogowego dla wszystkich czujników w tej kompilacji:

wewn czujnik temp = A0; int dissensor = A1;

// Zasady publikowania:

// Czas opóźnienia i nazwa zdarzenia do opublikowania. // Czas opóźnienia w milisekundach. intOpCzas = 15000; String eventName = "Rzeczywista_Temperatura";

/////////////////////////////////////////////////

// Kod wyświetlacza ciekłokrystalicznego ///////////// ////////////////////////////// ////////////////// // Zainicjuj wyświetlacz pinami danych LiquidCrystal lcd(D5, D4, D3, D2, D1, D0);

// Ustaw granice dla wartości wskaźnika ciepła

wewn. ostrożność = 27; wewn eCD = 33; wewn. niebezpieczeństwo = 40; int ekstremum = 52;

// Zwraca komunikat dla określonej wartości wskaźnika ciepła.

String message(int hI) { if(hI < ostrożność) { return "Bez ostrożności. "; } if(hI < eCD) { return "Uwaga! "; } if(hI < niebezpieczeństwo) { return "Skrajna ostrożność!"; } if(hI < ekstremum) { return "Niebezpieczeństwo!! "; } return "EKSTREMALNE NIEBEZPIECZEŃSTWO!!"; }

// Komunikat w drugim wierszu wyświetlacza.

String message2 = "Rzeczywiste T: ";

//////////////////////////////////////////////////////

// Kod czujnika odległości //////////////////////////// //////////////// //////////////////////////////////////// Minimalne i maksymalne wartości surowe zwracane przez czujnik. int minD = 2105; int maxD = 2754;

// Rzeczywiste wartości surowe, które czujnik zwracał co 5 mm.

int dziesięć = 2754; int tenP = 2691; int jedenaście = 2551; int jedenaścieP = 2499; int dwanaście = 2377; int dwanaścieP = 2276; int trzynaście = 2206; int trzynaścieP = 2198; int czternaście = 2105;

// Zwraca odległość w cm, która należy do wartości surowej na każde 5 mm.

float getDis(liczba int) {przełącznik(liczba){przypadek 2754:zwróć 10; sprawa 2691: zwrot 10,5; sprawa 2551: zwrot 11; sprawa 2499: zwrot 11,5; sprawa 2377: zwrot 12; sprawa 2276: zwrot 12,5; sprawa 2206: zwrot 13; sprawa 2198: zwrot 13,5; sprawa 2105: zwrot 14; } }

// Oblicza rzeczywistą odległość w cm, którą przechwycił czujnik odległości.

float obliczajDis(int start, float stop, int measurement) { float distance = getDis(start); krok pływaka = (stop - start)/10; for(int i = 0; i < 5; i++) { if(pomiar = (krok początkowy)){ odległość powrotu; } start = start - krok; odległość = odległość + 0,1; } }

// Sprawdza duże granice, pomiędzy którymi znajduje się czujnik odległości.

float distance(pomiar int) { // Jeżeli czujnik odległości nie był pomiędzy 10 a 14 cm, // nie znamy rzeczywistej odległości i zwróć 10. if(pomiar maxD) { return 10.0; } if(pomiar <= trzynaścieP) { return obliczDis(trzynaścieP, czternaście, pomiar); } if(pomiar <= trzynaście) { return obliczDis(trzynaście, trzynaścieP, pomiar); } if(pomiar <= dwanaścieP) { return obliczDis(dwanaścieP, trzynaście, pomiar); } if(pomiar <= dwanaście) { zwróć obliczDis(dwanaście, dwanaścieP, pomiar); } if(pomiar <= jedenaścieP) { return obliczDis(jedenaścieP, dwanaście, pomiar); } if(pomiar <= jedenaście) { return obliczDis(jedenaście, jedenaścieP, pomiar); } if(pomiar <= tenP) { return obliczDis(dziesięćP, jedenaście, pomiar); } if(pomiar <= dziesięć) { return obliczDis(dziesięć, dziesięćP, pomiar); } // Kod nigdy nie powinien się tutaj dostać. powrót -2; }

///////////////////////////////////////////////////////////////////////////////////////

// Kod czujnika temperatury //////////////////////////////////////////// ////////////// /////////////////////////////////// //////////////////////////////////////////////// / // Maksymalne napięcie w mV używane przez czujnik temperatury. pływak maxV = 3300,0;

// Napięcie bazowe i towarzysząca mu temperatura zwracana przez czujnik temperatury.

// Napięcie w mV. int bazaV = 750; int podstawa T = 25;

// Oblicza temperaturę ze zmierzonej wartości na pinie analogowym.

float obliczTemp(pomiar int) { napięcie float = ((maxV/4096)*pomiar); float diff = baseV - napięcie; float temp = baseT - (różn/10); temp. powrotu; }

///////////////////////////////////////////////////

// Obliczenia wilgotności //////////////////////////////////////////// //////////////////////////////// Zmienne do obliczeń wilgotności, // pochodzą z czujników wilgotności. pływak h15 = 10,0; pływak h30 = 10,5; pływak h60 = 11,5; pływak h75 = 12,0; pływak h90 = 12,5; skok pływakaH = 0,167;

// Zwraca wilgotność względną dla określonego zakresu odległości.

int obliczHum(float dis, float lowH, float highH, int start) { float diff = dis - lowH; pływak i1 = różnica/krokH; int i = runda(i1); int wyjście = (start + (5*i)); wyjście zwrotne; }

// Zwraca wilgotność względną.

int wilgotność(float dis) { if (dis <= h30) { return obliczHum(dis, h15, h30, 15); } if (dis <= h60) { return obliczHum(dis, h30, h60, 30); } if (dis <= h75) { return obliczHum(dis, h60, h75, 60); } if (dis <= h90) { return obliczHum(dis, h75, h90, 75); } return 100; }

///////////////////////////////////////////////////

// Wzór na wskaźnik ciepła //////////////////////////// //////////////// /////////////////////////////////////////// // Stałe użyte we wzorze na indeks cieplny float c1 = -8.78469475556; pływak c2 = 1,61139411; pływak c3 = 2,33854883889; pływak c4 = -0,14611605; pływak c5 = -0,0123008094; pływak c6 = -0.0164248277778; pływak c7 = 0,002211732; pływak c8 = 0,00072546; zmiennoprzecinkowe c9 = -0,00003582;

// Formuła indeksu ciepła, która uwzględnia temperaturę i wilgotność względną.

float heatIndex(float t, int h) { return c1 + (c2*t) + (c3*h) + (c4*t*h) + (c5*t*t) + (c6*h*h) + (c7*t*t*h) + (c8*t*h*h) + (c9*t*t*h*h); }

///////////////////////////////////////////////////////////////////////////////

// Inne funkcje/zmienne ////////////////////////////////////////// ////// /////////////////////////////////////////// ////////////////////////////////// // Zwraca ciąg reprezentujący liczbę zmiennoprzecinkową zaokrągloną w dół do jednego miejsca po przecinku. String rOne(liczba zmiennoprzecinkowa) { wartość int = round(liczba*10); String output = (String) wartość; koniec znaku = wyjście[strlen(wyjście)-1]; int po lewej = wartość/10; Początek ciągu = (ciąg) w lewo; powrót początek + "." + koniec; }

//////////////////////////////////////////////////////////////////////////////

/ Cały kod powinien zostać uruchomiony raz na Photonie przed uruchomieniem funkcji zapętlania.

void setup() { // Ustaw liczbę kolumn i wierszy wyświetlacza LCD: lcd.begin(16, 2); }

// Cały kod tutaj jest zapętlony i powinien zawierać pobieranie danych, poprawianie ich i umieszczanie online.

void loop() { // Pobierz temperaturę i wilgotność. float temp = obliczTemp(analogRead(tempSensor)); float dis = distance(analogRead(disSensor)); int hum = wilgotność(dis); String wilgotny = (String) szum; // Oblicz wskaźnik ciepła. float hI = heatIndex(temp, hum); // Ustaw ciąg wyjściowy i drukuj wszystkie komunikaty na wyświetlaczu LCD. Wyjście ciągu = rOne(hI); lcd.setCursor(0, 0); lcd.print(wiadomość(round(hI))); lcd.setCursor(0, 1); lcd.print(wiadomość2 + wyjście + "C"); wyjście = wyjście + " " + wilgotne; // Opublikuj wartości indeksu ciepła online i poczekaj przed ponownym zapętleniem. Cząstka.publish(nazwa zdarzenia, dane wyjściowe); opóźnienie (czas opóźnienia); }

Krok 8: Verbind De Photon

Benodigdheden:

- Photon i płytka do krojenia chleba

- Czujnik temperatury

- Stojak na 220 Ohm

- Afstandssensor

- LCD-scherm i potencjometr 10k Ohm (opcja)

- draadjes z płyty chlebowej Genoeg, 9+

- Draadjes męski/żeński, 12 lat (opcja)

Verbindt de 3.3V van de photon met de + rails aan dezelfde kant en verbindt de ground aan de - rails.

Verbindt de 5V van de photon aan de andere kant aan de + rails aan die kant.

Stop de temperatuursensor ergens met genoeg ruimte eromheen in het breadboard.

Verbindt de analoge output van de temperatuursensor met A0 van de photon en de ground met de ground rails.

Zet de weerstand voor de input van de sensor en verbindt de weerstand met de 3.3V rails.

De afstandssensor kan verbonden worden door de input in de 3.3V rails te stoppen, de ground in de ground rails en de analoge output in A1 van de photon te stoppen.

Als je een LCD-scherm wilt aansluiten werkt dat als volgt:

1. Verbindt de potentiometer aan het breadboard met 5V en de ground.

2. Verbindt de volgende jumper draadjes aan het LCD-scherm waarbij pin 1 het dichtsbij de rand van het scherm is.

Pin 1, 5 i 16 van de LCD na ziemi. Pin 2 i 15 na 5V.

Verbindt de analoge output van de potentiometer, de middelste pin, met pin 3 van de LCD.

3. Verbindt de volgende photon pins naar LCD pins met jumper draadjes.

Pin D5 na Pin 4

Pin D4 na Pin 6

Pin D3 na Pin 11

Pin D2 na Pin 12

Pin D1 na Pin 13

Pin D0 na Pin 14

Als de photon nu aanstaat en er aan de potentiometer gedraaid wordt moeten er op het LCD-scherm blokjes verschijnen.

Krok 9: Plaats De Photon En Het LCD-Scherm w De Opstelling

Benodigdheden:- Powerbank (opcja)

Nu de photon klaar voor gebruik is kan deze op het plankje in de bak geplaatst worden en het LCD-scherm kan tegen het gat geplakt worden. Nu is het een goed moment om de photon de laten draaien op een powerbank maar dit is natuurlijk niet verplicht.

Krok 10: Kalibreren (opcja)

Benodigdheden:

- Luchtvochtigheidssensor

- Miernik temperatury

- Rolmaat

- Code output voor rauwe waarden van de sensoren die gekalibreerd moeten worden

Als de software niet goed blijkt te werken met de sensoren kan er voor gekozen worden om de sensoren zelf de kalibreren.

De temperatuurmeter kan vrij makkelijk gekalibreerd worden drzwi metingen met een temperatuurmeter te vergelijken met de sensor.

Voor de luchtvochtigheid zal eerst de afstandssensor gekalibreerd moeten worden op afstand met behulp van een rolmaat en daarna zal het pas mogelijk zijn om de luchtvochtigheid goed te meten en te vergelijkenchmeter/metheidcht een.

W de bijgeleverde code zitten komentarze die aangeven waar dit soort kalibratie variabelen staan.

Krok 11: Miernik indeksu De Warmte to Klaar Voor Gebruik

Weel plezier!