Kit para monitoreo ambiental y kit para monitoreo de agua

Buenos días,

Mi nombre es Javi y soy un ingeniero interesado en el control medioambiental.

Mi idea es realizar dos kits, uno para monitoreo ambiental y otro par el monitoreo de la calidad del agua utilizando para ello un arduino Leornardo.

Para ello utilizare sensores de bajo coste con la idea de hacer estos kits asumibles para los usuarios.

Estoy ahora mismo en proceso de buscar los sensores, mañana estare en disposición de ir colocando algunos sensores de los que he ido encontrando para que los veaís.

Quiza un posible futuro avance sería subir estos datos aun servidor en internet.

Espero que os interese!

Javier

Para calidad de agua: necesitas un sensor de (ver link)

  1. turbidez
  2. ph
    Estos son los básico, luego los que miden métales solo con espectrometría

para monitorear el aire…
algo parecido. México hace algo muy interesante con su índice IMECA
El IMECA se calcula empleando los promedios horarios de la medición de los contaminantes ozono (O3), dióxido de azufre (SO2), dióxido de nitrógeno (NO2), sangre de carbono (CO) y partículas menores a 10 micrómetros (PM10). (tomado de Wikipedia)

Que tan profundo será tu análisis?

Poco profundo, y en agua dulce. Mi idea es utilizar esto de forma un poco educacional y para concienciar. Para la estación de agua dispongo de una sonda de temperatura ya, en breve os pongo el link y el datasheet. Para la estación medioambiental ya he conseguido uno de presión del aire y uno d humedad relativa.

Precisamente ahora estoy buscando los de turbidez y pH para agua (la cuestión es encontrarlos barato).

Saludos

Ahhh bien. Es interesante igualmente.
No se como harías la toma de muestras o sin toma de muestras?

A que te refieres con la toma de muestras?

Se toma una muestra de aire (se captura aire) y se analiza.
se captura agua y se analiza.

O se tiene los sensores en agua/aire en modo continuo

Mi intención era que el usuario se desplazara por ejemplo a un rió y tomara ahí directamente el dato, así que supongo que la respuesta sería tenerlos en modo continuo. O quizás que leyeran al pulsar un botón.

De todas maneras hay sensores como el de turbiedad que tienen que tomar una muestra de agua y cerrarse (para que la camara este oscura). Así que no tienen porque trabajar todos de la misma forma.

Saludos.

Bien ya tengo algunos sensores:

La sonda de temperatura para el agua:

http://ledsandchips.com/store/246?search=water

Soil sensor

http://inmotion.pt/documentation/others/INM-0798/DS_IM121017001.pdf

Y un sensor de temperatura y humedad relativa para aire:

http://img.svbtle.com/gfzlez24b6nfsq.png

https://plot.ly/static/img/workshop/arduino-dht22-temperature-hookup.svg

http://www.aosong.com/en/products/details.asp?id=117

Decidme que os parecen.

Saludos!

javikomu increible lo tuyo. Si eres el mismo del ROV no puedo creer que no sepas usar los tags de los enlaces.
Y si, eres el del ROV asi que Sin palabras!!. Tirón de orejas. No eres novato javikomu.

Editalos por favor.
Usa el tag 7 de las Normas del Foro

Lucen bien los sensores.

Perdona perdona, es que se me fue la oya y no lo encontraba xDDDDDDDDD

Este es el sensor que he encontrado de presión del aire.
http://ledsandchips.com/store/290?search=pressure

javi he visto de casualidad algo que tal vez solo tal vez, sea muy de tu agrado. Buscando un tutorial en www.tecbolivia.com me encuentro con esto :

Portal de Enlace Para Monitoreo y Control de Energía en Viviendas

Leelo y me cuentas.
Por cierto estaba dando mis pasos con BB, dime si puedo hacerte consultas al respecto por PM.

surbyte:
javi he visto de casualidad algo que tal vez solo tal vez, sea muy de tu agrado. Buscando un tutorial en www.tecbolivia.com me encuentro con esto :

Portal de Enlace Para Monitoreo y Control de Energía en Viviendas

Leelo y me cuentas.
Por cierto estaba dando mis pasos con BB, dime si puedo hacerte consultas al respecto por PM.

