Enseñando scratch a alumnos de M2

Este año estoy combinando mi trabajo como IT Manager con el de profesor de IT. La idea de enrolarme en el apartado académico surgió a raiz de una encuesta que se le envió a los alumnos preguntándoles qué cosas relacionadas con las nuevas tecnologías les gustaría aprender; ya que algunos de ellos apuntaron que les gustaría aprender a programar, me puse a buscar de qué forma podía enseñar programación a alumnos de entre 12 y 13 años.
La respuesta la encontré en un software desarrollado por el MIT y que otras universidades como Harvard (https://www.cs50.net/) utilizan para introducir a sus alumnos en el desarrollo de aplicaciones, se llama scratch y es completamente gratis para descargar y para usar, además está disponible para los principales sistemas operativos (windows, macs y linux).

Scratch permite introducir a los alumnos en el mundo de la programación utilizando una especie de pseudocódigo en formato visual, es decir, prácticamente no tenemos que escribir nada simplemente utilizaremos una serie de comandos que vienen presentados en forma de bloques, estos bloques encajan entre sí para formar "funciones" más o menos complejas.


En internet hay muchísimos tutoriales sobre scratch, en la mayoría de ellos te van explicando poco a poco los diferentes comandos y secciones, sin embargo, a mi personalmente nunca me han gustado las clases en las que el profesor simplemente se planta delante de los alumnos y les suelta un rollo más o menos largo que se olvida al cabo de 5 días. Por lo que dividí la clase en las siguientes secciones:


1. Investigación de scratch y cosas que se pueden hacer con él: Otra ventaja de scratch es que viene con un montón de "programas" simples como ejemplo y que pueden ayudarnos a la hora de enseñar este "lenguaje". Por otro lado en la página oficial, los usuarios de scratch pueden subir sus programas para el disfrute del resto del mundo. Así que mi primera clase consistió en, después de una breve introducción de lo que íbamos a hacer, mostrarles como acceder tanto a los ejemplos como a los programas subidos a internet por los usuarios; de esta forma, ellos pueden ver qué tipo de cosas pueden hacerse con Scratch y ayuda a capturar su atención sobre todo porque la mayoría de ejemplos son pequeños juegos.

2. Crear tu primer programa: después de haber jugado durante toda una clase, les mostré como hacer un programa muy muy sencillo, nuestro hello world en scratch, que consistía en coger al gato que viene por defecto al abrir scratch y hacer que se mueva por la pantalla. De esta forma les expliqué la interfaz de scratch y los diferentes tipos de bloques que había. Al final de la clase ya estaban usando bloques que no creía que controlarían hasta mucho más adelante.

3.Aprendiendo con ejemplos: En las clases siguientes, les decía que eligieran alguno de los ejemplos que más les habían gustado y que investigaran para qué servía cada uno de los bloques de los que se componía el programa, al tiempo que hacían pequeñas modificaciones para que ellos vieran como afectaban esas pequeñas modificaciones al programa, cosas como cambiar el valor de una variable para que una bola se mueva más rápido o hacer que se emita un sonido cada vez que se pulse una tecla. Al principio tenía mis dudas por si no fueran capaces de "innovar" pero de nuevo volvieron a sorprenderme y algunos de ellos terminaron cambiando completamente el ejemplo inicial...

Al tiempo que íbamos modificando ejemplos a ellos le iban surgiendo más y más dudas del tipo como puedo hacer esto o como puedo hacer aquello, y fue ahí donde aproveché para instruirles un poco más en el uso del programa y de las diferentes opciones.

4. Una vez que ya se habían familiarizado con scratch lo suficiente les propuse un projecto que era diseñar su propio juego desde el principio, por lo que tuvieron que empezar describiendo las características del juego que querían crear, cuales iban a ser los personajes, los escenarios si había puntuaciones como serían, cuantos niveles habría, qué sonidos sonarían al pasar según qué cosa, etc, etc...

Una vez tuvieron hecho todo el diseño, empezaron a desarrollar el juego siguiendo sus propias especificaciones, algunos hicieron juegos de carreras, otros de agilidad mental, y hubo uno que llegó a construirse un pacman completo con sus fantasmas y todo, algunos de sus compañeros quedaron tan sorprendidos que le animaron a crear un vídeo para compartir lo que habían hecho.

[Vídeo en proceso]

Pues hasta aquí la entrada, siento haberme enrollado mucho, quizá mi metodología no sea la más adecuada pero al final de la unidad todos sabían lo que era un bucle, una variable, una condición una entrada y salida de datos etc. etc... lo que les hará ser más receptivos cuando el año que viene empecemos a programar "de verdad" :)

