Instrucciones paso a paso
Este tutorial pretende detallar todos los entresijos para conectar, programar y configurar un arduino. Como ejemplo se ha tomado la configuración que se refiere al CasDuino Mega pero puede aplicarse al TSXDuino Mega con leves cambios, a cualquier otro emulador de casete teniendo en cuenta algunos cambios más, y como pauta de uso general para configurar y cargar programas en todos los diseños con Arduino.
PASO 1 Instalación y configuración del driver de comunicaciones de la placa de ARDUINO.
El primer paso que deberemos realizar es la instalación del controlador de dispositivo (aka driver) adecuado en nuestro ordenador Windows para asegurarnos que no toma uno inapropiado y esto requiera de muchos más pasos después para subsanarlo.
–Driver USB
En el caso que nos ocupa el driver necesario es el adecuado para el chip programador CH340G integrado en la placa Arduino Mega 2560 Embed, utilizada en Casduino Mega y TSXDuino Mega.
El primer paso es descargar el driver USB del microcontrolador,.
http://www.wch-ic.com/downloads/CH341SER_EXE.html
Nota: si este enlace no funcionase también se puede acceder desde cualquier buscador, basta con escribir «driver CH340G» saldrán varios enlaces para obtenerlo. La descarga de la versión actual (CH341SER) es inferior a 300Kb.
Pulsaremos en el botón «download» y seguiremos los pasos necesarios para la descarga según que navegador utilicemos.
Como en la mayoría de programas Windows basta con hacer «doble click», pulsar INSTALL y varias veces «siguiente» para eligir así las opciones por defecto y completar la tarea.
PASO 2 Instalación y configuración del IDE de ARDUINO.
El siguiente paso es la instalación del entorno de desarrollo para Arduino, también llamado IDE, que es la aplicación encargada de compilar y cargar el programa de ejecución en nuestro Arduino.
Primero hay que descargar el programa desde https://www.arduino.cc/en/Main/Software donde estará la última versión. En mi ejemplo descargué la versión 1.8.12.
Una vez descargado debemos ejecutar el programa de instalación con el botón derecho y eligiendo «ejecutar como administrador», ya que instala unos controladores necesarios para muchos modelos de placas arduino y compatibles. Una vez instalado abrimos el programa que mostrará una pantalla como esta.
PASO 3 conexión de la placa al ordenador e identificación del puerto
Una vez realizados los pasos anteriores, ya tendremos preparado el entorno para conectar nuestra placa al ordenador por primera vez. Ahora basta con enchufar el MEGA2560 al PC mediante un cable microUSB-USB y automáticamente detectará el dispositivo y le asignará el driver previamente instalado. Este añade un puerto de conexión (COM) para la trasmisión de datos. Deberéis estar atentos a esto para apuntar el número de puerto COM que añadirá el sistema, Windows lo mostrará en la barra inferior y necesitamos conocerlo para más adelante.
Esta asignación se repetirá cada vez que conectemos un arduino a nuestro sistema (no sólo la primera vez) y podría respetar el mismo número de puerto o bien cambiarlo a veces, así que deberemos estar atentos a cualquier cambio.
A continuación accederemos al menú herramientas del IDE arduino y configuraremos los siguientes detalles:
- La placa arduino que estamos utilizando en el menú Herramientas – Placa (en nuestro caso la que dice «Arduino Mega o Mega2560»)
- El procesador adecuando, en el menú Herramientas – procesador (en nuestro caso Atmega2560)
- Y su puerto de conexión, en el menú Herramientas – puerto (en nuestro caso el que hemos apuntado en el paso anterior).
PASO 4 ejecución de los primeros programas.
Para asegurarnos de que todo ha ido bien transferiremos ahora un programa de ejemplo al Arduino confirmando incluso que acata nuestras órdenes.
para ello, una vez configurado modelo y conexión en el paso anterior elegiremos lo siguiente desde el menú del IDE: Archivo – Ejemplos – 01.Basics – Blink
Esto cargará un programa de ejemplo cuya única misión es demostrar el funcionamiento del sistema, haciendo parpadear con cadencia de 1 segundo uno de los LED integrados en la propia placa Arduino.
Desde el entorno IDE ahora pulsaremos en 1) el icono de compilar y 2) el icono de carga:
y en ambos casos recibiremos abajo un mensaje de respuesta, cuando acaba el botón 1 si todo ha ido correcto COMPILADO:
Y cuando pulsemos el botón 2 cargaremos este programa al Arduino y obtendremos como resultado: SUBIDO.
Si todo ha ido correctamente ahora podremos ver que hay un LED del Arduino que está parpadeando con cadencia fija, demostrando así que el cable funciona, que el arduino puede cargar un programa simple y que el entorno de desarrollo en el PC pudo compilar un programa sencillo. Si algo fue mal tendremos que revisar los mensajes de error en la ventana negra de arduino.
PASO 5. Escáner de pantallas
Muchos de los proyectos con arduino necesitan de una pantalla, en el caso de los emuladores de casete es así.
Aunque hay más formas de conectar estas pantallas, lo normal es que necesiten (o bien lleven integrado) una placa que permite conectarnos con una conexión de 4 hilos (en realidad 2 hilos más la alimentación): el I2C (también llamado IIC).
Nota: Esta imagen solo muestra el módulo I2C para pantallas LCD, el módulo I2C de las pantallas OLED está integrado en la propia pantalla por lo que conectaríamos directamente a los pines de esta. Además también hay pantallas LCD que vienen pre-soldadas al módulo I2C en cuyo caso verías el módulo anterior en la parte trasera.
El módulo I2C conecta la pantalla al Arduino utilizando un puerto de conexión a este. Como en este modo de comunicación se podrían conectar múltiples dispositivos, necesitamos saber el número de puerto que nuestro I2C utiliza para que ambos dispositivos tengan la misma configuración y se entiendan. Para ello carguemos un segundo programa, uno que nos permitirá averiguar el puerto del dispositivo I2C conectado como pantalla.
Repetiremos algunos pasos, primero introduciremos el programa a ejecutar, en este caso crearemos un nuevo proyecto con el menú: Archivo – nuevo, y reemplazamos texto que aparece por defecto con el siguiente:
// I2C Scanner
#include <Wire.h>
void setup() {
Serial.begin (9600);
Serial.println ();
Serial.println ("I2C scanner. Scanning ...");
byte count = 0;
Wire.begin();
for (byte i = 8; i < 120; i++)
{ Wire.beginTransmission (i);
if (Wire.endTransmission () == 0)
{
Serial.print ("Found address: ");
Serial.print (i, DEC);
Serial.print (" (0x");
Serial.print (i, HEX);
Serial.println (")");
count++;
delay (1);
} // end of good response
} // end of for loop
Serial.println ("Done.");
Serial.print ("Found ");
Serial.print (count, DEC);
Serial.println (" device(s).");
}
void loop() {}
Como no dejará ejecutar el programa sin guardarlo, mejor lo guardamos con un nombre como «escáner I2C«.
Una vez guardado, procederemos como con el programa anterior, conectaremos el arduino al ordenador si no lo está ya, confirmaremos que el puerto COM está correctamente seleccionado (y el modelo de placa y procesador) y ejecutaremos con el botón 1 para compilar y el 2 para subirlo a la placa de arduino.
Ahora probaremos este programa, y para ello (antes de nada) desconectaremos la placa de arduino del ordenador para conectarle lo un módulo I2C de la siguiente manera:
I2C Arduino Pro Embed GND GND VCC 5V SDA 20 SCL 21
Ved aquí donde están estos pines en el arduino:
Una imagen vale más que mil palabras:
Ahora conectamos el Arduino al PC mediante el cable USB.
Listo para detectar el puerto I2C. Desde la consola IDE de Arduino en el PC pulsamos el icono «monitor serie» que se muestra en la figura siguiente:
Y aparecerá la siguiente pantalla indicándonos el número de puerto detectado.
Tomaremos nota del puerto detectado para configurar el programa más adelante.
PASO 4 Instalación de las librerías necesarias.
Dado nuestro ejemplo, hay que descargar el proyecto desde Megaduino firmware_1.3 y descomprimir el contenido en una carpeta que se llame «MegaDuino_1.3».
A continuación hay que descargar e instalar unas librerías que son necesarias para compilar el proyecto. La primera librería se encuentra en la pagina web de @Merlinkv https://github.com/merlinkv y concretamente dentro de MegaDuino firmware libraries. Si descargáis el sitio de github entero descarga un zip de todo el contenido y podréis descomprimirlo entonces, pero sólo nos hacen falta los ficheros siguientes: LiquidCrystal_I2C.zip, SdFat.zip, TimerOne.zip y TMRpcm.zip. descomprimiremos cada una de ellas en una carpeta con su mismo nombre (LiquidCrystal_I2C, SdFat, TimerOne y TMRpcm) y moveremos estas carpetas a la ubicación del programa, haciendo lo siguiente:
Para empezar, el programa de arduino IDE debe permanecer cerrado, sobre el icono del programa pulsaremos con el botón de la derecha y elegiremos «abrir la ubicación del archivo» esto abrirá un navegador en la carpeta del propio programa. Dentro debe haber una carpeta llamada «libraries» (si no existe la creamos) y una vez dentro las librerías del programa, cada una en su carpeta. Squí es donde copiaremos las carpetas obtenidas anteriormente. Si es una instalación nueva de arduino no debería de haber ninguna carpeta con esos nombres, en otro caso mejor renombrar las carpetas antiguas.
Tanto para renombrar como para copiar nos pedirá utilizar los permisos de administrador.
NOTA: Si has seguido estos pasos correctamente el programa ya te debería compilar sin errores graves (quizás algún warning sin importancia). En caso de que no sea así el github de MerlinKV contiene todas las librerías y un procedimiento para reemplazarlas como modo para superar todos los problemas de librerías.
Paso 5: Carga del firm MegaDUINO 1.3 al CASuino MEGA.
Una vez que hemos configurado correctamente las librerías, ya podemos abrir el entorno Arduino IDE de nuevo, y abrir el proyecto contenido en la carpeta que hemos llamado previamente «MegaDuino_1.3».
Si el nombre de la carpeta no fuese exactamente el mismo que el del fichero «.ino» en su interior, nos daría un código de error, así que hay que renombrar correctamente la carpeta antes de seguir.
-Ir a: Archivo/Abrir, y navegar por las carpetas hasta localizar la carpeta MegaDuino_1.3 y seleccionar MegaDuino_1.3.ino.
Una vez cargado el fichero nos deberá aparecer el código principal y varias pestañas con más contenido.
Configuración de la pantalla OLED/LCD
-Una vez visualizamos el código nos dirigimos a la pestaña MEGA2560config.h y vamos bajando hasta encontrar unas lineas por debajo del mensaje:
/////////////////////////////////////////////////////// /* Configure your screen settings here */ //////////////////////////////////////////////////////
A partir de esta línea configuramos el tipo de pantalla que queremos en nuestro CASduino MEGA. Las líneas que definan nuestra pantalla deben de estar activas y las que no deben ser desactivadas.
El entorno Arduino considera como un comentario cualquier texto a la derecha de una barra inclinada doble («//») por tanto…
Desactivamos cualquier línea añadiendo «//» al principio, y para activar una línea desactivada tenemos que eliminar «//» al inicio de la linea. Estas barras dejan sin efecto cualquier texto a su derecha. Si observamos el ejemplo de la imagen inferior, se puede ver que las líneas 55 a 59 que pertenecen a las pantallas LCD están todas activas salvo la 56. Así pues podemos imaginar que la pantalla LCD de 16×02 está desactivada y la de 20×04 habilitada. Como las pantallas OLED serían incompatibles con cualquier LCD las líneas 67 a 72 también están desactivadas.
Si desactivamos la línea 57 y activamos la 56 estaríamos configurando el código para pantallas LCD de 16×02. Tal que así:
Por último, si lo que queremos es utilizar una pantalla OLED (tanto si es de 0.96″ como de 1.3″) tendríamos que desactivar las líneas 55 a 59 y activar las que van del 67 al 72.
En todos los casos hay que configurar además el número de puerto que nos dió el escáner de puertos en el paso 3. Para ello confirmaremos o corregiremos el número en la línea correspondiente a su tipo, para pantallas LCD en la línea 55 o para pantallas OLED en la línea 69.
Una vez tengamos configurada la pantalla el siguiente paso es compilar el código. Para ello, como hemos visto anteriormente, pulremos el icono (1) y el IDE arduino compilara el código en un archivo binario.
-Si todo es correcto en la parte inferior del IDE arduino obtendréis un resultado como: COMPILADO tal como se vio en pasos anteriores.
-Y por último ya podemos cargar la firm al MEGA2560 pulsado el icono (2) obteniendo como resultado: SUBIDO.
Para poder comprobar que el firmware está funcionando correctamente en la placa de arduino realizaremos el siguiente montaje, ya sea con una pantalla LCD o bien una OLED, OJO! con el arduino desconectado de alimentación, una vez todo conectado correctamente volvemos a alimentarlo.
Tal como hemos conectado antes, los pines 5v, GND, 20 (SDA) y 21 (SCL) a los pines con el mismo nombre en el I2C o pantalla utilizados. Véase como lo conecto a una pantalla OLED de 0.96″:
Aquí de identica forma lo conecto a una pantalla OLED de 1.3″:
También hay que hacer la prueba si nuestra pantalla es LCD, aunque en tal caso es probable que no tengáis el módulo LCD aun soldado con el módulo I2C, un truco es insertar el módulo en los agujeros del LCD y presionando con la mano, mantenerlos inclinados para que haga contacto, así conseguiremos comprobar el módulo LCD de 20×04 antes de haberlo soldado:
Por último os muestro la misma conexión funcionando con un módulo LCD de 16×02 que ya venía soldado a su I2C:
Importante, en estos módulos suele ser necesario ajustar el contraste para poder ver texto alguno en pantalla, por lo que si estáis apretando el módulo I2C inclinado contra la pantalla LCD alguien tendrá que ayudaros para enchufar la alimentación y ajustar el potenciómetro del contraste.
Redactado por Capsule5000 y J. Solís
MSXmakers
MSXmakers! 