Le echo un vistazo a tu enlace. Si te refieres a BealeBone Black tampoco soy un experto pero en lo que te pueda ayudar te ayudo. He utilizado mas la raspberry que la BeagleBone.

Me sería de mucha ayuda si me ayudaseis con el sensor de temperatura del agua.

Estoy empezando a programar pero con este me he atrancado un poco la verdad.

En breve ire poniendo los códigos.

sf-DS18B20.pdf (256 KB)

Para el sensor de presión del aire he encontrado este código que estoy tratando de adaptar…

//***************************************
// BMP085 IIC DEMO
//****************************************

#include  <REG51.H>	  
#include  <math.h>    //Keil library  
#include  <stdlib.h>  //Keil library  
#include  <stdio.h>   //Keil library	
#include  <INTRINS.H> //Keil library  
#define   uchar unsigned char
#define   uint unsigned int	
#define   DataPort P0    //LCD1602 data port
sbit	  SCL=P1^0;      //IIC clock pin definition 
sbit 	  SDA=P1^1;      //IIC data pin definition
sbit      LCM_RS=P2^0;   //LCD1602 command port		
sbit      LCM_RW=P2^1;   //LCD1602 command port			
sbit      LCM_EN=P2^2;   //LCD1602 command port	

#define	BMP085_SlaveAddress   0xee	  //Define the slave address of the part in IIC bus                               

#define OSS 0	// Oversampling Setting (note: code is not set up to use other OSS values)
							   
typedef unsigned char  BYTE;
typedef unsigned short WORD;
   	
uchar ge,shi,bai,qian,wan,shiwan;           //Display variable
int  dis_data;                              //Variable

short ac1;
short ac2; 
short ac3; 
unsigned short ac4;
unsigned short ac5;
unsigned short ac6;
short b1; 
short b2;
short mb;
short mc;
short md;

void delay(unsigned int k);
void InitLcd();                            //Initialize lcd1602

void WriteDataLCM(uchar dataW);
void WriteCommandLCM(uchar CMD,uchar Attribc);
void DisplayOneChar(uchar X,uchar Y,uchar DData);
void conversion(long temp_data);

void  Single_Write(uchar SlaveAddress,uchar REG_Address,uchar REG_data);   //Write single data
uchar Single_Read(uchar REG_Address);                                      //Read single data in internal register
void  Multiple_Read(uchar,uchar);                                          //Read multiple data in internal register
//------------------------------------
void Delay5us();
void Delay5ms();
void BMP085_Start();
void BMP085_Stop();
void BMP085_SendACK(bit ack);
bit  BMP085_RecvACK();
void BMP085_SendByte(BYTE dat);
BYTE BMP085_RecvByte();
void BMP085_ReadPage();
void BMP085_WritePage();
//-----------------------------------


//*********************************************************
//******Main program********
//*********************************************************
void main()
{ 
    delay(50);	                   //Power-up delay		
    InitLcd();                     //Initialize LCD
    Init_BMP085();                //Initialize BMP085 
  while(1)                         //Cycle
  { 
    bmp085Convert();
	delay(1000); 
  }
}
//*********************************************************
void conversion(long temp_data)  
{  
    
    shiwan=temp_data/100000+0x30 ;
    temp_data=temp_data%100000;   //Complementation 
    wan=temp_data/10000+0x30 ;
    temp_data=temp_data%10000;   //Complementation 
	qian=temp_data/1000+0x30 ;
    temp_data=temp_data%1000;    //Complementation 
    bai=temp_data/100+0x30   ;
    temp_data=temp_data%100;     //Complementation 
    shi=temp_data/10+0x30    ;
    temp_data=temp_data%10;      //Complementation 
    ge=temp_data+0x30; 	
}

