Ayuda con sensor humedad-temperatura SHT15

Hola, he empezado hace poco con arduino y sobre el sensor SHT15, no encuentro nada, lo unico que tengo me da los valores en unas cifras que no coinciden con la realidad, tales como

Temperatura:6744

Humedad:1492

No logro descifrarlos, ni hacer que aparezcan en un lcd de 2x16, a ver si me podeis echar un cable, que me estoy volviendo loco.

/*
 * Serial TTY
 * -----------------
 * This is a simple example of how to use serial communication to
 * poll analog input values
 *
 * Created 26 December 2007
 * copyleft 2007 Wayne Prasek <wprasek@gmail.comm>
 * http://ragingreality.thotbot.com/
 * 
 */

int dataPin = 9;
int sckPin = 8;

void resetSHT()
{
  pinMode(dataPin,OUTPUT);
  pinMode(sckPin,OUTPUT);
  
  shiftOut(dataPin, sckPin, LSBFIRST, 255);
  shiftOut(dataPin, sckPin, LSBFIRST, 255);
  
  digitalWrite(dataPin,HIGH);
  for(int i = 0; i < 15; i++){
     digitalWrite(sckPin, LOW);
     digitalWrite(sckPin, HIGH);
  }
}

//Specific SHT start command
void startSHT()
{
  pinMode(sckPin,OUTPUT);
  pinMode(dataPin,OUTPUT);
  digitalWrite(dataPin,HIGH);
  digitalWrite(sckPin,HIGH);
  digitalWrite(dataPin,LOW);
  digitalWrite(sckPin,LOW);
  digitalWrite(sckPin,HIGH);
  digitalWrite(dataPin,HIGH);
  digitalWrite(sckPin,LOW);
}

void writeByteSHT(byte data)
{ 
  pinMode(sckPin,OUTPUT);
  pinMode(dataPin,OUTPUT);  
  
//  digitalWrite(dataPin,LOW);
  shiftOut(dataPin,sckPin,MSBFIRST,data);
  
  pinMode(dataPin,INPUT);

  //Wait for SHT15 to acknowledge by pulling line low
  while(digitalRead(dataPin) == 1);
  
  digitalWrite(sckPin,HIGH);
  digitalWrite(sckPin,LOW);  //Falling edge of 9th clock
  
  //wait for SHT to release line
  while(digitalRead(dataPin) == 0 );
 
  //wait for SHT to pull data line low to signal measurement completion
  //This can take up to 210ms for 14 bit measurments
  int i = 0;
  while(digitalRead(dataPin) == 1 )
  {
    i++;
    if (i == 255) break;
    
    delay(10);
  } 
  
  //debug
  i *= 10;
  Serial.print("Response time = ");
  Serial.println(i);
}

//Read 16 bits from the SHT sensor
int readByte16SHT()
{
  int cwt = 0;
  unsigned int bitmask = 32768;
  int temp;
  
  pinMode(dataPin,INPUT);
  pinMode(sckPin,OUTPUT);
  
  digitalWrite(sckPin,LOW);
  
  for(int i = 0; i < 17; i++) {
    if(i != 8) {
      digitalWrite(sckPin,HIGH);
      temp = digitalRead(dataPin);
//      Serial.print(temp,BIN);
      cwt = cwt + bitmask * temp;
      digitalWrite(sckPin,LOW);
      bitmask=bitmask/2;
    }
    else {
      pinMode(dataPin,OUTPUT);
      digitalWrite(dataPin,LOW);
      digitalWrite(sckPin,HIGH);
      digitalWrite(sckPin,LOW);
      pinMode(dataPin,INPUT); 
    }
  }
  
  //leave clock high??
  digitalWrite(sckPin,HIGH);
  
//  Serial.println();
  
  return cwt;
}

int getTempSHT()
{
  startSHT();
  writeByteSHT(B0000011);
  return readByte16SHT();
}

int getHumidSHT()
{
  startSHT();
  writeByteSHT(B00000101);
  return readByte16SHT();
}


void setup() {
  pinMode(dataPin,OUTPUT);
  pinMode(sckPin,OUTPUT);

  Serial.begin(9600);        // connect to the serial port
  
  Serial.println("Resetting SHT...");
  resetSHT();
}

void loop () {
  delay(2000);
  Serial.println("Starting Temperature/Humidity reading...");
  int temp = getTempSHT();
  Serial.print("Temprature:");
  Serial.println(temp);

  temp = getHumidSHT();
  Serial.print("Humidity:");
  Serial.println(temp);  
}

