Mostrando entradas con la etiqueta arduino. Mostrar todas las entradas
Mostrando entradas con la etiqueta arduino. Mostrar todas las entradas

sábado, 21 de septiembre de 2013

Corazón de acrílico y leds RGB

Hacía tiempo que quería jugar un poco con leds RGB y hacer alguna manualidad, por eso me decidí a hacer un corazón con acrílicos, y utilizar los leds RGB y un Atmega328 (Arduino) para poder crear una transición de colores suave que refleje en los bordes del acrílico.
Para empezar, los leds RGB como su nombre indica (en inglés,  Red Green Blue), son diodos leds que tienen 4 patillas,  pudiendo tener 3 ánodos para los tres colores (rojo, azul y verde) y un cátodo común a los tres o bien 3 cátodos para cada color y un ánodo común. Veamos:
A partir de los colores rojo, verde y azul, combinando entre ellos podemos crear nuevos colores como pueden ser amarillo, violeta, celeste o blanco, por lo que son muy versátiles para realizar pequeños y coloridos proyectos. Así que sabiendo que son los leds RGB, vamos a la construcción del corazón de acrílico y más tarde volvemos a los leds.
Sigue leyendo!

Para empezar la construcción de un corazón o cualquier figura de acrílico, lo más importante (además del propio acrílico), es una dremel con mini-discos de lija de grano medio para poder recortar el acrílico a nuestro gusto.
Procedemos a cortar el acrílico (recomendable tener gafas de seguridad ya que el acrílico se derrite y saltan pedazos)  de la forma que queramos, en mi caso un corazón por duplicado, para poder introducir una fotografía en medio.
Ya puestos con el acrílico, yo aproveché para realizar una base para el corazón, una cajita de acrílico también, de modo que queden las siguientes partes:
Corazón y caja de acrílico
Una vez tengamos listo el corazón de acrílico y las piezas para montar la cajita que servirá como base para el corazón, procedemos a montar la caja, en mi caso utilizando silicona caliente para armar la cajita donde irá el circuito, realizando 2 agujeros de 5 mm en la tapa superior de la caja para introducir los leds y colocar encima de estos, el corazón.
Para un mejor acabado, recomiendo utilizar una lija de grano fino, para lijar los bordes del corazón, de modo que queden difuminados y la luz de los leds “choque” contra estos, haciendo que brillen los bordes y creando un efecto muy bonito.
Ya con la parte manual terminada, procedemos con la electrónica, para la cuál utilizando un Arduino y PWM (Modulación de ancho de pulso), podemos realizar transiciones de colores lentas y suaves y combinar los distintos colores de un led RGB para crear colores nuevos.
Pero… ¿Qué es el PWM? Según nuestra amiga la wikipedia:
La modulación por ancho de pulsos (también conocida como PWM, siglas en inglés de pulse-width modulation) de una señal o fuente de energía es una técnica en la que se modifica el ciclo de trabajo de una señal periódica (una senoidal o una cuadrada, por ejemplo), ya sea para transmitir información a través de un canal de comunicaciones o para controlar la cantidad de energía que se envía a una carga.
Visto así, no se entiende mucho, y sin entrar en mucho detalle, las salidas PWM del Arduino nos sirven para controlar la cantidad de energía que se envía a una carga, en este caso a los leds, por lo que a través de ellas podemos ir aumentando la intensidad que atraviesa los leds para ir aumentando la luminosidad de estos de forma gradual.
Una placa de Arduino UNO, solo dispone de 6 salidas PWM y como los leds RGB (de cátodo común necesariamente) tienen 3 patillas de colores, solamente podemos controlar 2 leds. Para conectarlos, lo haremos de la siguiente manera:
Las salidas digitales Nº 3, 5, 6, 9, 10 y 11 son las únicas salidas PWM de las que dispone el Arduino UNO por lo que esas utilizaremos para controlar los dos leds. Para controlar un led mediante PWM, podemos utilizar como ejemplo el sketch “Fading” que viene de ejemplo en el IDE de Arduino, o descargar del siguiente enlace el código que usé yo con el corazón.
- Código Arduino:  RGB_Colores.pde
Podemos utilizar la propia placa de Arduino para el montaje final, aunque también podemos optar por retirar el microcontrolador Atmega328 programado y preparar una placa PCB específica con un regulador de tensión 7805 para poder alimentarlo con una pila de 9V, las conexiones para los leds, y un interruptor para encenderlo y apagarlo.  En mi caso opté por crear una PCB aparte (Gracias a Dani!):
PCB Atmega 328 + Leds RGB
Aquí dejo el esquema electrónico para el que quiera realizar la misma placa que he realizado yo, es decir, el ATmega328 quitarlo del Arduino y ponerlo en una PCB casera.
Y al que no quiera diseñar su propia PCB, aquí dejo los archivos para OrCAD 10.5 con mi diseño de la PCB, descargar en este enlace: PCB OrCAD
Ya simplemente procedemos a colocar la placa dentro de la cajita realizada previamente, y a colocar los leds en los agujeros hechos en la tapa superior de la caja, de modo que colocando el corazón encima de los leds, al encenderlos se iluminen los acrílicos y los bordes.
Terminado el montaje, nos queda un fantástico regalo bonito y barato para regalarle a la novia.
Corazón terminado y funcionando
Y como siempre… una prueba de funcionamiento!

