Hur man mäter termisk komfort med elektriska Imp och Ubidots (5 / 10 steg)
Steg 5: Styrkod
Låt oss börja kodning! När du arbetar med elektriska imp, du behöver två kodavsnitt: en för enheten och en annan för agenten. Tack till Thomas Byrne för att ge klassen för att hantera DHT11 sensorn i Github. Här kommer styrkod (lite lång eftersom det har klassen att hantera DHT11):
< br >< p > const SPICLK = 937.5; < br > / / klass för att läsa DHT11 temperatur/hygrometergivare
Dessa sensorer oss en egen one-wire protokoll. Imp
emulerar detta protokoll med SPI.
Att använda:
-knyta MOSI till MISO med en 10 k resistor
-knyta MISO till raden data på sensorn
klass DHT11 {
statiska STARTTIME_LOW = 0.001000; 1 ms låg tid för start
statiska STARTTIME_HIGH = 0.000020; 20 US min hög tid för start
statiska STARTTIME_SENSOR = 0.000080; 80 USA låg / 80 oss hög "ACK" från sensorn på START
statiska MARKTIME = 0.000050; 50 US låg puls mellan varumärken som 0 eller 1
statiska noll = 0.000026; 26 amerikanska högt för "0"
statisk en = 0.000075; 70 US högt för "1"
SPI = null;
clkspeed = null;
bittime = null;
bytetime = null;
start_low_bits = null;
start_low_bytes = null;
start_high_bits = null;
start_high_bytes = null;
start_ack_bits = null;
start_ack_bytes = null;
mark_bits = null;
mark_bytes = null;
zero_bits = null;
zero_bytes = null;
one_bits = null;
one_bytes = null;
klasskonstruktor
Ingång:
_spi: förkonfigurerade SPI kringutrustning (t.ex. spi257)
_clkspeed: den hastighet som SPI har konfigurerats för att köras på
Avkastning: (Ingen)
konstruktören (_spi, _clkspeed) {
This.SPI = _spi;
This.clkspeed = _clkspeed;
bittime = 1,0 / (clkspeed * 1000);
bytetime = 8.0 * bittime;
start_low_bits = STARTTIME_LOW / bittime;
start_low_bytes = (start_low_bits / 8);
start_high_bits = STARTTIME_HIGH / bittime;
start_high_bytes = (start_high_bits / 8);
start_ack_bits = STARTTIME_SENSOR / bittime;
start_ack_bytes = (start_ack_bits / 8);
mark_bits = MARKTIME / bittime;
mark_bytes = (mark_bits / 8);
zero_bits = noll / bittime;
zero_bytes = (zero_bits / 8);
one_bits = ett / bittime;
one_bytes = (one_bits / 8);
}
hjälpare funktion
med tanke på en lång klump, hitta tider mellan övergångar och tolka till
temp och luftfuktighet värden. Utgår från 40-bitars returvärdet (16 fukt / temp-16 / 8 kontrollsumma)
Ingång:
hexblob (blob av godtycklig längd)
Återkomst:
tabell som innehåller:
"rh": relativ luftfuktighet (float)
"temp": temperatur i celsius (float)
om Läs misslyckas, kommer rh och temp tillbaka 0
funktion parse(hexblob) {
lokala laststate = 0;
lokala lastbitidx = 0;
lokala gotack = false;
lokala rawidx = 0;
lokala resultat = blob(5); 2-byte fukt, 2 byte temp, 1-byte checksum
lokala fuktigt = 0;
lokala temp = 0;
iterera igenom varje bit av varje byte av returnerade signalen
för (lokala byte = 0; byte < hexblob.len(); byte ++) {
för (lokala bit = 7; lite > = 0; lite--) {
lokala thisbit = (hexblob [byte] & (0x01 << bit))? 1:0;
om (thisbit! = laststate) {
om (thisbit) {
låg till hög övergången; titta för att se hur länge det är hög
laststate = 1;
lastbitidx = (8 * byte) + (7 - bitars);
} annat {
hög-till låg övergången;
laststate = 0;
lokala idx = (8 * byte) + (7 - bitars);
lokala hightime = (idx - lastbitidx) * bittime;
Vi har nu en giltig lite info. Räkna ut vad symbol det är.
lokala resultbyte = (rawidx / 8);
lokala resultbit = 7 - (rawidx % 8).
Server.log (format ("bit %d av %d byte", resultbit, resultbyte));
om (hightime < noll) {
Detta är en nolla
om (gotack) {
inte spela in några data innan ACK ses
resultatet [resultbyte] = resultat [resultbyte] & ~ (0x01 << resultbit);
rawidx ++;
}
} else om (hightime < en) {
Detta är en
om (gotack) {
resultatet [resultbyte] = resultat [resultbyte] | (0x01 << resultbit);
rawidx ++;
}
} annat {
Detta är en START ACK
gotack = sant;
}
}
}
}
}
Server.log (format ("parsed: 0 x % 02 x % 02 x 02 x % 02 x % 02x",result[0],result[1],result[2],result[3],result[4]));
fuktigt = (resultatet [0] * 1,0) + (resultat [1] / 1000.0);
om (resultat [2] & 0x80) {
negativ temperatur
resultatet [2] = ((~result[2]) + 1) & 0xff;
}
Temp = (resultat [2] * 1,0) + (resultat [3] / 1000.0);
om (((resultatet [0] + resultat [1] + resultat [2] + result[3]) & 0xff)! = result[4]) {
returnera {"rh": 0, "temp": 0};
} annat {
returnera {"rh": fuktigt, "temp": temp};
}
}
Läs sensorn
Ingång: (ingen)
Återkomst:
tabell som innehåller:
"rh": relativ luftfuktighet (float)
"temp": temperatur i celsius (float)
om Läs misslyckas, kommer rh och temp tillbaka 0
funktion read() {
lokala bloblen = start_low_bytes + start_high_bytes + (40 * (mark_bytes + one_bytes));
lokala startblob = blob(bloblen);
för (lokala jag = 0; jag < start_low_bytes; i ++) {
startblob.Writen(0x00,'b');
}
för (lokala j = start_low_bytes; j < bloblen; j ++) {
startblob.Writen(0xFF,'b');
}
Server.log (format ("Skicka %d byte", startblob.len()));
lokala resultat = spi.writeread(startblob);
återvända parse(result);
}
}
relevanta <-hardware.pin9;
SPI <-hardware.spi257; < /p >< p > while(1) {
clkspeed <-spi.configure (MSB_FIRST, SPICLK);
dht11 <-DHT11 (spi, clkspeed);
data <-dht11.read();
Server.log (format("Relative Humidity: %0.1f",data.rh) + "%");
Server.log (format ("temperatur: %0.1f C",data.temp));
agent.send("Temp",data.Temp);
IMP.Sleep(1); < /p >< p >} < /p >