Minitutorial, sensor de distancia

Como ya comenté en un post anterior, este año estoy dando clases de IT a alumnos de diferentes niveles. Por lo que me he decidido a escribir pequeñas entradas con  opciones que nos brinda arduino con su conexionado y su sketch correspondiente, así me servirá también como un repositorio a la hora de mostrarles ejemplos que pueden utilizar para aprender a programar y montar proyectos con arduino.

En esta ocasión le toca el turno a los sensores de distancia, el que voy a utilizar es el HC-SR04, comprado en dealextreme por poco más de 3$.

El sensor funciona por ultrasonidos y el mecanismo consiste en una señal de ultrasonido que envía uno de esos cilindros y que el otro recibe, en función del tiempo que tarde en volver el ultrasonido se determina la distancia hasta el objeto que tiene en frente.

Tiene un rango de 2 a 450 cm por lo que tiene muchas utilidades como detección de intrusos, contador de personas, detección de obstáculos para pequeños proyectos de coches autodirigidos y cualquier otra cosa que se nos ocurra.

Cuenta con 4 pines que por suerte vienen etiquetados en la misma placa, así tenemos vcc para el voltaje, Trig que es el que envía la señal y va conectado a una salida digital, echo que es el que recibe la señal y se conecta a una entrada analógica y por último Gnd para la toma a tierra. Esto nos facilita mucho las cosas a la hora de hacer el conexionado en una placa de montaje por ejemplo. Aquí tenéis como ejemplo el esquema he estado usando yo para pruebas.

Y aunque muy simple, os dejo un esquema del conexionado:

Una vez que tenemos el hardware listo vamos a pasar al software, para poder utilizar este sensor necesitaremos enviar una señal durante dos microsegundos, después silenciar esa señal y leer el valor que nos devuelve el pin de ECHO. De esta forma aplicando una pequeña fórmula nos devuelve el valor en CM. He aquí el sketch:

 // Definimos para que vamos a usar cada pin
#define ECHO 6       
#define TRIGGER 7 

//Primera bateria de instrucciones que se ejecutara
//Solo cuando inicie arduino
void setup()
{
  //Declaramos la velocidad con la que operaremos el puerto serie
  Serial.begin(9600);
  //Definimos que el pin de echo (6) es de entrada
  pinMode(ECHO, INPUT);
  //Y que el TRIGGER
  pinMode(TRIGGER, OUTPUT);
  //Mostrampos un mensaje por pantalla diciendo que estamos conectados
  Serial.println("El dispositivo se ha conectado.");
}

/*
 * Funcion de loop que se ejecutara de forma reiterativa
 * 
 */
void loop()
{
  // Ponemos el TRIGGER a 0
  digitalWrite(TRIGGER, LOW);
  // Esperamos 2 microsegundos
  delayMicroseconds(2);
  // Ponemos el TRIGGER a 1
  digitalWrite(TRIGGER, HIGH);
  // Y volvemos a esperar, ahora 10 microsegundos
  delayMicroseconds(10);
  // Por ultimo volvemos a poner el TRIGGER a 0
  digitalWrite(TRIGGER, LOW);
  // Ahora recogemos el valor recibido en el pin de ECHO
  // El cual determinara la distancia
  float distancia = pulseIn(ECHO, HIGH);
  // Para pasar el valor a CM tendremos que dividir el valor 
  // obtenido por 58 y esto nos dara como resultado los cm
  distancia= distancia/58;
  // Imprimimos por el puerto serie la distancia recien calculada
  Serial.print(distancia);
  Serial.println(" CM");
  // Ponemos otra pausa de 200 milisegundos
  // a tener en cuenta que son milisegundos, lo de antes
  // eran microsegundos, un valor aun mas pequeño
  delay(200);
}