Arduino + Shield Tarjeta SD

Volvemos con Arduino! y esta vez con un elemento que ofrece muchas posibilidades a nuestros proyectos! Un shield casero para lectura/escritura de tarjetas SD con arduino!
Primero, hablemos un poco sobre tarjetas SD: ¿Qué son? ¿Para qué sirven? y muy importante para trabajar con Arduino, ¿Cómo se comunican?
¿Qué son las tarjetas SD y para qué sirven? Me sirvo de Wikipedia para explicar un poco.

SD (Secure Digital) es un formato de tarjeta de memoria
no-volátil
 inventado por Panasonic allá por 1999.
Son tarjetas de pequeña dimensión, que permiten el almacenaje de datos en todo tipo de dispositivos de hoy en día, como cámaras fotográficas, teléfonos móviles, PDA’s, etc.
Su tamaño ha ido creciendo con los años, hasta hoy en día donde ya se comercializan tarjetas SD de hasta 128 Gigabytes.
Existen dos tipos de tarjeta dependiendo de la velocidad a la que trabajan, las SD y las SDHC que tienen tasas de transferencia de datos más altas.
Son muy utilizadas a día de hoy por la gran ventaja que nos suponen, pudiendo obtener una gran capacidad de almacenamiento de datos a un muy bajo precio.
Veamos cómo se comunican las tarjetas SD para poder interactuar con Arduino!
¿Cómo se comunican las tarjetas SD?  Sigue leyendo!Las tarjetas SD poseen dos protocolos de comunicación que son:
Bus SD: Utiliza transferencias paralelas de 4 bits.
SPI (Serial Peripheral Interface): Interfaz de Periféricos Serie.
Este último es el que nos interesa a nosotros ya que comunicaremos la tarjeta SD con Arduino utilizando el protocolo de comunicación SPI. En Wikipedia está bien explicado:
El Bus SPI es un estándar de comunicaciones usado principalmente para la transferencia de información entre circuitos integrados en equipos electrónicos. Sirve para controlar casi cualquier dispositivo electrónico digital que acepte un flujo de bits serie regulado por un reloj.
Este protocolo funciona con una configuración Master-Slave (maestro-esclavo), donde en nuestro caso el Arduino será el maestro, y la tarjeta SD será el esclavo. Veamos:
CLK (Línea de reloj): Es la señal de reloj.
- MOSI (MasterOut-SlaveIn): Línea por donde el maestro envía y el esclavo recibe.
- MISO (MasterIn-SlaveOut): 
Línea por donde el maestro recibe y el esclavo envía.
- CS (Chip Select)/ SS (Slave Selector): Conecta o desconecta la operación del dispositivo con el que comunicamos. Permite la comunicación de varios esclavos a un mismo maestro, multiplexando la señal de reloj.
El maestro configura la velocidad de transmisión a la máxima permitida por el esclavo, y seguidamente pone a nivel bajo la señal “Selector Slave” para indicarle que va a comunicar.
Durante cada ciclo de reloj se produce una comunicación bidireccional, ya que por una parte el maestro va a enviar bits en serie (MOSI) y el esclavo a recibir, mientras que a la vez el esclavo va a enviar bits en serie (MISO) para que el maestro lo reciba.
Al terminar la comunicación el maestro coloca a nivel alto la señal SS y para la señal de reloj.
Arduino Shield casero para tarjetas SD
Como vemos en la imagen de Maestro-Esclavo, necesitamos 4 líneas de conexión para establecer la comunicación SPI, así que vamos a identificar dichas conexiones tanto en el Arduino como en la tarjeta SD.  Veamos el pinout de una SD:
Identificados los pines de la tarjeta SD, tenemos que saber donde conectarlos en el Arduino UNO, los pines de conexión del bus SPI son los siguientes:
- Pin digital 4 – CS / SS (En librería Arduino SD / Este pin es configurable vía software)
- Pin digital 11 – MOSI
- Pin digital 12 – MISO
- Pin digital 13 – CLK  
Los pines 8 y 9 de la tarjeta SD, no se conectan ya que son necesarios solamente si utilizaramos el protocolo BUS SD, que utiliza 4 líneas de bits en paralelo para comunicar.
Ya sabemos como conectar, pero nos surje un pequeño problema, y muy importante!
Las tarjetas SD funcionan a un voltaje comprendido entre 2,7V y 3,3V máximo! 
Por lo que no podemos conectar la tarjeta directamente al Arduino, ya que los pines digitales funcionan a 5V y quemaríamos la SD.
A partir de aquí hay varias opciones, podemos utilizar un divisor de tensión con resistencias, utilizar circuitos integrados como el 74HC4050 que regula el voltaje a 3.3V, o bien, comprar un shield ya montado, en cuyo caso no sigas leyendo a partir de aquí. (xD)
El modo más barato, es utilizar un divisor de tensión con resistencias, que es el que he utilizado yo, por lo que hay que calcular el valor de las resistencias para obtener una salida de 3,3V a partir de una entrada de 5V, mediante la siguiente fórmula:
Vamos a suponer el valor de R2 y así simplemente tenemos que despejar R1. (R2 = 2k2)
Sabemos Vin = 5V (De los pines digitales del Arduino), R2 = 2k2 y Vout = 3,3V (La tensión de salida que queremos conseguir). Despejamos R1 y nos sale que R1 = 1133 Ω que como no es un valor normalizado, usamos 2 resistencias en serie de 1k + 100 Ω.
Si presuponemos otro valor de R2, al hacer los cálculos obtendremos otro valor de R1, podemos conseguir 3,3V con muchas combinaciones distintas de valores de resistencias.
Estos divisores no son de lo más estable y no siempre se consigue el voltaje de salida deseado debido a las tolerancias de las resistencias, pero suele ser muy cercano al que necesitemos. Hacemos la prueba, medimos y el valor es “perfecto”:
Midiendo el voltaje de salida del divisor de tensión
Así que conseguido el divisor de tensión necesario para conectar la tarjeta SD con Arduino, procedemos a crear el circuito. Los materiales necesarios son:
- Slot para tarjetas SD
- 3x Resistencias 2k2
- 3x Resistencias 1k
- 3x Resistencias 100 Ω
- Placa perforada o placa de cobre a elección de cada uno.
- Conector de tira de pines hembra.
- Cables.
Y el circuito en cuestión es…  (Descarga el esquemático en OrCAD: SD Shield)
Procedemos al montaje como cada uno desea, y fin!! Ya tenemos un SD Shield para poder dotar de almacenamiento a nuestros proyectos!
Es muy importante que las tarjetas SD estén formateadas en formato FAT16 para poder trabajar con Arduino!Normalmente es el tipo de formato que traen por defecto, pero en caso de no ser así, habría que formatearlas.  
Aquí unas fotos del resultado del mío, como estoy sin impresora, las placas perforadas apañan a uno muy bien:
SD Shield 1
SD Shield 2
SD Shield 3
SD Shield 4
Arduino trae por defecto una librería específica para trabajar con tarjetas SD, por lo que podemos utilizar los ejemplos que trae que son muy interesantes, como crear un archivo de texto en la SD, leer y escribir en archivos de texto, etc.
Y esta vez, no hay vídeo de funcionamiento, pero prometo ponerlo pronto! Eso si, hay foto!
Funcionando!
SD Shield Funcionando!

