Medidor de índice Warmte: 11 pasos

2024 Autor: John Day | [email protected]. Última modificación: 2024-01-30 08:42

Met deze instructable kun je je eigen medidor de índice de calor maken.

Un medidor de índice de calor geeft de gevoelstemperatuur aan op base van de omgevingstemperatuur en de luchtvochtigheid.

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

Suministros

- Tablero de pruebas de partículas de fotón reunido

- Sensor de temperatura (TMP36)

- Afstandssensor voor afstanden tussen 10 en 20 cm.

- Banco de energía

- Soporte de agua de 220 ohmios

- Draadjes de tablero, 9+

- Teléfono móvil + Ordenador

- Paardenhaar

- Hout en houtlijm

- Gereedschap: Boormachine / schroevendraaier, zaag en vijl

- Zeep

- 2 potloden- Kurk

- Kartonnen plaatje + wit papier

- Gewichtjes, denk aan kleine loodjes de metalen plaatjes

Optioneel:

- LCD scherm + potenciómetro de 10k Ohm + draadjes jumper macho / hembra, 12

- Luchtvochtigheidsmeter

- Medidor de temperatura - Rolmaat

Paso 1: De Photon Instellen

Benodigdheden: - Teléfono móvil

- Fotón

- Computadora

Descargue la aplicación de partículas op je telefoon y haga una cuenta de partículas.

Detenga el usb-kabel van de photon en la computadora je, reclame de photon en stel de wifi in.

Dit kan a través de setup.particle.io.

Paso 2: Paardenhaar

Benodigdheden: - Paard

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

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

Paso 3: Maak Een Horizontale Opstelling conoció a 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)

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

Benodigdheden: - Hout en houtlijm

- Gereedschap: zaag

Haga un simple houten bak zonder deksel con een houten plank die in het midden staat als een divider. Op deze plank moet het breadboard con fotones de pasajeros 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 paralelo zijn met het plankje dat in de bak is gezet. Als de bak klaar es kan deze op zijn zijkant naast de haar worden gezet aan de kant waar de gewichtjes aan de haar hangen.

Paso 5: hacer 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).

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

Benodigdheden:

- Sensor de afstand

- Opzetstukje (optioneel)

- Juego extra de soldadura y draad (optioneel)

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.

Paso 7: Código Schrijven

Benodigdheden: - Cuenta de partículas por ordenador

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

En otras bibliotecas, zoek LiquidCrystal e import deze en la aplicación.

Dan kan de volgende code gekopieerd worden en la aplicación:

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

Ook también hay un problema optreedt es het goed om de comments te raadplegen.

// Incluir las siguientes bibliotecas: #include #include

// Los pines de lectura analógica para todos los sensores en esta compilación:

int tempSensor = A0; int disSensor = A1;

// Reglas de publicación:

// El tiempo de retraso y el nombre del evento para la publicación. // Tiempo de retardo en milisegundos. int delayTime = 15000; String eventName = "Actual_Temperature";

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

// Código de la pantalla de cristal líquido ///////////// ///////////////////////////////// //////////////////// // Inicialice la pantalla con los pines de datos LiquidCrystal lcd (D5, D4, D3, D2, D1, D0);

// Configurar límites para valores de índice de calor

int precaución = 27; int eCD = 33; int peligro = 40; int extreme = 52;

// Devuelve un mensaje para un valor de índice de calor específico.

Mensaje de cadena (int hI) {if (hI <precaución) {return "Sin precaución"; } if (hI <eCD) {return "¡Precaución!"; } if (hI <peligro) {return "¡Extrema precaución!"; } if (hI <extremo) {return "¡¡Peligro !!"; } devuelve "¡¡PELIGRO EXTREMO !!"; }

// El mensaje en la segunda línea de la pantalla.

String message2 = "T actual:";

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

// Código del sensor de distancia /////////////////////////////// ////////////////// ////////////////////////////////////// // Valores brutos mínimos y máximos que devuelve el sensor. int minD = 2105; int maxD = 2754;

// Valores brutos reales que el sensor devuelve cada 5 mm.

int diez = 2754; int tenP = 2691; int once = 2551; int onceP = 2499; int doce = 2377; int doceP = 2276; int trece = 2206; int treceP = 2198; int catorce = 2105;

// Devuelve la distancia en cm que pertenece a un valor bruto por cada 5 mm.

float getDis (int número) {switch (número) {caso 2754: return 10; caso 2691: retorno 10.5; caso 2551: retorno 11; caso 2499: retorno 11.5; caso 2377: retorno 12; caso 2276: retorno 12.5; caso 2206: retorno 13; caso 2198: retorno 13.5; caso 2105: retorno 14; }}

// Calcula la distancia real en cm que capturó el sensor de distancia.

flotar calcularDis (inicio int, parada flotante, medición int) {distancia flotante = getDis (inicio); paso flotante = (parada - inicio) / 10; for (int i = 0; i <5; i ++) {if (medida = (paso de inicio)) {distancia de retorno; } inicio = inicio - paso; distancia = distancia + 0,1; }}

// Comprueba los grandes límites entre los que se encuentra el sensor de distancia.