/*******************************/
void delay(unsigned int k)	
{						
unsigned int i,j;				
for(i=0;i<k;i++)
{			
for(j=0;j<121;j++)			
{;}}						
}
/*******************************/
void WaitForEnable(void)	
{					
DataPort=0xff;		
LCM_RS=0;LCM_RW=1;_nop_();
LCM_EN=1;_nop_();_nop_();
while(DataPort&0x80);	
LCM_EN=0;				
}					
/*******************************/
void WriteCommandLCM(uchar CMD,uchar Attribc)
{					
if(Attribc)WaitForEnable();	
LCM_RS=0;LCM_RW=0;_nop_();
DataPort=CMD;_nop_();	
LCM_EN=1;_nop_();_nop_();LCM_EN=0;
}					
/*******************************/
void WriteDataLCM(uchar dataW)
{					
WaitForEnable();		
LCM_RS=1;LCM_RW=0;_nop_();
DataPort=dataW;_nop_();	
LCM_EN=1;_nop_();_nop_();LCM_EN=0;
}		
/***********************************/
void InitLcd()				
{			
WriteCommandLCM(0x38,1);	
WriteCommandLCM(0x08,1);	
WriteCommandLCM(0x01,1);	
WriteCommandLCM(0x06,1);	
WriteCommandLCM(0x0c,1);
}			
/***********************************/
void DisplayOneChar(uchar X,uchar Y,uchar DData)
{						
Y&=1;						
X&=15;						
if(Y)X|=0x40;					
X|=0x80;			
WriteCommandLCM(X,0);		
WriteDataLCM(DData);		
}						

/**************************************
Delay for 5ms(STC90C52RC@12M)
The function must be modified in different working environments. Note that it must be modified when the clock is moving too fast.
When switching to 1T MCU, please modify the delay function.
**************************************/
void Delay5us()
{
    _nop_();_nop_();_nop_();_nop_();
    _nop_();_nop_();_nop_();_nop_();
	_nop_();_nop_();_nop_();_nop_();
	_nop_();_nop_();_nop_();_nop_();
}

/**************************************
Delay for 5ms(STC90C52RC@12M)
The function must be modified in different working environments.
When switching to 1T MCU, please modify the delay function.
**************************************/
void Delay5ms()
{
    WORD n = 560;

    while (n--);
}

/**************************************
Starting signal
**************************************/
void BMP085_Start()
{
    SDA = 1;                    //Pull up the data curve
    SCL = 1;                    //Pull up the clock curve
    Delay5us();                 //Delay
    SDA = 0;                    //Generate the descending portion
    Delay5us();                 //Delay
    SCL = 0;                    //Pull down the clock curve
}

/**************************************
Terminating signal
**************************************/
void BMP085_Stop()
{
    SDA = 0;                    //Pull down the data curve
    SCL = 1;                    //Pull up the clock curve
    Delay5us();                 //Delay
    SDA = 1;                    //Generate the ascending portion
    Delay5us();                 //Delay
}

/**************************************
Send response signal
Entry parameter:ack (0:ACK 1:NAK)
**************************************/
void BMP085_SendACK(bit ack)
{
    SDA = ack;                  //Write response signal
    SCL = 1;                    //Pull up the clock curve
    Delay5us();                 //Delay
    SCL = 0;                    //Pull down the clock curve
    Delay5us();                 //Delay
}

/**************************************
Receive response signal
**************************************/
bit BMP085_RecvACK()
{
    SCL = 1;                    //Pull up the clock curve
    Delay5us();                 //Delay
    CY = SDA;                   //Read response signal
    SCL = 0;                    //Pull down the clock curve
    Delay5us();                 //Delay

    return CY;
}

/**************************************
Send one-byte data to IIC bus
**************************************/
void BMP085_SendByte(BYTE dat)
{
    BYTE i;

    for (i=0; i<8; i++)         //8-bit counter
    {
        dat <<= 1;              //Remove highest data
        SDA = CY;               //Sending to data port
        SCL = 1;                //Pull up the clock curve
        Delay5us();             //Delay
        SCL = 0;                //Pull down the clock curve
        Delay5us();             //Delay
    }
    BMP085_RecvACK();
}

