Archivo de la categoría: Arduino

Cosas varias relacionadas con Arduino

Enviar SMS con Python y la libreria PySerial

Mandar un SMS con Python
Mandar un SMS con Python

Algunos módem usb permiten recibir ordenes mediante comandos AT, con estos comandos podemos hacer muchas cosas. Hace años, muchos años, estos comandos los utilizábamos para configurar centralitas, realizar llamadas, obtener información del aparato, etc. Ahora esta técnica esta en desuso, pero aun así, algunos módems están preparados todavía para poderse programar con estos comandos.

Aprovechando la librería PySerial y python he creado un programa para cuando lee ciertos valores desde el arduino me los mande por SMS a mi móvil.

Para empezar con el programa tenemos que saber cual es el puerto serie del módem, en mi caso cuando pincho el módem usb al ordenador me crea tres puertos /dev/ttyUSB0, /dev/ttyUSB1 y /dev/ttyUSB2, para windows no tengo ni idea que hace.

Una vez que sabemos los puertos del módem, tenemos que saber cual de ellos es el que responde a los comandos AT. Para saber que puerto responde a los comandos hice este programa

#!/usr/bin/env python

import serial

sSerie = serial.Serial('/dev/ttyUSB0', 9600)
#sSerie.open()
try:
    sSerie.write("AT\r\n")
    print sSerie.readline()
    print sSerie.readline()

except ValueError:
    print "Oops!  se ha producido un error ..."

#sSerie.close()

Con este programa, lo que hacemos es abrir el puerto correspondiente, y le enviamos el comando “AT”. Si el módem sabe que es lo que le estoy enviando nos devolverá “OK”, en caso contrario “ERRROR”, o saltara la excepción del programa.

También lo podemos probar con un programa de terminal, como el “Serial port Terminal” o el “minicom” en Linux, o con el “Hiperterminal” en windows. Solo tenemos que abrir el puerto a probar y escribir “AT” y esperar la respuesta

Así con todos los puertos disponibles, en mi caso me admitió peticiones por los puertos /dev/ttyUSB1 y /dev/ttyUSB2.

Una vez que sabes el puerto, podes probar ha enviar un SMS de la siguiente forma.

#!/usr/bin/env python

import serial
# para enviar el Ctrl-Z
from curses import ascii

sSerie = serial.Serial('/dev/ttyUSB2', 9600)
#sSerie.open()
try:
    # Enviamos un reset al modem
    sSerie.write("ATZ\r\n") 
    # Le ponemos en modo para SMS
    sSerie.write("AT+CMGF=1\r\n") 
    # Le pasamos el numero al que vamos ha mandar el SMS
    sSerie.write("AT+CMGS=\"123456789\"\r\n"); 
    # Texto del mensaje terminado en Ctrl+Z
    sSerie.write("Esto es un mensaje" + ascii.ctrl('z')) 
    # Leemos la informacion devuelta
    print sSerie.readline() 
    # Leemos la informacion devuelta
    print sSerie.readline() 
    # Leemos la informacion devuelta
    print sSerie.readline() 

except ValueError:
    print "Oops! se ha producido un error ..."

#sSerie.close()

Y con esto ya podemos mandar SMS desde python, esta un poco chapucero, pero para lo hace y lo que he tardado en el, sobra la mitad.

Ya solo nos queda leer los datos del arduino y mandar el SMS.

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

 

Comunicación bluetooth y arduino

Añadirle la comunicación bluetooth al arduino es muy sencilla. Lo único que tenemos que hacer es conseguir un adaptador bluetooth HC-05 (KKmoon Wireless Bluetooth Maestro y Esclavo HC-05 del módulo de transceptor para Arduino ARM DSP PIC) o HC-06 (XINTE Inalámbrica Bluetooth Serial esclavo módulo HC-06 apto para Arduino).

Comunicación bluetooth con arduino

Este adaptador nos permite una comunicación serie con el dispositivo de comunicación bluetooth al que nos conectemos. Podemos configurarlo en modo maestro, el adaptador seleccionara el dispositivo al que se quiere conectar, o en modo esclavo, el adaptador estará a la espera de dispositivos que se quieran conectar a el.

El HC-05 / HC-06 es un componente de tipo smd, es decir, es como un integrado que tendremos que soldar a nuestra placa con conectores de superficie.

