Archivo de la etiqueta: sensor

Leer temperatura de un sensor DS18B20 con Raspberry Pi

Mediante un sensor DS18B20 podemos obtener una lectura de temperatura fácil y precisa. Este sensor puede ser una gran aliado para nuestro montajes. Este sensor de temperatura utiliza el protocolo de comunicación 1-Wire, lo que nos permite una facil comunicación con el, y la posibilidad de crear un red de sensores, sin tener que ocupar muchos de nuestros pines de entradas y salidad de datos de nuestro Raspberry Pi.

Materiales usados

Raspberry Pi 2 Raspberry Pi 3 Modelo B (1,2 GHz Quad-core ARM Cortex-A53, 1GB RAM, USB 2.0)

Raspberry Pi 2 Model B – Placa base (ARM Quad-Core 900 MHz, 1 GB RAM, 4 x USB, HDMI, RJ-45)

Sensor temperatura DS18B20 DS18B20 con carcasa de acero inoxidable
protoboard Protoboard
cables_union Cables de conexión
Resistencia 4k7 Resistencias varias
RPi GPIO Breakout Pi 2 Model B & B+ RPi GPIO Breakout Pi 2 Model B & B+

Esquema de montaje DS18B20 y Raspberry Pi

El montaje del sensor en un sencillo, la alimentación del sensor lo haremos mediante el pin de 3,3v del conector GPIO (pin 1), al clave rojo del sensor, en mi caso, si utilizamos la versión como un transistor, la conectaremos al pin más a la izquierda. La masa, la sacaremos el pin 6 del GPIO, y lo conectaremos al cable negro, o al pin de la derecha del sensor. La salida de datos la conectaremos al pin 4, al cable amarillo, o al pin del medio del sensor. Para terminar el montaje, tendremos que situar una resistencia de 4K7 Ohm, entre el pin positivo del sensor y el pin de datos.

Esquema de montaje del sensor DS18B20 con un Raspberry Pi

Esquema de montaje del sensor DS18B20 con un Raspberry Pi

El sensor DS18B20, permite conectar varios sensores al mismo canal, es decir, que si queremos añadir más sensores DS18B20 a nuestro circuito, no tendremos que ocupar más pines de datos de nuestra raspberry, colo tendremos que conectar cada uno de los pines del sensor al mismo circuito que el primero.

Ejemplo de montaje de varios sensores DS18B20 a una Raspberry Pi.

Montaje de varios sensores DS18B20 a una Raspberry Pi
Montaje de varios sensores DS18B20 a una Raspberry Pi

 

Comprobando la instalación de los sensores DS18B20

Como todas las comunicaciones que Linux hace con cualquier dispositivo, ya sea puertos serie, USB, comunicaciones I2C, etc. La forma de trabajar la Raspberry Pi con el sensor de temperatura DS18B20 es creando un fichero, donde el sensor escribe los datos devuelto. Esta comunicación la realiza mediante el bus 1-Wire.

Para comprobar que nuestra Raspberry Pi lee todos los sensores que tenemos instalados, solo tendremos que mirar cuantas carpetas con el inicio “28” tenemos dentro del directorio que maneja las comunicaciones con el bus 1-Wire. Cada una de estas carpetas que comienzan por “28” corresponde con el numero de serie del sensor de temperatura.

ls /sys/bus/w1/devices/

Cada una de estas carpetas que comienzan por “28” corresponde con el número de serie del sensor de temperatura. Si faltase alguna carpeta, habría que comprobar la conexión de ese sensor.

Lectura del sensor DS18B20 con una Raspberry Pi

Para leer los datos proporcionados por el sensor de temperatura DS18B20 con nuestra Raspberry Pi solo tendremos que acceder a cada una de las carpetas, y leer los datos que hay dentro del fichero “w1-slave”. En este fichero tendremos el valor de la temperatura leída por el sensor * 1000, es decir, para obtener el valor real de la temperatura, dividiremos el valor del parametro “t” / 1000.

Para hacer esto desde Python, haremos los siguiente.