distancia flotante (medida int) {// Si el sensor de distancia no estaba entre 10 y 14 cm, // no sabemos la distancia real y devolvemos 10. if (medida maxD) {return 10.0; } if (medida <= treceP) {return calculateDis (treceP, catorce, medida); } if (medida <= trece) {return calculateDis (trece, treceP, medida); } if (medida <= doceP) {return calculateDis (doceP, trece, medida); } if (medida <= doce) {return calculateDis (doce, doceP, medida); } if (medida <= onceP) {return calculateDis (onceP, doce, medida); } if (medida <= once) {return calculateDis (once, onceP, medida); } if (medida <= diezP) {return calculateDis (diezP, once, medida); } if (medida <= diez) {return calculateDis (diez, diezP, medida); } // El código nunca debería llegar aquí. return -2; }

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

// Código del sensor de temperatura /////////////////////////////////////////////// ////////////// ////////////////////////////////////// //////////////////////////////////////////////////// / // El voltaje máximo en mV usado para el sensor de temperatura. flotador maxV = 3300.0;

// El voltaje base y la temperatura que lo acompaña que devuelve el sensor de temperatura.

// El voltaje está en mV. int baseV = 750; int baseT = 25;

// Calcula la temperatura a partir del valor medido en el pin analógico.

float calculateTemp (medición int) {voltaje de flotación = ((maxV / 4096) * medición); float diff = baseV - voltaje; temperatura de flotación = baseT - (diff / 10); temperatura de retorno; }

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

// Cálculos de humedad ///////////////////////// /////////////////////// ////////////////////////////// // Las variables para los cálculos de humedad, // provienen de los sensores de humedad reales. flotador h15 = 10.0; flotador h30 = 10,5; flotador h60 = 11,5; flotador h75 = 12,0; flotador h90 = 12,5; paso de flotación H = 0,167;

// Devuelve la humedad relativa para un rango de distancia específico.

int calculateHum (float dis, float lowH, float highH, int start) {float diff = dis - lowH; flotar i1 = diff / stepH; int i = round (i1); int salida = (inicio + (5 * i)); salida de retorno; }

// Devuelve la humedad relativa.

int humedad (flotador dis) {if (dis <= h30) {volver calcularHum (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); } return 100; }

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

// Fórmula del índice de calor /////////////////////////////// ////////////////// ///////////////////////////////////// // Constantes utilizadas en la fórmula del índice de calor float c1 = -8.78469475556; flotador c2 = 1.61139411; flotador c3 = 2,33854883889; flotador c4 = -0,14611605; flotador c5 = -0.0123008094; flotador c6 = -0.0164248277778; flotador c7 = 0,002211732; flotador c8 = 0.00072546; flotador c9 = -0,000003582;

// La fórmula del índice de calor que toma la temperatura y la humedad 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); }

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

// Otras funciones / variables ////////////////////////////////////////////// ////// //////////////////////////////////////////////// /////////////////////////////////// // Devuelve una representación de cadena de un flotante redondeado a un decimal. String rOne (número flotante) {valor int = round (num * 10); Salida de cadena = valor (Cadena); char end = salida [strlen (salida) -1]; int left = value / 10; String begin = (String) left; return begin + "." + fin; }

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

/ Todo el código aquí debe ejecutarse una vez en Photon antes de que comiencen las funciones de bucle.

void setup () {// Configure el número de columnas y filas de la pantalla LCD: lcd.begin (16, 2); }

// Todo el código aquí está en bucle y debe contener la obtención de datos, refinarlos y ponerlos en línea.

void loop () {// Obtiene la temperatura y la humedad. float temp = calculateTemp (analogRead (tempSensor)); flotar dis = distancia (analogRead (disSensor)); int hum = humedad (dis); String húmedo = (String) zumbido; // Calcula el índice de calor. flotar hI = heatIndex (temperatura, zumbido); // Configure la cadena de salida e imprima todos los mensajes en la pantalla LCD. Salida de cadena = rOne (hI); lcd.setCursor (0, 0); lcd.print (mensaje (ronda (hI))); lcd.setCursor (0, 1); lcd.print (mensaje2 + salida + "C"); salida = salida + "" + húmedo; // Publique los valores del índice de calor en línea y espere antes de volver a ejecutar el bucle. Particle.publish (eventName, salida); delay (delayTime); }

Paso 8: Verbind De Photon

Benodigdheden:

- Photon en protoboard

- Sensor de temperatura

- Soporte de agua de 220 ohmios

- Sensor de presencia

- Potenciómetro LCD-scherm en 10k Ohm (opción)

- Draadjes de tablero Genoeg, 9+

- Draadjes jumper macho / hembra, 12 (opcional)

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.

Detener el sensor de temperatura ergens se reunió con genoeg ruimte eromheen en el tablero de pruebas.

Verbindt de analoge output van de temperatureursensor 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 puerta de entrada en rieles de 3.3V te stoppen, de suelo en rieles de suelo y salida analógica en A1 van de photon te stoppen.

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

1. Verbindt de potenciómetro aan het protoboard 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 en 16 van de LCD naar ground. Pin 2 en 15 naar 5V.

Verbindt de salida analógica van de potenciómetro, pin middelste, met pin 3 van de LCD.

3. Verbindt de volgende photon pins naar LCD pins with 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 potenciómetro gedraaid wordt moeten er op het LCD-scherm blokjes verschijnen.

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

Benodigdheden: - Powerbank (optioneel)

Nu de photon klaar voor gebruik es kan deze op het plankje in de bak geplaatst worden en het LCD-scherm kan tegen het gat geplakt worden. Nu es el momento anterior del fotón de la última vez que se abre un banco de energía y es natuurlijk niet verplicht.

Paso 10: Kalibreren (optioneel)

Benodigdheden:

- Luchtvochtigheidssensor

- Medidor de temperatura

- Rolmaat

- Salida de código 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.

El termómetro kan vrij makkelijk gekalibreerd worden door metingen se reunió con un termómetro te vergelijken con el 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 luchtvochtigheidsmeter.

En el código bijgeleverde zitten comentarios die aangeven waar dit soort kalibratie variabelen staan.

Paso 11: ¡De Warmte Index Meter es Klaar Voor Gebruik

Veel plezier!