¿Cómo trucar servos Futaba S3003?

Buenas! Hoy toca hablar de motores, y exactamente de servomotores, ya que me encuentro construyendo un robot mini-sumo que utilizará este tipo de motores para moverse.
Pero… ¿Qué son los servomotores y cómo funcionan?
En Wikipedia, vemos una primera definición:
“Un servomotor (también llamado servo) es un dispositivo similar a un motor de corriente continua que tiene la capacidad de ubicarse en cualquier posición dentro de su rango de operación, y mantenerse estable en dicha posición. “
Esto quiere decir, que podemos mover el motor y pararlo en la posición que nosotros queramos, para poder realizar movimientos precisos, incluso controlar su velocidad.
Estos motores se utilizan sobretodo en robótica, modelismo y en sistemas de radiofrecuencia. Normalmente los utilizados en robótica tienen un ángulo de giro limitado (180º) tanto física como electrónicamente aunque existen servomotores de rotación continua (360º) .
Para poder utilizar un servo y controlar su posición y fuerza, utilizamos la modulación del ancho de pulso de una señal (PWM), enviando señales moduladas menores de 100 Hz, por lo que tendrán un período de pocos milisegundos para poder controlar el movimiento del motor.
En el siguiente gif (Univ. de Castilla-La Mancha) podemos ver como funciona un servomotor:
No voy a entrar en el uso del servo con PWM (Quizás en un algún post futuro lo haga) ya queel trucaje que haremos será para utilizar un servomotor de giro limitado (180º) como motor de corriente continua y que tenga un giro de 360º. Veamos como hacerlo.
Sigue leyendo!!
En la siguiente imagen (Klugers.net) vemos el interior de un servo y sus partes:

- Un motor de corriente continua (A la izquierda de la imagen)
Un circuito regulador (A la derecha del motor)
Una serie de engranajes de distintos tamaños que forman la caja reductora del motor
Un potenciómetro (Debajo del engranaje más grande, en la imagen no aparece)
Los motores de corriente continua se caracterizan por girar a mucha velocidad y no tener demasiada fuerza, por lo que para cambiar esto, se le añade una serie de engranajes de gran reducción para limitar las revoluciones por minuto y obtener más fuerza de motor.
El eje del potenciómetro, está directamente unido con el engranaje más grande, con lo que el circuito regulador utiliza el valor del potenciómetro para determinar la posición angular actual del servo, y así saber en que sentido y cuánto tiene que girar.
Bien, ese es el interior del servo y a nosotros nos interesa mucho, ya que para trucar un servo de 180º y que pueda girar a 360º existen 2 maneras:
- Engañando al circuito regulador: Este truco consiste en cambiar el valor del potenciómetro por dos resistencias del mismo valor, pero que serán siempre fijas. De esta manera, al no retirar el circuito regulador, podremos utilizar el servo directamente si necesidad de una etapa de potencia anterior. Podemos ver como realizarlo paso a paso en la siguiente web: Uctrl – Trucar servo.
- Quitando el circuito regulador: Esta otra manera de trucar un servo, es en la que yo me voy a centrar, consiste en quitar el circuito regulador y retirar los topes físicos tanto del potenciómetro como del engranaje mayor. De modo que quede un motor de corriente continua con una caja reductora. Este sistema nos obliga a utilizar una etapa de potencia para poder controlar el motor. Vamos paso a paso:
Los servos que voy a trucar son los siguientes: Futaba S3003 – Enlace Ebay.
Son de precio muy reducido, por lo que tampoco podemos esperar una gran calidad, como veremos a continuación:
1) En primer lugar, retiramos los tornillos de la parte trasera del servo y vemos el circuito regulador y el motor. Cortamos los cables que unen el circuito y el motor y en la otra cara de la plaquita, está soldado el potenciómetro. El potenciómetro está atornillado a la carcasa, esto yo no lo sabía así que para retirar el circuito regulador, hice palanca… partiendo en 2 partes el potenciómetro como vemos en la siguiente imagen.
Esto demuestra la baja calidad del producto pero a su vez, es una ventaja para nosotros, ya que mantenemos el eje del potenciómetro.
Abrimos el servo y retiramos el circuito
2) Una vez retirado el circuito, vemos que el potenciómetro tiene 2 salientes que limitan el giro, por lo que hay que deshacerse de ellas. En la imagen siguiente vemos los salientes con un circulo rojo, debemos cortarlas o levantarlas para que no choquen con la mueca (Cuadrado azul) y así lograr que gire 360º sin problemas. No olvidemos que el eje del potenciómetro está unido al engranaje principal.
Cortar las muecas del potenciómetro y soldar los cables al motor
Una vez conseguido que el potenciómetro gire 360º, vemos en la imagen anterior quepodemos reutilizar el cable del servomotor. Yo he quitado el cable blanco (El cable de señal) y el cable rojo y negro lo soldamos al motor de corriente continua sin importar la polaridad y opcionalmente añadiendo un condensador de filtro para evitar el ruido.
3) Soldados los cables, cerramos la parte trasera del servo y abrimos la parte delantera, veremos los engranajes que forman la caja reductora. Este paso es el último, pero no por ello menos importante: El engranaje principal contiene un saliente que limita el giro. Debemos eliminarlo cortándolo o limándolo con cuidado de no dañar los dientes y tratando de que quede lo más uniforme posible para evitar rozes. Vemos dicho saliente en la siguiente imagen con un círculo rojo.
Limamos el saliente que limita el giro
Una vez terminado colocamos cuidadosamente todos los engranajes y si todo ha ido correctamente, tenemos un servomotor trucado para girar 360º.  Este sistema tiene la desventaja de que necesitaremos una etapa de potencia para hacer girar bien el servo, como puede ser el circuito integrado L293 o un puente en H.
En otro post explicaré como utilizar el integrado L293 con Arduino, aunque al que le haga falta, en este vídeo está muy bien explicado:  Funcionamiento y conexión de L293
Conectamos al Arduino de acuerdo al vídeo siguiente y probamos.
Servomotor Futaba S3003 trucado con Arduino