Añadiremos las siguientes librerías, para el manejo de ficheros y directorios del sistema

# Librerias para la lectura de la temperatura
import os
import glob

Cargamos los módulos en el kernel del sistema para manejar el bus 1wire del conector GPIO del Raspberry Pi.

os.system('modprobe w1-gpio')
os.system('modprobe w1-therm')

Cargamos la ruta donde se encuentra nuestro sensor.

Carpeta_Sensor = glob.glob( '/sys/bus/w1/devices/' + '28*')[0]

Con esta linea cargamos el nombre del primer sensor de la lista disponible, para cargar las demás rutas solo tendremos que cambiar “[0]” por la posición deseada.

Lo siguiente que haremos es leer el fichero “w1_slave”, para leer el valor de la temperatura del sensor. Leemos el fichero y cargamos todas las lineas disponibles en una variable.

fSensor = open(Carpeta_Sensor + ',/w1_slave' 'r')
linSensor = fSensor.readlines()
fSensor.close()

Una vez que ya tenemos el contenido del fichero, buscamos el parámetro “t” donde esta la temperatura. Una vez que encontramos la temperatura, la multiplicamos por 1000, par obtener el valor real.

posTemp = linSensor[1].find('t=')
# Si la posicion es valida
if posTemp != -1:
    # Anadimos son posiciones mas por t=
    strTemp = lines[1][posTemp+2:]
    # Calculamos la temperatura real
    temperatura = float(strTemp) / 1000.0

Con esto ya tendríamos el valor del sensor, con su valor real, dentro de la variable “temperatura”.

Temperatura con Arduino, DHT11 y python (II)

modulo-sensor-de-tempertura-y-humedad-dht11-para-arduino_MEC-O-3277967849_102012Una vez que ya hemos hecho que nuestro arduino nos “hable”, ya solo nos queda “escuchar” lo que nos dice. Para ello vamos a utilizar Python para obtener la temperatura con Arduino.

Lo primero que tenemos que hacer es conectarnos con nuestro arduino (Arduino Uno R3), para ello, lo primero que haremos es descubrir en que puerto esta conectado nuestro arduino, este método esta explicado en un por anterior, así que no me detendré el ello.

Temperatura con Arduino

Una vez que ya sabemos en que puerto esta el arduino, pasamos a leer los datos que nos esta trasmitiendo. para la lectura de estos datos utilizaremos la librería PySerial. como con la búsqueda de puerto del arduino, ya esta explicado en otro post, por lo que tampoco me detendré en ello. Como siga así no explico nada :-).

Bueno, ahora es cuando llega la hora de saber lo que nos dice nuestro arduino. Como ya dije en la otra parte de este post, lo que nos envía el arduino es un registro formateado con los datos que nosotros queremos, por lo que solo tendremos que dividir el registro leído en los diferentes campos en que se compone el registro.

Cuando leamos el registro lo primero que hacemos es comprobar que el registro esta completo. Esto lo hago comprobando que los últimos caracteres del registros son los que establecimos como final de este “|f|” y que la longitud es la que definimos.

if sArduino.endswith("|f|") and len(sArduino) == cTamanoRegistro:

Si todo esta bien, pasamos a trocear el registro, si esta mal, pasamos de los datos leídos y volvemos a leer un nuevo registro. Si el sistema fuera para el control de sistemas críticos, este método no nos valdría, debido a la perdida de datos. Para mi caso me sobra, ya que esto va ha controlar la temperatura y humedad de un invernadero.

Para dividir el registro utilizamos el carácter que hemos utilizado en el arduino como separador de campos, en mi caso el carácter “|”, y el numero de campos de que consta nuestro registro, en mi proyecto 2, uno para la temperatura y otro para la humedad (Módulo de Sensor de Humedad Módulo de Temperatura Digital). Y lo guardamos en sus correspondientes variables. El resto del registro lo podemos guardar en una variable temporal, pero hay que pasarle una variable, sino, nos daría error.

sHumedad, sTemp, sFin = sArduino.split("|", 2)

