Indicatore di indice Warmte: 11 passaggi

2024 Autore: John Day | [email protected]. Ultima modifica: 2024-01-30 10:02

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

Un misuratore dell'indice di calore geeft de gevoelstemperatuur aan op base van de omgevingstemperatuur en de luchtvochtigheid.

Questo metro è letto per binnen maar kan buiten worden gebruikt mits er geen neerslag valt en er een windvrij plekje wordt gebruikt.

Forniture

- Particle Photon con breadboard

- Sensore di temperatura (TMP36)

- Afstandssensor voor afstanden tussen 10 e 20 cm.

- Accumulatore di energia

- 220 Ohm in piedi

- Tagliere di tagliere, 9+

- Telefono cellulare + 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

Opzioni:

- Schermo LCD + potenziometro 10k Ohm + ponticello maschio/femmina, 12

- Luchtvochtigheidsmeter

- Temperatuurmeter- Rolmaat

Passaggio 1: De Photon Instellen

Benodigdheden:- Telefono cellulare

- Fotoni

- Computer

Scarica l'app per le particelle sul telefono e fai un account sulle particelle.

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

Dit kan tramite setup.particle.io.

Passaggio 2: Paardenhaar

Benodigdheden:- Paard

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

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

Passaggio 3: Maak Een Orizzontale 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 orizzontale, bij voorkeur minimaal 50 cm. Zorg dat er genoeg haar over is om de hefboom en het gewicht te bevestigen (zie volgende stap)

Passaggio 4: fare un salto per il fotone sullo schermo LCD

Benodigdheden:- Hout en houtlijm

- Tipologia: zaag

Maak een semplice houten bak zonder deksel met een houten plank die in het midden staat als een divider. Opta per la tavola e per la breadboard con il fotone passen anche per la zijn zijn zijkant wordt gezet. Daarnaa kan derkant 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 è kan deze op zijn zijkant naast de haar worden gezet aan de kant waar de gewichtjes aan de haar hangen.

Passaggio 5: fare un salto di qualità

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

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

Benodigdheden:

- Sensore di posizione

- Opzetstukje (opzionale)

- Set di saldature extra (opzionale)

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

Indien nodig su un opzetstukje.

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

Passaggio 7: codice Schrijven

Benodigdheden: - Il computer ha incontrato le particelle

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

Oltre alle librerie, puoi importare LiquidCrystal e importare nell'app.

Il codice successivo è stato modificato nell'app:

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

Ook anche se un problema è stato risolto è het goed om de commenti te raadplegen.

// Includi le seguenti librerie:#include #include

// I pin di lettura analogici per tutti i sensori in questa build:

int tempSensor = A0; int disSensor = A1;

// Regole di pubblicazione:

// Il tempo di ritardo e il nome dell'evento per la pubblicazione. // Tempo di ritardo in millisecondi. int delayTime = 15000; String eventName = "Actual_Temperature";

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

// Codice display a cristalli liquidi ///////////// ////////////////////////////// ////////////////// // Inizializza il display con i pin di dati LiquidCrystal lcd(D5, D4, D3, D2, D1, D0);

// Imposta i limiti per i valori dell'indice di calore

int attenzione = 27; int eCD = 33; int pericolo = 40; int estremo = 52;

// Restituisce un messaggio per un valore dell'indice di calore specifico.

Stringa messaggio(int hI) { if(hI < attenzione) { return "Nessuna avvertenza. "; } if(hI < eCD) { return "Attenzione!"; } if(hI < pericolo) { return "Estrema cautela!"; } if(hI < estremo) { return "Pericolo!! "; } return "PERICOLO ESTREMO!!"; }

// Il messaggio sulla seconda riga del display.

String message2 = "T effettivo: ";

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

// Codice sensore di distanza ///////////////////////////// //////////////// ///////////////////////////////////// // Valori grezzi minimi e massimi restituiti dal sensore. int minD = 2105; int maxD = 2754;

// Valori grezzi effettivi restituiti dal sensore ogni 5 mm.