Se me ocurre que en lugar de probar un software completo como el que adjuntas, podrías empezar leyendo valores del sensor de forma simple (sin convertirlos) y enviándolos al puerto serie para monitorizar los valores.

Luego, poco a poco, irías empezando con el LCD y demás.

Saludos.

Tienes que usar el MAP para convertir los datos. echa un vistazo en la web principal. salu2

Hola Hamijos Mios:

Yo tambien me he estado peleando con el Sensirion SHT 75, que es el SHT 15 pero sin ser en formato SMD. Es decir, el 75 es como el 15 pero en grande (recomendable, mas manejable).

Yo tambien me he basado en el ejemplo q tu posteas, pero lo he tenido q modificar. Tuve bastantes problemas pq con el code original no podia leer la segunda palabra de datos. Lo resolvimos metiendo delays y alguna cosa mas.

Dices q obtienes valores como temp = 6744. Bien, en principio has hecho las cosas correctamente, lo unico es q tienes q convertir este valor leido del chorro de bits a temperatura. Las formulas correspondientes estan en el data sheet del SHT, no hace falta q lo mireis, ya lo he hecho yo.

Debo decir q el Sensirion funciona muy bien una vez q tienes un buen code. Pero el trabajo para sacar un buen code es alucinante!! No me parece logico q Sensirion saque un sensor con un protocolo propio sin codes ya hechos, muy mal por su parte… :frowning:

Te pongo el code q hicimos, copia y pega sin mas. OLVIDATE de hacer librerias y hostias.

El code es para comaparar la performance del Sensirion frente a otros 2 sensores. Hay parte del code q sobra (ojo, ninguna funcion sobra), borralo con cuidadin. Tambien sobran bastantes variables. OS LO PONGO EN 2 POSTS pq no me cabe en uno (solo deja 9000/post):

/*
 * Lee la sñ de - sensor de temperatura
 *              - sensor de humedad Sencera
 *              - sensor de Tª y humedad Sensirion SHT75
 * y compara valores 
 *
 * Presenta por pantalla los resultados
 *
 * Acumula 100 muestras y hace un promedio, para mayor precision
 *
 * Conexion sensor temp: negro a gnd, morado al pin ANALOGICO 0 y rojo a 5 volt
 * Conexion sensor humd: + a 5 volt, - a gnd y V al pin ANALOGICO 1
 *
 * LEDs: rojo a 9 y verde al 10 
 *
 * Conexion del Sensirion: negro a GND, rojo a 5 volt, naranja al pin DIGITAL 3 y blanco al pin DIGITAL 4
 * 
 * Pongo 2 Cs: puenteando los 5 vols-GND y antes del pin de entrada
 */        

#include <math.h>

// comandos para el Sensirion
int temperatureCommand  = B00000011;  // comando para leer temperatura 
int humidityCommand     = B00000101;  // comando para leer humedad 
int comandoEstatus      = B00000111;  // comando para leer registro de estatus

// especifico para el sensor Sensirion
int clockPin = 3;  // pin para el reloj // HAY Q CAMBIAR LOS PINEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEES
int dataPin  = 4;  // pin para datos 
int ack;  // detectar posible ocurrencia de errores

// para los 2 sensores independientes
int temPin = 0;    // pin para el sensor de temperatura
int humPin = 1;    // pin para el sensor de humedad
int rojo  = 9;     // los LEDs van en las salidas PWM 9..
int verde = 10;    // ..y 10
int valT = 0;      // variable to store the value coming from the sensor
int valH = 0;      // idem
int Nlectura = 0;  // esto cuenta el numero de lecturas
int aux = 0;       // auxiliar q se resetea cada 100 lecturas
float valTFloat = 0.0;   // aqui pongo la transformacion a flotante de 'val'
float valHFloat = 0.0;   // idem
float milivoltsT = 0.0;  // transformo a milivolts
float milivoltsH = 0.0;  // idem
float temp = 0.0;       // aqui va la temperatura en C
float hum  = 0.0;       // idem en %
float acumT = 0.0;       // aqui voy acumulando hasta 100 lecturas
float acumH = 0.0;       // idem
float tempMedia = 0.0;  // el promedio de 100 lecturas
float humMedia = 0.0;   // idem
float umbralTemperatura = 27.0;  // fijo un umbral para iluminar LEDs
float umbralHumedad     = 50.0;  // fijo un umbral para iluminar LEDs
int   espera = 3;        // lo que se espera
float diferenciaT = 0.0;  // para comparar valores de temperatura
float diferenciaH = 0.0;  // para comparar valores de humedad
float RHtrue = 0.0;       // aqui se pone la humedad relativa compensada por humedad
float Rocio  = 0.0;       // y aqui la temperatura de rocio
int numerobitsT = 14;     // especifico el numero de bits con los q voy a medir (es la precision), por defecto 14
int numerobitsH = 12;     // especifico el numero de bits con los q voy a medir (es la precision), por defecto 12