Con esto ya tenemos nuestro campos guardados en sus respectivas variables para poder procesarlas como queramos. Y ya esta, hemos escuchado al arduino y sabemos lo que nos esta diciendo.

Este es el proceso completo que he utilizado.

# Abrimos el puerto del arduino a 9600
    PuertoSerie = serial.Serial(str(self.pPuerto), 9600)
    PuertoSerie.timeout = 1 

    while not self.Terminar:
        sArduino = PuertoSerie.read(PuertoSerie.inWaiting())
	time.sleep(1)

	# leemos hasta que encontarmos el final de linea
	sArduino = PuertoSerie.readline()
	sArduino = sArduino.strip()

	if sArduino.endswith("|f|") and len(sArduino) == cTamanoRegistro:
	# Separamos los datos recibidos mediante el seprador "|"
	sHumedad, sTemp, sFin = sArduino.split("|", 2) 
	global tTempMax
	global tTempMin

	global tHumeMax
	global tHumeMin

	if int(sTemp) > tTempMax: 
            tTempMax = int(sTemp)
	if int(sTemp) < tTempMin:
	    tTempMin = int(sTemp)

	if int(sHumedad) > tHumeMax:
	    tHumeMax = int(sHumedad)
	if int(sHumedad) < tHumeMin:
	    tHumeMin = int(sHumedad)

    else:
        PuertoSerie.close()
        time.sleep(5)

Y esto es todo para obtener la temperatura con Arduino, si tienes alguna duda, o si ves que se puede mejorar, que se puede mejorar y mucho, no te cortes y deja tu comentario.

Temperatura con Arduino, sensor DHT11 y python (I)

modulo-sensor-de-tempertura-y-humedad-dht11-para-arduino_MEC-O-3277967849_102012El sensor DHT11 (Módulo de Sensor de Humedad Módulo de Temperatura Digital), y sus variantes, es uno de los sensores más fáciles de manejar para obtener la temperatura con arduino. Gracias a la librería disponible para el, solo tenemos que pedir la temperatura o la humedad y ya la tenemos, sin hacer ninguna otra operación.

Materiales usados

Arduino UNO Arduino UNO
 Sensor DHT 11 Sensor DHT11
protoboard Protoboard
cables_union Cables de conexión

Sensor DHT11

Para conectarlo al arduino es muy sencillo, alimentamos el pin vcc, primero por la izquierda, con 5v desde unos de los pines del arduino, conectamos la masa al más a la derecha, y desde un pin analogico del arduino al 2 pin del sensor, empezando por la izquierda, el 3 pin no hay que conectarlo a nada.

Montaje de un sensor DHT11 en una placa Arduino UNO
Montaje de un sensor DHT11 en una placa Arduino UNO

El código como he dicho antes es muy fácil gracias a la librería existente, solo tenemos que inicializar una variable que nos permita manejar en sensor y poco mas.

Importamos la libreria

#include <DHT.h>

Inicializamos la variable para manejar el sensor DHT11

#define DHTPIN A0     // Indicamos el pin donde conectaremos la patilla data de nuestro sensor DHT11

#define DHTTYPE DHT11   // modelo del sensor que vamos a usar DHT 11 

// Inicializamos la variable
DHT dht(DHTPIN, DHTTYPE);  //Indica el pin con el que trabajamos y el tipo de sensor

Ahora solo tenemos que leer los datos del sensor DHT11 tanto de temperatura como de humedad de la siguiente forma

int iHumedad = dht.readHumidity();  // Guarda la humedad en iHumedad
int iTemepratura = dht.readTemperature(); // guarda la temepratura en iTemperatura

y con esto ya tendríamos tanto el % de la humedad con los grados de temperatura en la escala Celsius.

Pero ahora me queda mandar la información por el puerto serie para luego poderla leer en python.

Para esto creo un registro de 30 caracteres formateado, donde incluyo los dos valores leídos, una cadena variable de caracteres para ajustar la longitud del registro, un carácter separador de los campos “|”  y un campo “|f|” indicando que es el final del registro. quedando de la siguiente forma