NanoPhone: Envia SMS con Arduino

Hoy toca volver a hablar de comunicaciones inalámbricas y Arduino! Concretando un poco, del proyecto que me tocó realizar para el 1º trimestre del curso de 2º de D.P.E.:
Un sistema capaz de leer un sensor de temperatura y enviar dichos datos por SMS.
A este sistema, decidí convertirlo en una especie de teléfono móvil, añadiéndole una pantalla LCD a color, un reloj de tiempo real y bautizarlo como “NanoPhone”.
De este modo además del envío del SMS, añadía la posibilidad de visualizar los datos obtenidos tanto del sensor de temperatura, como del reloj, y poder ver la fecha y hora.
Los materiales que he utilizado para realizarlo son: 
  • Placa Arduino UNO
  • Placa Cellular Shield SparkFun
  • Pantalla μLCD-144 (GFX) 4D Systems
  • Reloj RTC DS1307 SparkFun
  • Sensor de temperatura LM35 DZ
Empezamos por el plato fuerte, el envío del SMS, que es lo más interesante del proyecto a mi parecer, ya que nos brinda una nueva posibilidad de comunicación inalámbrica muy potente.
Para poder enviar SMS con Arduino necesitamos de una placa Cellular Shield de SparkFun (Imagen), que es todo un teléfono móvil en potencia.
Esta placa gobernada por el circuito integrado SM5100B, está específicamente diseñada para su encaje en una placa Arduino y es tan completa que con ella podríamos realizar un teléfono móvil con muchas de las características que puede tener un teléfono móvil de hoy en día.
Vamos a ver las funciones principales que utilizo en el proyecto: ¿Cómo se utiliza? 
Empecemos a montar el NanoPhone…
Sigue leyendo!!
La placa Cellular Shield como podemos ver en la imagen, se encaja sobre un Arduino Duemilanove/UNO y se comunica a través de puerto serie.
Como primer paso, deberemos soldar las tiras de 8 y 6 pines de los lados ya que viene sin estos, por lo que no debemos olvidar comprarlos! Y tener mucho cuidado con los movimientos, puesto que el cable de la antena viene sujeto por una triste soldadura sin más.
Una vez que esté listo y montado sobre el Arduino, debemos insertar la tarjeta SIM, y es muy importante, que no tenga código PIN, así procedemos a la configuración inicial.
Configuraremos la conexión con Arduino, como viene por defecto en el sketch de ejemplo que podemos descargar de la web de SparkFun o de aquí mismo: Cellular Shield Passthrough.zip
Analizamos un poco dicho sketch, y vemos que realiza una conexión serie virtual, con la librería NewSoftSerial, utilizando los pines digitales 2 y 3 para la comunicación, dejando libres los pines digitales 0 y 1 del puerto serie que necesitaremos para poder ver el proceso de configuración en el serial monitor. Una vez terminada la configuración podremos utilizar los pines 0 y 1 para conectar cualquier otro dispositivo.
Vemos el código del sketch de configuración inicial de la placa:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
#include <NewSoftSerial.h>; // Librería del puerto serie virtual
#include <string.h>; // Librería para manejo de cadenas
 