/**************************************
Receive one-byte data from IIC bus
**************************************/
BYTE BMP085_RecvByte()
{
    BYTE i;
    BYTE dat = 0;

    SDA = 1;                    //Enable internal pulling up, ready for reading data,
    for (i=0; i<8; i++)         //8-bit counter
    {
        dat <<= 1;
        SCL = 1;                //Pull up the clock curve
        Delay5us();             //Delay
        dat |= SDA;             //Read data               
        SCL = 0;                //Pull down the clock curve
        Delay5us();             //Delay
    }
    return dat;
}
/*
//Write internal data of BMP085 in single byte*******************************

void Single_Write(uchar SlaveAddress,uchar REG_Address,uchar REG_data)
{
    BMP085_Start();                  //Starting signal
    BMP085_SendByte(SlaveAddress);   //Send device address + write signal
    BMP085_SendByte(REG_Address);    //Internal register address
    BMP085_SendByte(REG_data);       //Internal register data
    BMP085_Stop();                   //Send terminating signal
}
*/
/*
//Read internal data of BMP085 in single byte********************************
uchar Single_Read(uchar REG_Address)
{  uchar REG_data;
    BMP085_Start();                          //Starting signal
    BMP085_SendByte(BMP085_SlaveAddress);           //Send device address + write signal
    BMP085_SendByte(REG_Address);            //Send storage unit address 	
    BMP085_Start();                          //Starting signal
    BMP085_SendByte(BMP085_SlaveAddress+1);         //Send device address + read signal
    REG_data=BMP085_RecvByte();              //Read register data
	BMP085_SendACK(1);   
	BMP085_Stop();                           //Terminating signal
    return REG_data; 
}
*/
//*********************************************************
//Read internal data of BMP085, consecutive two
//*********************************************************
short Multiple_read(uchar ST_Address)
{   
	uchar msb, lsb;
	short _data;
    BMP085_Start();                          //Starting signal
    BMP085_SendByte(BMP085_SlaveAddress);    //Send device address + write signal
    BMP085_SendByte(ST_Address);             //Send storage unit address 
    BMP085_Start();                          //Starting signal
    BMP085_SendByte(BMP085_SlaveAddress+1);         //Send device address + read signal

    msb = BMP085_RecvByte();                 //BUF[0] save
    BMP085_SendACK(0);                       //Respond ACK
    lsb = BMP085_RecvByte();     
	BMP085_SendACK(1);                       //Must respond NOACK for the last data

    BMP085_Stop();                           //Terminating signal
    Delay5ms();
    _data = msb << 8;
	_data |= lsb;	
	return _data;
}
//********************************************************************
long bmp085ReadTemp(void)
{

    BMP085_Start();                  //Starting signal
    BMP085_SendByte(BMP085_SlaveAddress);   //Send device address + write signal
    BMP085_SendByte(0xF4);	          // write register address
    BMP085_SendByte(0x2E);       	// write register data for temp
    BMP085_Stop();                   //Send terminating signal
	delay(10);	// max time is 4.5ms
	
	return (long) Multiple_read(0xF6);
}
//*************************************************************
long bmp085ReadPressure(void)
{
	long pressure = 0;

    BMP085_Start();                   //Starting signal
    BMP085_SendByte(BMP085_SlaveAddress);   //Send device address + write signal
    BMP085_SendByte(0xF4);	          // write register address
    BMP085_SendByte(0x34);       	  // write register data for pressure
    BMP085_Stop();                    //Send terminating signal
	delay(10);    	                  // max time is 4.5ms
	
	pressure = Multiple_read(0xF6);
	pressure &= 0x0000FFFF;
	
	return pressure;	
	//return (long) bmp085ReadShort(0xF6);
}

//**************************************************************