void setup() {
  pinMode(verde,  OUTPUT);   // sets the pin as output
  pinMode(rojo,   OUTPUT);   // sets the pin as output
  Serial.begin(9600); // open serial at 9600 bps
} 
 
void loop() {
  // 1 - esto del principio es para el Sensirion
  delay(12);   // hay q esperar 12 ms desde el start up
  
  
  // leo el registro de estatus, por defecto todo 0s (opcional, para verificar)
  leerEstatus();
  
  // leer la temperatura (por defecto en 14 bits) y convertirla a grados Celsius
  valT = leerValorTemperatura();                   // lee el dato (integer)
  temp = calcularTemperatura(valT, numerobitsT);   // lo traduzco a grados Celsius
  diferenciaT = temp;                              // pongo de momento un dato
  
  // leer la humedad (por defecto en 12 bits) y convertirla a HR en tanto por ciento
  valH = leerValorHumedad();                       // leo el dato (integer)
  hum = calcularHR(valH, numerobitsH);             // lo traduzco a HR en tanto por ciento
  diferenciaH = hum;                               // pongo de momento un dato
  
  // calculos adicionales
  RHtrue = calcularHumedadVerdadera(temp, valH, hum, numerobitsH);
  Rocio  = calcularRocio(hum, temp);
  
  // saco por pantalla
  representar(temp, hum, RHtrue, Rocio, valT, valH);
  
  // 2 - a partir de aqui, dentro del loop, es para los sensores independientes
  Nlectura = Nlectura + 1;    // incrementos
  valT = analogRead(temPin);  // leemos el calor de los sensores analogicos
  // delay(500);      // es opcional
  valH = analogRead(humPin);
  valTFloat = (float) valT;
  valHFloat = (float) valH; 
  milivoltsT = valTFloat * 5 * 1000 / 1023;  // calculo los volts q llegan
  milivoltsH = valHFloat * 5 * 1000 / 1023;
  temp = milivoltsT / 10.0;    // convierto a temperatura
  hum = ((milivoltsH/1000.0) - 0.78) * 31.84;
  diferenciaT -= temp;
  diferenciaH -= hum;  
  
  // saco por pantalla los datos decimales calculados
  Serial.print("Independientes (T, HR) :  ");
  Serial.print(temp);  
  Serial.print(" C   ");
  Serial.print(hum);
  Serial.print(" %             diferencia de temp = ");
  Serial.print(diferenciaT);
  Serial.print(" y de hum = ");
  Serial.println(diferenciaH);

/*
  // hago una media de los ultimos 100 valores (opcional)
  aux = aux + 1; 
  acumT = acumT + temp;        // lo voy acumulando
  acumH = acumH + hum;
  if (aux == 100) {
    tempMedia = acumT / 100.0;
    humMedia  = acumH / 100.0;
    Serial.println("******************************************************");
    Serial.print("Temperatura promedio en las ultimas 100 muestras  =  ");
    Serial.println(tempMedia);
    Serial.print("Humedad promedio en las ultimas 100 muestras  =  ");
    Serial.println(humMedia);
    Serial.println("******************************************************");
    acumT = 0.0;
    acumH = 0.0;
    aux = 0;
    delay(espera);
  }
*/  
  // para iluminar los LEDs segun el umbral de temperatura o de humedad
  if (temp < umbralTemperatura) {   // si esto es q no se supera el umbral y 
    analogWrite(verde,1000);        // escribo en uno cero y en otro el valor
    analogWrite(rojo,0);}
  else {
    analogWrite(rojo,1000);
    analogWrite(verde,0);}    
 
  // esperamos X segundos hasta la proxima medida (minimo 1000 milisec para no calentar el Sensirion)
  delay(1500);
} 
 
 
// funciones para lectura / escritura del Sensirion

// leer el valor de temperatura que da el sensor (hace todo el proceso transparente)
int leerValorTemperatura() {
  int valT = 0;
  
  sendCommandSHT(temperatureCommand, dataPin, clockPin); // envio peticion
  waitForResultSHT(dataPin);                             // espero a q tenga el resultado
  valT = getData16SHT(dataPin, clockPin);                // capturo el valor
  skipCrcSHT(dataPin, clockPin);                         // me salto la CRC
  return valT;
}

