Warmte Index Meter

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.

- Particle Photon met breadboard

- Temperatuursensor (TMP36)

- Afstandssensor voor afstanden tussen 10 en 20 cm.

- Powerbank

- 220 Ohm weerstand

- Breadboard draadjes, 9+

- Mobiele telefoon + 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:

- LCD scherm + 10k Ohm potentiometer + Male/Female jumper draadjes, 12

- Luchtvochtigheidsmeter

- Temperatuurmeter
- Rolmaat

Benodigdheden:
- Mobiele telefoon

- Photon

- Computer

Download the particle app op je telefoon en maak een particle account.

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

Dit kan via setup.particle.io.

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

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)

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.

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

Benodigdheden:

- Afstandsensor

- Opzetstukje (optioneel)

- Extra draad en soldeer set (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.

Benodigdheden:
- Computer met particle account

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

Onder libraries, zoek LiquidCrystal en import deze in de app.

Dan kan de volgende code gekopieerd worden in de app:

Lees de 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 the following libraries:<br>#include <LiquidCrystal.h><liquidcrystal.h>
#include <String.h><string.h></string.h></liquidcrystal.h>

// The analog read pins for all sensors in this build:
int tempSensor = A0;
int disSensor = A1;

// Publishing rules:
// The delay time and event name for publishing.
// Delay time in milliseconds.
int delayTime = 15000;
String eventName = "Actual_Temperature";

/////////////////////////////////////////////////
// Liquid crystal display code      /////////////
/////////////////////////////////////////////////
// Initialise the display with the data pins
LiquidCrystal lcd(D5, D4, D3, D2, D1, D0);

// Setup boundaries for heat index values 
int caution = 27;
int eCD = 33;
int danger = 40;
int extreme = 52;

// Returns a message for a specific heat index value.
String message(int hI) {
    if(hI < caution) {
        return "No caution.     ";
    }
    if(hI < eCD) {
        return "Caution!        ";
    }
    if(hI < danger) {
        return "Extreme caution!";
    }
    if(hI < extreme) {
        return "Danger!!        ";
    }
    return "EXTREME DANGER!!";
}

// The message on the second line of the display.
String message2 = "Actual T: ";

//////////////////////////////////////////////////////
// Distance sensor code  /////////////////////////////
//////////////////////////////////////////////////////
// Minimum and maximum raw values the sensor returns.
int minD = 2105;
int maxD = 2754;

// Actual raw values the sensor returned every 5mm.
int ten = 2754;
int tenP = 2691;
int eleven = 2551;
int elevenP = 2499;
int twelve = 2377;
int twelveP = 2276;
int thirteen = 2206;
int thirteenP = 2198;
int fourteen = 2105;

// Returns the distance in cm that belongs to a raw value for every 5mm.
float getDis(int number) {
    switch(number){
        case 2754:
            return 10;
        case 2691:
            return 10.5;
        case 2551:
            return 11;
        case 2499:
            return 11.5;
        case 2377:
            return 12;
        case 2276:
            return 12.5;
        case 2206:
            return 13;
        case 2198:
            return 13.5;
        case 2105:
            return 14;
    }
}

// Calculates the actual distance in cm that the distance sensor captured.
float calculateDis(int start, float stop, int measurement) {
    float distance = getDis(start);
    float step = (stop - start)/10;
    for(int i = 0; i < 5; i++) {
        
        if(measurement <= start && measurement >= (start-step)){
            return distance;
        }
        start = start - step;
        distance = distance + 0.1;
    }
}

// Checks the big boundaries the distance sensor is inbetween.
float distance(int measurement) {
    // If the distance sensor was not between 10 and 14 cm,
    // we do not know the actual distance and return 10.
    if(measurement < minD || measurement > maxD) {
        return 10.0;
    }
    if(measurement <= thirteenP) {
        return calculateDis(thirteenP, fourteen, measurement);
    }
    if(measurement <= thirteen) {
        return calculateDis(thirteen, thirteenP, measurement);
    }
    if(measurement <= twelveP) {
        return calculateDis(twelveP, thirteen, measurement);
    }
    if(measurement <= twelve) {
        return calculateDis(twelve, twelveP, measurement);
    }
    if(measurement <= elevenP) {
        return calculateDis(elevenP, twelve, measurement);
    }
    if(measurement <= eleven) {
        return calculateDis(eleven, elevenP, measurement);
    }
    if(measurement <= tenP) {
        return calculateDis(tenP, eleven, measurement);
    }
    if(measurement <= ten) {
        return calculateDis(ten, tenP, measurement);
    }
    // Code should never get here.
    return -2;
}

///////////////////////////////////////////////////////////////////////////////////////
// Temperature sensor code  ///////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////
// The maximum voltage in mV used for the temperature sensor.
float maxV = 3300.0;

// The base voltage and accompanying temperature that the temperature sensor returns.
// Voltage is in mV.
int baseV = 750; 
int baseT = 25;

// Calculates the temperature from the measured value at the analog pin.
float calculateTemp(int measurement) {
    float voltage = ((maxV/4096)*measurement);
    float diff = baseV - voltage;
    float temp = baseT - (diff/10);
    return temp;
}

///////////////////////////////////////////////////
// Humidity calculations  /////////////////////////
///////////////////////////////////////////////////
// Variables for humidity calculations,
// come from actual humidity sensors.
float h15 = 10.0;
float h30 = 10.5;
float h60 = 11.5;
float h75 = 12.0;
float h90 = 12.5; 
float stepH = 0.167;

// Returns the relative humidity for a specific distance range.
int calculateHum(float dis, float lowH, float highH, int start) {
    float diff = dis - lowH;
    float i1 = diff/stepH;
    int i = round(i1);
    int output = (start + (5*i));
    return output;
}

// Returns the relative humidity.
int humidity(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);
    }
    return 100;
}

