Het lezen van de druksensor van BMP180 met een Attiny85 en voeg een DHT11 ook

Ik hou van de serie Attiny 85 en willen alle dingen die u met het doen kunt verkennen. Als het niet teveel pennen hebben, is met behulp van I2C hardware op het een goed idee. I2C op de attiny kan worden een beetje onhandig als het kan niet de draad bibliotheek compileren, maar de TinyWireM-bibliotheek prima werkt.

De BMP180 druk is een relatief goedkope en populaire sensor te lezen van de atmosferische druk. Bovendien kan het temperatuur kan lezen. Als u gebruik wilt maken deze sensor op een arduino, Adafruit beschikt over een bibliotheek (voor de BMP085 en de BMP180) die wil lezen voor u. Echter, de nieuwe bibliotheek moet ook hun algemene 'Sensor bibliotheek' en dat zijn geheugen schrokoppen. Misschien OK op een Arduino, maar niet op een attiny. Ze hebben een voor de Tiny85 ook. Sparkfun heeft ook een bibliotheek voor de Arduino.

Dus, als u lezen van de BMP180-sensor op een attiny wilt, zou u moeten doen wat werk jezelf. Gelukkig, het gegevensblad is zeer duidelijk. Pagina 15 vertelt ons precies wat te doen. De volgorde is als volgt: 1-Lees de chip kalibratie gegevens 2-Lees de ongecorrigeerde temparature waarde 3-Lees de waarde van de niet-gecorrigeerde druk 4-ware temperatuur 5 berekenen-berekenen waar druk

Ook u ziet wat moet worden in een lus en wat niet: het lezen van de kalibratiegegevens moeten alleen worden gedaan eenmaal en gaat dus in de 'Setup'-routine. De rest is in een lus en gaat dus in de 'loop' routine.

Dus, programmering is een fluitje van een cent als je het stroomschema op pagina 15 volgen... We moeten alleen 'vertalen' die in taal die de I2C protocol begrijpt. We beginnen daarom het programma bij het definiëren van enkele algemene parameters: voor de Attiny er de TinyWireM-bibliotheek die een I2C protocol op de attiny is implementeert, dus we moeten laden van die bibliotheek. We moeten de I2C adres van de BMP180 (oftewel 0x77), en we moeten een gehele bos van variabelen declareren. Allermeest naar de variabelen gebruikt de chip kalibratiegegevens bevatten die we zullen het lezen van de chip EEPROM, zullen we enkele variabelen voor de verschillende berekeningen en zullen we enkele variabelen bevatten de output (temperatuur en druk) om het te houden gemakkelijk, ik heb gekozen namen voor de variabelen zoals vermeld in het gegevensblad.

Gewoon een woordje uitleg over het apparaatadres 0x77. Pagina 20 van het gegevensblad vermeldt twee apparaat adressen: 0xEE voor lezen en 0xEF voor schrijven.

Een I2C apparaatadres kan gespecificeerd worden als een 7 bits adres, oftewel 7 bits waarmee één apparaat van andere onderscheiden kunnen. Of als een byte opnemen dat de R/W-bit in de LSB-positie.
Het gegevensblad Bosch specificeert niet de 7-bits adres, oftewel 0x77. In plaats daarvan geeft het (pagina 20) het adres voor het schrijven van 8 bit, dat 0xEE is en de 8-bit Lees toespraak, wie 0xEF zit. Beide zijn 0x77 R/W
0x77 = 111 0111
0xEE = 111 01110
0xef = 111 01111
in de TinywireM bibliotheek twee waarden zijn gedefinieerd #define USI_SEND 0 / / geeft aan verzenden naar TWI #define USI_RCVE 1 / / geeft aan ontvangst van TWIthese worden gecombineerd met het 7-bits adres te geven te lezen of schrijven van actie

Dus, de eerste regels van een programma zal uitzien:

 //The connection for Attiny & BMP180 are SDA pin 5 ,SCL pin 7 for I2C #include <TinyWireM.h> #define BMP180_ADDRESS 0x77 // I2C address of BMP180 // define calibration data for temperature: int ac1; int ac2; int ac3; unsigned int ac4; unsigned int ac5; unsigned int ac6; int b1; int b2; int mb; int mc; int md; long b5; //define variables for pressure and temperature calculation long x1,x2; //define variables for pressure calculation long x3,b3,b6,p; unsigned long b4,b7; //define variables for temperature and pressure reading short temperature; long pressure; const unsigned char OSS = 0; // Oversampling Setting /* blz 12 Datasheet OSS=0 ultra Low Power Setting, 1 sample, 4.5 ms 3uA OSS=1 Standard Power Setting, 2 samples, 7.5 ms 5uA OSS=2 High Resolution, 4 samples, 13.5 ms 7uA OSS=3 Ultra High Resolution, 2 samples, 25.5 ms 12uA */ 