// leer el valor de humedad que da el sensor (hace todo el proceso transparente)
int leerValorHumedad() {
  int valH = 0;
  
  sendCommandSHT(humidityCommand, dataPin, clockPin);    // envio peticion
  waitForResultSHT(dataPin);                             // espero a q tenga el resultado
  valH = getData16SHT(dataPin, clockPin);                // capturo el valor
  skipCrcSHT(dataPin, clockPin);                         // me salto la CRC
  return valH;
}

// enviar comando al Sensirion 
void sendCommandSHT(int command, int dataPin, int clockPin) { 
  int ack;
 
  // empieza la transmision
  pinMode(dataPin,  OUTPUT);
  pinMode(clockPin, OUTPUT);
  digitalWrite(dataPin,  HIGH);
  digitalWrite(clockPin, HIGH);
  delayMicroseconds(1);
  digitalWrite(dataPin,  LOW);
  digitalWrite(clockPin, LOW);
  delayMicroseconds(1);
  digitalWrite(clockPin, HIGH);
  digitalWrite(dataPin,  HIGH);
  delayMicroseconds(1);
  digitalWrite(clockPin, LOW);
  
  // escribir el comando (los 3 primeros bits deben ser la direccion (siempre 000), y los ultimos 5 bits son el comando)
  shiftOut(dataPin, clockPin, MSBFIRST, command);
  
  // verificar q obtenemos los ACKs adecuados
  digitalWrite(clockPin, HIGH);
  pinMode(dataPin, INPUT);
  ack = digitalRead(dataPin);
  if (ack != LOW)
    Serial.println("ACK error 0");
  digitalWrite(clockPin, LOW);
  ack = digitalRead(dataPin);
  if (ack != HIGH)
    Serial.println("ACK error 1");
}

La segunda parte (necesaria) en el siguiente post…

Esta es la continuacion del code para el SHT 15 o 75. Copiadlo TODO junto en un mismo archivo:

// esperar a la respuesta del Sensirion
void waitForResultSHT(int dataPin) {
  int ack;
 
  pinMode(dataPin, INPUT);
  ack = digitalRead(dataPin);
  while (ack == HIGH){
    ack = digitalRead(dataPin);
    }
}

// leemos dato del data stream del Sensirion
int shiftIn(int dataPin, int clockPin, int numBits) {
  int ret = 0;
 
  for (int i=0; i<numBits; i++) {
    digitalWrite(clockPin, HIGH);
    delayMicroseconds(1000);
    ret = ret * 2 + digitalRead(dataPin);
    digitalWrite(clockPin, LOW);
  }
  return ret;
}
 
// obtener dato del Sensirion
int getData16SHT(int dataPin, int clockPin) {
  int val, aux;
 
  // obtener los MSB (bits mas significativos)
  pinMode(dataPin, INPUT);
  pinMode(clockPin, OUTPUT);
  val = shiftIn(dataPin, clockPin, 8);
  val *= 256; // esto es equivalente a desplazar a la izq, SHIFT: val << 8;
  
  // escucho el 1 de propina tras el MSB
  aux = digitalRead(dataPin);
  while (aux != 1) {aux = digitalRead(dataPin);}
  
  // enviar el ACK, MUCHO CUIDADO
  pinMode(dataPin, OUTPUT);
  digitalWrite(clockPin, HIGH);
  digitalWrite(dataPin, HIGH);
  delayMicroseconds(10);
  digitalWrite(dataPin, LOW);
  digitalWrite(clockPin, LOW);
  
  // obtener los LSB (bits menos significativos)
  pinMode(dataPin, INPUT);
  pinMode(clockPin, OUTPUT);
  val |= shiftIn(dataPin, clockPin, 8);
  return val;
}

// obtener el estatus del Sensirion
int getDataEstatus(int dataPin, int clockPin) {
  int val, aux;
 
  // obtener los 8 bits
  pinMode(dataPin, INPUT);
  pinMode(clockPin, OUTPUT);
  val = shiftIn(dataPin, clockPin, 8);
  
  // escucho el 1 de propina tras el less significant bit
  aux = digitalRead(dataPin);
  while (aux != 1) {aux = digitalRead(dataPin);}
  
  // enviar el ACK, MUCHO CUIDADO
  pinMode(dataPin, OUTPUT);
  digitalWrite(clockPin, HIGH);
  digitalWrite(dataPin, HIGH);
  delayMicroseconds(10);
  digitalWrite(dataPin, LOW);
  digitalWrite(clockPin, LOW);
}
 