HH|TT|XXXXXXXXXXXXXXXXXXXXX|f|

  1. HH seria el valor de la humedad, puede ser 1 0 2 caracteres dependiendo de la humedad que haya.
  2. TT valor de la temperatura, como la humedad el tamaño de este campo puede ser de 1 o 2 caracteres.
  3. X cadena variable, que dependiendo de la longitud de humedad o temperatura puede variar su longitud.
  4. |f| indica que es el final del registro. Para comprobar luego mediante python, que hemos leído correctamente la información enviada.

Si queremos enviar mas información solo tenemos que añadirla incluyendo los separadores. El tamaño del registro lo he establecido en 30 caracteres pero lo podemos variar cambiando la configuración del programa.

// Tamaño del registro a enviar al puerto serie 
int iTamanoCadena = 30;

Y el código seria el siguiente

    // añadimos la humedad y la temperatura, añadiendo al final de cada uno el caracter "|" 
    sResultado = String(h) + "|" + String(t) + "|";
    sEspacios = "";
    / Calculamos cuantos espacios tenemos que crear
    // Le restamos 3 que es el tamaño del campo final
    if (sResultado.length() < (iTamanoCadena - 3))
    {      
      // Creamos la cadena
      for (iContador = 0; iContador < ((iTamanoCadena - 3) - sResultado.length()); iContador ++)
      {
        // le añadimos el caracter que queramos, no vale para nada
        sEspacios += "X";
      }
    }
    // Añadimos el campo de fin de registro
    sResultado = sResultado + sEspacios + "|f|";
    // lo enviamos al puerto serie
    Serial.println(sResultado);
  }

Y con esto ya hemos leído la temperatura y la humedad desde el sensor DHT11 (Módulo de Sensor de Humedad Módulo de Temperatura Digital), y enviada al puerto serie para ser leída por nuestro programa en python.

Código completo.

#include <DHT.h>

#define DHTPIN A0     // Indicamos el pin donde conectaremos la patilla data de nuestro sensor

// Descomenta el tipo de sensor que vas a emplear. En este caso usamos el DHT11
#define DHTTYPE DHT11   // DHT 11 
//#define DHTTYPE DHT22   // DHT 22  (AM2302)
//#define DHTTYPE DHT21   // DHT 21 (AM2301)

// Conecta el pin 1 (el de la izquierda) del sensor a +5V
// Conecta el pin 2 del sensor al pin que has elegido para DHTPIN
// Conecta el pin 4 (el de la derecha) del sensor a GROUND

DHT dht11(DHTPIN, DHTTYPE);  // indicamos en que pin esta conectado el data, y el tipo de sensor

String sResultado, sEspacios;
int iContador;
int iTamanoCadena = 30;

void setup() 
{
  //Inicio comunicacion serie para ver los datos en el ordenador
  Serial.begin(9600); 
  //Iniciamos el sensor
  dht11.begin();
}

void loop() 
{
  int iHumedad = dht11.readHumidity();  //Guarda la lectura de la humedad
  int iTemperatura = dht11.readTemperature();  //Guarda la lectura de la temperatura

  // Comprobamos si lo que devuelve el sensor es valido, si no son numeros algo esta fallando
  if (isnan(iHumedad) || isnan(iTemperatura)) // funcion que comprueba si son numeros las variables indicadas 
  {
    Serial.println("Fallo al leer del sensor DHT 11"); //Mostramos mensaje de fallo si no son numeros
  } 
  else 
  {
    // añadimos la humedad y la temperatura, añadiendo al final de cada uno el caracter "|" 
    sResultado = String(iHumedad) + "|" + String(iTemperatura) + "|";
    sEspacios = "";
    // Calculamos cuantos espacios tenemos que crear
    // Le restamos 3 que es el tamaño del campo final
    if (sResultado.length() < (iTamanoCadena - 3))
    {      
      // Creamos la cadena
      for (iContador = 0; iContador < ((iTamanoCadena - 3) - sResultado.length()); iContador ++)
      {
        // le añadimos el caracter que queramos, no vale para nada
        sEspacios += "X";
      }
    }
    // Añadimos el campo de fin de registro
    sResultado = sResultado + sEspacios + "|f|";
    // lo enviamos al puerto serie
    Serial.println(sResultado);
  }
  // y esperamos 1 segundo para volver a leer los datos del sensor.
  delay(1000);
}