char incoming_char=0; // Almacenamos los caracteres recibidos
NewSoftSerial cell(2,3); // Puerto serie virtual en pin 2(RX) y 3(TX).
 
void setup() {
 
Serial.begin(9600); //Inicializamos puertos para la comunicación!
cell.begin(9600);
 
Serial.println("Starting SM5100B Communication..."); // Empezamos!
}
 
void loop() {
 
if(cell.available()>0) // Si el módulo GSM envía un dato...
{
incoming_char=cell.read(); // Almacenamos dicho dato y...
Serial.print(incoming_char); // Lo mostramos por el puerto serie.
}
if(Serial.available() >;0)// Si enviamos un dato por el terminal...
{
incoming_char=Serial.read(); // Almacenamos dicho dato y...
cell.print(incoming_char); // Lo enviamos al módulo GSM.
} }
Vemos que simplemente inicia el proceso de configuración mediante la función “Cell.begin” y se dispone a mostrar cualquier dato que envíe la placa por el puerto serie, para que podamos verlo en el serial monitor y a capturar datos para enviarle a la placa.
Como primer paso, debemos decirle a la placa, qué tipo de red vamos a utilizar, esto depende de cada operador de telefonía por lo que según la tarjeta que vayamos a ponerle al Cellular shield, debemos averiguar que tipo de red utiliza. Yo en mi caso, utilizando Orange, pregunté y utiliza las redes GSM900.
Cargamos el sketch de configuración y abrimos el serial monitor o cualquier otro software de comunicación serie, y procedemos a decirle a la placa el tipo de banda que utilizaremos, mediante el siguiente comando: AT+SBAND=4.
En este caso, 4 significa GSM900, pero dependiendo de la zona y la red que utilicemos varía el número. Esto se ve en la documentación.
Bien, hecho esto la placa empezará a soltar números a diestro y siniestro, y tenemos que conocer los valores de dichos números para saber qué significan. Reiniciamos y veremos esto en el puerto serie:
1
2
3
4
5
6
7
8
Starting SM5100B Communication...
 