// saltarse (no solicitar) la comprobacion CRC
void skipCrcSHT(int dataPin, int clockPin) { 
  pinMode(dataPin, OUTPUT); 
  pinMode(clockPin, OUTPUT); 
  digitalWrite(dataPin, HIGH); 
  digitalWrite(clockPin, HIGH); 
  digitalWrite(clockPin, LOW); 
}

// calcular la temperatura en grados Celsius
float calcularTemperatura(int valT, int numerobitsT) {
  float d1, d2 = 0.0;
  float temperatura = 0.0;
  
  d1 = -40.1;      // es para el caso de alimentacion = 5 volts
  // d1 = -39.7;   // alimentacion = 3.5 volts
  // d1 = -39.6;   // alimentacion = 3.0 volts
  
  if (numerobitsT == 14) {
    d2 = 0.01;
  } else {
    d2 = 0.04;
  }
  temperatura = d1 + d2 * valT;
  return temperatura;
}

// calcular la humedad relativa en tanto por ciento
float calcularHR(int valH, int numerobitsH) {
  float c1 = -4.0;
  float c2, c3 = 0.0;
  float HR = 0.0;
  
  if (numerobitsH == 12) {
    c2 = 0.0405;
    c3 = -0.0000028;
  } else {
    c2 = 0.6480;
    c3 = -0.00072;
  }
  HR = c1 + c2 * valH + c3 * valH * valH;
  return HR;
}

// calcular el punto de rocio (T_dew)
float calcularRocio(float RH, float T) {
  float Tn1 = 243.12;  // de 0 a 50 grados C
  float Tn2 = 272.62;  // de -40 a 0 grados C
  float m1 = 17.62;    // de 0 a 50 grados C
  float m2 = 22.46;    // de -40 a 0 grados C
  
  float Ro = 0.0;  // variables
  float Tn = 0.0;
  float m  = 0.0;
  
  if (T < 0.0) {   // elijo segun por encima de 0 o no
    Tn = Tn1;
    m  = m1;
  } else {
    Tn = Tn2;
    m  = m2;
  }
  Ro = Tn * (log(RH/100) + ((m*T) / (Tn+T))) / (m - log(RH/100) - ((m*T) / (Tn*T)));
  return Ro;  // devuelvo
}

// sacar por pantalla (se puede comentar al gusto, para no sacar tanta info)
void representar(float T, float HR, float RHtrue, float Rocio, int valT, int valH) {
  Serial.println("*************************************************************************");
  // escribo los datos binarios q he leido (opcional)
  Serial.print("val temp = ");
  Serial.print(valT);
  Serial.print(" = ");
  Serial.print(valT, BIN);
  Serial.print(", val hum = ");
  Serial.print(valH);
  Serial.print(" = ");
  Serial.print(valH, BIN);
  // datos adicionales (opcional)
  Serial.print("    HR verdadera = ");
  Serial.print(RHtrue);
  Serial.print(" %,  T de rocio = ");
  Serial.print(Rocio);
  Serial.println(" C");
  // datos importantes
  Serial.print("Sensirion (T, HR) :       ");
  Serial.print(temp);
  Serial.print(" C   "); 
  Serial.print(hum);
  Serial.println(" %");  
}

// calcular la humedad relativa verdadera corregido por la temperatura
float calcularHumedadVerdadera(float T, int valH, float HR, int numerobitsH) {
  float t1 = 0.01;
  float t2 = 0.0;
  float HRtrue = 0.0;
  
  if (numerobitsH == 12) {  // el numero de bits para medir la humedad son 8 o 12
    t2 = 0.00008;
  } else {
    t2 = 0.00128;
  }
  
  HRtrue = (T - 25.0) * (t1 + t2 * valH) + HR;
  return HRtrue;
}

// leer la palabra de estatus
void leerEstatus() {
  int val= 0;

  sendCommandSHT(comandoEstatus, dataPin, clockPin);
  waitForResultSHT(dataPin); 
  val = getDataEstatus(dataPin, clockPin);
  skipCrcSHT(dataPin, clockPin);
  Serial.print("estatus = ");
  Serial.println(val, BIN);
}

Comentar q lo mejor (y lo q hago yo) es medir con la precision por defecto, es decir, la mas alta.

No hagais mucho caso a la palabra de estatus, q no lo he hecho muy bien.

Con esto seco los valores por pantalla del ordenador, usando el USB. Como tu quieres sacar la info por una LCD, tendras q hacer una pequeña funcion para enviar el valor de temperatura al LCD. Pero vamos, q poca cosa mas.

