Manual_tellymate_v4

Tellymate
Enero 2010
Introducción.
TellyMate Shield es una tarjeta que sirve de interface entre la tarjeta Arduino y el televisor. Con
ella podemos desplegar texto y gráficos en la televisión con códigos muy simples, además de
interactuar directamente con la Arduino. Una de las ventajas que posee, es que no tiene
necesidad de cables para hacer la conexión ya que esta viene con los pines listos para ser
insertados sobre la Arduino utilizando el puerto serie (TX, RX), GND, 5v y al reset de la placa
dejando libres todos los pines para el uso que estimemos necesario.
En el siguiente tutorial enseñaremos el uso de tarjeta TellyMate en lo que se refiere a
instalación y a su código, de forma sencilla a través de dos ejemplos los cuales nos darán una
pauta para continuar con proyectos más complejos. En el primero de los ejemplos
imprimiremos un texto en la pantalla, de modo de aprender a usar los comandos principales
para mostrar textos. El segundo tendrá funciones predefinidas para así tener más opciones en
el uso de este sistema, además utilizaremos una entrada analógica de Arduino para capturar
una señal y mostraremos los datos en la pantalla.
Materiales:

TellyMate Shield

Arduino (Nosotros usaremos Duemilanove)

Televisor PAL o NTSC

Computador

Cable USB A-B

Cable Rca/plug