Y con eso terminamos la primera entrega. en la segunda, la lectura de los datos en Python.

Medir distancias con el sensor HC-SR04 y arduino

Sensor de ultrasonidos HC-SR04
Sensor de ultrasonidos HC-SR04

El sensor HC-SR04 es un modulo que mediante ultrasonidos nos permite medir distancias. Lo que hace el sensor es enviar un sonido, este rebota en un objeto y es recogido de nuevo por el sensor, sabiendo cuanto tiempo ha tardado en volver la señal, podemos calcular la distancia que hay desde el sensor hasta el objeto. Con el HC-SR04 podemos obtener medidas desde 1 ó 2 cm hasta los 5 metros.

Materiales usados

Arduino UNO Arduino UNO
 Sensor HC-SR04 HC-SR04
protoboard Protoboard
cables_union Cables de conexión

Medir distancias con el sensor HC-SR04

La conexión con el arduino es muy sencilla, el sensor HC-SR04 (niceeshop(TM) HC SR04 distancia por ultrasonidos módulo de medición del sensor para Arduino) viene con 4 patillas, las normales de vcc, que la conectaremos al pin de arduino de 5 vol.,  y de GND, que lo conectaremos a uno de los pines de masa del arduino, y 2 pines más que son los que nos permitirán obtener los valores para hacer los cálculos para obtener la medición. Estos pines son TRIGGER, indica cuando se ha enviado la señal, y ECHO, cuando se ha detectado el retorno del sonido.

[singlepic id=39 w=400 h=400 float=center]

En el tema de la programación, tampoco tenemos demasiadas complicaciones, activamos los pines donde hemos conectado los pines de datos del HC-SR04 el TRIGGER como OUTPUT y el ECHO como INPUT. Ponemos en HIGH el pin del TRIGGER, y lo volvemos ha poner en LOW, esperamos a que el pin del ECHO detecte la señal. Calculamos cuanto a tardado, y sabiendo el tiempo que ha tardado calculamos la distancia.

// Código original en ingles en
// http://www.swanrobotics.com/HC-SR04_Project
// Este ejemplo es de dominio publico

const int TriggerPin = 10; // pin del TRIGGER
const int EchoPin = 11; // pin del ECHO

long Duracion = 0;

void setup(){
pinMode(TriggerPin,OUTPUT); // Pin del TRIGGER lo ponemos en output
pinMode(EchoPin,INPUT); // Pin del ECHO lo ponemos en input

Serial.begin(9600); // activamos el puerto serie para ver los resultados
}

void loop(){
digitalWrite(TriggerPin, LOW); // ponemos el pin TRIGGER en LOW
delayMicroseconds(2); // esperamos 2 milisegundos
digitalWrite(TriggerPin, HIGH); // ponemos el pin TRIGGER en HIGH
delayMicroseconds(10); // lo temos activado durante 10 milisegundos
digitalWrite(TriggerPin, LOW); // ponemos el pin del TRIGGER en LOW

Duracion = pulseIn(EchoPin,HIGH); // Esperamos a que el pin del ECHO devuelva HIGH, y guardamos el tiempo
// Devuelve el tiempo en milisegundos
long Distancia_mm = fDistancia(Duration); // Función para calcular la distancia

Serial.print("Distancia = "); // Y la mostramos por el puerto serie
Serial.print(Distancia_mm);
Serial.println(" mm");

delay(1000); // Esperamos 1 segundo para hace de nuevo la medición
}