Vale, espero q os guste.

Un saludo

Hey!!

Tan solo aclarar la config de los pines, hay 4: - el pin del relol CLK del Sensirion al pin 3 DIGITAL del Arduino - el pin de datos DATA del Sensirion al pin 4 DIGITAL del Arduino - el pin de alimentacion del Sensirion al pin 5V del Arduino (ojo, con alimenatcion de 3.3 voltios da problemas) - y tierra GND a tierra GND

He puenteado con una resistencia entre DATA y alimentacion, pero creo q no hace falta.

Pues eso, hamijo, comprueba primero q te salen los datos por pantalla en tu PC, borra el code q no quieras (aunque no haria falta) y luego haces una funcion para enviar los datos a tu LCD.

Maldito Sensiriooooooon ;D

Talueoo

Muchisimas gracias, es que prove con varias cosas, pero como hay tan poca informacion de estos sensores...

Probaré tu codigo a ver que tal, si me salen en pantalla, ya me esta bien, ya probaré para pasar al lcd.

De verdad, muy, muy agradecido.

Ya lo he probado, funciona a la perfeccion, solo me falta quitar lo que "sobra", osea lo de los sensores independentes y sacar los valores al lcd. Cuando lo consiga os pondre el codigo para quien lo quiera usar. Yo lo usaré para controlar y monitorear un terrario/vivario tropical.

Muchisimas gracias.

Hola Sistrax

Me alegro q te funcione bien. Dices q quieres monitorizar un terrario, ¿tu proyecto trata de agricultura? Yo estoy haciendo algunas cosas aplicadas a agricultura, ahora en concreto estoy integrando el sensor Watermark, de la casa Irrometer.

¿Alguien tiene idea de algun proyecto aplicado a agricultura? Me gustaria tambien incluir un sensor de humedad de hoja, de la casa HobbyBoards. Algo de ayuda por favor!!

Un saludo

Si, quiero controlar y automatizar todo lo posible un terrario/vivario tropical en el que mantengo varias especies de Dendrobates, las famosas ranas de colores de Sur America. Actualmente tiene un termostato con funcion dia/noche y un higrostato tambien dia/noche, este ultimo me costo un dineral, y no acaba de funcionar bien. En un futuro espero utilizar Arduino para automatizar una sala llena de terrarios de este tipo.

javiZgz:

Estoy intentando pasar las lecturas al lcd y no lo consigo pro que no se que comando debo poner para que imprima. Antes lo habia hecho con un sensor LM35 y salia perfecto, pero con el codigo que me diste, no se. o no se verlo, lo que hay que ponerle. Te pongo el codigo que utilizo, esta en conjunto con un reloj, me sale en la primera linea la hora:minutos:segundos, y en la segunda la "T"emperatura y "HR"humedad
Me urge saber como, porque tengo que ponerlo en marcha ya.

/*
 * Lee la señal del sensor de Tª y humedad Sensirion SHT75
 *
 * y compara valores
 *
 * Presenta por lcd los resultados
 *
 * Conexion del Sensirion: GND, VCC, Data pin 4, Sck pin 3
 */
#include <LCD4Bit.h>
LCD4Bit lcd = LCD4Bit(2);

int seconds=20, minutes=15, hour=01, i=0; //start the time on hh:mm:ss
char buf[12];

#include <math.h>

// comandos para el Sensirion
int temperatureCommand  = B00000011;  // comando para leer temperatura
int humidityCommand     = B00000101;  // comando para leer humedad
int comandoEstatus      = B00000111;  // comando para leer registro de estatus

// especifico para el sensor Sensirion
int clockPin = 3;  // pin para el reloj 
int dataPin  = 4;  // pin para datos
int ack;  // detectar posible ocurrencia de errores


void setup() {
  lcd.init();
  pinMode(13,OUTPUT);
}

void loop() {
  digitalWrite(13,HIGH);

  static unsigned long lastTick = 0; // set up a local variable to hold the last time we moved forward one second
  // (static variables are initialized once and keep their values between function calls)


  if (millis() - lastTick >= 1000) { // move forward one second every 1000 milliseconds
    lastTick = millis();
    seconds++;
    LCDOutput();
  }
  if (seconds >= 60) {
    minutes++;
    seconds = 0; // reset seconds to zero

  }
  if (minutes >=60) {
    hour++;
    minutes = 0; // reset minutes to zero
  }

  if (hour >=24) {
    hour=0;
    minutes = 0; // reset minutes to zero
  }



  // 1 - esto del principio es para el Sensirion
  delay(12);   // hay q esperar 12 ms desde el start up
}