Por último un pequeño vídeo de como funciona el sensor:

Habilitando y deshabilitando la opción de cambio de usuario en Windows 7

Al instalar windows 7 en el laboratorio de ordenadores del colegio, nos encontramos con el problema de que por defecto, windows 7 permite cambiar de usuario sin tener que desloguearse. Esto presenta un problema debido a que si los usuarios empiezan a utilizar esta opción en lugar de la de cerrar sesión o log off, al final del día podríamos tener pcs con múltiples usuarios logueados con la consiguiente bajada de rendimiento de los mismos.

Los pasos a seguir para deshabilitar el cambio rápido de usuario, son los siguientes:

e damos a inicio y escribimos regedit:

 

 

Esto nos abrirá el registro de windows:

 

 

 

A continuación, nos abrirá el registro de windows e iremos abriendo poco a poco el árbol de la siguiente forma:

 

HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows\CurrentVersion\Policies\System

Dentro de system buscamos la entrada HideFastUserSwitching:

 

Ahora modificaremos el valor del registro haciendo doble click en la entrada y cambiando el 0 por un 1, quedando así:

Si en el futuro queremos volver a habilitar  el cambio de usuario solo tendremos que volver a cambiar el 1 por un 0. Por último, reiniciamos el equipo, y cuando volvamos a hacer login la opción de cambio de usuarios aparecerá deshabilitado:

 

Cambiando el disco duro de un iMac

Es la primera vez que abro este tipo de iMac así que decidí hacer un pequeño foto-tutorial por si a alguien le dan ganas de poner un disco duro más grande o cambiarlo por un ssd.

En mi caso el disco duro no respondía y no había forma de formatearlo por lo que he tenido que cambiarlo por otro.

Lo primero que hay que hacer es desatornillar la trampilla que nos da acceso a los módulos de memoria que se encuentra en la parte inferior del iMac.

Una vez hecho esto, retiramos el cristal protector del lcd, el cual viene sujeto por un sistema de imanes; para retirarlo tenemos dos opciones o bien nos hacemos con unos chupones de los que usan los cristaleros o bien, con dos destornilladores muy finitos y con cuidado de no dañar la carcasa también podemos levantarlo:

A continuación retiramos todos los tornillos que vemos, para ello necesitaremos un destornillador con cabeza tipo torx.

Para que luego no haya confusiones a la hora de montar es recomendable etiquetar los tornillos que vamos quitando o al menos ir colocándolos de forma que luego podamos volver a montar sin perdernos.

Una vez hecho esto, ya podemos desprender la carcasa que rodea al lcd para ello hacemos una pequeña presión con los dedos tal como se ve en la imagen y la carcasa saldrá sin problemas. A tener en cuenta el conector de la webcam que tendremos que desconectar con cuidado para poder desprender la carcasa.

 He aquí el resultado de retirar la carcasa frontal.

Ya solo nos queda retirar el lcd y ya tendremos acceso al disco duro, para ello usando de nuevo el destornillador torx retiramos todos los tornillos que hay alrededor, estos son todos del mismo tamaño por lo que no hay lugar a equivocarse.

Terminando de quitar los tornillos tenemos que volver a ser cuidadosos ya que el lcd solo quedará sujeto al resto del equipo por varios cables, de ellos los únicos que es imprescindible retirar son dos grupos de dos cables (rojo y azul), en estos el conector hembra no lleva colores por lo que le he escrito a boli una A en el conector donde va el azul. Tras desconectar estos cuatro cables, ya podemos (siempre con sumo cuidado) doblar el lcd hacia adelante y tendremos acceso al disco duro, un par de fotos más:

Ya hemos terminado con la parte difícil, desde aquí ya solo nos queda desmontar el disco duro que cuenta con dos tornillos en la parte superior (para acceder a ellos quitamos la barrita de plástico que lo cubre):

La inferior está sujeta por dos pezoncillos. Vemos también que el disco duro tiene algo pegado, esto es un sensor de temperatura que usa el sistema para determinar la temperatura de funcionamiento del disco duro. 

Habremos de despegar dicho sensor y pegarlo en el disco duro nuevo, lo ideal es intentar pegarlo aproximadamente a la misma altura que se encuentra el otro.

Los pezoncillos del disco duro orignal también tendremos que ponerlos en el nuevo para poder encajarlo en el hueco donde estaba alojado el otro.

Aquí vemos el nuevo ya montado, si el sensor pierde el pegamento, se le puede echar una gotita para fijarlo al nuevo.

Pues ahora solo nos queda volver a montarlo todo de la misma forma que lo desmontamos, primero el lcd con sus conectores, a continuación la carcasa con el conector de la cámara web y por último el cristal protector del lcd. Aquí un pequeño vídeo del desmontaje y montaje, en el vídeo he omitido el cambio del disco duro ya que lo hice antes de grabar el vídeo.

En nuestro centro, ya que no tenemos servidor mac solemos resintalar los equipos usando una imagen creada con carbon copy cloner. Lo que hacemos es una vez está el sistema completamente instalado y actualizado, conectamos un disco duro portátil (usb or firewire) y volcamos la imagen en el disco duro portátil, así cuando tenemos problemas como este, solo hay que recuperar el sistema usando el disco duro usb. Para ello conectamos el disco por usb arrancamos el ordenador y ya que nuestro disco de sistema está completamente en blanco el sistema arranca desde el usb directamente y una vez dentro del sistema arrancamos el Carbon Copy Cloner y hacemos un volcado completo del disco usb al disco recien instalado:

Pues hasta aquí la entrada, espero que si has dado con esta página preguntándote como abrir un Mac para reemplazar el disco duro te haya servido de ayuda,

Control de temperatura v2 (sin necesidad de ordenador)

En el primer post, vimos como controlar la temperatura a través de arduino y hacer que nos enviase un correo electrónico usando processing.

En esta segunda versión, vamos a prescindir del ordenador ya que no siempre tendremos la posibilidad de tener un ordenador conectado en la sala que queremos controlar la temperatura. Para ello, he adquirido una placa de arduino llamada arduino ethernet, la diferencia de esta con el arduino uno que hemos usado anteriormente, es que esta en lugar de traer un conector usb viene con una toma de red, por lo demás es todo más o menos igual.

Arduino Ethernet 

Aclarar que esto no es un shield como el que utilizamos para el lcd, sino que es una placa arduino completa, la única cosa que echaremos de menos es que no trae el puerto usb para programarla por lo que tendremos que tirar de un conversor USB a TTL que cuesta unos 8€.

Conversor USB to TTL

Como ventajas, podemos decir que si vamos a dotar de alguna funcionalidad de red a nuestro arduino, esta es la mejor opción: primero, ahorramos espacio al  no tener que colocar un shield encima; segundo, es más barato comprar esta placa que comprar el arduino y el shield por serparado; y por último, lo que me terminó de convencer y es que venden un módulo que puede soldarse a esta placa y que nos permitirá utilizar POE en caso de que nuestra red disponga de esta característica, por lo que no necesitaremos conectar una fuente de alimentación externa:

Módulo POE

Para nuestro proyecto incial habíamos utilizado un sensor de temperatura TMP36 para recoger los datos de la temperatura ambiental, en esta versión reutilizaremos el mismo sensor y puesto que las entradas analógicas del  arduino ethernet son iguales que las de arduino uno el esquema queda exactamente igual que en la versión anterior.

