Bienvenido a mi blog relacionado con la programación de microcontroladores, mi nombre es Pablo y hoy quiero mostrarles como pasar o el <firmware> del cargador(bootloader Arduino) al microcontrolador de la tarjeta <Arduino> UNO, te recuerdo que si tienes alguna sugerencia o critica constructiva con la presente publicación, al final encontraras mis datos de contacto.
El objetivo principal es utilizar una tarjeta Arduino UNO como programador para cargar el firmware del <bootloader> en otra tarjeta UNO, así que hacer esto necesitaras al menos dos tarjetas UNO, o en todo caso puedes utilizar un Microcontrolador alimentado sobre un Protoboard.
Mencionar que este apartado esta bien documentado en la pagina oficial de Arduino como <Arduino As ISP>
Introducción al Tema
Un cargador o bootloader es programa muy ligero que tiene como propósito reprogramar la memora destinada a la aplicación, esto utilizando un modulo de comunicación propio del MCU, evitando de esta forma utilizar un programador externo. Para que esto funcione el firmware del bootloader debe ser programado en la tarjeta UNO con antelación, ya que este reside en un área de la memoria destinada para este fin, observe la figura 1.
Fig1. Memoria de Programa del ATMega328
Los Microcontroladores AVR como el ATMega328 disponen del soporte para utilizar un bootloader, lo que facilita bastante la implementación del mismo, porque agregan la funcionalidad para que el programa inicie desde el sector donde se encuentra el bootloader y posterior pasar el control a la aplicación, además agrega medidas de protección para evitar el acceso y posible modificación de esta área desde la sección destinada a la aplicación.
De hecho el MCU de todas las tarjetas Arduino ya tienen programado un bootloader, caso contrario no seria posible utilizar el software de Arduino para cargar [UPLOAD] nuestros programas de aplicación. Programar un bootloader no es algo habitual, pero podría ser necesario en las siguientes situaciones:
Si la memoria fue borrada aplicando el comando chip-erase.
Si compraste el MCU solo, este vendrá con la memoria vacía.
Programador Arduino As ISP
El programador Arduino As ISP es parte del software que traer Arduino, la documentos que se provee en la pagina oficial abarca a todas las tarjetas UNO, MEGA, DUE, ZERO, etc.
Nosotros trabajaremos solo con Arduino UNO, entonces lo que tienes que en primer instancia es conectar las dos tarjetas, tal como ser observa en la figura 2, los pines interconectados son:
TARGET: Pin[13][12][11][RESET][5V][GND]
PROGRAMMER: [13][12][11][10][5V][GND]
Fig2. Conexión Arduino Programador y Destino
En la imagen de la figura 2, la tarjeta que funcionara como programador se identifica como PROGRAMMER, y la tarjeta en la que se programara el firmware del bootloader, de denomina TARGET, entonces una vez realizada las conexiones, vamos a proceder con los siguientes pasos:
Paso 1: Conectar la tarjeta PROGRAMER al ordenador y abrir la Aplicación Arduino, yo utilice la versión 2.3.2, una vez abierto seleccionamos en el menú:
[File->Examples->ArduinoISP], esto abrirá una nueva ventana con el código para el programador, ver figura 3.
Fig3. Abrir el código del Programador ArduinoISP
Paso 2: Una vez abierto el código del programador ArduinoISP, procedemos a compilar y luego a cargarlo en la Tarjeta PROGRAMMER, ver figura 4.
Fig4. Compilar y Cargar ArduinoISP en el PROGRAMMER
Paso 3. Seleccionar en el menú: [Tools->Programmer->Arduino as ISP]
Fig5. Seleccionar el Programador ArduinoISP
Paso 4. Realizamos la programación del bootloader seleccionando en el menu: [Tools->Burn Bootloader], al finalizar nos muestra el mensaje de la figura 7.
Fig7. Bootloader cargado en el TARGET
Eso es todo, ya tenemos la tarjeta TARGET con el bootloader de Arduino listo para usarlo.
Si quieres conocer mas a profundidad la programación ISP con avrdude, puede ver la siguiente publicación. <Activar Protección Arduino UNO>
Conclusiones
Luego de haber realizar las pruebas del programador Arduino as ISP cargando el bootloader en otra tarjeta Arduino como Destino TARGET, se procedió a compilar un programa como ejemplo y cargarlo, verificando así el correcto funcionamiento del mismo. Abajo dejo un vídeo que muestra lo descrito en esta publicación.
Sin
mas que mencionar agradezco tu visita al blog y espero que el ejemplo
visto pueda ser útil en tu formación y el proyecto que desarrollas.
Atentamente, Pablo Zárate Arancibia email: pablinza@me.com / pablinzte@gmail.com, @pablinzar
Les doy la bienvenida a esta entrada en la quiero responder a la pregunta que me han hecho en varias oportunidades, "¿Como hacer para que no copien mi proyecto realizado en Arduino?". Pues bien, ante la consulta debo recordar que el principio de utilizar una plataforma de código abierto como Arduino, implica que el proyecto(software) elaborado no debería estar cerrado a otras personas, mas al contrario compartir tu trabajo representa un pilar fundamental en el desarrollo de esta plataforma de código abierto. Ahora si pese a esto tu no quieres que alguien copie tu proyecto porque es una idea original que te costo muchas noches en desvelo para que alguien pueda sacar beneficio de ello, en esta entrada te explicare como hacerlo.
Introduccion al Tema
Para empezar listare las cosas que necesitaras:
Un programador(UsbASP, UTK500, ArduinoISP, etc);
Una tarjeta Arduino(UNO, Mega o Nano);
Software de programación para AVR(avrdude, avrp, uisp, etc).
Utilizaremos el programador USBASP por ser una de las opciones mas asequibles, junto al software de programación avrdude y la tarjeta Arduino UNO que como saben posee un Microcontrolador <MCU> ATMega328.
Fig2. Programador UsbASP
Este programador nos posibilita leer y cargar el código del programa <firmware> en la memoria ROM <FLASH> del Microcontrolador ATMega utilizando la interfaz de comunicación serial ISP que poseen las tarjeta Arduino UNO.
Otra alternativa si no dispone de un programador, es utilizar un tarjeta Arduino UNO cargado con el programa ISP <Arduino as ISP>, que convertirá nuestro Arduino UNO en un programador, eso si, necesitaras realizar correctamente las conexiones entre el Arduino Programador y el Arduino que requiere ser programado. Abordare este punto en la entrada <Cargar el bootloader Arduino con Arduino UNO>
Bueno, ya entrando en el tema, indicar que la forma de llevar a cabo la protección de memoria del microcontrolador, es sencillamente impedir su lectura desde un programador, y esto es posible programando los bits del registro LOCK, ver figura 3, este registro permite activar la restricción de acceso a la memoria de programa y también la memoria datos EEPROM.
Fig3. bits del registro LOCK
Por defecto los bits del registro están sin programar o desactivados, lo que representa un valor 0xFF todo en 1, y pueden ser activados colocando en 0 en cualquier momento, pero una vez programados, la única forma de restablecer su valor a 1, es borrando toda la memoria de microcontrolador, esto significa aplicar la instrucción de borrado chip erase. Entonces si desea restringir la programación y lectura de la memoria Flash (Programa) y EEPROM (Datos), deberá colocar en 0 los bits LB1 y LB2, pero antes de realizar esto debe considerar que en arduino los bits BLB12 y BLB11 están activados para proteger el cargador, mientras que los bits BLB02 y BLB01 permanecen desactivados para permitir el acceso a la memoria utilizada por la aplicación, por lo tanto, el valor del registro lock con relación a la protección de la memoria de programa, sera:
0xCF = Se puede actualizar desde arduino y leer la memoria
0xCC = Se puede actualizar desde arduino pero no leer la memoria
0xC0 = No se puede actualizar desde arduino y tampoco leer la memoria
avrdude es un programa de linea de comandos disponible para linux y windows, que permitirá llevar a cabo la carga y descarga de toda la memoria, esto incluye el programa y los datos, así mismo con este programa podremos establecer los bits de los fusibles y el registro LOCK.
Puesto que no haremos uso de todos los parámetros de comandos con avrdude solo nos centraremos en aquello que no permita realizar y verificar la protección de la memoria, pero te dejo un enlace que brinda mas detalle al respecto <Manual AVRDURE>
La instalación de avrdude en el caso Linux/Debian solo requiere la ejecución del siguiente comando desde una terminal de consola:
#apt-get install avrdude
También dejo algunos enlaces de ayuda en caso de utilizar Windows:
Ahora describiré el proceso para efectuar la protección en tres pasos.
PASO 1 (Cargar el firmware al Microcontrolador desde Arduino)
Se entiende por código del programa o firmware al fichero con extensión hex generado por el compilador, a partir del código fuente elaborado por el desarrollador. En este paso veremos como cargar el firmware al microcontrolador de la tarjeta UNO, para lo cual tomaremos de ejemplo un programa sencillo que destellara el LED integrado en la tarjeta, el programa puede encontrarlo en los ejemplo de Arduino con el nombre BlinkLED
//Programa de ejemplo para destellar un LED void setup() { pinMode(LED_BUILTIN, OUTPUT); } void loop() { digitalWrite(LED_BUILTIN, HIGH); delay(250); digitalWrite(LED_BUILTIN, LOW); delay(250); }
Fig4. IDE Arduino
Como veras pasar el firmware al microcontrolador es sencillamente hacer click en el boton [UPLOAD], al hacer el programa previo es reemplazado por el recientemente compilado.
PASO 2 (Recuperar el firmware del Microcontrolador)
Recuperar o leer el firmware desde el microcontrolador, no es posible desde Arduino, y por lo tanto necesitara de un programador para este paso.
Entonces una con el programador USBASP, debe conectarlo al puerto ISP de la tarjeta Arduino UNO, observe la figura 4 que muestra la disposición de los pines y su orientacion.
Fig5. Orientación de la conexión ISP
Una vez realizada la conexión del programador al puerto ISP, conectamos el programador a nuestro ordenador, mismo que se vinculara a traves de una puerto serial, en mi caso el puerto asignado es /dev/ttyUSB0, en el caso de windows sera una COMx. Entonces ejecutamos desde la consola linux, el comando avrdude con los siguientes parametros:
Con esto avrdude recupero el contenido de la memoria de programa y tambien de datos del
microcontrolador Atmega328 (Arduino UNO), y los guardo en los archivos de sistema flash.hex y eeprom.hex.
El parametro -P especifica el puerto serie asignado al programador USBASP en mi caso.
Notara también que la respuesta al comando muestra al final los valores que tienen los fusibles del microcontrolador que son EFUSE, HFUSE y LFUSE con valores 0xFE, 0xDE y 0xFF respectivamente. Estos valores son los establecidos por el programa cargador bootloader que utiliza Arduino y por lo tanto no deben modificarse, al menos si planea seguir utilizando arduino.
Otra manera de hacer lectura de los fusibles es ejecutando avrdude en modo linea de comando, con la siguiente instrucción:
#avrdude -c usbasp -p m328p -t //Ingresara en modo comando
avrdude: AVR device initialized and ready to accept instructions
Reading | ################################################## | 100% 0.00 s
0000 fd
avrdude> d hfuse
Reading | ################################################## | 100% 0.00 s
0000 de
avrdude> d lfuse
Reading | ################################################## | 100% 0.00 s
0000 ff
avrdude> d lock
Reading | ################################################## | 100% 0.00 s
0000 cf
PASO 3 (Restringir la lectura de firmware del Microcontrolador)
Este seria el paso necesario para evitar recuperar el firmware del microcontrolador, es decir el programa de la tarjeta Arduino UNO, con esto no sera posible que alguien clone la funcionalidad en otra tarjeta.
El comando avrdude se ejecuta desde la consola con los siguientes parametros:
avrdude: 1 bytes of lock written avrdude: verifying lock memory against 0xCC: avrdude: load data lock data from input file 0xCC: avrdude: input file 0xC0 contains 1 bytes avrdude: reading on-chip lock data: Reading | ########################################### | 100% 0.00s
avrdude: verifying ... avrdude: 1 bytes of lock verified avrdude: safemode: Fuses OK (E:FE, H:DE, L:FF) avrdude done. Thank you.
El establecimiento del registro lock con el valor 0xCC, impedira la lectura de la memoria FLASH (Programa) y datos (EEPROM), manteniendo la posibilidad de seguir actualizando el programa desde arduino.
Otra manera de modificar el registro lock es ejecutando avrdude en modo linea de comando con la siguiente instrucción:
#avrdude -c usbasp -p m328p -t //Ingresara en modo comando avrdude: AVR device initialized and ready to accept instructions avrdude: device signature = 0x1e950f (probably m328p)
avrdude> w lock 0 0xcc Writing | ################################################## | 100% 0.00 s avrdude> d lock Reading | ################################################## | 100% 0.00 s 0000 cc
A manera comprobar la restricción establecidad por el lock = 0xcc, intentaremos extraer nuevamente el contenido de la memoria de programa, ejecutando la siguiente instrucción:
Aparentemente como respuesta a la instrucción nos indica que el código se recupero con normalidad y se almaceno en el archivo flash2.hex, pero haciendo una lista de los archivos de la carpeta de trabajo notamos que flash2.hex tiene 0 bytes, es decir no contiene informacion.
Fig6. Lista de ficheros recuperados
Entones esto hemos conseguido proteger la posible clonacion de la tarjeta Arduino UNO y la única manera de lograr quitar la restricción es borrando el microcontrolador con instrucción chip erase, este paso borrara incluso el cargador de arduino, por lo que necesitara cargarlo nuevamente con un programador.
PASO 4 (Cargar el firmware al Microcontrolador)
A diferencia del paso 1, considerando que el microcontrolador no cuenta con el cargador o bootloader de Arduino, no sera posible hacer la carga desde Arduino. Por lo tanto veremos como cargar el código de programa a una tarjeta UNO, a partir de los ficheros hex recuperados de otra tarjeta, este paso también nos servirá para restablecer los bits de protección de memoria en el registro LOCK al valor por defecto 0xCF.
La instrucción requerida para llevar a cabo esta tarea es:
avrdude: 1 bytes of lock written avrdude: safemode: Fuses OK (E:FE, H:DE, L:FF) avrdude done. Thank you.
Ahora con los bits del registro LOCK restablecidos al valor por defecto probaremos recuperar nuevamente el código de la memoria del microcontrolador, ejecutando la siguiente orden.
Se recomienda cautela en la transcripción al momento de ejecutar las instrucciones, sobre todo cuando se aplica el parámetro -e que borra y restablecer los fusibles del microcontrolador, tenga en cuenta que el bit SPIEN de HFUSE debe estar activado, caso contrario dejara al microcontrolador inhabitado para posteriores actualizaciones por SPI. para mayores datos puede consultar el apartado 31.2 de la hoja de datos del microcontrolador Atmega328.
Estos son los valores por defecto que el cargado(Bootloader) Arduino utiliza en las tarjetas Atmega.