// funciones para lectura / escritura del Sensirion

// leer el valor de temperatura que da el sensor (hace todo el proceso transparente)
int leerValorTemperatura() {
  int valT = 0;

  sendCommandSHT(temperatureCommand, dataPin, clockPin); // envio peticion
  waitForResultSHT(dataPin);                             // espero a q tenga el resultado
  valT = getData16SHT(dataPin, clockPin);                // capturo el valor
  skipCrcSHT(dataPin, clockPin);                         // me salto la CRC
  return valT;
}


// enviar comando al Sensirion
void sendCommandSHT(int command, int dataPin, int clockPin) {
  int ack;

  // empieza la transmision
  pinMode(dataPin,  OUTPUT);
  pinMode(clockPin, OUTPUT);
  digitalWrite(dataPin,  HIGH);
  digitalWrite(clockPin, HIGH);
  delayMicroseconds(1);
  digitalWrite(dataPin,  LOW);
  digitalWrite(clockPin, LOW);
  delayMicroseconds(1);
  digitalWrite(clockPin, HIGH);
  digitalWrite(dataPin,  HIGH);
  delayMicroseconds(1);
  digitalWrite(clockPin, LOW);

  // escribir el comando (los 3 primeros bits deben ser la direccion (siempre 000), y los ultimos 5 bits son el comando)
  shiftOut(dataPin, clockPin, MSBFIRST, command);

  // verificar q obtenemos los ACKs adecuados
  digitalWrite(clockPin, HIGH);
  pinMode(dataPin, INPUT);
  ack = digitalRead(dataPin);
  if (ack != LOW)
    Serial.println("ACK error 0");
  digitalWrite(clockPin, LOW);
  ack = digitalRead(dataPin);
  if (ack != HIGH)
    Serial.println("ACK error 1");
}  

// esperar a la respuesta del Sensirion
void waitForResultSHT(int dataPin) {
  int ack;

  pinMode(dataPin, INPUT);
  ack = digitalRead(dataPin);
  while (ack == HIGH){
    ack = digitalRead(dataPin);
  }
}

// leemos dato del data stream del Sensirion
int shiftIn(int dataPin, int clockPin, int numBits) {
  int ret = 0;

  for (int i=0; i<numBits; i++) {
    digitalWrite(clockPin, HIGH);
    delayMicroseconds(1000);
    ret = ret * 2 + digitalRead(dataPin);
    digitalWrite(clockPin, LOW);
  }
  return ret;
}

// obtener dato del Sensirion
int getData16SHT(int dataPin, int clockPin) {
  int val, aux;

  // obtener los MSB (bits mas significativos)
  pinMode(dataPin, INPUT);
  pinMode(clockPin, OUTPUT);
  val = shiftIn(dataPin, clockPin, 8);
  val *= 256; // esto es equivalente a desplazar a la izq, SHIFT: val << 8;

  // escucho el 1 de propina tras el MSB
  aux = digitalRead(dataPin);
  while (aux != 1) {
    aux = digitalRead(dataPin);
  }

  // enviar el ACK, MUCHO CUIDADO
  pinMode(dataPin, OUTPUT);
  digitalWrite(clockPin, HIGH);
  digitalWrite(dataPin, HIGH);
  delayMicroseconds(10);
  digitalWrite(dataPin, LOW);
  digitalWrite(clockPin, LOW);

  // obtener los LSB (bits menos significativos)
  pinMode(dataPin, INPUT);
  pinMode(clockPin, OUTPUT);
  val |= shiftIn(dataPin, clockPin, 8);
  return val;
}

// obtener el estatus del Sensirion
int getDataEstatus(int dataPin, int clockPin) {
  int val, aux;

  // obtener los 8 bits
  pinMode(dataPin, INPUT);
  pinMode(clockPin, OUTPUT);
  val = shiftIn(dataPin, clockPin, 8);

  // escucho el 1 de propina tras el less significant bit
  aux = digitalRead(dataPin);
  while (aux != 1) {
    aux = digitalRead(dataPin);
  }

  // enviar el ACK, MUCHO CUIDADO
  pinMode(dataPin, OUTPUT);
  digitalWrite(clockPin, HIGH);
  digitalWrite(dataPin, HIGH);
  delayMicroseconds(10);
  digitalWrite(dataPin, LOW);
  digitalWrite(clockPin, LOW);
}