//Initialize BMP085, please modify according to the PDF file based on your requirements**************
void Init_BMP085()
{
	ac1 = Multiple_read(0xAA);
	ac2 = Multiple_read(0xAC);
	ac3 = Multiple_read(0xAE);
	ac4 = Multiple_read(0xB0);
	ac5 = Multiple_read(0xB2);
	ac6 = Multiple_read(0xB4);
	b1 =  Multiple_read(0xB6);
	b2 =  Multiple_read(0xB8);
	mb =  Multiple_read(0xBA);
	mc =  Multiple_read(0xBC);
	md =  Multiple_read(0xBE);
}
//***********************************************************************
void bmp085Convert()
{
	long ut;
	long up;
	long x1, x2, b5, b6, x3, b3, p;
	unsigned long b4, b7;
	long  temperature;
	long  pressure;
	
	ut = bmp085ReadTemp();
	ut = bmp085ReadTemp();	   // Read temperature
	up = bmp085ReadPressure();
	up = bmp085ReadPressure();  // Read pressure
	
	x1 = ((long)ut - ac6) * ac5 >> 15;
	x2 = ((long) mc << 11) / (x1 + md);
	b5 = x1 + x2;
	 temperature = (b5 + 8) >> 4;

	 //*************

	 conversion(temperature);
	 DisplayOneChar(4,0,'T');       //Temperature display
     DisplayOneChar(5,0,':'); 
     DisplayOneChar(7,0,bai);       
     DisplayOneChar(8,0,shi); 
     DisplayOneChar(9,0,'.'); 
	 DisplayOneChar(10,0,ge); 
	 DisplayOneChar(11,0,0XDF);     //Temperature unit
	 DisplayOneChar(12,0,'C'); 

	 
     //*************
	
	b6 = b5 - 4000;
	x1 = (b2 * (b6 * b6 >> 12)) >> 11;
	x2 = ac2 * b6 >> 11;
	x3 = x1 + x2;
	b3 = (((long)ac1 * 4 + x3) + 2)/4;
	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 * 2) / b4 ;
           else  
		    p = (b7 / b4) * 2;
	x1 = (p >> 8) * (p >> 8);
	x1 = (x1 * 3038) >> 16;
	x2 = (-7357 * p) >> 16;
	 pressure = p + ((x1 + x2 + 3791) >> 4);

	 conversion(pressure);
     DisplayOneChar(4,1,'P');    //Display pressure
     DisplayOneChar(5,1,':'); 
	 DisplayOneChar(6,1,shiwan); 
	 DisplayOneChar(7,1,wan);    
     DisplayOneChar(8,1,qian); 
     DisplayOneChar(9,1,'.'); 
     DisplayOneChar(10,1,bai); 
     DisplayOneChar(11,1,shi); 
	 DisplayOneChar(12,1,'K');   //Pressure unit
	 DisplayOneChar(13,1,'p'); 
	 DisplayOneChar(14,1,'a'); 

}

Perdonad… no encontraba la manera de que me dejara ponerlos en un solo post, lo siento.

Esto debe ser mucho mas facil en arduino y haciendo uso de la libreria <wire.h>

Javi, del DS18B20 hay numerosa bibliografia y es de los mas usados en estos foros. Es un Dallas sensor asi que librería Dallas, libreria 1 Wire o simplemente Wire.h y ya lo tienes.
Busca Arduino DS18B20 y tienes muchos ejemplos.
En todos los casos usas la misma idea:
En google : Arduino bmp085 y lo mismo. Esta resuelto con librería y todo.

Tienes razon. Hay muchos ejemplos de ambos sensores y librerias completas. Dej lo que llevo de ambos códigos por si quereis echarle un vistazo. Si me funcion mañana pedire el sensor de pH y el de tubiedad para el agua.

//Sketch for a water monitoring KIT.

//Includes
#include <DallasTemperature.h>
#include <OneWire.h>

//Definitions
#define ULTRASONIC2TRIGPIN 8
#define ULTRASONIC2ECHOPIN 9
#define DS18B20_DATA_PIN 2

//Objets
OneWire ourWire(DS18B20_DATA_PIN); //We set the declared pin as bus for oneWire comunication
DallasTemperature ds18b20(&ourWire); //We istance the DallasTemperature libray

//Time Variables
const int loopPeriod = 1000;         // periodo de 100ms = frequencia de 10Hz
unsigned long timeLoopDelay = 0;

//Data Variables
int ultrasonic2Distance;
int ultrasonic2Duration;
int TempFarenheit;
int TempCelsius;



void setup()
{
  Serial.begin(9600);
  Serial.println("Water station setup. ");
  pinMode(ULTRASONIC2TRIGPIN, OUTPUT);
  pinMode(ULTRASONIC2ECHOPIN, INPUT);
  ds18b20.begin(); //We inicializate the temperature sensor

}

void loop()
{

    if(millis() - timeLoopDelay >= loopPeriod)
    {
        ReadData();
        DisplayData();
        timeLoopDelay = millis();
    }
    
    
  delay(10);
}

void ReadData(){
  readUltrasonicSensors();
  
}

void DisplayData(){
   Serial.print("Distance to the water level: ");
   Serial.println(ultrasonic2Distance);
   Serial.print("The temperature of water is ");
   Serial.print(TempCelsius); 
   Serial.print(" Centigrade degrees /");
   Serial.print(TempFarenheit); 
   Serial.println(" Fahrenheit degrees"); 
}