Antes de poner el código, cabe explicar que para poder enviar correos electrónicos desde arduino ethernet, tenemos que hacerlo utilizando telnet. Esto se hacía mucho antiguamente cuando los  servidores de correo no solían estar protegidos contra el reenvío de emails y cualquiera podía conectarse al puerto  25 de un servidor de correo y enviar un correo con un remitente falso... (aún recuerdo cuando le gastamos a un amigo la broma de que la guardia civil le había enviado un correo para reclamarle ciertas movidas :)

Hoy en día la gran mayoría de los servidores de correo requieren que nos autentiquemos por lo que se complica un poco el proceso de enviar correo a través de telnet pero esto no significa que no podamos hacerlo.

En mi caso he decidido utilizar mis cuentas de correo de gmail para enviar correo y esto presentaba otro problema añadido, google utiliza TLS como protocolo seguro para poder enviar correos y no he encontrado por ningún sitio la forma de hacerlo con arduino, si es que puede hacerse.

Para solucionarlo he tirado de una aplicación llamada stunnel, que es un software gratuito de tunneling ssl, lo que vamos a poder hacer con este programa es que nuestro arduino se conecte a él en lugar de conectarse directamente a google y usando una conexión al puerto 25 reenviar los comandos a google.

La configuración de stunnel es muy sencilla, solo hay que añadir estas líneas al archivo stunnel.conf y ya podemos enviar correos a través de conexiones al puerto 25 del ordenador donde hayamos instalado stunnel:

[ssmtp]

accept  = 25

connect = smtp.gmail.com:465

Por otro lado el proceso de autenticación no nos va a permitir utilizar nuestras credenciales utilizando texto plano, por lo que tendremos que hacer una transformación de nuestro usuario y contraseña a base64 para lo que he utilizado esta web. http://www.seguridadwireless.net/php/conversor-universal-wireless.php

Por poner un ejemplo si nuestro usuario para el correo fuese manolito.perez@gmail.com lo que tendríamos que mandar por telnet usando el arduino sería algo así: bWFub2xpdG8ucGVyZXpAZ21haWwuY29t

La opción a elegir dentro de la web de seguridadwireless es Encode64.

Bueno ya tenemos nuestro stunnel funcionando, tenemos nuestro usuario y nuestra password en base64 y tenemos una cuenta de gmail que es la que usaremos para enviar nuestros correos electrónicos. Por lo que el siguiente paso, será hacer el sketch que compruebe la temperatura y que si pasamos de Xº, nos envíe un correo electrónico:

//Como siempre empezamos llamando 
//las librerias necesarias
#include <SPI.h>
#include <Ethernet.h>
//Definimos las variables globales
//Variable de control para no enviar muchos emails seguidos
boolean correo=false;
//Pin donde conectaremos el sensor de temperatura
int anapin = 3;
//Mac address del arduinoethernet viene
//impreso por debajo de la placa, consta de 6 bytes en Hex
byte mac[] = { 0x90, 0xA2, 0xDA, 0x00, 0xF2, 0xA6 };
//Servidor de email o en nuestro caso
//servidor donde hemos instalado el stunnel
byte server[] = { 10, 0, 0, 5 }; 
//Variable que guardara los valores leidos 
//en el sensor de temperatura
float val=0;
//Creamos una objeto de clase EthernetClient
EthernetClient client;

//iniciamos el setup
void setup()
{
  //Se inicia el puerto serie
  Serial.begin(9600);
  //Mostramos por pantalla un mensaje
  Serial.println("Conectando el arduino ethernet a la red...");
  //conectamos el ethernet a la red, solo le pasamos la mac
  //ya que tenemos un servidor de dhcp en nuestra red
  //si queremos especificar la ip tendriamos que hacerlo aqui
  if (Ethernet.begin(mac)==0) Serial.println("Fall´ la conexi´n ethernet");
  //Dejamos un pequeño retardo para que se asigne la ip y demas
  delay(5000);
}