[singlepic id=36 w=320 h=320 float=center]

Pero hay en el mercado infinidad de montajes que ya bien preparados para su conexión directa con arduino (Arduino Uno R3). La alimentación estándar del HC-05/HC-06 es de 3.3v, pero el sistema ya viene preparado para poderlo alimentarlo hasta los 6v.

[singlepic id=37 w=320 h=320 float=center]

Para conectarlo al arduino lo podemos hacer de dos formas,

1º Modo: Conectarlo directamente a los pines de Tx-Rx del arduino.

Para ello solo tendremos que conectar el pin Tx del dispositivo bluetooth al Rx del arduino, y el Rx de la comunicación bluetooth al Tx del arduino. El problema que tiene este montaje, es que eliminamos la posibilidad de utilizar el monitor del ide del arduino para depurar el programa. Otro inconveniente que tiene, es que para poder programar el arduino, el bluetooth no puede estar conectado a la placa del arduino.

[singlepic id=34 w=320 h=320 float=center]

2º Modo: Conectarlo a cualquier pin y utilizar la librería “Software Serial”

Otra forma de conectarlo es utilizar las funciones que nos ofrece la librería “Software serial”, para poder hacer que, cualquier pin del arduino, pueda funcionar como un puerto serie. Lo único que tenemos que tener en cuenta es que el pin donde este conectado el Tx del bluetooth sera el pin Rx, y donde este el Rx sera el Tx

[singlepic id=35 w=320 h=320 float=center]

Como programarlo

La programación es muy sencilla. Solo tendremos que crear una variable para poder manejar el puerto serie.

Si lo conectamos directamente a los pines Rx-Tx del arduino solo tendremos que poner

  Serial.begin(9600);

Si lo hacemos con la librería “Software Serial” tendremos que crear el puerto y luego inicializarlo

// Creamos el puerto serie, le pasamos los pines que serán 
// Tx (donde esta conectado en Rx del bluetooth)
// y Rx (donde esta conectado el Tx del bluetooth)
SoftwareSerial miPuetoSerie =  SoftwareSerial(rxPin, txPin);

// Y lo inicializamos como cualquier puerto serie
miPuetoSerie.begin(9600);

Con esto ya tenemos establecida la comunicación bluetooth con el arduino.

Para leer los datos mediante la comunicación bluetooth utilizaremos en los dos casos

char unChar = miPuertoSerie.read();

Y para escribir utilizaremos

miPuertoSerie.print("Información a enviar");

Ejemplo de funcionamiento bluetooth HC-05/HC-06 y arduino

Ejemplo de funcionamiento, enciende el led del arduino, pin 13, cuando recibe a través de la comunicación bluetooth un “1”, y lo apaga cuando recibe un “0”

#include <SoftwareSerial.h>

#define rxPin 10
#define txPin 11
#define ledPin 13

// configura un nuevo puerto
SoftwareSerial miPuertoSerie =  SoftwareSerial(rxPin, txPin);

int unChar;

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

void loop() {
  // escucha la llegada de nuevos datos serie:
  char unChar = miPuertoSerie.read();
  // imprime el caracter:
  if (unChar > 0) {
    switch (unChar) {
      case '1':
        digitalWrite(ledPin, HIGH);
        miPuertoSerie.write("Led encendido");
        break;
      case '0':
        digitalWrite(ledPin, LOW);
        miPuertoSerie.write("Led apagado");
        break;
    }
  }
}

Para probarlo, solo tendremos que enlazar nuestro teléfono, ordenador, etc. al dispositivo de comunicación bluetooth, en el caso del HC-05 aparece como “HC-05” y en el caso del HC-06 como “linvor” o “HC-06”. Y, con un programa de terminal, mandar un “1” o un “0”.

En mi caso lo probé con mi teléfono y la aplicación “BlueTerm”.

Como conseguirlo

HC-05: KKmoon Wireless Bluetooth Maestro y Esclavo HC-05 del módulo de transceptor para Arduino ARM DSP PIC

HC-06: XINTE Inalámbrica Bluetooth Serial esclavo módulo HC-06 apto para Arduino

Arduino: Arduino Uno R3

Protoboard: 2860 Tiepoint Protoboard Sin Soldadura Incluye Jumpwires