int dieci = 2754; int tenP = 2691; int undici = 2551; int undiciP = 2499; int dodici = 2377; int dodiciP = 2276; int tredici = 2206; int trediciP = 2198; int quattordici = 2105;

// Restituisce la distanza in cm che appartiene a un valore grezzo per ogni 5 mm.

float getDis(int numero) { switch(numero){ case 2754: return 10; caso 2691: ritorno 10.5; caso 2551: ritorno 11; caso 2499: ritorno 11.5; caso 2377: ritorno 12; caso 2276: ritorno 12,5; caso 2206: ritorno 13; caso 2198: ritorno 13,5; caso 2105: ritorno 14; } }

// Calcola la distanza effettiva in cm acquisita dal sensore di distanza.

float calcolaDis(int start, float stop, int misura) { float distanza = getDis(start); passo float = (stop - start)/10; for(int i = 0; i < 5; i++) { if(measurement = (start-step)){ return distance; } inizio = inizio - passo; distanza = distanza + 0,1; } }

// Controlla i grandi confini tra il sensore di distanza.

float distanza(misura int) { // Se il sensore di distanza non era compreso tra 10 e 14 cm, // non conosciamo la distanza effettiva e return 10. if(misura maxD) { return 10.0; } if(misura <= trediciP) { return calcolaDis(trediciP, quattordici, misura); } if(misura <= tredici) { return calcolaDis(tredici, trediciP, misura); } if(misura <= dodiciP) { return calcolaDis(dodiciP, tredici, misura); } if(misura <= dodici) { return calcolaDis(dodici, dodiciP, misura); } if(misura <= undiciP) { return calcolaDis(undiciP, dodici, misura); } if(misura <= undici) { return calcolaDis(undici, undiciP, misura); } if(misura <= dieciP) { return calcolaDis(dieciP, undici, misura); } if(misura <= dieci) { return calcolaDis(dieci, dieciP, misura); } // Il codice non dovrebbe mai arrivare qui. ritorno -2; }

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

// Codice sensore di temperatura //////////////////////////////////////////// ////////////// //////////////////////////////////// ///////////////////////////////////////////////// / // La tensione massima in mV utilizzata per il sensore di temperatura. float maxV = 3300.0;

// La tensione di base e la relativa temperatura restituite dal sensore di temperatura.

// La tensione è in mV. int baseV = 750; int baseT = 25;

// Calcola la temperatura dal valore misurato al pin analogico.

float calcolaTemp (misura int) { float voltage = ((maxV/4096)*measurement); float diff = baseV - tensione; float temp = baseT - (diff/10); temperatura di ritorno; }

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

// Calcoli dell'umidità ///////////////////////// //////////////////// ///////////////////////////// // Le variabili per i calcoli dell'umidità, // provengono dai sensori di umidità reali. float h15 = 10.0; galleggiante h30 = 10,5; galleggiante h60 = 11,5; galleggiante h75 = 12,0; galleggiante h90 = 12,5; passo galleggiante H = 0,167;

// Restituisce l'umidità relativa per un intervallo di distanza specifico.

int calcolaHum(float dis, float bassoH, float altoH, int start) { float diff = dis - bassoH; float i1 = diff/passoH; int i = round(i1); int output = (inizio + (5*i)); uscita di ritorno; }

// Restituisce l'umidità relativa.

int umidità(float dis) { if (dis <= h30) { return calcolaHum(dis, h15, h30, 15); } if (dis <= h60) { return calcolaHum(dis, h30, h60, 30); } if (dis <= h75) { return calcolaHum(dis, h60, h75, 60); } if (dis <= h90) { return calcolaHum(dis, h75, h90, 75); } restituisce 100; }

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

// Formula indice di calore ///////////////////////////// //////////////// ////////////////////////////////// // Costanti utilizzate nella formula dell'indice di calore float c1 = -8.78469475556; float c2 = 1,61139411; float c3 = 2,33854883889; float c4 = -0,14611605; float c5 = -0.0123008094; float c6 = -0.0164248277778; float c7 = 0.002211732; float c8 = 0,00072546; float c9 = -0,000003582;

// La formula dell'indice di calore che prende una temperatura e un'umidità relativa.

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

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

// Altre funzioni/variabili /////////////////////////////////////////// ////// //////////////////////////////////////////// /////////////////////////////////// // Restituisce una rappresentazione di stringa di un float arrotondata a un decimale. String rOne(float num) { int value = round(num*10); Output stringa = (Stringa) valore; char end = output[strlen(output)-1]; int sinistra = valore/10; Inizio stringa = (Stringa) sinistra; ritorno inizio + "." + fine; }

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

/ Tutto il codice qui dovrebbe essere eseguito una volta sul Photon prima che inizino le funzioni di ciclo.

void setup() { // Imposta il numero di colonne e righe del display LCD: lcd.begin(16, 2); }

// Tutto il codice qui è in loop e dovrebbe contenere il recupero dei dati, il perfezionamento e la messa online.

void loop() { // Ottieni temperatura e umidità. float temp = calcolaTemp(analogRead(tempSensor)); float dis = distanza(analogRead(disSensor)); int ronzio = umidità(dis); Stringa umida = (Stringa) ronzio; // Calcola l'indice di calore. float hI = heatIndex(temp, hum); // Imposta la stringa di output e stampa tutti i messaggi sul display LCD. Uscita stringa = rOne(hI); lcd.setCursor(0, 0); lcd.print(messaggio(round(hI))); lcd.setCursor(0, 1); lcd.print(messaggio2 + output + "C "); uscita = uscita + " " + umido; // Pubblica i valori dell'indice di calore online e attendi prima di ripetere il ciclo. Particle.publish(nomeevento, output); ritardo(DelayTime); }

Passaggio 8: Verbind De Photon

Benodigdheden:

- Photon e breadboard

- Sensore di temperatura

- 220 Ohm in piedi

- Afstandssensor

- Schermo LCD e potenziometro 10k Ohm (opzionale)

- Genoeg breadboard draadjes, 9+

- Draadjes jumper uomo/donna, 12 (opzionale)

Verbindt de 3.3V van de photon con de + rails e un dezelfde kant en verbindt de ground e un de - rails.

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

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

Indicazione dell'uscita analogica del sensore di temperatura con A0 del fotone e del terreno con i binari di terra.

Zet de weerstand per input van de sensor e verbindt de weerstand con binari 3.3V.

Il supporto per la comunicazione verbale porta l'ingresso nei binari a 3,3 V per il blocco, la messa a terra nei binari di terra e l'uscita analogica in A1 per il fotone di arresto.

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

1. Verbindt de potenziometro su una breadboard con 5V e terra.

2. La fine del ponticello mostra lo schermo LCD con il pin 1 e lo schermo è diverso.

Pin 1, 5 e 16 del display LCD a terra. Pin 2 e 15 a 5V.

Indicato l'uscita analogica del potenziometro, il pin centrale, con il pin 3 del display LCD.

3. Visualizza i pin dei fotoni successivi ai pin LCD con i ponticelli.

Pin D5 vicino a Pin 4

Pin D4 vicino a Pin 6

Pin D3 vicino al Pin 11

Pin D2 vicino a Pin 12

Pin D1 vicino al Pin 13

Pin D0 vicino Pin 14

Inoltre, il fotone non è più un potenziometro e il potenziometro viene utilizzato per la modifica dei blocchi di schermo LCD.

Passaggio 9: Plaats De Photon En Het LCD-Scherm in De Opstelling

Benodigdheden:- Powerbank (opzionale)

Nu de photon klaar voor gebruik is kan deze on 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.

Passaggio 10: Kalibreren (opzionale)

Benodigdheden:

- Luchtvochtigheidssensor

- Termometro

- Rolmaat

- Output del codice voor rauwe waarden van de sensorn die gekalibreerd moeten worden

Inoltre, il software non è stato modificato con il sensore per la risoluzione dei problemi relativi al sensore.

Il misuratore di temperatura consente di visualizzare correttamente le parole chiave per la misurazione della temperatura con il sensore di temperatura.

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 vergelijteken met echtechidsmeter/luchtigheid

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

Passaggio 11: il misuratore dell'indice De Warmte è Klaar Voor Gebruik

Veel plezier!