Warmte Index Meter: 11 pași

2024 Autor: John Day | [email protected]. Modificat ultima dată: 2024-01-30 11:43

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.

Provizii

- Particulele Photon au întâlnit panoul de testare

- senzor de temperaturi (TMP36)

- Afstandssensor voor afstanden tussen 10 și 20 cm.

- Powerbank

- 220 Ohm înțelegem

- Draadjes pentru panouri, 9+

- Telefon mobil + Computer

- 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

Optioneel:

- Ecran LCD + potențiometru 10k Ohm + draadjes jumper masculin / feminin, 12

- Luchtvochtigheidsmeter

- Temperatuurmeter- Rolmaat

Pasul 1: De Photon Instellen

Benodigdheden: - Telefon mobil

- Foton

- Calculator

Descărcați aplicația pentru particule pe telefon în contul de particule.

Stop of usb-kabel van de photon in je computer, claim of photon in stel de wifi in.

Dit kan prin setup.particle.io.

Pasul 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).

Pasul 3: Maak Een Horizontale Opstelling Met Daaraan Een Kastje

Benodigdheden: - Zeep

- Hout + lijm

- Gereedschap

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

Ontvet de paardenhaar

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

Pasul 4: Maak Een Kastje Voor De Photon En LCD-screen

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 can aan de onderkant van de bak een gat worden gemaakt voor het LCD-screen. 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.

Pasul 5: Maak Een Hefboom

Benodigdheden: - 2 potloden

- Kurk

- 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 (in 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).

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

Benodigdheden:

- Afstandsensor

- Opzetstukje (optioneel)

- Set suplimentar de sudură (opțional)

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.

Pasul 7: Cod Schrijven

Benodigdheden: - Contul de particule computerizat

Ga naar build.particle.io en maak een nieuwe app aan. Noem deze bijvoorbeeld HeatIndex.

În cadrul bibliotecilor, accesați LiquidCrystal și importați o aplicație.

Puteți să codificați codul de cuvinte din aplicație:

Lees of comments 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.

// Includeți următoarele biblioteci: #include #include

// Pinii de citire analogici pentru toți senzorii din această construcție:

int tempSensor = A0; int disSensor = A1;

// Reguli de publicare:

// Timpul de întârziere și numele evenimentului pentru publicare. // Întârziere în milisecunde. int delayTime = 15000; String eventName = "Temperatura_actuală";

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

// Cod de afișare cu cristale lichide ///////////// ///////////////////////////////// ////////////////// // Inițializați afișajul cu pinii de date LiquidCrystal lcd (D5, D4, D3, D2, D1, D0);

// Configurați limitele pentru valorile indicelui de căldură

int precauție = 27; int eCD = 33; pericol int = 40; int extreme = 52;

// Returnează un mesaj pentru o anumită valoare a indexului de căldură.

Mesaj șir (int hI) {if (hI <precauție) {returnează "Fără precauție."; } if (hI <eCD) {returnează „Atenție!”; } if (hI <pericol) {returnează „Extremă precauție!”; } if (hI <extreme) {returnează "Pericol !!"; } returnează „PERICOL EXTREM !!”; }

// Mesajul de pe a doua linie a afișajului.

String message2 = "T actual:";

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

// Cod senzor de distanță ///////////////////////////// ////////////////// //////////////////////////////////////// // Valori brute minime și maxime pe care le returnează senzorul. int minD = 2105; int maxD = 2754;

// Valorile brute reale pe care le-a returnat senzorul la fiecare 5 mm.

int zece = 2754; int tenP = 2691; int unsprezece = 2551; int unsprezece = 2499; int doisprezece = 2377; int douasprezece = 2276; int treisprezece = 2206; int treisprezeceP = 2198; int paisprezece = 2105;

// Returnează distanța în cm care aparține unei valori brute pentru fiecare 5 mm.

float getDis (int number) {switch (number) {case 2754: return 10; caz 2691: returnare 10,5; caz 2551: retur 11; caz 2499: returnare 11,5; caz 2377: retur 12; cazul 2276: returnare 12,5; caz 2206: retur 13; cazul 2198: retur 13,5; caz 2105: retur 14; }}

// Calculează distanța reală în cm pe care a captat-o senzorul de distanță.

float calculateDis (int start, float stop, măsurare int) {float distance = getDis (start); float step = (stop - start) / 10; for (int i = 0; i <5; i ++) {if (măsurare = (start-step)) {distanță de retur; } start = start - pas; distanță = distanță + 0,1; }}

// Verifică limitele mari între care se află senzorul de distanță.