void readUltrasonicSensors()
{
    // ultrasonic 2
    digitalWrite(ULTRASONIC2TRIGPIN, HIGH);
    delayMicroseconds(10);                  //debemos mantener acivo el pin al menos 10us
    digitalWrite(ULTRASONIC2TRIGPIN, LOW);
    
    ultrasonic2Duration = pulseIn(ULTRASONIC2ECHOPIN, HIGH);
    ultrasonic2Distance = (ultrasonic2Duration/2)/3;
}

void ReadDS18B20Data()
{
  ds18b20.requestTemperatures(); //Prepare the sensor
  TempFarenheit = ds18b20.getTempFByIndex(0); //Fahrenheit
  TempCelsius = ds18b20.getTempCByIndex(0); //Celsius
}
//Sketch for Weather Station

//Includes
#include <dht.h>
#include <Wire.h>

//Definitions
#define DHT22_PIN 6

#define BMP085_ADDRESS 0x77  // I2C address of BMP085 

//Objets
dht DHT;

//Sampling variables
const int loopPeriod = 1000;         // periodo de 100ms = frequencia de 10Hz
unsigned long timeLoopDelay = 0;

const unsigned char OSS = 0;  // Oversampling Setting

// Calibration values for BMP085
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;

// b5 is calculated in bmp085GetTemperature(...), this variable is also used in bmp085GetPressure(...)
// so ...Temperature(...) must be called before ...Pressure(...).
long b5; 

short temperature;
long pressure;

// Use these for altitude conversions
const float p0 = 101325;     // Pressure at sea level (Pa)
float altitude;



void setup()
{
  Serial.begin(9600);
  Wire.begin();
  Serial.println("Weather station setup. ");
  WeatherStationInicialitation();

}

void loop()
{

    if(millis() - timeLoopDelay >= loopPeriod)
    {
        ReadData();
        DisplayData();
        timeLoopDelay = millis();
    }
    
    
  delay(10);
}

void WeatherStationInicialitation()
{
    bmp085Calibration();
}

void ReadData()
{
  ReadDHTdata();
  ReadBMP085Data();
}

void ReadBMP085Data()
{
  temperature = bmp085GetTemperature(bmp085ReadUT());
  pressure = bmp085GetPressure(bmp085ReadUP());
  altitude = (float)44330 * (1 - pow(((float) pressure/p0), 0.190295));
}

void DisplayData()
{
  DisplayDHTdata();
  DisplayBMP085Data();
}

void DisplayBMP085Data()
{
  Serial.print("Temperature read by BMP085: ");
  Serial.print(temperature, DEC);
  Serial.println(" *0.1 deg C");
  Serial.print("Pressure: ");
  Serial.print(pressure, DEC);
  Serial.println(" Pa");
  Serial.print("Altitude: ");
  Serial.print(altitude, 2);
  Serial.println(" m");
  Serial.println();
}

void ReadDHTdata()
{
    Serial.print("DHT22, \t");
  int chk = DHT.read22(DHT22_PIN);
  switch (chk)
  {
    case DHTLIB_OK:  
		Serial.print("OK,\t"); 
		break;
    case DHTLIB_ERROR_CHECKSUM: 
		Serial.print("Checksum error,\t"); 
		break;
    case DHTLIB_ERROR_TIMEOUT: 
		Serial.print("Time out error,\t"); 
		break;
    default: 
		Serial.print("Unknown error,\t"); 
		break;
  }
}

void DisplayDHTdata()
{
  Serial.print("Relative Humidity and air temperature: ");
  Serial.print(DHT.humidity, 1);
  Serial.print(",\t");
  Serial.println(DHT.temperature, 1);
}

// Stores all of the bmp085's calibration values into global variables
// Calibration values are required to calculate temp and pressure
// This function should be called at the beginning of the program
void bmp085Calibration()
{
  ac1 = bmp085ReadInt(0xAA);
  ac2 = bmp085ReadInt(0xAC);
  ac3 = bmp085ReadInt(0xAE);
  ac4 = bmp085ReadInt(0xB0);
  ac5 = bmp085ReadInt(0xB2);
  ac6 = bmp085ReadInt(0xB4);
  b1 = bmp085ReadInt(0xB6);
  b2 = bmp085ReadInt(0xB8);
  mb = bmp085ReadInt(0xBA);
  mc = bmp085ReadInt(0xBC);
  md = bmp085ReadInt(0xBE);
}

