******¡¡¡IMPORTANTE!!!******
- Lo que se explica en este POST, es únicamente con fines didácticos. Úsalo sólo a título personal.
- Tifloinformático, su autor y/o los desarrolladores de las herramientas mencionadas, no se hacen responsables del mal uso que le des al contenido de esta entrada, siendo tú el/la único/a responsable.
- Las herramientas mencionadas, son propiedad de sus autores.
- Si citas total o parcialmente este artículo, en internet o por otros medios, debes mencionar la fuente:
http://tifloinformatico.blogspot.com
- Las instrucciones que se describen a continuación son para componentes software y hardware concretos. Aunque pueden servir para otros programas o componentes, no se garantiza que sean válidas para programas y/o componentes distintos de los mencionados en este artículo.
-------------------------
Hoy vamos a dedicar esta entrada, a una mezcla entre informática y electrónica, aunque solo trabajaremos del lado del software, en el ordenador.
Lo que veremos hoy, solo servirá para los que desarrolléis para la plataforma Arduino, o cualquier otra similar. En realidad, para los que programéis microcontroladores; aunque aquí solo veremos como hacerlo con detalle con Arduino, y en concreto el micro Atmega328p.
Para otros programadores y micros, el proceso sería el mismo, pero cambiando algunos parámetros concretos que se refieren al programador y al micro.
Aunque todo lo que voy a explicar podría resumirse poniendo únicamente los comandos necesarios y su explicación, vamos a ir despacio, y vamos a ver también un poco de teoría, incluso sobre la construcción en general de programas, para que aquellos que no tengáis experiencia en el desarrollo de software y os animéis, podáis seguir sin problema esta entrada, y trabajar con las herramientas que he preparado para desarrollar de una forma totalmente accesible para Arduino, o incluso para otras plataformas.
¡Así que ponéos cómodos que empezamos!.
Poniéndonos en situación:
Aquellos que tengáis experiencia con la programación de Arduino en particular, sabréis que es una plataforma muy popular, por el bajo coste del hardware, y por programarse en un lenguaje de programación archiconocido, como es el C/C++; aunque se dice que no es en realidad C/C++, sino una variante de este ... En realidad no es así: Arduino se programa en C/C++, y la gente de Arduino, simplemente ha desarrollado un core (API) en el mismo lenguaje de programación, para facilitar ciertas cosas muy concretas, relacionadas directamente con el microcontrolador: gestión de pines, acceso a memoria ETC.
Arduino, como cualquier otra plataforma y/o lenguaje de programación, suele programarse en un IDE, que es algo así como un editor de texto para redactar documentos, pero para escribir código fuente.
Arduino, como es costumbre en otros lenguajes y plataformas, puede programarse en distintos IDE's. Pero la gente de Arduino ha desarrollado IDE Arduino, que es el IDE oficial de esta plataforma.
Con IDE Arduino, aunque es un IDE bastante básico, es más que suficiente para desarrollar aplicaciones para Arduino, de mayor o menor complejidad; aunque seguramente los usuarios con más experiencia en el desarrollo de software en general, hecharán de menos algunas funciones de IDE's más avanzados.
Una de las ventajas de IDE Arduino, es que al ser tan sencillo, los usuarios principiantes, o no acostumbrados a usar entornos de programación, también pueden usarlo sin problema, ya que no requiere de horas de aprendizaje. Incluso, puede usarse como si fuese un simple bloc de notas, que tuviera integradas las opciones necesarias para compilar y cargar el programa en la placa Arduino.
Problemas del IDE Arduino:
Como todo en la vida, IDE Arduino tiene sus ventajas, pero también sus inconvenientes.
En general, más allá de cuestiones demasiado técnicas para usuarios no avanzados en la programación, y en la programación en C/C++ en concreto, IDE Arduino tiene como desventaja su sencillez, que no gusta a todo el mundo.
Pero más allá de eso, presenta un inconveniente más; que está más bien relacionado con la accesibilidad: está escrito en Java.
Muchos ya sabréis lo que eso supone: muchísimos problemas con los lectores de pantalla, y el puente de accesibilidad entre estos y Java (Java access bridge). Ya que aunque instalándolo y configurándolo correctamente, debería funcionar; pero no siempre es así... Nunca he sabido por qué, pero es una lotería que Jaws o NVDA funcionen correctamente con Java access bridge, y sean capaces de leer correctamente aplicaciones escritas en Java. Y más difícil todavía, es que lo hagan los dos a la vez.
Pero eso no es el mayor problema de accesibilidad que presenta IDE Arduino: si todo funciona correctamente, conseguiremos leer correctamente casi toda la interfaz del programa sin problema, y podremos escribir el código de nuestros programas para Arduino, compilarlo, cargarlo en la placa ETC, sin problema.
*Casi; porque hay una parte del programa a la que no vamos a poder acceder de ninguna manera, ni siquiera usando el OCR de Jaws o NVDA. Y es la parte más importante para nosotros como programadores: el área de mensajes del IDE.
El área de mensajes, es una zona de la interfaz del programa (en la parte inferior) donde el IDE muestra algunos mensajes, como los relativos a la compilación del programa que hayamos escrito, o el resultado de la carga de este en la placa.
Al pulsar en las opciones correspondientes, el IDE nos indica si han habido errores durante la compilación o carga del programa en la placa, o si el proceso se ha realizado correctamente. Incluso, puede mostrarnos todo el proceso de forma transparente, si habilitamos las opciones correspondientes a mostrar la salida de cada proceso, en las preferencias del IDE.
Pero como decía, todo esto es imposible de leer con un lector de pantalla, ni siquiera utilizando las funciones OCR de estos.
Hasta ahora, yo intuía si todo había ido bien, o habían ocurrido errores al compilar, si por ejemplo, al compilar el programa, con cursor de Jaws a PC (usando Jaws for Windows) y por si acaso leía algo más, usando el OCR de este, aparecía un botón que pone "copiar mensajes de error".
En ese caso, algo no ha ido bien, y aquí si es posible pulsar este botón, y ver los mensajes de error.
Pero a la hora de cargar el programa en la placa, si ocurren errores, no hay manera de saberlo, salvo probando la placa, a ver si se comporta tal como hemos programado.
Solución de problemas:
Dado que me resulta muy incómodo trabajar así, y que no soy muy amigo de los IDE's (soy demasiado tradicional para programar, y me apaño más que bien con el blog de notas y un compilador independiente) no me merece la pena usar el IDE oficial de Arduino; que lejos de no ser muy amigo de los entornos de programación, es un suplicio trabajar con uno que no es accesible en las partes más importantes... Y eso cuando es accesible simplemente.
Así, que he hecho por probar otros IDE's, como Notepad++ o Eclipse con un plugin para Arduino.
El primero no conseguí hacerlo funcionar. Y siendo sincero, tampoco le puse mucho empeño para hacerlo.
El segundo, era más sencillo, ya que en teoría hay un paquete que trae el plugin instalado y configurado, listo para usar (salvo por que hay que hacer algunos ajustes menores).
Pero aunque intenté hacer algo con él, se colgaba muy amenudo, y nunca supe como utilizar Eclipse... Así que no conseguí gran cosa tampoco con este.
Así, que finalmente he decidido optar por lo que más me gusta, y lo que prefería desde un principio: desarrollar para Arduino de la forma más rudimentaria posible.
Si investigamos un poco, aprenderemos cosas muy interesantes. Como que IDE Arduino al igual que por ejemplo Eclipse con el plugin de Arduino integrado, no hacen otra cosa, que facilitarnos un poco la tarea de programar el microcontrolador, y a la hora de compilar el código que hemos escrito, dejar que lo hagan herramientas de terceros (no desarrolladas por la gente de Arduino) de una forma tan básica, como la línea de comandos.
Como decía al principio, Arduino se programa en C/C++. Por tanto, no hay necesidad de crear un compilador específico para Arduino, ya que además de que C/C++ es uno de los primeros lenguajes de programación, los microcontroladores de Arduino tampoco es algo que se haya creado específicamente para esta plataforma.
Así pues, la gente de Arduino, a la hora de crear el IDE oficial, solo tuvo que hacer un programa donde pudiéramos escribir el código fuente de nuestros programas, compilarlo y cargarlo en una placa Arduino (con algunas funciones típicas de IDE's). Pero nada de crear compiladores ETC; sino que han buscado las herramientas necesarias y las han empaquetado con el IDE que han creado, que por otra parte, éste sabe manejar perfectamente.
Así pues, cuando pulsamos en la opción correspondiente para compilar un programa en el IDE Arduino, este lo que hace es invocar un compilador de C/C++, con los parámetros necesarios para que este genere un archivo con el código binario que luego se transferirá a la placa Arduino.
Sabiendo esto, tenemos gran parte del trabajo hecho, para poder prescindir de IdE Arduino, y en realidad de cualquier IDE, y programar con el bloc de notas, o el editor de texto que prefiramos; o incluso, escribir el código fuente con el IDE que más nos guste, y compilarlo de forma independiente.
Esto que así visto parece sencillo, no lo es tanto. Y es que hay que usar varios programas, cada uno con muchos comandos, hasta que el programa que hayamos escrito, acabe cargado en la placa Arduino.
Hoy no veremos como programar en C/C++. Tan solo, como compilar código en este lenguaje, preparándolo para que funcione correctamente en Arduino. Y también veremos como cargar el programa compilado en una placa Arduino.
Para que os sea más sencillo, he preparado un paquete con todo el software necesario, para que no tengáis que buscarlo, descargarlo y hacer algunos ajustes para que sea un poco más sencillo todo el proceso.
El software puede descargarse de internet, tanto de páginas oficiales como de cualquier otro sitio. Pero para asegurar que es un software totalmente limpio y fiable, yo lo he extraído de una instalación de IDE Arduino.
Además del software para compilar y cargar programas en Arduino, en el paquete hay otras utilidades, como los drivers necesarios para la comunicación entre el ordenador y Arduino; que como sabréis, se conecta al ordenador mediante USB (aunque internamente la conexión es tratada como si de un puerto serie se tratara).
¡Manos a la obra!:
Después de una larga retaíla para calentar motores, ha llegado el momento de ponernos manos a la obra; porque si bien he intentado simplificar el proceso, no os voy a engañar: no es sencillo, y vais a tener que escribir bastante.
Puede que más adelante automatice casi al máximo todo lo que vamos a ver a continuación. Pero no está de más que sepáis como funciona realmente todo el proceso, y sepáis hacerlo a mano que siempre es lo más seguro.
Como ya había dicho, las herramientas que vamos a ver funcionan mediante línea de comandos.
Además, una de las ventajas que tiene hacer el proceso directamente con las herramientas de compilación y carga del programa en Arduino, es que estas son multiplataforma; por lo que están disponibles tanto para Windows como para Linux, y además, los comandos deberían ser exactamente los mismos.
Por lo que los pasos que vamos a ver para compilar y cargar programas en Arduino, servirán tanto para usuarios de Windows como de Linux.
Construcción de un programa C/C++:
Antes de empezar, es importante comprender el proceso de construcción (compilación) de un programa en C/C++.
Es importante, porque si bien con este método vamos a poder seguir programando para Arduino usando el Core desarrollado por la gente de Arduino, como si usáramos el IDE Arduino, lo cierto es que vamos a tener que trabajar de una forma más directa con C/C++ y también vamos a tener que conocer muy bien el Core Arduino, ya que tendremos que tratarlo más directamente.
Cuando desarrollamos en C/C++, desde que escribimos el código fuente hasta que obtenemos el programa, que podemos ejecutar en el ordenador, han de ocurrir varias cosas antes de poder ejecutar el programa.
Por eso, se dice que existen varias etapas en la construcción de un programa; esto puede aplicarse a la construcción de un programa en general (con cualquier lenguaje de programación). Pero en algunos lenguajes más modernos, el proceso puede variar simplificándose, respecto a C/C++.
Vamos a ver el proceso de creación de un programa en C/C++, que es lo que nos interesa, por ser el lenguaje en el que normalmente se desarrolla para Arduino.
Al margen del diseño del programa que sería la primera etapa (fase) en la que "sobre papel" se diseñan todas las funciones del programa, opciones, interfaz, objetivo de la aplicación ETC; lo primero que hay que hacer para crear una aplicación, una vez tenemos un boceto de este, es escribir el código fuente.
El código fuente, es la forma en que le indicamos al microprocesador qué hacer. Pero no es tan sencillo: hay que indicarle qué hacer; en cada caso, ante cualquier error, ante una respuesta correcta de un componente que controla... En definitiva, el código fuente son las instrucciones que le damos al microprocesador.
Es responsabilidad del programador, darle al microprocesador las instrucciones correctas y necesarias, ante cualquier situación; porque el microprocesador por si mismo, no sabrá qué hacer ante ninguna situación posible.
El código fuente se escribe utilizando un lenguaje "de alto nivel" (aunque los hay también de "bajo nivel").
"alto nivel" y "bajo nivel", se refieren a la proximidad del lenguaje en el que se programa, al lenguaje humano, o al lenguaje de las máquinas que es el binario... Sí, los archifamosos ceros y unos, que todo el mundo sin ser informáticos ni programadores; incluso aquellos que peor se llevan con la tecnología, conocen.
Existen lenguajes de bajo nivel, como el Ensamblador. Este lenguaje es sino el más, de los más complicados, ya que es muy próximo al "lenguaje binario".
Pero por suerte para nosotros, también existen muchos lenguajes de programación de alto nivel, que son mucho más fáciles de comprender.
Uno de ellos es el C/C++; que si bien no es de los lenguajes de programación más sencillos, se considera de alto nivel.
Las ventajas de C/C++ son muchas: un lenguaje robusto, con más de 30 años de antigüedad que lo han usado miles de programadores por todo el mundo.
Es un lenguaje de programación de propósito general. Esto quiere decir, que con C/C++ puede programarse absolutamente de todo: desde juegos, agendas, sistemas de navegación... hasta sistemas operativos: Windows o Linux están programados prácticamente en su totalidad en C/C++.
Los programas escritos en C/C++ son portables, lo que quiere decir que mientras se use el C/C++ estandar, los programas que se escriban en este lenguaje, podrán ejecutarse sin problema en cualquier plataforma.
Si hay que usar características concretas de una plataforma o sistema operativo, es necesario usar librerías para ello, tales como el Core Arduino; que como ya hemos dicho, es un API desarrollado para hacer más fácil la programación para la plataforma Arduino.
Igualmente, existen librerías para desarrollar software para Windows, Linux ETC.
Como no podía ser de otra manera, este lenguaje de programación también tiene desventajas, si se le puede llamar así; aunque para muchos las tiene: la curva de aprendizaje es más grande que la de otros lenguajes.
Para muchos es un lenguaje obsoleto, y prefieren otros más modernos como Java o C#. Pero detrás de estos lenguajes modernos, hay miles de líneas de código C/C++.
Tras este pequeño paréntesis para ver un poco de teoría sobre C/C++, continuamos con el proceso de creación de un programa.
*Recordad que esto es para crear programas en C/C++ en general, no sólo para Arduino. Por eso es importante verlo antes de empezar con nuestro objetivo de crear un programa para Arduino sin entornos de programación.
Tras haber escrito todo el código fuente del programa, viene la segunda fase, que podríamos considerar como la más compleja e importante de todo el proceso: la compilación.
Compilar, es la tarea de "traducir" el código fuente en código binario.
Dijimos que el código fuente son las instrucciones que escribimos en un lenguaje que comprendemos los humanos, para que las ejecute el microcontrolador.
Lo que no hemos dicho, es que el microcontrolador no es capaz de comprender estas instrucciones tal como las escribimos nosotros. Un microcontrolador únicamente conoce ése inexplicable lenguaje plagado de ceros y unos, que los humanos somos incapaces de comprender.
Así pues, para que humanos y procesadores sean capaces de entenderse, ha de haber un proceso de "traducción", del lenguaje de los humanos, al lenguaje de las máquinas: y a este proceso se le llama compilación.
Esta tarea tan compleja de convertir el código fuente en código binario, la hacen los compiladores.
Existen compiladores para todos los lenguajes de programación, y cada compilador puede ser más o menos difícil de usar.
Hay compiladores independientes, integrados en IDE's... Pero al final, su misión siempre es la misma: convertir el código fuente en código binario.
Como podéis imaginar, si programamos en C/C++ no podemos usar un compilador de Java, porque no sabría interpretar nuestro código fuente.
Es algo así, como que si hablamos español y queremos comunicarnos con una persona que hable inglés, hemos de hacerlo mediante un intérprete de español a inglés y viceversa, y no con uno de ruso a inglés, porque no nos entendería, y no podría transmitirle a la persona que habla inglés, lo que queremos decirle.
Algunos compiladores hacen otras funciones que veremos más adelante, además del proceso de conversión de código fuente a código binario. Esto es más común en lenguajes más modernos.
En C/C++, el proceso suele ser más transparente, y en algunos casos el programador ha de encargarse de realizar todas las etapas del proceso de la creación del programa; aunque esto también dependerá del compilador.
Si nos centramos en un proceso de construcción del programa "paso a paso", el compilador únicamente convierte el código fuente en código binario, por lo que aún el proceso no ha terminado; ya que el archivo que genera el compilador si todo ha ido bien, a partir del código fuente, todavía no puede ejecutarse, pese a ser ya un archivo que contiene código binario que es lo que entienden las máquinas.
Al archivo que genera el compilador se le conoce como archivo objeto, y aunque en otros compiladores puede cambiar, en los compiladores de C/C++ y en concreto el que vamos a usar nosotros, su extensión es .o.
Estos archivos por si mismos no son funcionales, ya que en C/C++ los programas suelen estar compuestos por distintos recursos, que se compilan por separado.
De hecho, el programa que escribamos nosotros mismos, se debe compilar en distintas partes... Tantas como ficheros compongan el proyecto de nuestra aplicación, o casi.
Esto es así, porque un programa sencillo que por ejemplo haga una suma de dos valores, puede escribirse en un único archivo fuente sin problema. Pero aplicaciones mucho más complejas como un sistema operativo, suele escribirse en muchos archivos fuente, para una mejor organización del código fuente, y mejor comprensión del mismo.
En el caso de dividir el código fuente en varios archivos, hay que compilar cada archivo por separado, de forma que obtengamos un archivo objeto por cada archivo fuente. Esto se hace de forma automática en todos o la mayoría de IDE's, pero hemos de hacerlo de uno en uno, si usamos directamente el compilador.
Una vez obtenidos los archivos objeto del programa, habremos superado la parte más compleja del proceso, ya que significará que hemos escrito el código fuente sin errores; al menos, sin errores sintácticos, porque existen otros errores "sutiles", mucho más difíciles de detectar.
Pero al menos, obteniendo el código máquina del programa, podremos finalizar el proceso de construcción de este.
El siguiente paso, es el enlazado: En este punto, lo que se hace es mezclar todos los archivos del código fuente que habíamos escrito, con las librerías y demás recursos necesarios del programa, si los hubiera.
Esto puede en ocasiones hacerlo el propio compilador, si es un compilador más o menos avanzado, que disponga de la función de linker. Pero no siempre ha de ser así, y pueden haber compiladores que no tengan esta opción, y tengamos entonces, que usar un linker, que es una herramienta cuyo objetivo no es otro, que empaquetar todos los archivos objeto y/o otros recursos, en un archivo ejecutable, que luego podremos usar normalmente para ejecutar el programa.
Es aconsejable, aun cuando el compilador sea capaz de enlazar los archivos objeto, decirle expresamente que no lo haga, y detener el proceso en la etapa de compilación; de forma que únicamente genere los archivos objeto, para luego enlazar manualmente los archivos: así es como lo haremos en el ejemplo que veremos más adelante, de creación de un programa para Arduino.
Una vez terminada la etapa de enlazado, tenemos construido por completo el programa. Como decía, esto no quiere decir que el programa no tenga errores: el compilador es capaz de detectar errores sintácticos, que son errores en la sintaxis del código fuente. Pero no es capaz de detectar errores semánticos que hay quien los llama "sutiles".
Este tipo de errores, es responsabilidad del programador, encontrarlos y depurarlos, si bien son difíciles de detectar.
para ello solo hay una fórmula: paciencia y practicar.
Adaptación de un squetch arduino:
Ahora que conocemos el proceso real de la construcción de un programa en C/C++, estamos en condiciones de empezar con lo realmente interesante.
Como ya hemos dicho, IDE Arduino nos facilita un poco la vida a la hora de programar para Arduino, ya que incluye un core que podemos utilizar para programar más fácilmente algunas cosas concretas del microcontrolador, que de otra forma, simplemente valiéndonos de las instrucciones de C/C++, podríamos hacer; pero sería bastante más complicado.
Además, tendríamos que conocer ciertas instrucciones concretas, y el funcionamiento interno de microcontroladores AVR, que son los que normalmente tienen las placas Arduino.
Así pues, en principio no podríamos ponernos a programar en el blog de notas y compilar, ya que, si lo hacemos intentando usar las funciones del core Arduino, al no estar presentes las librerías de este, el compilador nos daría errores y no obtendríamos los archivos objeto.
Por eso, en el paquete de software que he preparado, está incluido el core Arduino para que podáis usarlo sin problema.
Este al igual que las herramientas de compilación y carga de los programas en Arduino, está sacado de una instalación de IDE Arduino, para garantizar que sea el core oficial y no tenga modificaciones más allá de las necesarias para que todo funcione correctamente.
Es importante conocer el core Arduino; cosa que es tarea vuestra, encontrar documentación y aprender a usar el API, así como aprender a programar en C/C++.
Pero si queremos programar para Arduino fuera de cualquier entorno de programación que tenga incluido el API, es imprescindible conocer el core, aún más si cabe.
Es importante, porque por ejemplo, una de las cosas que hace IDE Arduino para facilitarnos la programación es incluir las librerías del core Arduino que sean necesarias, según el código fuente que hayamos escrito: es decir, al pulsar el botón correspondiente para compilar el programa, IDE Arduino analiza el código fuente y hace un preprocesado, donde entre otras cosas, incluye código fuente que nosotros no hayamos puesto como por ejemplo la inclusión de las librerías que contengan las funciones y/o prototipos de estas, que hayamos usado en el código fuente de nuestro programa.
Además, hace otras cosas, como incluir en el programa una función Main, que habitualmente no se escribe en un squetch Arduino, pero que en cambio es una función obligatoria en todo programa escrito en C/C++.
No lo habíamos dicho. Pero un squetch, es la forma en que en el mundo Arduino se llama a lo que tradicionalmente, en la programación en C/C++ al igual que en otros lenguajes, se conoce como archivo fuente.
En la fase del preprocesamiento del squetch, IDE Arduino hace otras cosas, como concatenar todos los archivos del proyecto en uno solo y renombrar el archivo a compilar; ya que en IDE arduino, la extensión de los archivos fuente es .ino, mientras que en C/C++ la extensión de estos ha de ser .c, .cpp, .h ETC.
Arduino CMD builder:
Este es el nombre que le he dado al paquete de software que he preparado, que contiene todo lo necesario para compilar y cargar un squetch Arduino en una placa de esta plataforma.
Sí, lo sé: el nombre no es muy original. Pero expresa el cometido de las herramientas que contiene.
Antes de empezar, vamos a ver el contenido del paquete, que cuando lo descarguéis, estará comprimido en un archivo RAR, que al descomprimirlo veréis que contiene un archivo ejecutable, desde el que podréis extraer todo el contenido del paquete, únicamente eligiendo la ruta donde queréis ponerlo.
El paquete está formado por archivos y carpetas. Todas las herramientas que se necesitan para compilar y cargar un squetch en una placa Arduino son portables, por lo que no es necesario instalar nada, salvo los drivers para la comunicación entre las placas Arduino y el ordenador, tal como ya habíamos dicho.
Al extraer el contenido del archivo ejecutable encontraréis los siguientes directorios:
- Arduino:
Dentro de esta carpeta encontraréis, dentro de un subdirectorio llamado AVR, distintas herramientas que posiblemente podáis necesitar en algún momento.
Entre otras, se encuentra una carpeta llamada Core, que es la que posiblemente más vayáis a utilizar ya que contiene todas las librerías del core Arduino.
Otra de las carpetas que podéis encontrar es "bootloaders" que contiene los bootloaders de las placas Arduino; las he incluido para que las tengáis a mano, por si os hace falta alguna vez. Pero normalmente no será el caso.
En cualquier caso, deberéis buscar información sobre como quemar un bootloader en internet, ya que eso no lo veremos aquí.
El resto de archivos y carpetas, igualmente se incluyen por si fueran necesarios en casos puntuales. Pero es igualmente poco probable que los necesitéis.
- drivers:
Esta carpeta es muy importante, y la primera que tendremos que utilizar, ya que como dije, es imprescindible instalar los drivers necesarios para que pueda establecerse correctamente la comunicación entre el ordenador y las placas Arduino.
Cuando instalamos IDE Arduino, los controladores se instalan directamente (desde esta carpeta). Pero cuando vamos a trabajar sin el IDE, y no lo tenemos instalado, hemos de hacer nosotros la instalación manualmente.
Para ello, podéis instalar si queréis todos los controladores que encontréis, si no tenéis claro cual es el de vuestra placa Arduino. Si sabéis qué controlador tenéis que instalar, podéis hacerlo, omitiendo el resto.
En cualquier caso, instalar todos los controladores no afectará al rendimiento del ordenador, ni a la hora de trasferir los programas a la placa Arduino.
Un controlador que debéis instalar en cualquier caso es el que se encuentra en el subdirectorio "FTDI USB Drivers".
Su archivo de instalación es "ftdibus.inf".
Existen varias formas de instalar un controlador en Windows; podéis hacerlo de la forma que más os guste.
Si es posible, lo más rápido siempre es pulsar tecla aplicaciones sobre el archivo INF del controlador, y pulsar sobre la opción "instalar". Pero a veces puede ocurrir que Windows dé un error diciendo que el método de instalación no es compatible con ése controlador.
En ese caso, podéis instalarlo desde el símbolo del sistema; aunque también podéis usar un instalador que contiene la carpeta Drivers del paquete de software, que os hará mucho más fácil la tarea de instalar los controladores.
El archivo del instalador se llama "dpinst-amd64.exe" para sistemas operativos Windows de 64 bits, y "dpinst-x86.exe" para Windows de 32 bits.
Es importante ejecutar cualquiera de los dos instaladores según la edición de Windows que tengáis: 32 o 64 bits, como administrador, como viene siendo habitual en Windows.
Una vez ejecutado el instalador, simplemente tenemos que pulsar "siguiente" en la primera pantalla que nos aparece y esperar que finalice la instalación de los controladores.
Una vez terminada la instalación, aparece una pantalla que nos indica que la instalación se ha realizado correctamente, y nos muestra una lista de los controladores que se han instalado en el equipo; entre los que se encuentra el controlador USB que realizará la conexión entre el ordenador y las placas Arduino.
De todas formas, si véis que no se han instalado todos los controladores que hay dentro de la carpeta Drivers, podéis instalarlos manualmente como ya he explicado.
- examples:
Esta carpeta también la he cogido de una instalación de IDE Arduino.
La he incluido en el paquete para que tengáis ejemplos que revisar de programación Arduino, si lo necesitáis.
- Lib:
Esta carpeta contiene una subcarpeta llamada "Static", que contiene una librería estática.
No entraremos demasiado en detalle sobre las librerías estáticas; tan solo decir, que es un tipo de librerías de los programas hechos en C/C++.
Estas librerías contienen librerías escritas en código C/C++. En este caso, en este subdirectorio se encuentra el archivo "LibCore.a", que contiene todo el Core Arduino compilado y empaquetado en una librería estática.
En realidad, la construcción de la librería estática ha de ser tarea vuestra, ya que cada programa requerirá unas librerías del Core Arduino distintas, y prácticamente nunca haréis un programa que las requiera todas; por lo que no es necesario incluirlas todas, ya que eso hace aumentar el tamaño final del programa. Y Arduino no anda sobrado de recursos precisamente, por lo que hay que optimizar al máximo los programas que hagamos para esta plataforma.
En cualquier caso, si no váis a hacer proyectos muy complejos, y vuestros programas no ocupan demasiado, aunque lo aconsejable es que construyáis vuestra propia librería estática como ya veremos más adelante, podéis usar la que incluye Arduino CMD builder, que he construido con todo el core Arduino, para que podáis saltaros este paso del proceso de compilación que luego veremos.
- libraries:
Esta carpeta contiene las librerías que vienen en una instalación de IDE Arduino, y alguna más que había instalado yo y que dejo en Arduino CMD builder porque considero interesante tenerlas: "DFPlayer_Mini_Mp3". Es una librería para un reproductor de MP3 bastante popular llamado DFPlayer Mini, y "HC-SR04". Una librería para el sensor de ultrasonidos HC-SR04.
En todas las librerías viene todo lo necesario para usarlas y en la mayoría también algunos ejemplos. La documentación de todas ellas podéis encontrarla en internet sin problema.
- Make:
Esta es la carpeta más importante, ya que contiene todo el software necesario para la compilación y carga de los squetchs en las placas Arduino.
Más adelante veremos su contenido.
- OBJ:
Esta carpeta contiene todas las librerías del core Arduino compiladas, pero sin empaquetar en una librería estática; tan solo se trata del archivo objeto de cada librería.
además, aunque normalmente no os hará falta, en esta carpeta he dejado también el archivo de dependencias de cada archivo objeto. Estos son los archivos con extensión .d, por si os fuera de utilidad en algún momento.
Hay que tener en cuenta un par de cosas en cuanto al contenido de esta carpeta: Existe un archivo al que le he modificado lijeramente el nombre, respecto al core Arduino de IDE Arduino: "wiring_pulseASM.o".
Este archivo, originalmente se llama "wiring_pulse.S", y al compilar todos los recursos por separado, IDE Arduino lo renombra como "wiring_pulse.S.o". Pero a mi me ha parecido más descriptivo sustituir ".S" por "ASM" de asembler (ensamblador); porque los archivos con extensión .S, son los que contienen código en Ensamblador.
Le he añadido "ASM", porque ya existe un archivo llamado "wiring_pulse.o" que es el archivo objeto del archivo fuente de "wiring_pulseASM.c".
Si os fijáis, dentro de \Arduino_CMD_builder\OBJ, hay un archivo llamado "main.o".
Este archivo contiene una función Main() que IDE Arduino vincula automáticamente a los squetchs, pero que al prescindir de él, hemos de vincular nosotros manualmente.
Para ello, únicamente hay que incluir el archivo "main.cpp" en nuestro squetch, y luego empaquetar el archivo "main.o" en la librería estática, para que el programa pueda encontrar el código fuente de la función Main.
Como véis, es muy sencillo, ya que no hemos ni siquiera de escribir el código de la función.
- SRC:
Por último, la carpeta SRC contiene un pequeño squetch de ejemplo. Es el código con el que he ido probando que todo funcionara correctamente.
Luego veremos que el programa está compilado en todas las fases, en otro directorio dentro de la carpeta Make.
El directorio sRC no es imprescindible, por lo que podéis eliminarlo si queréis.
También podéis dejarlo, y colocar en él los archivos de vuestros programas para tenerlos organizados dentro de Arduino CMD builder.
Compilando un squetch:
Ahora que ya hemos visto todo el contenido de Arduino CMD builder y algunas cosas a tener en cuenta antes de compilar un squetch, es hora de empezar a compilar un squetch desde el símbolo del sistema.
Vamos a usar el código que hay en \Arduino_CMD_builder\SRC como ejemplo en el proceso de compilación que vamos a ver aquí.
Cada vez que veáis una ruta a un archivo, tal como se irá indicando en cada caso, podéis sustituirla por la ruta que corresponda en vuestro caso.
Las instrucciones que vienen a continuación son para Windows, pero salvo cosas puntuales, servirán también para Linux, o cualquier otro sistema para el que estén disponibles las herramientas que vamos a usar.
El software incluido en Arduino CMD builder sólo es para Windows. Si usáis otro sistema operativo, tendréis que buscar las herramientas para el sistema que corresponda.
Lo primero que tendremos que hacer es abrir una ventana de consola del sistema.
En Windows podemos hacerlo llendo al menú inicio, y escribiendo CMD en el cuadro de búsqueda; para abrir el símbolo de sistema que es uno de los resultados que aparecen, nos ponemos sobre éste, y con tecla aplicaciones pulsamos sobre "Ejecutar como administrador".
Una vez en el símbolo del sistema, lo primero que tendremos que hacer es ir a la ruta donde tengamos el paquete de Arduino CMD builder.
Esto dependerá de donde lo hayáis descomprimido. Vamos a asumir que el paquete se encuentra en C:\Arduino_CMD_builder para hacerlo más fácil.
*intentad no usar rutas con espacios para evitar errores.
Lo primero que tendremos que hacer es ir a la raíz del disco, para desde ahí ir a la ruta del paquete de Arduino CMD builder. Para eso escribiremos:
cd C:\
Con este comando iremos directamente a la raíz del disco, sin necesidad de ir retrocediendo carpetas de una en una.
Ahora, para acceder al directorio de Arduino CMD builder, escribiremos:
cd C:\Arduino_CMD_builder
Si os fijáis, en la parte inferior de la ventana de la consola nos aparece la ruta en el que estamos en cada momento; si nos equivocamos escribiendo la ruta, nos aparecerá un mensaje de error que indicará que la ruta no se encuentra, si no existe la ruta indicada. Si existe, veremos en el prompt como nos indica la ruta errónea.
Una vez en el directorio raíz del paquete, hemos de ir al directorio donde se encuentran las herramientas de compilación con el siguiente comando:
cd make\avr\bin
Ahora ya estamos en el directorio de las herramientas más importantes de Arduino CMD builder, solo nos falta escribir todos los comandos para compilar y cargar nuestro squetch en la placa Arduino.
Antes de eso, vamos a ver un directorio más que vamos a necesitar. Usaremos este, que he incluido en el paquete, para que tengáis ya creada una carpeta donde almacenar los binarios de vuestros programas de forma ordenada. Pero podéis usar cualquier otra ruta que queráis: "C:\Arduino_CMD_builder\Make\Build".
Por defecto, al descomprimir Arduino CMD builder, veréis que esta ruta no está vacía. He dejado todos los binarios ahí, del código de ejemplo que hay en el directorio SRC, de la raíz del paquete; así como los binarios del core Arduino. Pero podéis borrar todos los archivos que contiene si queréis. En cualquier caso, siempre y cuando los archivos de vuestros squetchs no tengan el mismo nombre no pasará nada. De lo contrario, el contenido existente será sobreescrito por el compilador y la herramienta de enlazado.
Teniendo claro donde tenemos almacenado el código fuente de nuestro squetch, y donde queremos guardarlo, vamos a ejecutar el primer comando para compilarlo.
Recordad que el squetch hemos de compilarlo archivo por archivo: El código fuente que vamos a usar, está escrito todo en un único archivo, porque es muy básico (el típico ejemplo de papadeo de un LED de Arduino). Pero un programa más complejo podría dividirse en varios archivos fuente.
En ese caso, deberíamos repetir el comando siguiente, una vez por cada archivo del proyecto, cambiando en cada caso el nombre del fichero fuente y del archivo objeto; y de las rutas de estos si fuera necesario:
avr-g++ -I C:\Arduino_CMD_builder\Arduino\avr\cores\Arduino\ -c -Wall -x c++ -MMD -DF_CPU=16000000L -Os -mmcu=atmega328p -O -o C:\Arduino_CMD_builder\Make\Build\blink.o C:\Arduino_CMD_builder\SRC\blink.ino
*Es importante respetar las mayúsculas de los parámetros precedidos por guiones, ya que como puede verse en la línea del comando anterior, este contiene "-O" y "-o" que no significan lo mismo para el compilador: -O le indica que optimice el código, y en cambio -o le indica la ruta del archivo fuente.
El parámetro "-I" idnica al compilador donde buscar el core Arduino.
Esto quizás no sería necesario, ya que es importante incluir explícitamente en el código fuente del programa las librerías que vamos a usar. Pero por si acaso, es mejor que también le indiquemos al compilador la ruta del core Arduino.
El parámetro "-Wall", indica al compilador que nos muestre todos los mensajes tanto de warnings (alertas) como errores.
En cambio, si no hay ninguno de estos mensajes que mostrar, significa que el código fuente está bien escrito y el compilador no mostrará ningún mensaje... Ni siquiera para confirmar la operación.
El parámetro "-x c++" indica al compilador que vamos a compilar un código fuente escrito en C++. Por lo general, C++ incluye a C, así que no debería haber ningún problema si pasamos este parámetro para un squetch escrito puramente en C. Pero en ese caso podríamos quitarlo sin problema.
El parámetro "-DF_CPU" indica al compilador la velocidad del reloj del microcontrolador. En este caso, para el Atmega328p que es el microcontrolador para el que estamos compilando, su velocidad es "16000000L" (16 MHZ). Pero tendréis que consultar la velocidad del microcontrolador para el que vayáis a compilar, si es distinto al Atmega328p.
Por último, el parámetro "-mmcu" indica al compilador para qué microcontrolador estamos compilando nuestro programa; en este caso, el Atmega328P. Pero las placas Arduino usan otros micros.
Deberéis consultar qué microcontrolador tiene vuestra placa Arduino y si está soportada por AVR-G++.
¡IMPORTANTE!: cada archivo fuente de un squetch ha de incluir explícitamente Arduino.h, que forma parte del core de Arduino.
Este archivo de cabecera contiene todos los prototipos de las funciones del API, por lo que debe ser incluido, al margen de si se usan o no todas las funciones del API.
Vinculación de librerías:
¡Ya queda menos!. Si todo ha ido bien, ahora en "C:\Arduino_CMD_builder\Make\Build" tendremos los archivos "blink.d" y "blink.o".
El primero es el archivo de dependencias del archivo objeto, que es "blink.d".
El archivo de dependencias nosotros no lo usaremos directamente, pero lo dejaremos de momento junto con el archivo objeto, para evitar errores durante la fase de enlazado.
Si os habéis fijado la primera vez que habeis abierto esta carpeta, como dije, he dejado en ella, el contenido de "C:\Arduino_CMD_builder\OBJ". esto es, para que sea más fácil vincularlo todo y no tengáis que mover vosotros los archivos.
En caso de no necesitar todas las librerías del core Arduino, y construir vosotros la librería estática, tan solo tendréis que indicar al compilador las librerías que necesitáis. El resto no se vincularán a la biblioteca estática.
Recordad que siempre hay que vincular los archivos objeto, nunca los archivos fuente. Es distinto: en el archivo fuente incluimos librerías, en el proceso de enlazado, las enlazamos.
La diferencia entre ambos, es que al incluir librerías en el archivo fuente, estamos diciéndole al compilador que copie el contenido del archivo fuente que le indicamos, y lo añada al archivo fuente desde el que se lo estamos diciendo.
A la hora de compilar ese código fuente en el que hemos incluido una librería o cualquier otro archivo, estaremos creando un archivo objeto, que contendrá en realidad varios archivos fuente.
En el proceso de enlazado, es algo similar, pero con todo ya compilado: en código binario, y con los archivos objeto creados como proceda. Sería algo así como cuando comprimimos archivos y carpetas en un archivo RAR o ZIP.
El siguiente comando nos creará una biblioteca estática con tantas librerías del core Arduino como le indiquemos.
Veréis que el uso de esta herramienta no es difícil, pero sí puede ser muy largo, ya que tendremos que escribir el nombre y la ruta de todas las librerías del core Arduino que queramos incluir:
avr-ar rcs C:\Arduino_CMD_build\Make\Build\LibCore.a C:\Arduino_CMD_build\Make\Build\hooks.o C:\Arduino_CMD_build\Make\Build\wiring.o C:\Arduino_CMD_build\Make\Build\wiring_digital.o
En este caso, simplemente le hemos dicho a AVR-AR, que nos genere una biblioteca estática en "C:\Arduino_CMD_build\Make\Build", con el nombre "LibCore.a". El resto de parámetros puede variar, como decía anteriormente, según la cantidad de librerías que necesitemos.
En este caso, le pasamos las tres necesarias para el squetch de ejemplo que estamos usando.
Si todo ha ido bien, obtendremos la biblioteca estática en la ruta indicada. En este caso, la ruta es la misma donde se encuentran los binarios del squetch.
El siguiente paso de la fase de enlazado, es empaquetar la biblioteca estática que acabamos de crear con los archivos del programa con algo así:
avr-gcc -mmcu=atmega328p -Wl,--gc-sections -Os -o C:\Arduino_CMD_build\Make\Build\blink.bin C:\Arduino_CMD_build\Make\Build\blink.o C:\Arduino_CMD_build\Make\Build\LibCore.a -lc -lm
Nuevamente, es importante respetar las mayúsculas en los parámetros precedidos por guiones.
De este comando, lo único que cabe destacar, es que nuevamente, le indicamos el microcontrolador para el que estamos en este caso, empaquetando el programa.
Por lo demás, es importante únicamente asegurarnos de indicarle al compilador correctamente las rutas y los nombres de los archivos a los que nos referimos.
En primer lugar, indicamos el archivo binario que se generará. Podría ser con extensión .ELF, o .BIN; yo he optado por esta segunda.
En segundo lugar, indicamos el archivo objeto de nuestro programa: blink.o. En caso de que el squetch se compusiera de varios archivos, y tuviéramos más de un archivo objeto, tendríamos que indicarlos todos, precedidos de sus rutas correspondientes.
Y por último, le indicamos al compilador la ruta y el nombre de archivo de la biblioteca dinámica que hemos creado anteriormente con las librerías del core Arduino.
Conversión de formato:
Aunque ahora tenemos el squetch realmente compilado, y ya podría funcionar en algunos micros, no será el caso de los que suelen tener las placas Arduino.
Estos microcontroladores no aceptarían un archivo .BIN como ejecutable, así que hay que hacer una conversión a un formato que soporten estos microcontroladores.
Por lo general, los microcontroladores de las placas Arduino trabajan con archivos Intel Hexadecimal (.HEX).
No vamos a preocuparnos demasiado por esto ahora; simplemente nos quedaremos con que los archivos .HEX son un tipo de ejecutable, al igual que lo son los .exe para Windows.
Arduino CMD builder cuenta con una herramienta que nos permite hacer la conversión de .ELF o .BIN a .HEX.
Y es que, no sirve renombrar el archivo para cambiarle la extensión.
Así pues, para pasar el binario que hemos creado a Intel Hexadecimal escribiremos lo siguiente en la consola:
avr-objcopy -j .text -j .data -O ihex C:\Arduino_CMD_build\Make\Build\blink.bin C:\Arduino_CMD_build\Make\Build\blink.hex
Básicamente, le estamos diciendo a avr-objcopy que convierta el archivo blink.bin, en archivo Intel Hexadecimal, indicándole las rutas tanto de origen como de destino.
Cargar el programa en la placa Arduino:
¡POR FIN!. Ahora sí, ya tenemos un ejecutable, totalmente funcional que podemos grabar en el microcontrolador de nuestra placa Arduino y que si todo va bien, debería funcionar.
*El código de ejemplo de "\Arduino_CMD_builder\SRC" puede no serviros para probar, puesto que es un programa que hace parpadear un LED.
Para una persona ciega sería mejor modificar la parte del código que activa y desactiva el LED, para hacer lo propio con un buzzer.
Esto podéis hacerlo cambiando simplemente el número del pin, y conectar un buzzer en otro pin de la placa Arduino, o incluso conectando un buzzer en el pin que se usa en el ejemplo.
Para cargar el programa en la placa Arduino, usaremos una herramienta que también está incluida en Arduino CMD builder y que como no, también funciona mediante línea de comandos.
Esta aplicación se llama avrdude, y sinceramente... ¡Es de temer!.
La mayoría de los problemas en general; tanto usando IDE Arduino, otro IDE o ninguno, a la hora de programar para Arduino, más que en la fase de construcción del squetch, vienen a la hora de cargar el programa en la placa.
Si hecháis un vistazo en internet, veréis que montones de personas tienen problemas para hacerlo. Y por experiencia propia (porque yo también los he tenido, y de hecho los estoy teniendo ahora) os aseguro, que las soluciones que se encuentran por todas partes (típicas soluciones obvias por otra parte) no suelen funcionar.
y es que, no lo había dicho para no desanimaros. Pero suelen haber muchos problemas para comunicar correctamente Arduino con el ordenador.
Pero la culpa no es de las herramientas que se usan para compilar o cargar el programa, ni si quiera del IDE o el entorno que se use para programar: ya sea IDE Arduino, Eclipse... O el bloc de notas.
El problema está en los puertos USB, y los controladores.
Muchas veces, sin saber por qué (no he encontrado una explicación para eso) como solemos tener instaladas muchas cosas que utilizan los puertos USB, los controladores de Arduino no funcionan correctamente; y aunque el ordenador es capaz de reconocer la placa Arduino correctamente, y nos indica el puerto COM en el que se encuentra, avrdude no es capaz de comunicarse con el microcontrolador y da errores al cargar el programa en la placa.
Os preguntaréis, por qué entonces os explico todo esto...
Pues porque cuando eso ocurre, no es solo cuando intentamos programar Arduino sin el IDE oficial. Sino que incluso con este, avrdude no funciona y aparecen exactamente los mismos errores.
Por eso, os voy a explicar como cargar el programa en la placa, usando directamente avrdude. Porque si conseguís que os funcione, lo hará tanto directamente, con IDE Arduino como con cualquier otro IDE.
avrdude se encuentra en el mismo directorio en el que estamos en la consola. Así que únicamente hay que ejecutarlo y pasarle los parámetros necesarios:
avrdude -CC:\Arduino_CMD_builder\make\avr\bin\avrdude.conf -v -patmega328p -carduino -PCOM6 -D -Uflash:w:C:\Arduino_CMD_builder\make\build\blink.hex:i
De nuevo, aquí también es importante respetar las mayúsculas en los parámetros precedidos por guiones.
En el primer parámetro: "-CC:\Arduino_CMD_builder\make\avr\bin\avrdude.conf" estamos indicándole a avrdude, donde se encuentra su archivo de configuración.
En una instalación de IDE Arduino se encuentra en otro directorio; pero yo lo he movido a la ruta en la que trabajamos para que sea más cómodo, ya que aunque yo lo indico en el comando anterior, al estar ubicado en el mismo directorio que avrdude.exe, no es necesario pasarle a éste la ruta del archivo de configuración.
El parámetro "-v" hace que avrdude nos muestre más información del proceso de carga del programa en la placa Arduino.
A continuación, el parámetro "-patmega328p" le indica a avrdude que estamos cargando un programa en un microcontrolador Atmega328p. Debéis consultar qué micro tiene vuestra placa, e indicarlo en éste parámetro si fuera distinto.
"-carduino" indica a avrdude el tipo de programador que estamos usando.
No debéis preocuparos demasiado por esto. Si vais a programar placas Arduino, Arduino será el valor que tendréis que poner siempre aquí.
Fijaos que el parámetro es "-c", igual que el primero. Pero en este caso es una c minúscula, mientras que en el primer caso es mayúsculas; y en cambio no indican lo mismo a avrdude. De ahí la importancia de respetar siempre las mayúsculas.
"-PCOM6" indica el puerto donde se encuentra conectada la placa Arduino que queremos programar.
Esto puede variar cada vez que conectéis la placa, así que es aconsejable asegurarse antes de intentar cargar el programa, para no tener errores.
para ver en qué puerto está conectado Arduino, podemos ir al administrador de dispositivos del sistema.
En Windows; a partir de Windows 7, esto podemos hacerlo llendo al menú inicio, y escribiendo "dispositivos" (sin las comillas) en el cuadro de búsqueda.
Deberemos ir hasta donde pone "Administrador de dispositivos" entre los resultados (en Windows 10 aseguraos de que no es un "Resultado WEB") y pulsar enter sobre él.
Una vez abierto el administrador de dispositivos, deberemos buscar la rama "Puertos (COM y LPT)" y expandirlo.
Una vez abierto, aparecerán más o menos puertos, según la cantidad de cosas que tengáis conectadas al ordenador, y los puertos que este tenga instalados.
Si la placa Arduino ha sido reconocida correctamente por el ordenador, la encontraréis rápidamente ya que os aparecerá algo como "Arduino Uno (COM6)".
Esto es lo que me pone a mi, al conectar una placa arduino UNO.
Así pues, vemos que en mi caso Arduino está conectado en el COM6, que es el que tendría que poner en avrdude para que encuentre la placa sin problema.
Pero a vosotros puede ponernos cualquier otro número, que tendréis que cambiar en el comando de avrdude.
"-D" indica si hay o no que borrar el contenido del chip antes de cargar el programa en la placa.
"-Uflash:w:C:\Arduino_CMD_builder\make\build\blink.hex:i" Indica a avrdude varias cosas.
Por un lado, estamos diciéndole que queremos grabar el programa en la placa. Luego le indicamos la ruta y el nombre de archivo, y por último le decimos en qué formato. Normalmente lo haremos en Intel Hexadecimal, tal como dijimos antes. Pero hay que indicarlo, porque avrdude soporta otros programadores distintos a Arduino, y muchos microcontroladores que pueden trabajar con otro tipo de binarios.
Con este último comando, podríamos hacer muchas otras cosas, como grabar en la eeprom del micro, recuperar un firmware que hubiéramos grabado antes en el microcontrolador, grabar un bootloader, configurar los fusibles del micro ETC.
Pero aquí no veremos nada de eso.
Si todo va bien, avrdude nos informará de que el programa se ha cargado correctamente en la placa. En ese caso, solo nos queda probarla y ver que todo funciona como esperamos.
En caso de haber algún problema, avrdude nos lo indicará, con mensajes bastante descriptivos como "programer is not responding". Si eso pasa ... Preparaos, es una tortura, y puede llevaros muchas horas solucionarlo.
Además, avrdude siempre devuelve cun código de error, que podéis utilizar para buscar información en internet. Avrdude es una aplicación muy popular en la programación de microcontroladores, así que información no os va a faltar.
Eso sí, mucha de ella está en inglés.
Además, avrdude hace hasta diez intentos de cargar el programa en la placa, si detecta algún error.
Al ser línea de comandos no podréis cancelarlo; en ese caso, si no ha funcionado a la primera, difícilmente lo hará en los intentos posteriores... Simplemente dejad que termine y listo.
Solución de problemas con avrdude:
Seguramente, a partir de la carga del programa en la placa, os he desanimado al deciros que suelen haber muchos problemas con esto. Pero creo que tenía que hacerlo, ya que es una realidad; pero una realidad, que no viene por el hecho de usar Arduino CMD builder, sino que como dije, ocurre incluso utilizando IDE Arduino.
Porque como ya he dicho, no tiene que ver ni con el entorno de programación ni con avrdude; sino con los controladores, y con algunas aplicaciones que usan los puertos USB, serie o paralelo.
Como ya he dicho antes, si ocurre algún problema a la hora de cargar un programa en una placa Arduino, os va a costar bastante dar con el problema.
típicamente, en internet, la gente suele recomendar desinstalar IDE Arduino, reinstalar los controladores tanto de Arduino como del USB (de los que hemos hablado más arriba), verificar el cable que usamos para conectar Arduino al ordenador, conectar la placa a otro puerto USB, reiniciar la placa si esta cuenta con un botón de Reset... Y mil cosas más similares.
Incluso me he encontrado gente que dice que la culpa de que avrdude no cargue un programa en la placa, puede ser de que tengamos la placa sobre una superficie metálica... O que se haya cortocircuitado alguno de los pines de alimentación de la placa con GND.
Si os ocurre esto y queréis verificar todas estas cosas, perfecto: no está de más.
Pero por experiencia os digo que no suele ser la solución.
Normalmente el problema viene como decía anteriormente, por los controladores o algún programa que incluso sin tener nada conectado al ordenador, esté haciendo uso de los puertos USB: por algún motivo, se crea un conflicto y misteriosamente, el perjudicado siempre es Arduino.
Un consejo, es que si tenéis instalado algún programa de virtualización en el ordenador donde vayáis a programar una placa Arduino, como VMWare, que lo cerréis por completo.
Este tipo de aplicaciones al igual que otras tantas, suelen crear servicios en el ordenador, que se ejecutan nada más entrar en el sistema, incluso si no abrimos el programa.
Muchos programas lo hacen simplemente para buscar actualizaciones. Pero otros como las máquinas virtuales, hacen otras cosas más complejas. Entre ellas, las máquinas virtuales monitorizan constantemente los puertos del ordenador, al igual que cualquier otro componente hardware; porque los puertos también los virtualizan.
Os digo esto, porque ya me pasó nada más comprar una placa Arduino por primera vez, que no hubo forma de cargar un programa en esta, y el problema, por más que revisé cosas como las que os he dicho más arriba, resultó ser el maldito VMWare player: fue configurarlo para que no se iniciara con Windows, reiniciar ¡y mano de santo!.
En cambio, ahora en otro ordenador, donde alguna vez he programado la misma placa Arduino, ahora es imposible.
También en este ordenador está instalado VMWare player, pero ya me he asegurado de que no inicie con Windows ... He desinstalado controladores de otras cosas que hay conectadas al ordenador, y nada: no hay manera.
Por eso os decía que si tenéis este problema, os puede costar mucho solucionarlo. Pero nada que no le haya pasado ya a medio mundo, que programa placas Arduino.
Por cierto: es aconsejable que no haya nada conectado en ningún pin de Arduino, sobre todo los pines marcados como RX y TX que son los del puerto serie, a la hora de cargar un programa.
Conclusiones:
Como ya había previsto al empezar el post, la entrada esta vez se ha hecho bastante larga,y encima escrita. Pero como decía al principio: he preferido ir despacio y explicando algunos conceptos, que podría haberme saltado; pero quería que esto le sirviera al máximo de personas posible.
El mundo Arduino no es nada sencillo, y el no ver le añade un plus de dificultad en muchas cosas. Pero con paciencia, si realmente os llama la atención la programación y la electrónica, podréis hacer cualquier cosa que se os ocurra. Eso sí, muchas veces sí o sí, con ayuda. pero si os sabéis apañar, con la menos posible que es de lo que se trata.
Desde luego, si optáis por usar IDE Arduino, os resultará mucho más sencillo escribir un squetch, compilarlo y cargarlo en la placa. Pero os acabaréis hartando, porque la mitad lo haréis a ciegas.
En cambio, aunque podéis usar otros entornos de programación, hacerlo con Arduino CMD builder os garantizará que todo el proceso sea totalmente accesible, y usando software multiplataforma y bastante menos pesado que algunos IDES con plugins integrados.
Aunque hay que escribir varios comandos, y todos bastante largos, Arduino CMD builder en realidad, lo hace un poco más sencillo.
En cualquier caso, el proceso podría automatizarse, por ejemplo con un makefile en Linux, o con un BATCH en Windows.
Las herramientas que hemos visto para construir un programa para Arduino, como ya se ha dicho también sirven para otros programadores y microcontroladores. Además, avrdude, es también una herramienta muy potente, que permite hacer muchas otras cosas más allá de cargar un programa en una placa Arduino.
Todas las posibilidades que ofrecen las distintas herramientas que hemos visto, podéis encontrarlas en internet, o usando los comandos de ayuda de cada una de ellas, que normalmente serán algo como: --help, help, -help, /help, /? ETC.
Incluso, en ocasiones escribir solo el nombre del ejecutable del programa ya devuelve información sobre este y su uso.
Si preferís tener la ayuda de cualquiera de estas herramientas en un archivo de texto en vez de en la ventana de la consola, podéis redirigir la salida de la consola a un archivo.
En Windows, esto podéis hacerlo con algo como esto:
avrdude --help > c:\Ayuda_avrdude.txt
Por supuesto, siempre estando en el directorio del ejecutable que váis a invocar, y usando el parámetro correcto para que el programa mueste la ayuda.
Si todo ha ido bien, en la consola no aparecerá nada. Pero en C:\ tendréis un archivo llamado "Ayuda_avrdude.txt" donde tendréis todo el texto que haya devuelto avrdude con sus instrucciones de uso.
Esto mismo podéis hacerlo con cualquier herramienta, ya que la redirección es un comando de la consola, no de los programas que hemos usado.
Espero que os haya gustado esta entrada.
¡Os espero en un próximo post!
Descarga Arduino + Digispark CMD Builder
md5 del archivo: c178988032958ee371c8f7ad4acb2ae2