//Iniciamos el loop
void loop(){
  //leemeos la temperatura del sensor llamando a la función getVoltage
  //y le aplicamos la formula para que aparezca en grados centígrados
  //en este sketch obviamos la conversión en grados F ya que no la vamos
  //a necesitar
  val = (getVoltage(anapin) - .5)*100;
  //Como método de control imprimimos al puerto serie el 
  //el valor del sensor
  Serial.println(val);
  //Dejamos una pausa para que las 
  //muestras se tomen cada 5 segundos
  delay(5000);
  //Comprobamos si el valor de la temperatura esta 
  //por debajo de 31ºC en cuyo caso no mandamos email
  if (val<31){
    Serial.println("NO SE MANDA EMAIL");
    if(correo) correo=false;
    //si la temp es superior mandamos el email
    //y cambiamos el valor de correo para que no vuelva a enviarse
  }else{
    //Comprobaos el valor de la variable correo
    //Si el valor de correo es falso mandamos el correo 
    //y ponemos el valor de correo a true
    if(!correo){
      //LLamamos a la función que enviara el correo
      sendEmail();
      correo=true;
      //Dejamos un retardo de 1' para que en el caso
      //de que la temperatura se esté moviendo 
      //entre 30 y 32º no envíe montones de correos
      delay(60000);
    }
  }
}

//Función que lee el voltaje del pin 3 de
//entradas analogicas
float getVoltage(int anapin){
  return (analogRead(anapin) * .004882814);
}

//Función que envia el email
byte sendEmail()
{
    //Conectamos el cliente al puerto 25
    //de nuestro servidor en caso de resultar
    //fallida la conexion nos devolverá un error
    //por pantalla
    if (client.connect(server,25)) {
      Serial.println("connected");
    } else {
      Serial.println("connection failed");
      return 0;
    }
    //Para cada comando llamamos la función
    //eRcv a fin de comprobar la respuesta del
    //servidor y de ir limpiando el buffer de recepción
    if(!eRcv()) return 0;
    //estos comandos son los que usariamos
    //en una conexion telnet, empezamos saludando
    //al servidor
    client.println("HELO google");
    if(!eRcv()) return 0;
    //Le decimos que queremos autenticarnos
    client.println("AUTH LOGIN");
    if(!eRcv()) return 0;
    //Enviamos el usuario en base64
    client.println("fjgkriemrerkEE54F=");
    if(!eRcv()) return 0;
    //Enviamos el password en base64    
    client.println("aGTvaiefSA==");
    if(!eRcv()) return 0;
    //especificamos el sender
    client.println("MAIL From:<mi@gmail.com>"); 
    if(!eRcv()) return 0;
    //especificamos el que recepciona el email
    client.println("RCPT To:<otro@gmail.com>");    
    if(!eRcv()) return 0;
    //indicamos que vamos a empezar a escribir el correo
    client.println("DATA");
    if(!eRcv()) return 0; 
    //Aquí ponemos todo el cuerpo del mensaje incluyendo
    //el from el to y el subject
    client.println("From: mi@gmail.com");                
    client.println("To: otro@gmail.com");                         
    client.println("Subject: Alerta de temperatura en el cuarto de servidores!!!!" + String(int(val)) + "ºC");
    client.println("");                              
    client.println("Se ha detectado una temperatura anormalmente alta en el cuarto de servidores, concretamente de " + String(int(val)) + "ºC");
    client.println(""); 
    //Cuando enviamos un punto indica el fin del mensaje
    client.println(".");
    if(!eRcv()) return 0;
    client.println("QUIT");
    //Cerramos la conexion telnet
    if(!eRcv()) return 0;
    //Paramos el cliente
    client.stop();
    return 1; 
}