Protocolo I2C y Arduino

El protocolo I2C, define las reglas de como podemos conectar diferentes dispositivos entre si, desarrollado por Philips en la década de los 80/90, convirtiéndose en la actualidad como un estándar. I2C crea un bus de comunicación entre los diferentes dispositivos en serie, esto nos permite conectar hasta 1000 dispositivos uno detrás de otro. La comunicación siempre se realizara entre dos dispositivos, uno actuara de maestro, este es el que trasmitirá la señal para sincronizar la transferencia de datos, y el otro de esclavo. El que hace de maestro, no tiene por que hacer esta función siempre, puede ir pasándose de uno a otro, aunque no todos los periféricos tienen esta funcionalidad, están diseñados para ser siempre esclavos.

Para identificar que periférico a enviado la información, cada uno de ellos tiene una dirección única, igual que una red de ordenadores donde cada ordenador tiene sus propia dirección.

El bus I2C consta de 3 lineas, SDA ( datos), SCL (reloj) y GND (masa)

  • SDA: Es la linea por donde circulan los datos, formateada de la siguiente forma:
    | start | A7 A6 A5 A4 A3 A2 A1 R/W | ACK | … DATA … | ACK | stop | idle |
  • SCL: Por esta linea va la señal para sincronizar las transferencias de datos.
  • GND o masa: Se utiliza como referencia de voltaje para el calculo de las otras lineas.

I2C y Arduino

Arduino cuenta la posibilidad de poder manejar comunicaciones I2C. Según el modelo de Arduino que tengamos, los pines de SDA y SCL, varían, En el caso del Arduino UNO los pines son: para SDA es el pin A4, y el SCL es el pin A5, para el LEONARD estos vienen marcados como tales, y en caso de MEGA el pin para el SDA es el pin digital 20 y para SCL es el pin digital 21.

[singlepic id=31 w=480 h=480 float=center]

Para el manejo de comunicaciones I2C en Arduino debemos importar la librería “Wire.h” ha nuestro programa. Esta librería esta incluida con las básicas que trae el programa de Arduino.

 Ejemplo con dos Arduinos

Ejemplo de como podemos unir dos Arduinos a través de una comunicación I2C. Uno de los Arduinos sera el maestro y el otro el esclavo.

Esquema de conexionado

[singlepic id=32 w=480 h=480 float=center]

Código fuente para el Arduino maestro:

#include <Wire.h>

void setup()
{
  Wire.begin();                // Iniciamos la comunicacin I2C, en el maestro la direccion no es obligatoria
  Serial.begin(9600);          // Iniciamos la comunicacion por el puerto serie para mostrar los datos

}

void loop()
{
  Wire.requestFrom(1, 12);       // Manda una peticion al escaldo numero 2 de 6 bytes

  while(Wire.available())       // Miestras tengamos datos en el buffer seguimos leyendo
  {
    char Datos = Wire.read();       // Leemos un byte y lo pasamos a una variable de tipo char
    Serial.print(Datos);            // Lo mostramos en el puerto serie
  }

  delay(60000);                  // Esperamos 1 minuto para volver a pedir informacin al esclavo
}

Código para el Arduino que hace las funciones de esclavo

#include <Wire.h>

void setup()
{
  Wire.begin(1);                // Nos añadimos al bus como esclavo, con la direccion 1
  Wire.onRequest(requestEvent); // Registro de eventos
}

void loop()
{
  delay(100);                    // retraso de 100 milisegundos
}

// Funcion que se ejecuta cuando recibe una peticion desde el maestro

void requestEvent()
{
  Wire.write("Hola maestro");   // Responde a la peticion del maestro de enviarle 12 bytes
}

Como descubrir el puerto arduino con Python