// Función para calcular la distancia
long fDistancia(long tiempo)
{
// Calculamos la distancia en mm
// ((tiempo)*(Velocidad del sonido)/ el camino se hace dos veces) 

long DistanceCalc; // Variable para los cálculos
DistanceCalc = (tiempo /2.9) / 2; // Cálculos en milímetros
// DistanceCalc = (tiempo /29) / 2; // Cálculos en centímetros
// DistanceCalc = (tiempo / 74) / 2; // Cálculos en pulgadas
return DistanceCalc; // Devolvemos el calculo
}

Seguro que alguno le parecerá difícil, pero lo único que hacemos es mediante el sensor HC-SR04 enviar un señal, esperar a que vuelva, calcular cuanto a tardo, y por la formula de la velocidad del sonido calcular la distancia.

Pero aun así es mas fácil todavía, por internet se puede encontrar una librería para el sendor HC-SR04 para el ide del arduino que facilita enormemente el calculo.

El código quedaría de la siguiente manera

// Ultrasonic - Library for HR-SC04 Ultrasonic Ranging Module.
// Rev.4 (06/2012)
// J.Rodrigo ( www.jra.so )
// more info at www.ardublog.com

#include <Ultrasonic.h>

Ultrasonic ultrasonic(10,11); // (Trig PIN,Echo PIN)

void setup() {
  Serial.begin(9600); 
}

void loop()
{
  Serial.print(ultrasonic.Ranging(CM)); // CM or INC
  Serial.println(" cm" );
  delay(100);
}

El programa nos devuelve la distancia en centímetros (CM), si lo queremos en pulgadas (INC), tendremos que cambiar esto

ultrasonic.Ranging(CM)

por esto

ultrasonic.Ranging(INC)

Aun así, según esta codificado el programa, solo obtendremos mediciones de hasta 50 centímetros, para poder obtener mediciones mas largas tendremos que modificar la siguiente linea

Ultrasonic ultrasonic(10,11); // (Trig PIN,Echo PIN)

Por esta otra

Ultrasonic ultrasonic(10, 11, 30000); // (Trig PIN,Echo PIN, Timeout)

Lo único que hemos hecho es cambiar el timeout, que esta establecido por defecto en 3.000 ms, que es igual a 50 cm, por 30.000 ms, que son 5 metros.

Con este parámetro podremos configurar la distancia máxima que queremos medir con el sensor HC-SR04.  Para calcular el timeout correspondiente a la distancia que queremos, los podemos hacer con la siguiente formula

Timeout = Distancia máxima en centímetros * 58

 Con estos ya podemos calcular distancias con nuestro arduino (Arduino Uno R3).

Como conseguirlo

niceeshop(TM) HC SR04 distancia por ultrasonidos módulo de medición del sensor para Arduino

Arduino Uno R3

 

Obtener la temperatura con Arduino y un termistor

En este proyecto vamos ha ver como podemos obtener la temperatura mediante la utilización de un termistor. Lo primero, que es un termistor, esta es una simple resistencia que varia según la temperatura que tenga, con el valor devuelto por la resistencia y una pequeña formula podemos calcular que temperatura hace.

Esquema del circuito:

El esquema de este circuito es muy sencillo, esta basado en un simple divisor de tensión, en este caso quedaría de la siguiente manera.

[singlepic id=3 w=320 h=240 float=center]

Este esquema es el utilizado en la mayoría de sensores, simplemente cambiando el termistor, por un lcr, por ejemplo, tendríamos un sensor para detectar la luminosidad.

En mi caso el termistor no es de 10 k, como se muestra en el esquema, sino que es de 100k (NJ28 NTC Thermistor,2.8mm,100K,1%), esto no varia mucho lo fundamental del sistema, ya que en el código para el arduino , le diremos tanto el valor de resistencia del termistor, como el valor de la resistencia secundaria.

Esquema de la conexión en al arduino:

[singlepic id=10 w=320 h=240 float=center]

Para calcular la temperatura necesitamos saber el valor beta de nuestro termistor, normalmente, este valor lo suele facilitar el fabricante de la resistencia, pero si el fabricante no nos lo da o no sabemos el fabricante, lo podremos calcular sabiendo la temperatura a la que esta el termistor, apuntamos el valor de resistencia ha esa temperatura y la temperatura en grados Kelvin, después elevamos la temperatura y volvemos a puntar la resistencia y la temperatura. Cuanto mas diferencia de temperatura mas fiable sera el calculo.