+SIND: 1                                            // Inicia la comunicación
+SIND: 10,"SM",1,"FD",1,"LD",1,"MC",1,"RC",1        // SIM detectada.
+SIND: 3                                            // Modulo GSM parcialmente listo.
+SIND: 4                                            // Modulo GSM totalmente listo.
+SIND: 7                                            // Red para llamadas de emergencia
+SIND: 11                                           // Conectado a la red 
Este proceso dura apróximadamente unos 30-40 segundos, y debe terminar en el código +SIND: 11, que nos indica que todo ha ido bien y la placa está correctamente configurada y lista para utilizar. Si algo falla, seguiremos viendo números en el puerto serie, la placa entrará en el bucle de configuración y si hay algo mal configurado no saldrá nunca de ahí, por lo que lo mejor es repetir el proceso desde 0.
Hecho esto, ya podemos llamar o enviar SMS! Yo me voy a centrar en el envío del SMS, pero hacer una llamada es más de lo mismo,  todo se controla mediante comandos a través del puerto serie.
El mismo sketch de configuración nos indica los comandos para envío de SMS y llamada. Preparamos un sketch de Arduino para decirle que envíe un SMS a un número determinado configurado mediante código y lo ejecutamos. Veamos:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
#include <NewSoftSerial.h> // Libreria del Cellular Shield
NewSoftSerial cell(2,3);  // Puerto serie para comunicacion con el modulo GSM
 
char telefonoMovil[] = "XXXXXXXXX";  //Numero de telefono
 
void setup(){
 
 cell.begin(9600);           // Iniciamos el cellular shield
 delay(35000);               // Delay de 35 segundos para inicializacion
 cell.println("AT+CMGF=1");} // Preparamos el modulo GSM para envio de SMS
 