//Esta función nos permite ir mostrando
//las respuestas del servidor para cada
//comando que enviamos, asi mismo va limpiando
//el buffer RX, hay servidores de correo que funcionan
//sin esta función pero con google es necesario.
byte eRcv()
{
  byte respCode;
  byte thisByte;
  while(!client.available()) delay(2000);
  respCode = client.peek();
  while(client.available())
  {  
    thisByte = client.read();    
    Serial.write(thisByte);
  }
  if(respCode >= '4')
  {
    efail();
    return 0;  
  }  
  return 1;
}

//Esta función nos dara un error en caso
//de que la respuesta del servidor sea un fallo
//y desconectara la sesion
void efail()
{
  byte thisByte = 0;
  client.write("QUIT\r\n");
  while(!client.available()) delay(1);
  while(client.available())
  {  
    thisByte = client.read();    
    Serial.write(thisByte);
  }
  client.stop();
  Serial.println("disconnected");
}

Pues con esto ya tendríamos nuestro controlador de temperatura avisador por email funcionando y listo para ponerlo en producción...

LCD Shield with keypad para Arduino

Hola de nuevo, tengo en mente la creación de un sistema de control de accesos para la sala de servidores utilizando RFID para cuando sepa mejor como funciona arduino; una de las cosas que quiero ponerle es una pequeña pantalla LCD que muestre el nombre de la persona que se identifica, por lo que el otro día pedí una LCD Shield como la de la foto en dealextreme por unos 9$ que viene a ser unos 6€.

Un shield de arduino es una placa con una funcionalidad (las hay para wifi, controlador de motores, bluetooth, etc) que encaja perfectamente sobre la placa de arduino. por lo que no es necesario poner ningún tipo de cable para poder usar la funcionalidad inherente del shield.

Este tipo de pantalla no me servirá para mi proyecto ya que al ser un shield me limita las posibilidades de colocación de la pantalla, pero puede serme útil a la hora de entender como funcionan las pantallas LCD y como se comunica con Arduino.

La shield viene además de con la pantalla con una serie de botones que van todos conectados a una entrada analógica la A0 de arduino. Cada vez que se pulsa un botón arduino recibe un valor entre 0 y 1100 aproximadamente  en función del botón pulsado. Esto está muy bien ya que solo usaremos una entrada analógica para manejar un total de 5 botones si excluimos el reset.

Lo primero que intenté hacer al sacar el shield del sobre fue intentar probar el ejemplo que viene con el compilador de arduino que es tal que así:

// include the library code:
#include <LiquidCrystal.h>

// initialize the library with the numbers of the interface pins
LiquidCrystal lcd(12, 11, 5, 4, 3, 2);

void setup() {
  // set up the LCD's number of columns and rows: 
  lcd.begin(16, 2);
  // Print a message to the LCD.
  lcd.print("hello, world!");
}

void loop() {
  // set the cursor to column 0, line 1
  // (note: line 1 is the second row, since counting begins with 0):
  lcd.setCursor(0, 1);
  // print the number of seconds since reset:
  lcd.print(millis()/1000);
}

Al ver que no funcionaba, entendí que el problema eran los pines que utiliza el lcd, el sketch del ejemplo utiliza (12,11,5,4,3,2), pero con mi shield no venía info alguna que dijera que pines de arduino utilizaba, por lo que el siguiente paso fue buscar info en la página de delaextreme que pines utilizan y encontré que los pines a usar eran (8, 9, 4, 5, 6, 7).

Sin embargo tras cambiar el código del programa seguía sin funcionar... El shield trae un potenciómetro que regula el contraste de las letras que aparecen en la pantalla y tras chequear lo con el polímetro ví que el valor que devolvía siempre era el mínimo... la placa estaba defectuosa. Por suerte, tenía a mano un potenciómetro que soldé en lugar del antiguo y el programa de hola mundo, empezó a mostrar la frase por la pantalla del arduino..

Ahora que todo funciona, solo queda hacer un programita para poder explorar un poco las posibilidades de la pantalla y de los botones de nuestro shield.