[singlepic id=20 w=320 h=240 float=right]Cuando desconecto y vuelvo a conectar el Arduino (Arduino Uno R3), el Ubuntu dependiendo si se ha enterado o no que lo he desconectado, al volver a conectarlo me lo instala en otro puerto, con lo que tengo que decirle al programa cual es el nuevo puerto. Para solucionar esto y aprovechando la librería PySerial y la función “try”, podemos descubrir donde esta instalado el puerto Arduino. Para ello solo tenemos que probar los puertos que posiblemente pueda estar utilizando el Arduino. Si al intentar abrir el puerto arduino nos da error, eso es que el Arduino no esta instalado en ese puerto. Gracias a la función “try”, controlamos ese error que se ha producido y podemos seguir con el funcionamiento normal de nuestro programa. Cuando al abrir el puerto no nos da error, eso quiere decir que en ese puerto hay algún dispositivo instalado. si solo tenemos el Arduino instalado ya tendremos el puerto Arduino y podemos salir del bucle y guardar el puerto.

Descubrir el puerto arduino

Código de ejemplo en Python:

#! /usr/bin/env python

# Importamos la libreria PySerial
import serial

# Varialbe para saber si hemos encontrado el puerto o no
bEncontrado = False
# Hacemos un bulce para recorrer los puertos que queremos comprobar
for iPuerto in range(0, 4):
    try:
        # Puerto que vamos a probar
        PUERTO = '/dev/ttyACM' + str(iPuerto)
        # Velocidad 
        VELOCIDAD = '9600'
        # Probamos ha abrir el puerto
        Arduino = serial.Serial(PUERTO, VELOCIDAD)
        # si no se ha producido un error, cerramos el puerto
        Arduino.close()
        # cambiamos el estado del la variable para saber si lo hemos encontrado
        bEncontrado = True
        # Salimos del bucle
        break
    except:
        # Si hay error, no hacemos nada y continuamos con la busqueda
        pass

# Si encontramos el puerto?
if bEncontrado:
    # Mostramos el puerto donde esta el arduino
    print('el puerto del arduino es: ' + '/dev/ttyACM' + str(iPuerto))
else:
    # Si no lo encotramos mostramos el mensaje de no encontrado
    print('No se ha encontrado Ardunio')

Aunque este código es de Python, el portarlo a cualquier otro lenguaje es muy sencillo, por lo básico de su planteamiento, lo único que podrida complicar el código seria las funciones que se tengan que utilizar para la apertura del puerto serie, por lo demás, el resto de funciones están disponibles en cualquier lenguaje.

Leer el puerto serie de Arduino con Python y PySerial

[singlepic id=20 w=320 h=240 float=right]Desde hace ya un tiempo he hoy buenos comentarios sobre Python y lo “fácil” que es programar con él, su potabilidad entre sistemas, etc. Me he puesto ha ello, y la verdad es que es muy fácil programar con él, después de un rato, se le coge el tranquillo a esa forma tan peculiar de escribir el código que tiene, solo utilizando tabulación, sin puntos y comas, llaves o cualquier otra forma de indicar el inicio y el fin de las lineas,  a la declaración de las variables, mejor dicho a la no declaración, la formar de trabajar con las funciones, etc. En general es un lenguaje muy fácil de trabajar y encima puedes hacer verdaderas locuras con el. Me ha recordado mucho al Basic que aprendí ya hace muchas lunas.

Para empezar, que mejor que trabajar con Arduino. Lo primero que he hecho es leer del puerto serie la información que escribe el Arduino.

Para el Arduino solo le he metido un código muy simple, genera un numero aleatorio, de -100 a 100,  y lo escribe en el puerto serie.

Codigo para Arduino

int x = 0;    // variable

void setup() {
  Serial.begin(9600);      // abre el puerto serie a 9600 bps:    
}

void loop() {

  Serial.println(random(-100, 100)); // Escribe en el puerto un numero aleatorio de -100 a 100
  delay(2000);
}

Y en Python lo que he hecho es aprovechar la librería PySerial que hay para Python para leer el puerto y leer los datos que escribe el Arduino.  Para instalar la librería PySerial es muy fácil, solo tenemos que seguir los pasos que hay en la propia pagina de PySerial.

El código en Python es muy simple, este mismo código en Java, me llevo bastante tiempo pelearme con la librería RxTx, en cambio en Python es tan sencillo como escribir el siguiente código.

Código Pytho

#!/usr/bin/python

# Importamos la libreira de PySerial
import serial

# Abrimos el puerto del arduino a 9600
PuertoSerie = serial.Serial('/dev/ttyACM0', 9600)
# Creamos un buble sin fin
while True:
  # leemos hasta que encontarmos el final de linea
  sArduino = PuertoSerie.readline()
  # Mostramos el valor leido y eliminamos el salto de linea del final
  print "Valor Arduino: " + sArduino.rstrip('\n')