Vervolgens moeten we definiëren de 'Setup'-routine. Eerlijk gezegd, is het enige wat dat we moeten doen er de kalibratiegegevens lezen. Het om eenvoudig te houden, zal ik gewoon het bellen van een procedure 'bmp180ReadInt(address)', die we dan later kunt uitvoeren. Daarom zal onze opstelling als dit kijken:

 void setup() { // First read calibration data from EEPROM ac1 = bmp180ReadInt(0xAA); ac2 = bmp180ReadInt(0xAC); ac3 = bmp180ReadInt(0xAE); ac4 = bmp180ReadInt(0xB0); ac5 = bmp180ReadInt(0xB2); ac6 = bmp180ReadInt(0xB4); b1 = bmp180ReadInt(0xB6); b2 = bmp180ReadInt(0xB8); mb = bmp180ReadInt(0xBA); mc = bmp180ReadInt(0xBC); md = bmp180ReadInt(0xBE); } 

Natuurlijk ik kon hebben belde 1 procedure en oproep dat 'bmp180ReadCalibration' maar die procedure vervolgens hetzelfde doen zou als ik nu al in de installatie omschreven

De 'loop'-procedure is even eenvoudig. Het is eigenlijk lezen ongecorrigeerd temperatuur juist dat ongecorrigeerd temperatuur ongecorrigeerd druk juist dat ongecorrigeerd leest druk maar als niemand geïnteresseerd in de niet-gecorrigeerde gegevens is, maken wij die procedure: Correct(Read Uncorrected temperature) Correct(Read Uncorrected pressure) als volgt:

 void loop() { // first, read uncompensated temperature //temperature = bmp180ReadUT(); //and then calculate calibrated temperature temperature = bmp180CorrectTemperature(bmp180ReadUT()); // then , read uncompensated pressure //pressure = bmp180ReadUP(); //and then calculate calibrated pressure pressure = bmp180CorrectPressure(bmp180ReadUP()); } 

Dus is dat het. We hebben nu alleen om de procedures waar wij om vragen te definiëren. We beginnen met 'bmp180ReadInt(address)' dit procedure zal de TinyWireM bibliotheek gebruiken om te lezen van een geheel getal van een bepaald adres. Bij het verkrijgen van gegevens vanaf een I2C-device, de algemene regel is eerst naar dat apparaat om het te vertellen wat te doen is schrijven en vervolgens te lezen op een specifiek adres voor het resultaat. Zoals we zullen het lezen van de EEPROM is er geen specifieke opdracht die we sturen, moeten anders dan op de hoogte van de I2C-poort waar we willen zijn (op de I2C adres van de chip) en stuur het adres dat we willen lezen en hoeveel bytes wilt dat we willen lezen. We combineren die twee butes in een geheel getal en retourneren die. Onze precedure zal dus als volgt uitzien:

 int bmp180ReadInt(unsigned char address) { unsigned char msb, lsb; TinyWireM.beginTransmission(BMP180_ADDRESS); TinyWireM.send(address); TinyWireM.endTransmission(); TinyWireM.requestFrom(BMP180_ADDRESS, 2); while(TinyWireM.available()<2); msb = TinyWireM.receive(); lsb = TinyWireM.receive(); return (int) msb<<8 | lsb; } 

We moeten van de volgende procedure is om te lezen van de niet-gecompenseerde temperatuur. Om dat te krijgen moeten we eerst verzenden de waarde van 0x2E register 0xF4 en wacht ten minste 4,5 msec. Dat wil zeggen de tijd de chip moet Neem 1 lezing. Nadat we wachtten lezen we de niet-gecompenseerde temperatuur uit registers 0xF6 en 0xf7. Laatst gelezen dat we doen met de eerder gedefinieerde 'bmp180ReadInt' procedure die 2 bytes leest en combineert hen in een geheel getal. De procedure dus zal als volgt uitzien:

 unsigned int bmp180ReadUT() { unsigned int ut; // Write 0x2E into Register 0xF4 and wait at least 4.5mS // This requests a temperature reading // with results in 0xF6 and 0xF7 TinyWireM.beginTransmission(BMP180_ADDRESS); TinyWireM.send(0xF4); TinyWireM.send(0x2E); TinyWireM.endTransmission(); // Wait at least 4.5ms delay(5); // Then read two bytes from registers 0xF6 (MSB) and 0xF7 (LSB) // and combine as unsigned integer ut = bmp180ReadInt(0xF6); return ut; } 

Vervolgens hebben we voor de berekening van de gecorrigeerde temperatuur van de niet-gecorrigeerde temperatuur. Het gegevensblad wordt dat als volgt gedefinieerd: UT = niet-gecompenseerde temperatuur X1 =(UT-AC6) * AC5/2 ^ 15 X 2 = (MC * 2 ^ 11 /(X1+MD) B5 X = 1 + X 2 T =(B5+8)/2 ^ 4 in software die als dit kijkt

 double bmp180CorrectTemperature(unsigned int ut) { x1 = (((long)ut - (long)ac6)*(long)ac5) >> 15; x2 = ((long)mc << 11)/(x1 + md); b5 = x1 + x2; return (((b5 + 8)>>4)); } 

De temperatuur is goed gedaan, nu we moeten om te lezen van de niet-gecompenseerde druk. Voor dat we moeten schrijven de waarde 0x34 in het register 0xF4, maar we moeten ook de waarde vor de oversampling snelheid instellen. De oversampling snelheid bepaalt de hoeveelheid monsters die de chip maken moet alvorens een resultaat. Pagina 4 van het gegevensblad vertelt we hebben 4 keuzes: OSS = 0 de ultra lage instelling van het vermogen, 1 monster, 4,5 ms 3uA OSS = 1 standaard instelling van het vermogen, 2 monsters, 7,5 ms 5uA OSS = 2 hoge resolutie, 4 monsters, 13,5 ms 7uA OSS = 3 Ultra hoge resolutie 12 monsters, 25,5 ms 12uA voor dit programma heb ik gekozen de OSS 0 de OSS bevat bit 6 en 7 in register 0xF4. Bit 0-4 bepalen de controle van de meting. Als we schrijven de waarde 0x34 in binaire: 00110100. Bits 0 tot en met 4 zijn niet zo belangrijk voor nu, maar beetje 5 zal ook worden ingesteld en dus start de conversie. Het zal blijven hoog tijdens de conversie en reset op laag na de conversie. Om het instellen van de bits en 6 of 7 moeten wij linker shift 6 de waarde van OSS. Stel dat we wilden OSS als 3 instellen. in het binaire bestand dat zich van 0b11 als we vertrokken shift 6 die, zullen het 11000000 (= 192d of 0xC0), die zal het instellen van bit 6 en 7. 0x34 + 0xC0 = 0xF4 = 0b11110100 die zoals we kunnen zien hetzelfde als 0x34 plus is bit 6 en 7. Als we zijn met behulp van '0' voor de OSS-waarde, zullen beide bit 6 en 7 niet worden ingesteld. we moeten wachten tussen 4.5 en 25,5 msec. (afhankelijk van OSS) nadat we de conversie start. Zoals we OSS hebben = 0 we 5msec zal wachten. Vervolgens lezen we 3 bytes als de temperatuur is een 'long' (4 bytes) niet integer, zullen we echter alleen naar 3 bytes. Met betrekking tot de vertraging zou het mooi zijn als we dit gedeelte als een afhankelijkheid van de OSS definiëren zal zodat u niet hoeft te handmatig veranderen wanneer u de OSS wijzigt. De Adafruit bibliotheek solevs dit met enkele uitspraken als:

Als (oversampling == BMP085_ULTRALOWPOWER) delay(5);

anders als (oversampling == BMP085_STANDARD) delay(8);

anders als (oversampling == BMP085_HIGHRES) delay(14);

anders delay(26);

Echter, ik hoopte te vinden van een formule die bepalend zijn voor het. Omdat het niet een strikte, lineaire functie, het dichtst men krijgt is de formule: 5+(OSS*5). OSS = 0 -> 5 OSS = 1 -> 10 OSS = 2 -> 15 OSS = 3 -> 25 goed, ik denk dat zou dicht genoeg de procedure is als volgt

 /------------------------------------------- // Read the uncompensated pressure value unsigned long bmp180ReadUP() { unsigned char msb, lsb, xlsb; unsigned long up = 0; // Write 0x34+(OSS<<6) into register 0xF4 // Request a pressure reading w/ oversampling setting TinyWireM.beginTransmission(BMP180_ADDRESS); TinyWireM.send(0xF4); TinyWireM.send(0x34 + (OSS<<6)); TinyWireM.endTransmission(); // Wait for conversion, delay time dependent on OSS delay(5 + (5*OSS)); // Read register 0xF6 (MSB), 0xF7 (LSB), and 0xF8 (XLSB) TinyWireM.beginTransmission(BMP180_ADDRESS); TinyWireM.send(0xF6); TinyWireM.endTransmission(); TinyWireM.requestFrom(BMP180_ADDRESS, 3); // Wait for data to become available while(TinyWireM.available() < 3) ; msb = TinyWireM.receive(); lsb = TinyWireM.receive(); xlsb = TinyWireM.receive(); up = (((unsigned long) msb << 16) | ((unsigned long) lsb << 8) | (unsigned long) xlsb) >> (8-OSS); return up; } 

Nu dat is gedaan, moeten wij corrigeren van de niet-gecompenseerde druk. Het resultaat zal zijn in Pascal

 double bmp180CorrectPressure(unsigned long up) { b6 = b5 - 4000; // Calculate B3 x1 = (b2 * (b6 * b6)>>12)>>11; x2 = (ac2 * b6)>>11; x3 = x1 + x2; b3 = (((((long)ac1)*4 + x3)<<OSS) + 2)>>2; // Calculate B4 x1 = (ac3 * b6)>>13; x2 = (b1 * ((b6 * b6)>>12))>>16; x3 = ((x1 + x2) + 2)>>2; b4 = (ac4 * (unsigned long)(x3 + 32768))>>15; b7 = ((unsigned long)(up - b3) * (50000>>OSS)); if (b7 < 0x80000000) p = (b7<<1)/b4; else p = (b7/b4)<<1; x1 = (p>>8) * (p>>8); x1 = (x1 * 3038)>>16; x2 = (-7357 * p)>>16; p += (x1 + x2 + 3791)>>4; return p; } 

Met het bovenstaande programma kan men beslissen voor zichzelf wat te doen met de gevonden gegevens: het verzenden van een display of misschien stuur het via een RF-link naar een basisstation. Zoals gezegd, is de output van de druk-lezing in Pascal (Pa). hectopascal zijn een handiger eenheid. Sommige andere kan worden berekend in eenheden zijn: 1 hPa = 100 Pa = 1 mbar = 0,001 bar 1 hPa = 0.75006168 Torr 1 hPa = 0.01450377 psi (pond per vierkante inch) 1 hPa 0.02953337 inHg (inch van kwik) = 1 hpa = 0.00098692 atm (standaard atmosferen)

Een laatste woord van advies nog: wanneer u de BMP180 gebruikt, vergeet niet het moet 3.3 Volt. 5 volt zal het doden. Gebruik het op de I2C uit een 5 Volt microcontroller gehanteerd oorzaak een probleem wel. Verschillende pauze buitenboordmotor hebben eigenlijk een 3.3 spanningsregelaar op het.
Waarschuwing van 1: Er zijn nogal wat 'vishaken' in het bovenstaande programma en helaas instructables (en andere websites) hebben de neiging om soms zien die als HTML-code. Ik heb grondig gecontroleerd als de code OK is, en ik denk dat het is. Echter, is het best om de code die ik naar in mijn volgende stap verwijzen zal te controleren.

Waarschuwing 2: Toen ik wilde de waarden gevonden door de BMP180 wilt weergeven, pakte ik aanvankelijk een twee draads LCD-interface dat ik had op te bouwen met een 164 Shift Register als ik had die beschikbaar. Ik heb vervolgens geprobeerd om erachter te komen waarom ik fatsoenlijk lezen was niet uitstappen urenlang. In feite, veranderde het lezen uit niet of ik de BMP180 aangesloten of niet. Na vele vele proeven ik begon te vermoeden van mijn display-interface en besloot voor het aansluiten van een I2C-LCD. Welk gehanteerd zoals te tovermiddel. De LiquidCrystal_I2C van Francisco Malpertida werkt niet op de Attiny85. Ik gebruikte de klassieke LiquidCrystal_I2C dat is aangepast door Bro Hogan aan werken op de Attiny85 zo goed. Hij deed dat door de regel te wijzigen:

#include <Wire.h>in#if defined(__AVR_ATtiny85__) || (__AVR_ATtiny2313__) #include "TinyWireM.h"

// include this if ATtiny85 or ATtiny2313

#else

#include <Wire.h> // original lib include #endif // original lib include #endif