Me encanta la serie Attiny 85 y les gusta explorar todas las cosas que puede hacer con él. Como no tiene demasiados pins, usando hardware I2C es una buena idea. I2C en el attiny puede ser un poco incómodo ya que no puede compilar la biblioteca de alambre, pero la biblioteca de TinyWireM funciona bien.
El sensor de presión de BMP180 es un sensor relativamente barato y popular para leer la presión atmosférica. Además puede leer la temperatura. Si desea utilizar este sensor en un arduino Adafruit dispone de una biblioteca (para el BMP085 y el BMP180) que wil leer para usted. Sin embargo, la nueva biblioteca también necesita su biblioteca general' Sensor' y esos son el carburante de la memoria. Tal vez OK en un Arduino, pero no en un attiny. Tienen uno para la Tiny85 así. Sparkfun también cuenta con una biblioteca para el Arduino.
Por lo tanto, si usted quiere leer el sensor de BMP180 un attiny, necesitará hacer algunos trabajos. Afortunadamente, la hoja de datos es muy evidente. Página 15 nos dice exactamente qué hacer. La secuencia es como sigue: 1-leer el chip calibración específica datos 2-leer la temperatura sin corregir valor 3-leer la presión sin corregir 4-calcular la temperatura verdadera 5-calcular presión verdadera
También muestra lo que debería ser en un lazo y lo que no: lectura de los datos de calibración sólo debe hacerse una vez y por lo tanto va en la rutina de 'Setup'. El resto está en un bucle y por lo tanto va en la rutina de 'lazo'.
Por lo tanto, la programación es una brisa si siguen el diagrama de flujo en la página 15... sólo hay ' traducir ' en idioma que entienda el protocolo I2C. Por lo tanto, comenzamos el programa con definir algunos parámetros generales: para el Attiny allí es la biblioteca TinyWireM que implementa un protocolo I2C en el attiny, así que tenemos que cargar esa biblioteca. Necesitamos la dirección I2C de la BMP180 (que es 0x77), y tenemos que declarar un montón de variables. La mayoría de las variables utilizadas contiene los datos de calibración específica del chip que leeremos desde el chip EEPROM, necesitamos algunas variables para los distintos cálculos y necesitamos algunas variables para contener la salida (temperatura y presión) para mantener fácil, he elegido los nombres de las variables como se ha mencionado en la hoja de datos.
Sólo una palabra de explicación en la dirección del dispositivo 0x77. Página 20 de la hoja de datos menciona dos direcciones de dispositivo: 0xEE para leer y 0xEF para escribir.
Una dirección de dispositivo I2C puede especificarse como una dirección de 7 bits, que es de 7 bits que puede distinguir un dispositivo de otro. O como un byte que incluir el bit de R/W en la posición de LSB.
La hoja de datos de Bosch no especifica la dirección de 7 bits, que es 0x77. Por el contrario especifica (página 20) la dirección de escritura de 8 bits, que es 0xEE y los 8 bits de dirección de lectura, que es 0xEF. Ambos son 0x77 R/W
0x77 = 111 0111
0xEE = 01110 111
0xEF = 01111 111
en la TinywireM biblioteca dos valores se definen #define USI_SEND 0 / indica enviar a TWI #define USI_RCVE 1 / / indica recepción de TWIthese se combinan con la dirección de 7 bits para indicar a leer o escribir la acción
Así, las primeras líneas de un programa se ven así:
//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 */
Luego tenemos que definir la rutina de 'Setup'. Francamente, lo único que tenemos que hacer es leer los datos de calibración. Para mantenerlo simple, le acabo de llamar un procedimiento 'bmp180ReadInt(address)', que luego podemos llevar a cabo más adelante. Por lo tanto nuestro programa de instalación se verá así:
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); } Por supuesto que pude haber llamar 1 procedimiento y llamada 'bmp180ReadCalibration' pero que procedimiento después haría lo mismo ahora ya definida en la configuración
El procedimiento de 'bucle' es igualmente sencillo. Es básicamente leer sin corregir temperatura correcta que temperatura leer sin corregir la presión correcta que sin corregir la presión pero como nadie está interesado en los datos sin corregir, que hacer ese procedimiento: Correct(Read Uncorrected temperature) Correct(Read Uncorrected pressure) como esta:
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()); } Por lo es. Sólo ahora tenemos que definir los procedimientos que llamamos. Vamos a empezar con 'bmp180ReadInt(address)' este procedimiento utiliza la biblioteca TinyWireM para leer un número entero de una determinada dirección. Obtener datos de un dispositivo I2C, la regla general es primero escribir en ese dispositivo para decirle qué hacer y entonces a leer en una dirección específica para el resultado. Como leeremos de la EEPROM no hay ningún comando específico que tenemos que enviar, que para notificar el puerto I2C donde queremos ser (en la dirección de I2C del chip) y la dirección que queremos leer y cuántos bytes que queremos leer. Luego combinar esos dos butes en un entero y devuelva. Así se verá nuestro precedure así:
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; } Lo siguiente que necesitamos es leer la temperatura compensada. Para llegar tenemos en primer lugar enviar el valor de 0x2E registro 0xF4 y espere por lo menos 4.5 mseg. Es el tiempo el chip debe tener 1 lectura. Después esperamos leemos la temperatura compensada de registros 0xF6 y 0xf7. Último leer que lo hacemos con el anterior procedimiento definido 'bmp180ReadInt' que lee 2 bytes y combina en un entero. Así, el procedimiento se verá así:
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; } Posteriormente deberemos calcular la temperatura corregida de la temperatura sin corregir. La hoja de datos que define como sigue: UT = temperatura compensada X1 =(UT-AC6) * AC5/2 ^ 15 X 2 = (MC * 2 ^ 11 /(X1+MD) B5 = X 1 + X 2 T =(B5+8)/2 ^ 4 en software que se ve así
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)); } La temperatura se hace bien, ahora tenemos que leer la presión compensada. Para que necesitamos escribir el valor 0x34 en el registro 0xF4, pero también tenemos que definir el vor de valor de la velocidad de sobremuestreo. La tasa de sobre muestreo determina la cantidad de muestras que el chip tiene que hacer antes de dar un resultado. Página 4 de la hoja de datos dice que tiene 4 opciones: OSS = 0 ajuste de potencia baja ultra, 1 muestra, 4,5 ms 3uA OSS = 1 configuración de potencia estándar, 2 muestras, 7,5 ms 5uA OSS = 2 alta resolución, 4 muestras, 13,5 ms 7uA OSS = 3 Ultra alta resolución, 12 muestras, ms 25,5 12uA para este programa he elegido la OSS que 0 el OSS contiene bits 6 y 7 en registro 0xF4. Bits 0-4 determinar el control de la medición. si escribimos el valor 0x34 que es en binario: 00110100. Bits 0 a 4 no son tan importantes por ahora, pero poco 5 será también determinado y así iniciar la conversión. Se mantendrán alto durante la conversión y restablecer a bajo después de la conversión. Para fijar los bits 6 y 7 tenemos a cambio izquierda 6 el valor de OSS. Supongamos que habíamos querido establecer OSS como 3. en binario 0b11 que si dejábamos cambio 6, será 11000000 (= 192d o 0xC0), que bits 6 y 7. 0x34 + 0xC0 = 0xF4 = 0b11110100, que como podemos ver es lo mismo que 0x34 plus bit set 6 y 7. Como estamos usando '0' el valor de la OSS, ambos bits 6 y 7 no se establecerá. después de empezar la conversión tenemos que esperar entre 4.5 y 25.5 milisegundos (dependiendo de la OSS). Como tenemos OSS = 0 esperamos 5msec. Posteriormente leeremos 3 bytes como la temperatura es un largo (4 bytes) no es un entero, sin embargo sólo necesitamos 3 bytes. Con respecto a la demora, sería agradable que definiremos como una dependencia de la OSS, por lo que no necesitará cambiar manualmente cuando se cambia el OSS. La solevs de la biblioteca de Adafruit esto con algunas declaraciones de IF:
Si (oversampling == BMP085_ULTRALOWPOWER) delay(5);
else if (oversampling == BMP085_STANDARD) delay(8);
else if (oversampling == BMP085_HIGHRES) delay(14);
delay(26) otra cosa;
Sin embargo, esperaba encontrar una fórmula que lo determina. Como no es una función lineal estricto, lo más cercano que uno recibe es la fórmula: 5+(OSS*5). OSS = 0 -> 5 OSS = 1 -> 10 OSS = 2 -> 15 OSS = 3 -> 25 bien, supongo que sería lo suficientemente cerca el procedimiento es el siguiente
/------------------------------------------- // 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; } Ahora que se hace, tenemos que corregir la presión compensada. El resultado será en 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; } Con el programa anterior uno puede decidir por sí mismo qué hacer con los datos encontrados: enviar a una pantalla, o tal vez lo envíe a través de un enlace de RF a una estación base. Como dijo, la salida de la lectura de la presión es Pascal (Pa). hectopascales son una unidad más conveniente. Algunas otras unidades puede calcularse en: 1 hPa = 100 Pa = 1 mbar = 0,001 bar 1 hPa = 0.75006168 Torr 1 hPa = 0.01450377 psi (libras por pulgada cuadrada) 1 hPa = 0.02953337 inHg (pulgadas de mercurio) 1 hpa = 0.00098692 atm (atmósfera estándar)
Un último Consejo todavía: cuando se utiliza el BMP180, recuerde que necesita 3,3 voltios. 5 voltios la matará. Usar el I2C de causa 5 voltios microcontrolador shouldnot un problema aunque. Varios motores fuera de borda de descanso realmente tienen un regulador de tensión 3.3 en él.
ADVERTENCIA 1: Hay bastante 'anzuelos' en el programa anterior y lamentablemente instructables (y otros sitios web) tiene una tendencia a ver a veces ésos como código html. He comprobado bien, si el código es correcto y creo que es. Sin embargo, es mejor consultar el código que unirá a mi siguiente paso.
ADVERTENCIA 2: Cuando quise mostrar los valores encontrados por el BMP180, inicialmente tomó un interfaz de dos hilos LCD que tenía construir con un registro de desplazamiento 164 tuve disponible. Posteriormente traté de averiguar por varias horas por no sacar cualquier lectura decente. De hecho, la lectura hacia fuera no cambia ya conecté el BMP180 o no. Después de muchos ensayos muchos empecé a sospechar mi interfaz de la exhibición y decidió conectar un LCD I2C. Trabajó como un encanto. El LiquidCrystal_I2C de Francisco Malpertida no funciona en el Attiny85. He utilizado el LiquidCrystal_I2C clásico que está adaptado por Bro Hogan para trabajar en el Attiny85 así. Lo hizo cambiando la línea:
#include <Wire.h>en#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