void loop(){
 
 cell.print("AT+CMGS=");     // Numero de telefono entre comillas AT+CMGS="Numero"
 cell.print(34,BYTE);        // ASCII equivalente a las "
 cell.print(telefonoMovil);  // Numero de telefono al que enviamos el SMS
 cell.println(34,BYTE);      // ASCII equivalente a las "
 delay(500);                 // Tiempo de espera.
 cell.print("Aqui va el mensaje que enviaremos!");
 cell.println(26,BYTE);      // ASCII equivalente al Ctrl-Z
delay(15000);                // Tiempo de "descanso" del modulo
while(true) delay(1);  }     // Bucle infinito para no enviar infinitos SMS.  
Vemos que configuramos el número de teléfono mediante un array e iniciamos el programa con una espera de 35 segundos para que se inicie y conecte a la red el cellular shield, y lo preparamos para envío de SMS mediante el comando “AT+CMGF=1″.
Procedemos a mandarle el número al que enviaremos el SMS mediante el comando:“AT+CMGS=”NUMERO”" donde el número deberá ir entrecomillado, por lo que enviamos el comando, seguido de el ASCII 34, que corresponde a las comillas, luego el número, y cerramos con unas comillas nuevamente. Luego el mensaje de texto a enviar y por último para terminar, Ctrl-Z, cuyo ASCII es el 26.
Podemos ver toda la documentación, esquemáticos, comandos, etc en la web de SparkFun:Cellular Shield SM5100B
Así, enviamos un SMS con Arduino, con un par de funciones, podemos enviar datos a cualquier parte del mundo.
Sigamos con el montaje del NanoPhone. 
Para hacerlo más interactivo, incluí una pantalla a color µLCD-144 de 4D Systems, utilizandola en modo GFX mediante un interfaz serie TTL, por lo que la conectaremos a los pines del puerto serie del Arduino, digitales 0 y 1.
Este modo es el más sencillo de utilizar y mediante la librería displayshield4d de BricoGeek.com podemos escribir con distintos tipos de fuentes y tamaños, dibujar formas geométricas, elegir el color del fondo, texto y formas, etc.
La forma de conectarla es la siguiente:
Mediante la librería, instanciamos una pantalla LCD y simplemente hacemos llamadas a las funciones que nos permitan escribir, dibujar o cambiar los colores.
Podemos ver una review más completa sobre la librería y la pantalla en el siguiente articulo de BricoGeek: Ejemplo con Arduino y pantalla LCD.
Para poder navegar mediante el menú del teléfono, utilizamos 2 botones tipo switch 12mm con circuito “Pull-down”, de modo que a partir de la pulsación de estos botones, podamos elegir en el menú la opción que queramos, ya sea visualizar la temperatura, la hora, o enviar un SMS pudiendo elegir el número de teléfono al que queramos enviar el SMS.
El sensor de temperatura utilizado, el LM35DZ  es un circuito integrado de precisión capaz de obtener datos de temperatura en grados centígrados en un rango entre -55 °C y + 150 °C.
Su pinout se compone de los pines de alimentación +5Vcc, GND y una salida de datos que provee una tensión lineal de 10 mV por grado centígrado.
Conectaremos la salida a un pin analógico del Arduino y haremos la conversión mediante la siguiente función:
1
2
3
4
5
6
#define lm35 A0   // Pin analógico del sensor de temperatura
 
void recojeTemperatura()
{
float temperatura = (5.0 * analogRead(lm35) * 100.0 ) / 1023.0 ;
Así obtenemos la temperatura y podemos mostrarla por pantalla o enviarla por SMSya que es el objeto final de este proyecto.
Como retoque final, también he añadido un Reloj en tiempo real DS1307 de SparkFun, aunque este lo explicaré más adelante en otro post, incluyendo el proceso para diseñarlo, montarlo,  y configurarlo nosotros mismos. :)
Una vez montado todo, en mi caso, diseñé una placa de entradas y salidas donde conectar el LM35, la pantalla LCD, el RTC DS1307 y los botones, que encajara en Arduino, de modo que quedase todo montado de la siguiente manera:
Todos los elementos conectados a la placa de entradas y salidas, ésta se encaja en la placa cellular Shield, y por último, encajamos el cellular shield en Arduino. La alimentación de todos los elementos dependerá únicamente de la alimentación del Arduino, por lo que alimentando éste último, alimentamos a todo el conjunto. 
Una especie de caja de acrílico  y una antena de una tarjeta de red Wi-fi completa el sistema.
Esquema del diseño del NanoPhone :)
Así como en este caso, el fin del proyecto era enviar los datos de la temperatura mediante SMS para poder tener conocimiento de la temperatura en establecimientos como invernaderos, campos agrícolas, industrias, plantas de producción, etc, la placa cellular shield junto con Arduino nos permiten realizar infinitos tipos de aplicaciones.
Una de las aplicaciones más interesantes es conectar un módulo GPS a Arduino y recibir la posición global mediante SMS al realizar una llamada al cellular shield, de modo que si lo incluimos en nuestro coche podamos conocer la posición exacta cuando queramos.
Aquí dejo los vídeos de las pruebas de funcionamiento de todos los elementos por separados y por último el vídeo final del NanoPhone montado y funcionando! :)  
Menú y selección – uLCD-144 + Arduino
Temperatura y hora en uLCD-144 con Arduino
uLCD + Cellular Shield + Arduino: NanoPhone en protoboard
NanoPhone: Enviando SMS con Arduino!