Por ejemplo, ponemos el termistor sobre un hielo, con otro termómetro miramos la temperatura, por ejemplo T1 = 3º + 273,15 y resistencia R1 = 34500 Ohm. Luego lo metemos el agua caliente y hacemos la misma comprobación T2 = 80º + 273,15 y R2 = 134 Ohm. Con esos datos aplicamos la siguiente formula:

beta=(log(RT2/RT1))/((1/T2)-(1/T1))

Quedando de la siguiente manera:

beta = (log(143 / 345000)) / ((1/353,15)-(1 / 276,15))

beta = 4283,9970482988 = 4284

Código para el Arduino.

#include <stdio.h>
#include <math.h>

int analogPin=0;     // Pin donde esta conectado el divisor de tension en el Arduino

float Vin=5.0;       // [V]       Voltage de entrada en el divisor de tension
float Raux=10000;    // [ohm]     Valor de la resistencia secundaria del divisor de tension
float R0=100000;     // [ohm]     Valor de resistencia nominal del termistor (NTC) a 25ºC
float T0=298.15;     // [K] (25ºC)

float Vout=0.0;      // [V]        Voltage given by the Voltage-Divider
float Rout=0.0;      // [ohm]      Resistencia actual del Termistor (NTC)

// Valores para calcular el valor Beta, si no lo sabemos
// float T1=273;     // [K]        Temperatura del 1º punto del test (en grados Kelvin)
// float T2=373;     // [K]        Temperatura del 2º punto del test (en grados Kelvin)
// float RT1=19750;  // [ohms]     Resistencia a 273K grados Kelvin (0ºC)
// float RT2=2150;   // [ohms]     Resistencia a 373K grados Kelvin (100ºC)

float beta=0.0;      // [K]        Parametro Beta
float Rinf=0.0;      // [ohm]      Parametros Rinf
float TempK=0.0;     // [K]        Temperatura de salida en grados Kelvin
float TempC=0.0;     // [ºC]       Temperatura de salida en grados Celsius

int iCont;            // Contador de ciclos, par el calculo de la temperatura media
float cTemp1;         // Variable temporal para acumular las temperaturas leidas 

void setup() {
  // Configuramos el puerto Serie
  Serial.begin(9600);

  // Configuramos el pin del Arduino en entrada
  pinMode(analogPin, INPUT);

  // Parametros generales para el calculo
  // Formula para calcular el valor beta si no disponemos de el
  // beta=(log(RT1/RT2))/((1/T1)-(1/T2));
  // Valor beta, los fabricantes suelen disponer ya de este valor, 
  // mirar en la tabla de carateristicas del termistor
  beta = 4380;
  Rinf=R0*exp(-beta/T0);
}

void loop()
{
  cTemp1=0;  
  for (iCont = 1; iCont <= 500; iCont ++)
  {
    // Cálculo del valor de la resistencia termistor (NTC) actual (a través de Vout)
    Vout=Vin*((float)(analogRead(analogPin))/1024.0); 
    Rout=(Raux*Vout/(Vin-Vout));

    // Calculo de la temperatura en grados Kelvin
    TempK=(beta/log(Rout/Rinf));
    // Calculo de la temperatura en grados Celsius
    TempC=TempK-273.15; 
    // Almacenamos la temperatura (grados Celsuis) actual para despues obtener la media
    cTemp1 = cTemp1 + TempC; 
    // Hacemos una pausa de 10 milisegundos    
    delay(10);
  }

  // Calculamos la temperatura media
  TempC = cTemp1/iCont;

  // Mostramos la temperatura media en grados Celsius
  Serial.println(TempC);

  // Hacemos una pausda de 1 seg.
  delay(1000);
}

Y con esto ya tendríamos un termómetro digital con nuestro Arduino.