// saltarse (no solicitar) la comprobacion CRC
void skipCrcSHT(int dataPin, int clockPin) {
  pinMode(dataPin, OUTPUT);
  pinMode(clockPin, OUTPUT);
  digitalWrite(dataPin, HIGH);
  digitalWrite(clockPin, HIGH);
  digitalWrite(clockPin, LOW);
}

// calcular la temperatura en grados Celsius
float calcularTemperatura(int valT, int numerobitsT) {
  float d1, d2 = 0.0;
  float temperatura = 0.0;

  d1 = -40.1;      // es para el caso de alimentacion = 5 volts
  // d1 = -39.7;   // alimentacion = 3.5 volts
  // d1 = -39.6;   // alimentacion = 3.0 volts

  if (numerobitsT == 14) {
    d2 = 0.01;
  } 
  else {
    d2 = 0.04;
  }
  temperatura = d1 + d2 * valT;
  return temperatura;
}

// calcular la humedad relativa en tanto por ciento
float calcularHR(int valH, int numerobitsH) {
  float c1 = -4.0;
  float c2, c3 = 0.0;
  float HR = 0.0;

  if (numerobitsH == 12) {
    c2 = 0.0405;
    c3 = -0.0000028;
  } 
  else {
    c2 = 0.6480;
    c3 = -0.00072;
  }
  HR = c1 + c2 * valH + c3 * valH * valH;
  return HR;

}

// sacar por lcd (se puede comentar al gusto, para no sacar tanta info)
void representar(float T, float HR, float RHtrue, float Rocio, int valT, int valH) {


  // datos importantes
  lcd.printIn("T, HR :       ");

  lcd.printIn(" C   ");

  lcd.printIn(" %");
}

// calcular la humedad relativa verdadera corregido por la temperatura
float calcularHumedadVerdadera(float T, int valH, float HR, int numerobitsH) {
  float t1 = 0.01;
  float t2 = 0.0;
  float HRtrue = 0.0;

  if (numerobitsH == 12) {  // el numero de bits para medir la humedad son 8 o 12
    t2 = 0.00008;
  } 
  else {
    t2 = 0.00128;
  }

  HRtrue = (T - 25.0) * (t1 + t2 * valH) + HR;
  
  return HRtrue;
  
}

void LCDOutput() {


  lcd.cursorTo(1, 0);            //move cursor to 1st line
  lcd.printIn("Hora:");  
  lcd.printIn(itoa(hour, buf, 10));
  lcd.printIn(":");  //convert int to string
  lcd.printIn(itoa(minutes, buf, 10));
  lcd.printIn(":");  
  lcd.printIn(itoa(seconds, buf, 10));
  lcd.cursorTo(2, 0);          //move cursor to 2nd line
  lcd.printIn("T:   ");lcd.printIn("oC  ");
  lcd.printIn("HR:   ");lcd.printIn("%");
  
}

Hola

Lo siento Hamijo Mio, no tengo ni idea de como manejar una pantalla LCD. :'( :'( :'(

En todo caso, pon el link del data sheet de la pantallica o algun ejemplo. Incluye tb los errores y/o warnings q te da el compilador del Arduino.

Ahora pienso q puede ser q te de error pq acepta un tipo de datos y tu le metes otros. P ejem, imagina q solo acepta integers y le estas metiendo un float. O yo q se, puede q hayas olvidado algun include. En la funcion q falla pon ecos en plan 'Serial.println("hasta aki correcto");' para ver en la pantalla DEL PC el punto exacto dnd peta.

Ve poco a poco: primero saca la hora nada mas, si va bien luego saca nada mas q la temperatura, ... y por ahi!!

A ver si podemos echar una mano...

Muy buenas. Para el SHT15 hay que colocar una resistencia pull-up entre vcc y data, a mi me funciona bastante bien.

Saludos.

amigos como estan, estoy trabajando con un sensor SHT71 alimentandolo a 3,3V, con una resistencia de 10K para el pin de DATA, el problema es que yo programo en c sinembargo el codigo que colocó el compañero jaVizgz parece prometedor pero la funcion shiftout() no se que hace ni cual es su equivalente en c, si alguien puede explicarme como hacerla en c se lo agradeceria, porfavor ayudaaaaaaaaaaaaaaaaaaaaaaa

¿como les fué con esto? yo tengo otro código que tal vez les pueda servir, hace tiempo trabajé con un SHT15, y lo publicaba en internet con ethernet shield y lo mostraba en el LCD de 16x2 (pero necesito buscar el código) xD

en cuanto a lo que dice joserumo yo te recomiendo que le des las instrucciones al arduino para que te "imrpima" todos los valores por el puerto serial y ya tu desde c# los manipulas

saludos