Después de este código tan simple, ya tenemos un programa que nos lee los datos del puerto serie y lo muestra en pantalla. Esto con cualquier otro lenguaje te lleva un buen rato. Esto no me ha llevado mas de media hora de buscar por internet como se programa en Python y como funciona la libreria PySerial.

Que opinas de ello???

Problemas con el puerto de Arduino en Ubuntu (Linux)

[singlepic id=1 w=320 h=240 float=right]En un sistema linux, no todos los usuario pueden tender acceso a poder manejar los puertos. Solo los usuarios que estén en el grupo “dialout” tiene permiso para manejar los puertos. Lo normal es que nuestro usuario no este dentro de ese grupo, por lo que tendremos problemas para poder acceder al puerto que crea el arduino. Para solucionar este problema solo tendremos que añadir nuestro usuario al grupo “dialout” de la siguiente manera.

sudo usermod -a -G dialout <NombreDeUsuario>

Nos pedirá la contraseña de root. y con esto, nuestro usuario ya sera miembro del grupo “dialout”.

Ya solo nos queda cerrar la sesión para que los cambios efectuados tenga efecto y podamos acceder al puerto del Arduino desde nuestro usuario.

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.

Mi primer contacto con Arduino

Ya me ha llegado mi placa de Arduino, me he decido por el modelo mas normal, el Arduino UNO, en la versión SMD, Entre las diferencias que he podido observar con respecto a la otra versión del arduino UNO rev. 3, es que esta, el procesador es la versión de soldadura en superficie, mucho mas pequeño en tamaño que el que viene en la versión normal, Arduino UNO Rev. 3, y la disposición de alguno componentes, como puede ser el botón del reset, pero ha efectos prácticos,  son iguales.

Imagen del Arduino UNO versión SMD[singlepic id=11 w=320 h=240 float=center]

Imagen del Arduino UNO versión Rev. 3[singlepic id=12 w=320 h=240 float=center]

Para tener un primer contacto con el, he probado el típico “Hola mundo” pero para un arduino, es decir, encender y apagar un led. Hay varias formas de hacer esta prueba.

1º.- Encender y apagar el led que trae la propia placa, este led esta conectado al pin 13, solo tendremos que hacer que nuestro programa mande la señal necesaria por ese pin y el led se encenderá o se apagara.

2º.- Instalar nuestro propio led al pin 13, solo tendremos que insertar la patilla del positivo (ánodo, la patilla más larga) en el pin 13 y la patilla del negativo (catado, la patilla más corta) en el pin de masa, el pin a la izquierda del pin 13, no hace falta poner la resistencia que se necesita para hacer funcionar cualquier led normalmente, este pin aprovecha la resistencia que tiene para el led que viene en la placa para hacerlo funcionar. Y ya estaría listo, ejecutamos el mismo programa que en el caso anterior y ya lo tendríamos funcionando. En este caso se encenderían los 2 leds, tanto el que acabamos de instalar nosotros, como el que trae la propia placa.

3º.- Instalar nuestro propio led en un pin que no sea el 13, en este caso la única diferencia que tenemos con respecto a los casos anteriores, es que tendremos que instalar junto al led la resistencia necesaria, en este caso, una resistencia de 220 oh. Cambiamos en nuestro programa el pin 13 por el pin donde tenemos conectado nuestro led y a funcionar.

Código para encender y apagar un led  cada 1 seg con el Arduino.

/* Blinking LED
 * ------------
 *
 * turns on and off a light emitting diode(LED) connected to a digital  
 * pin, in intervals of 2 seconds. Ideally we use pin 13 on the Arduino 
 * board because it has a resistor attached to it, needing only an LED

 *
 * Created 1 June 2005
 * copyleft 2005 DojoDave <http://www.0j0.org>
 * http://arduino.berlios.de
 *
 * based on an orginal by H. Barragan for the Wiring i/o board
 */

int ledPin = 13;                 // LED conectado al pin digital 13

void setup()
{
  pinMode(ledPin, OUTPUT);      // Establecer el pin a modo salida
}