///////////////////////////////////////////////////
// Heat index formula /////////////////////////////
///////////////////////////////////////////////////
// Constants used in the heat index formula
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;

// The heat index formula that takes a temperature and relative humidity.
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);
}

///////////////////////////////////////////////////////////////////////////////
// Other fucntions/variables //////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////
// Returns a string representation of a float rounded down to one decimal.
String rOne(float num) {
    int value = round(num*10);
    String output = (String) value;
    char end = output[strlen(output)-1];
    int left = value/10;
    String begin = (String) left;
    return begin + "." + end;
}

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

/ All code here should be ran once on the Photon before the looping functions start.
void setup() {
    // Set up the LCD's number of columns and rows:
    lcd.begin(16, 2);
}

// All code here is being looped and should contain getting data, refining it and putting it online.
void loop() {
    // Get temperature and humidity.
    float temp = calculateTemp(analogRead(tempSensor));
    float dis = distance(analogRead(disSensor));
    int hum = humidity(dis);
    String humid = (String) hum;
    // Calculate the heat index.
    float hI = heatIndex(temp, hum);
 
    // Set up the output string and print all messages on the LCD display.
    String output = rOne(hI);
    lcd.setCursor(0, 0);
    lcd.print(message(round(hI)));
    lcd.setCursor(0, 1);
    lcd.print(message2 + output + "C ");
    output = output + " " + humid;
    // Publish the heat index values online and wait before looping again.
    Particle.publish(eventName, output);
    delay(delayTime);
}

Benodigdheden:

- Photon en breadboard

- Temperatuursensor

- 220 Ohm weerstand

- Afstandssensor

- LCD-scherm en 10k Ohm potentiometer (optioneel)

- Genoeg breadboard draadjes, 9+

- Male/Female jumper draadjes, 12 (optioneel)

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 en 16 van de LCD naar ground. Pin 2 en 15 naar 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 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-scherm blokjes verschijnen.

Benodigdheden:
- Powerbank (optioneel)

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.

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 luchtvochtigheidsmeter/sensor.

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

Veel plezier!