// Calculate temperature given ut.
// Value returned will be in units of 0.1 deg C
short bmp085GetTemperature(unsigned int ut)
{
  long x1, x2;
  
  x1 = (((long)ut - (long)ac6)*(long)ac5) >> 15;
  x2 = ((long)mc << 11)/(x1 + md);
  b5 = x1 + x2;

  return ((b5 + 8)>>4);  
}

// Calculate pressure given up
// calibration values must be known
// b5 is also required so bmp085GetTemperature(...) must be called first.
// Value returned will be pressure in units of Pa.
long bmp085GetPressure(unsigned long up)
{
  long x1, x2, x3, b3, b6, p;
  unsigned long b4, b7;
  
  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;
}

// Read 1 byte from the BMP085 at 'address'
char bmp085Read(unsigned char address)
{
  unsigned char data;
  
  Wire.beginTransmission(BMP085_ADDRESS);
  Wire.write(address);
  Wire.endTransmission();
  
  Wire.requestFrom(BMP085_ADDRESS, 1);
  while(!Wire.available())
    ;
    
  return Wire.read();
}

// Read 2 bytes from the BMP085
// First byte will be from 'address'
// Second byte will be from 'address'+1
int bmp085ReadInt(unsigned char address)
{
  unsigned char msb, lsb;
  
  Wire.beginTransmission(BMP085_ADDRESS);
  Wire.write(address);
  Wire.endTransmission();
  
  Wire.requestFrom(BMP085_ADDRESS, 2);
  while(Wire.available()<2)
    ;
  msb = Wire.read();
  lsb = Wire.read();
  
  return (int) msb<<8 | lsb;
}

// Read the uncompensated temperature value
unsigned int bmp085ReadUT()
{
  unsigned int ut;
  
  // Write 0x2E into Register 0xF4
  // This requests a temperature reading
  Wire.beginTransmission(BMP085_ADDRESS);
  Wire.write(0xF4);
  Wire.write(0x2E);
  Wire.endTransmission();
  
  // Wait at least 4.5ms
  delay(5);
  
  // Read two bytes from registers 0xF6 and 0xF7
  ut = bmp085ReadInt(0xF6);
  return ut;
}

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

Por favor una ayudita con el sensor de profundidad!!

Ahora mismo estoy usando la siguiente función:

void readUltrasonicSensors()
{
    // ultrasonic 
    pinMode(ULTRASONIC2TRIGANDECHOPIN, OUTPUT);
    digitalWrite(ULTRASONIC2TRIGANDECHOPIN, LOW);
    delayMicroseconds(2);  
    digitalWrite(ULTRASONIC2TRIGANDECHOPIN, HIGH);
    delayMicroseconds(5);                  //debemos mantener acivo el pin al menos 10us
    digitalWrite(ULTRASONIC2TRIGANDECHOPIN, LOW);
    
    pinMode(ULTRASONIC2TRIGANDECHOPIN, INPUT);
    ultrasonic2Duration = pulseIn(ULTRASONIC2TRIGANDECHOPIN, HIGH);
    ultrasonic2Distance = (float(ultrasonic2Duration)/2)/3;
    centimetres = float(ultrasonic2Duration) / 29 / 2;
    Serial.print("Echo received in: ");
    Serial.println(ultrasonic2Duration);
}

La he repasado mil veces, tanto eso como la conexion (es un sensor de ultrasonidos de tres pines), y he probado varios tiempos de delay de microsegundos... pero el caso es que me dice que recive el echo en 0 y por tanto la distancia es cero, alguno sabeis que puede estar ocuriendo?

Muchas gracias!

No se si sera esto, pero la sentencia pinmode va en setup no en el las subrrutinas

La sentencia pinMode puede utilizarse donde se quiera, pero lo estructurado es ponerlo en el setup. Sin embargo, al ser un sensor que utiliza el mismo pin para el trig y el echo necesito hacerlo ahí.

La conexion OneWire del sensor de temperatura tampoco termino de entenderla.