void loop()
{
                                // Este ciclo se repetira hasta que se apage el Arduino
  digitalWrite(ledPin, HIGH);   // Encender el LED
  delay(1000);                  // Esperar un segundo
  digitalWrite(ledPin, LOW);    // Apagar el LED
  delay(1000);                  // Esperar un segundo
}

Este programa esta en el menú de ejemplos del software del Arduino.

Y de momento es todo. Espero que te haya servido de ayuda.

Arduino, ¿que es y para que vale esa cosa?

Desde hace mucho tiempo había oído hablar de este aparato, que si era hardware de código libre, que si era muy fácil de manejar, que te permitía controlar multitud de componentes electrónicos  etc.  Como siempre me ha gustado manejar cosas mediante el ordenador, me decidí a probarlo.

Pero, ¿que es Arduino?

[singlepic id=12 w=320 h=240 float=right]Según la Wikipedia “Arduino es una plataforma de hardware libre, basada en una placa con un microcontrolador y un entorno de desarrollo, diseñada para facilitar el uso de la electrónica en proyectos multidisciplinares”. Es decir, es una placa que nos permite conectar determinados componentes electrónicos, procesar los datos que nos dan y realizar determinadas tareas con esa información, posee entradas y salidas tanto analógicas como digitales. En el caso del Arduino no tenemos por que tenerlo siempre conectado al ordenador, dispone una entrada de corriente propia que lo hace autónomo, ademas de tener su propia memoria donde poder almacenar tanto la información que va generando, como el programa para manejar esa información. Y si le añadimos algún modulo extra, la información nos la puede mandar al ordenador a través del Internet. Pero lo primero que me llamo la atención, al buscar más información de este aparato, fue su precio, en la pagina de Rs-Online, por ejemplo, se puede comprar uno por unos 21€, o en la pagina de BricoGeek por 22€,  o en la pagina de Cookig Hacks, el mas caro de las tres, pero con una amplia gama de accesorios disponibles, por 24€. Por ese precio no hay que pensárselo demasiado para querer probarlo. La otra cosa que me llamo la atención era la cantidad de módulos y accesorios que hay disponibles. El modulo que mas me impresiono fue  el de Ethernet, con este modulo podemos conectar el arduino directamente a la red mediante un clave de red normal, y poder ver la información a través de la red, al conectar el ardunio con este modulo, este nos instala un servidor web donde podremos ver toda la información en una pagina web, también podemos personalizar estas paginas, para poder ver la información como nosotros queramos. Otros módulos que hay disponibles nos permite conectar un módem GPRS, un módem WIFI, bluetooth, etc.

¿Que características tiene la versión básica de Arduino?

[singlepic id=13 w=320 h=240 float=right]La versión que he decido comprar es la que podemos decir que es la basica, el Ardunio UNO, en mi casa la versión rev.3. Este viene con un procesador Atmega328, tiene 14 entradas/salida, de las que 6 podemos utilizar como salida PWM, no se muy bien lo que son este tipo de salidas, pero por lo visto se pueden manejar motores de paso a paso con ellas, si no estoy equivocado, tengo que buscar mas información sobre ello. Cambien tiene 6 entradas analógicas  un oscilador de 16 Mhz, conexión al ordenador por USB, pulsador de reset y un conectar para poder alimentarlo se necesidad de estar conectado al ordenador y por si los componentes instalados en el consumen mas de lo que nos ofrece el conector USB. Ofrece también conectores para poder alimentar la electrónica que añadamos de 5 y 3.3 voltios.

¿Que podemos hacer con el Arduino?

[singlepic id=15 w=320 h=240 float=right]No hace falta buscar mucho para ver la amplia gama de posibilidades que nos ofrece este aparato, desde el aprendizaje de electrónica o robótica, hay muchos centros de enseñanza que lo utilizan para dar clases con ellos, hasta realizar todo un complejo sistema de domótica que pueda controlar cualquier cosa de nuestra casa, oficina, etc. La aplicación que mas me ha impresionado a sido una impresora que imprime en 3D, eso demuestra que el limite que tiene el arduino es la imaginación que la persona que trabaja con el tiene.

Así, viendo lo versatilidad que ofrece, la amplia información que hay disponible sobre él y el precio que tiene. Tendremos que hacernos con uno.

¿Que te parece el aparato?