distanță de plutire (măsurare int) {// Dacă senzorul de distanță nu a fost între 10 și 14 cm, // nu cunoaștem distanța reală și revenim 10. dacă (măsurare maxD) {returnează 10,0; } if (măsurare <= treisprezeceP) {return calculateDis (treisprezeceP, paisprezece, măsurare); } if (măsurare <= treisprezece) {return calculateDis (treisprezece, treisprezeceP, măsurare); } if (măsurare <= doisprezeceP) {return calculateDis (douasprezece, treisprezece, măsurare); } if (măsurare <= doisprezece) {return calculateDis (douasprezece, doisprezeceP, măsurare); } if (măsurare <= unsprezeceP) {return calculateDis (unsprezeceP, doisprezece, măsurare); } if (măsurare <= unsprezece) {return calculateDis (unsprezece, unsprezece P, măsurare); } if (măsurare <= tenP) {return calculateDis (tenP, unsprezece, măsurare); } if (măsurare <= zece) {return calculateDis (zece, zece, măsurare); } // Codul nu ar trebui să ajungă niciodată aici. retur -2; }

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

// Cod senzor de temperatură ///////////////////////////////////////////////// ////////////// //////////////////////////////////////// ////////////////////////////////////////////////////// / // Tensiunea maximă în mV utilizată pentru senzorul de temperatură. plutitor maxV = 3300,0;

// Tensiunea de bază și temperatura însoțitoare pe care o returnează senzorul de temperatură.

// Tensiunea este în mV. int bazaV = 750; int bazaT = 25;

// Calculează temperatura din valoarea măsurată la pinul analogic.

float calculateTemp (măsurare int) {float tension = ((maxV / 4096) * măsurare); float diff = baseV - tensiune; float temp = baseT - (dif / 10); revenire temp; }

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

// Calcule umiditate ///////////////////////// /////////////////////// //////////////////////////////// // Variabile pentru calculul umidității, // provin de la senzori de umiditate reali. plutitor h15 = 10,0; plutitor h30 = 10,5; plutitor h60 = 11,5; plutitor h75 = 12,0; plutitor h90 = 12,5; pasul plutitor H = 0,167;

// Returnează umiditatea relativă pentru un anumit interval de distanță.

int calculateHum (float dis, float lowH, float highH, int start) {float diff = dis - lowH; float i1 = diff / stepH; int i = rotund (i1); ieșire int = (start + (5 * i)); ieșire de retur; }

// Returnează umiditatea relativă.

umiditate int (float dis) {if (dis <= h30) {return calculateHum (dis, h15, h30, 15); } if (dis <= h60) {return calculateHum (dis, h30, h60, 30); } if (dis <= h75) {return calculateHum (dis, h60, h75, 60); } if (dis <= h90) {return calculateHum (dis, h75, h90, 75); } returnează 100; }

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

// Formula indexului de căldură /////////////////////////////// ////////////////// ///////////////////////////////////// Constante utilizate în formula indicelui de căldură plutesc c1 = -8.78469475556; plutitor c2 = 1,61139411; plutitor c3 = 2.33854883889; plutitor c4 = -0.14611605; float c5 = -0,0123008094; float c6 = -0.0164248277778; plutitor c7 = 0,002211732; plutitor c8 = 0,00072546; float c9 = -0.000003582;

// Formula indicelui de căldură care ia o temperatură și o umiditate relativă.

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); }

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

// Alte funcții / variabile //////////////////////////////////////////////// ////// //////////////////////////////////////////////// ///////////////////////////////////// Returnează o reprezentare în șir a unui plutitor rotunjit în jos la o zecimală. String rOne (float num) {valoare int = round (num * 10); Ieșire șir = valoare (șir); char end = output [strlen (output) -1]; int left = valoare / 10; String begin = (String) left; return start + "." + sfârșit; }

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

/ Tot codul de aici ar trebui rulat o dată pe Photon înainte de a începe funcțiile de looping.

void setup () {// Configurați numărul LCD de coloane și rânduri: lcd.begin (16, 2); }

// Tot codul de aici este în buclă și ar trebui să conțină obținerea de date, rafinarea și punerea lor online.

void loop () {// Obțineți temperatura și umiditatea. float temp = calculateTemp (analogRead (tempSensor)); float dis = distanță (analogRead (disSensor)); int hum = umiditate (dis); String umid = (String) hum; // Calculați indicele de căldură. float hI = heatIndex (temp, hum); // Configurați șirul de ieșire și imprimați toate mesajele pe ecranul LCD. Ieșire șir = rOne (hI); lcd.setCursor (0, 0); lcd.print (mesaj (rotund (hI))); lcd.setCursor (0, 1); lcd.print (mesaj2 + ieșire + "C"); ieșire = ieșire + "" + umed; // Publică valorile indicelui de căldură online și așteaptă înainte de a face din nou buclă. Particle.publish (eventName, output); întârziere (delayTime); }

Pasul 8: Verbind De Photon

Benodigdheden:

- Photon en breadboard

- senzor de temperaturi

- 220 Ohm înțelegem

- Afstandssensor

- Ecran LCD cu potențiometru de 10k Ohm (opțional)

- draadjes Genoeg, 9++

- Draadjes jumper masculin / feminin, 12 (opțiune)

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.

În plus, ecranul LCD se va lăsa să se înlocuiască cu volumul:

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

2. Verificați volumul jumperului și afișați ecranul LCD cu pinul 1 cu această descriere a ecranului.

Pin 1, 5 și 16 van de LCD naar ground. Pin 2 en 15 naar 5V.

Verbindt de ieșire analogică de potențiometru, de pin mediu, met pin 3 de LCD.

3. Verbindt de volgende photon pins on the LCD pins and jumper draadjes.

Pin D5 naar Pin 4

Pin D4 naar Pin 6

Pin D3 naar Pin 11

Pin D2 naar Pin 12

Pin D1 naar Pin 13

Pin D0 naar Pin 14

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

Pasul 9: Plăci De Foton În Het LCD-Scherm în De Opstelling

Benodigdheden: - Powerbank (optioneel)

Nu de photon klaar voor gebruik is kan deze op het plankje in de bak geplaatst worden en het LCD-screen 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.

Pasul 10: Kalibreren (optioneel)

Benodigdheden:

- Luchtvochtigheidssensor

- Temperatuurmeter

- 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 door 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 vergelijken met een echte luchtvochtigm

In de bijgeleverde code zitten comments die aangeven waar dit soort kalibratie variabelen staan.

Pasul 11: Indicatorul De Warmte este Klaar Voor Gebruik

Veel plezier!