//Incluimos la librería de LCD que trae arduino
#include <LiquidCrystal.h>
//Indicamos los pins que vamos a usar para 
//comunicarnos con la pantalla
//En mi caso, al usar una lcd shield los botones
//son los siguientes
LiquidCrystal lcd(8, 9, 4, 5, 6, 7);
//Creamos una constante para tomar 
//indicar a que pin está conectado
const int analogInPin = A0; 
//Creamos una variable para almacenar los 
//valores tomados por los botones
int sensorValue = 0;  

//Inicia el void setup que solo se ejecuta
//una vez
void setup() {
  //iniciamos el puerto serie
  //lo hemos usado para debugginh
  //y así ver los valores que devuelve 
  //al pulsar cada uno de los botones
  Serial.begin(9600); 
  //iniciamos también la pantalla lcd y le 
  //indicamos el número de columnas x el número de filas
  lcd.begin(16, 2);
  //Imprimimos por pantalla la frase HOLA MUNDO!
  lcd.print("HOLA MUNDO!");
  //Movemos el cursor a la segunda línea
  lcd.setCursor(0, 2);
  //Ponemos un mensaje en la segunda línea
  //que nos pide que pulsemos un botón
  lcd.print("Pulse un boton");
}

//Inicia el loop que se ejecutará 
//mientras el arduino esté conectado
void loop() {
  //Recogemos el valor en el pin analógico
  //que nos dirá que botón hemos pulsado
  sensorValue = analogRead(analogInPin);
  //Para hacer el debuggin hemos usado esta instrucción
  //que nos va mostrando en la pantalla del ordenador
  //el valor devuelto al pulsar cada botón  
  Serial.println(sensorValue); 
  //Ponemos un pequeño retardo para que 
  //podamos leer los valores sin marearnos
  delay(100); 
  //En el debuggin hemos visto que al no tener ningún botón
  //pulsado los valores devueltos están entre 
  //1020 y 1025 por lo que cuando se den valores distintos 
  //a ese rango se ejecutará lo que hay dentro del if
  if (sensorValue <1000 ||  sensorValue>1100) {
    //llamamos a la función limpiar línea que veremos 
    //un poco más abajo
    limpiarLinea();
    //Imprimimos por pantalla lo que nos devuelve
    //la función opcion(int) que veremos más abajo
    //y que comprueba a cuanto equivale el valor del sensor 
    //y en función de éste, nos devuelve una cadena de texto
    lcd.print(opcion(sensorValue));
  }  
}


//Esta función comprobará el valor 
//del pin analógico conectado a los botones
//para determinar que botón hemos pulsado
//y devolver un texto en función de este
String opcion(int sensor){
  //Solo explicaré el primero, ya que el resto de ifs
  //son iguales.
  //En el debug vimos que al pulsar la tecla left, nos devolvía
  //un valor de aprox 479 por lo que cuando el valor del sensor esté 
  //entre 400 y 500 devolverá la cadena de texto izquierda
  if(sensor > 400 && sensor<500){
    return("Izquierda");
  }
  if(sensor > 600 && sensor<750){
    return("Select");
  }
  if(sensor > 300 && sensor<350){
    return("Abajo");
  }
  if(sensor > 100 && sensor<150){
    return("Arriba");
  }
  if(sensor < 10){
    return("Derecha");
  }
}

//Esta función la llamamos cuando queremos borrar 
void limpiarLinea(){
  //Colocamos el cursor la principio de la segunda
  //línea
  lcd.setCursor(0, 2);
  //Con este bucle recorremos toda la línea y la ponemos
  //en blanco
  for (int i = 0; i < 16; i = i + 1) {
    lcd.print(" ");
  }
  //Volvemos a colocar el cursor
  //al principio de la línea
  //para cuando volvamos a escribir algo
  //salga desde el principio de la línea
  lcd.setCursor(0, 2);
}

El resultado del programa es el siguiente:









Como veis es bastante soso, pero a partir de aquí podemos empezar a hacer otros sketchs o mezclar los resultados mostrados por pantalla con algún sensor como el de temperatura...