Resistencia variable 10Komh (potenciómetro)
Ingeniería MCI Ltda. – Luis Thayer Ojeda 0115 of 402, Providencia, Santiago, Chile
http:www.olimex.cl Fono: + 56 2 3339579 Fax: +56 2 3350589
2 |T e l l y M a t e S h i e l d
1.- Unir las tarjetas.
Unir Arduino con TellyMate de acuerdo a la siguiente figura.
2.- Conexión al PC.
Con un cable USB A-B conectaremos nuestra Arduino al computador
Hay que verificar el puerto COM virtual que lo veremos en Propiedades de Mi PC-->Hardware->Administrador de dispositivos--> Puertos (COM & LPT) desplegamos las ramas y al momento
de conectar el cable nos indicara que puerto le corresponde, es importante saber el puerto al
momento de cargar el código a la Arduino. Para mayor información sobre la instalación de
Arduino revisa nuestro tutorial el cual detalla paso a paso la conexión entre la tarjeta y el PC
www.olimex.cl/present.php?page=tut_arduino
Ingeniería MCI Ltda. – Luis Thayer Ojeda 0115 of 402, Providencia, Santiago, Chile
Fono: + 56 2 3339579 Fax: +56 2 3350589
3 |T e l l y M a t e S h i e l d
3.- Descarga del programa (IDE).
Arduino trabaja con un programa propio (IDE) que está hecho en java y lo podemos descargar
gratuitamente del siguiente enlace http://arduino.cc/en/Main/Software
en donde podremos elegir entre las versiones disponibles para distintos sistemas operativos.
Luego de bajar el archivo se descomprime y listo (no se necesita instalar el programa). En el
escribiremos nuestro código, lo compilaremos y lo cargaremos a nuestra tarjeta.
4.- Código.
Para el manejo de nuestra Arduino a través de programas que uno cargue, estos correr en dos
partes importantes, una es setup() que es como la base que se ejecuta una sola vez al inicio
del programa en la cual se inicializa la comunicación serial, se asignan las entradas, las
salidas, etc. El siguiente es el loop() que es un ciclo infinito donde se encuentra el código en sí,
que controlara activamente la placa Arduino pudiendo leer las entradas, ajustando las salidas,
etc.
Otro punto es sobre nuestra TellyMate, ya que necesita de un código específico para que
imprima en pantalla y realice otras funciones. La función más importante en este ejemplo es
Serial.println(“ ”) que muestra en la televisión el texto que está entre comillas. Para inicializar
la salida se usa Serial.begin( ) que dentro del paréntesis va la velocidad de transferencia.
Ejecutamos el archivo Arduino.exe que se encuentra en la carpeta que descomprimimos y en el
escribiremos el siguiente programa.
Ejemplo 1
Como primer ejemplo realizaremos un sencillo código el cual imprimirá en pantalla un texto el
cual se muestra en la siguiente figura.
Imagen del programa 1.
Ingeniería MCI Ltda. – Luis Thayer Ojeda 0115 of 402, Providencia, Santiago, Chile
Fono: + 56 2 3339579 Fax: +56 2 3350589
4 |T e l l y M a t e S h i e l d
void setup()
{
Serial.begin( 56700 );
//Por defecto es esa velocidad
Serial.println("Ingenieria MCI"); //es lo que mostrara en pantalla junto
con un “guion bajo (_)” parpadeante llamado cursor.
}
void loop()
{
// No realizara nada dentro del loop
}
Una vez que terminamos de escribir nuestro programa tenemos que verificar dos cosas.
Primero Tools-->Board y que corresponda al modelo que nosotros estamos usando, en este
caso elegimos la opción ARDUINO DUEMILANOVE ATMEGA328. Lo otro importante es
indicarle cual es el puerto que le corresponde Tools--> Serial port y seleccionamos el puerto
que buscamos en el paso 2. Luego presionamos el botón “play” (Verify) que está en la parte
superior izquierda de nuestra pantalla para compilar y verificar si está bien nuestro programa.
Si toda va bien podremos cargar el programa con el botón “Upload” que está ubicado en el
sexto lugar de donde se encuentra el botón “play”(Verify). Tardará unos segundos y el
programa quedará cargado en la tarjeta.
Ejemplo 2.
Este programa nos ayudara de dos maneras muy simples debido a que tendremos funciones
predeterminadas para una mejor presentación de los textos y el uso de una aplicación con
nuestra Arduino. Las funciones que se presentarán serán ocultar el cursor, limpiar la pantalla y
posicionar el texto en la posición que estimemos conveniente para nuestros futuros
desarrollos. El otro beneficio del programa será leer una entrada analógica de nuestra Arduino
que variaremos con un potenciómetro para que el valor sea mostrado en la pantalla.
La resistencia variable será conectada a los 5 volt, GND y a la entrada analógica 1 (el pin
central de la resistencia debe ir en la entrada analógica y los dos pines laterales a los 5v y
GND).
Imagen de la resistencia unida con la Arduino-TellyMate
Ingeniería MCI Ltda. – Luis Thayer Ojeda 0115 of 402, Providencia, Santiago, Chile
Fono: + 56 2 3339579 Fax: +56 2 3350589
5 |T e l l y M a t e S h i e l d
Otro punto importante que se tiene que aclarar antes de continuar es sobre el uso de
secuencias que entiende el dispositivo, en este programa se hará uso de una de ellas para que
tengan un mayor manejo de nuestra tarjeta TellyMate. Para este ejemplo se usará la secuencia
<ESC> que tiene múltiples variantes de las cuales aplicaremos el limpiado de pantalla (<ESC>
E), pero que en nuestro programa se escribirá CHAR_ESC "E" ya que la secuencia <ESC>
será asignada a una variable que siempre tendrá ese valor llamada CHAR_ESC, como se
muestra a continuacion.
#define CHAR_ESC "\x1B”
En el código ASCII 1B (hexadecimal) representa <ESC> así de esta forma queda guardada la
secuencia en CHAR_ESC.
En el siguiente link se muestran las secuencias que maneja el dispositivo
www.batsocks.co.uk/products/Other/TellyMate_UserGuide_ControlSequences.htm
Imagen del programa 2.
Estas son las funciones que nos ayudarán en las distintas tareas que realizaremos a
futuro.
Función que desaparece el cursor de la pantalla. Recuerda que en el ejemplo número 1 en el
que sí se muestra.
void cursor_show( bool show )
{
Serial.print( CHAR_ESC ) ;
Serial.print( show?'e':'f' ) ;
}
Función que elimina todos los textos mostrados en la pantalla del televisor, dejando limpio para
que los futuros textos que serán mostrados a continuación no sean interferidos.
void screen_clear( void )
{
Serial.print( CHAR_ESC "E");
}
Ingeniería MCI Ltda. – Luis Thayer Ojeda 0115 of 402, Providencia, Santiago, Chile
Fono: + 56 2 3339579 Fax: +56 2 3350589
6 |T e l l y M a t e S h i e l d
Función que posiciona el texto en el lugar que nosotros queramos dentro de la pantalla.
void tm_cursor_move( uint8_t row , uint8_t col )
{
Serial.print( CHAR_ESC ) ;
Serial.print( 'Y' ) ;
Serial.print((unsigned char)(32 + row)) ;
Serial.print((unsigned char)(32 + col)) ;
}
Para leer la entrada analógica se usa analogRead() y en el paréntesis va el pin que deseamos
leer (un numero de 0 al 5 ya que ellas son las entradas analógicas de nuestra Arduino) para
ello se le asigna uno de los valor a una variable que en este caso llamaremos analogPin1.
Una forma fácil seria escribir analogRead(1) para que lea la entrada 1 pero la idea es también
ir variando las entradas para un desarrollo más completo, por ello se asigna una variable antes
mencionada en este ejemplo. El valor obtenido por la entrada numero uno será guardada en
otra variable que en este caso la llamaremos value para que sea usado con distintos
propósitos, en este caso será para que se imprima en pantalla el valor.
value = analogRead(analogPin1);
Para continuar se escribirá el código completo con algunos comentarios para que sea de mayor
entendimiento.
#define CHAR_ESC "\x1B"" // toma el valor 1B que en el código ASCII,
representa <ESC>.
int analogPin1 = 1;
// se selecciona la entrada analógica numero 1.
void cursor_show( bool show )
// función que no muestras el cursor
{
Serial.print( CHAR_ESC ) ;
Serial.print( show?'e':'f' ) ;
}
void screen_clear( void )
// función que limpia la pantalla
{
Serial.print( CHAR_ESC "E" );
}
void tm_cursor_move( uint8_t row , uint8_t col ) // función que
posiciona lo que se muestra en pantalla
{
Serial.print( CHAR_ESC ) ;
Serial.print( 'Y' ) ;
Serial.print((unsigned char)(32 + row)) ;
Ingeniería MCI Ltda. – Luis Thayer Ojeda 0115 of 402, Providencia, Santiago, Chile
Fono: + 56 2 3339579 Fax: +56 2 3350589
7 |T e l l y M a t e S h i e l d
Serial.print((unsigned char)(32 + col)) ;
}
void setup()
// Lo primero que realiza
{
Serial.begin( 56700 ) ;
// se abre el puerto
cursor_show( false ) ;
// desaparece el cursor
tm_cursor_move( 12,12 ) ;
// posicionara Ingeniería MCI en el
centro de la pantalla
Serial.println("Ingenieria MCI") ; // sin tilde (véase nota final)
tm_cursor_move( 20,20 ) ;
Serial.println("www.olimex.cl") ;
delay(3000);
// retardo de 3000 milisegundos
screen_clear() ;
// limpia la pantalla para que muestre
solamente el texto que viene a continuación.
}
void loop()
// Se repite infinitas veces es el cuerpo principal
del programa.
{
int value = 0;
// variable que se le asigna el valor cero
como inicio.
value = analogRead(analogPin1); // lee la entrada analógica numero
1.
tm_cursor_move( 12,0 ) ;
// posiciona en el centro la siguiente
frase.
Serial.println("Valor referencia..................");
tm_cursor_move( 12,36 ) ;
Serial.println(value); // imprime en pantalla el valor guardado en
value
delay(1000);
}
5.- Jumpers.
Existen tres tipos de formatos de televisores NTSC, PAL y SECAM los dos primeros son los
usados en América (en Chile se usa NTSC). TellyMate tiene la ventaja de poder elegir entre
uno de los dos formatos de una forma simple, para ello en nuestra tarjeta TellyMate se usa un
jumper en la posición J6 para seleccionar el formato PAL, para NTSC no se usa el jumper. Si el
televisor que usaremos no tiene una resistencia interna de 78 Ohm (los portátiles normalmente)
usaremos un jumper en el lugar J7 en el caso contrario no será necesario. Nosotros usamos un
televisor de 5 pulgadas NTSC no necesita de un jumper en la posición 6 y si el jumper numero
7 ya que no viene con la resistencia como se muestra en la siguiente figura.
Ingeniería MCI Ltda. – Luis Thayer Ojeda 0115 of 402, Providencia, Santiago, Chile
Fono: + 56 2 3339579 Fax: +56 2 3350589
8 |T e l l y M a t e S h i e l d
Imagen del jumper 7 para la resistencia de 78 Ohm..
6.- Conectar al televisor.
El cable Rca/plug que viene con TellyMate lo conectaremos al televisor en la conexión de video
y veremos Ingeniería MCI en la parte superior de la televisión para el primer programa.
Imagen de la conexión al televisor.
Ingeniería MCI Ltda. – Luis Thayer Ojeda 0115 of 402, Providencia, Santiago, Chile
Fono: + 56 2 3339579 Fax: +56 2 3350589
9 |T e l l y M a t e S h i e l d
Notas:
Para imprimir en pantalla con el comando Serial.println(“”) no acepta tildes ya que los
remplaza por otros caracteres en la pantalla.
Para mayor información visita www.olimex.cl y http://arduino.cl
Ingeniería MCI Ltda. – Luis Thayer Ojeda 0115 of 402, Providencia, Santiago, Chile
Fono: + 56 2 3339579 Fax: +56 2 3350589