Bienvenido a mi blog, hoy hablaremos un poco de la configuración mínima de los Microcontroladores ATmega, los cuales son una línea de microcontroladores fabricados por Atmel que utilizan la arquitectura AVR, para poder utilizarlos en el entorno Arduino, la idea es poder programar estos modelos de micros "con el IDE de Arduino" e integrarlos en nuestras placas de una forma profesional o en el caso de estudiantes universitarios, poder presentar un proyecto sin un Arduino del que salen muchos cables. Para
llevar acabo este procedimiento vamos a utilizar como ejemplo un
Arduino UNO Rev3 y
vamos a diseñar y construir nuestra propia pcb para actuar como una
Shield AVR ISP. Primero que todo recordar la definición de bootloader que vimos en el
post de "bootloader usb para microcontroladores", teniendo esto claro iniciemos.
Los Microcontroladores se programan a través de un programador o quemador, a menos que tengan una pieza de firmware embebido que les permita reescribir su memoria flash sin la necesidad de un programador externo. A esto se le llama bootloader o gestor de arranque y es básicamente un archivo ".hex" que se ejecuta cuando se enciende la placa. Es similar al BIOS/UEFI que se ejecuta en una PC al inicializarse. El bootloader de Arduino está programado en la memoria flash, en este caso, de un ATMega328P-PU y ocupa 0,5 KB de los 32KB disponibles. El bootloader se comunica usando el protocolo STK500. El bootloader de Arduino es esencialmente el bootloader STK500 versión 2 de Atmel. Además del bootloader que viene precargado en los microcontroladores de las placas Arduino, existen otros bootloaders con mejoras en algunos aspectos o para ofrecer nuevas características.
- Por ejemplo el Optiboot es un bootloader muy conocido que está más optimizado que el bootloader oficial de Arduino, permitiendo sketch's mayores y carga más rápida.
Para poder utilizar un ATmega328P-PU como un Arduino UNO es necesario cargar
la configuración de este o «quemar el bootloader» (grabar la secuencia de
inicio). Comenzaremos por abrir nuestro Arduino IDE y nos dirigimos al menú
Herramientas - Placa - Arduino AVR Boards - Arduino Uno, con esto le
indicamos al IDE que trabajaremos con una placa Arduino UNO:
Ahora vamos al menú Archivo - abrir y seleccionaremos el sketch "ArduinoISP.ino" (El ArduinoISP que se envía como ejemplo con el software Arduino es antiguo. Puedes descargar gratis "ArduinoISP.ino" versión 04m3 de Randall Bohn aquí y reemplazar el que se encuentra en "C:\Program Files (x86)\Arduino\examples\11.ArduinoISP\ArduinoISP" esta versión también funciona con el avrdudess) hecho esto, se mostrará el siguiente código que programara nuestro Arduino como ISP:
Ahora vamos al menú Archivo - abrir y seleccionaremos el sketch "ArduinoISP.ino" (El ArduinoISP que se envía como ejemplo con el software Arduino es antiguo. Puedes descargar gratis "ArduinoISP.ino" versión 04m3 de Randall Bohn aquí y reemplazar el que se encuentra en "C:\Program Files (x86)\Arduino\examples\11.ArduinoISP\ArduinoISP" esta versión también funciona con el avrdudess) hecho esto, se mostrará el siguiente código que programara nuestro Arduino como ISP:
Una vez abierto nuestro Sketch, conectaremos el Arduino a un puerto USB, es importante verificar que en el menú de herramientas se encuentre
seleccionado el puerto COM correcto de nuestro Arduino, y presionaremos <subir>, que es el segundo símbolo de izquierda a
derecha en la parte superior izquierda de nuestro IDE y esperamos hasta que
nos indique que se ha subido. Una vez hayamos cargado el sketch correctamente procederemos a desconectar
nuestro Arduino del cable USB y conectaremos el circuito (o shield AVR
ISP) que se muestra en la siguiente imagen (es altamente aconsejable
que el Arduino tenga el sketch "ArduinoISP" versión 04m3 de Randall Bohn ya cargado y este desconectado al momento de armar el circuito o
conectar la shield):
Regresamos al IDE y vamos al menú Herramientas - programador y seleccionaremos "Arduino as ISP" una vez hayamos conectado nuestro circuito o shield, conectaremos el Arduino al puerto USB de nuestra PC y debe encender fijamente el led azul "RUN" que indica que nuestro Arduino esta en modo programador y la shield esta lista:
Ahora seleccionaremos que bootloader le vamos a cargar, como para este
ejemplo trabajaremos con un Microcontrolador ATmega328P-PU y queremos que actué como un Arduino UNO, verificamos nuevamente
que este seleccionado en Herramientas - Placa - Arduino Uno, así el IDE
sabrá que bootloader elegir para cargarle al micro:
Hecho esto volveremos a la pestaña de Herramientas y haremos click en la opción de «Quemar Bootloader» o grabar la secuencia de inicio:
Hecho esto volveremos a la pestaña de Herramientas y haremos click en la opción de «Quemar Bootloader» o grabar la secuencia de inicio:
Si hemos seguido los pasos correctamente pasados unos segundos en la
parte inferior izquierda nos mostrara la leyenda
«Quemado de bootloader completado». Ahora para probar, vamos al
menú Archivo - Ejemplos - 01.Basics - Blink y verificamos también que en
Herramientas - Programador siga seleccionado Arduino as ISP:
Ya después de abierto el sketch del blink y verificado que siga como Arduino as ISP, vamos al menú Programa y seleccionamos "Subir usando Programador":
Después de cargado este sketch en el micro, el led amarillo de "Testing
Blink" comienza a parpadear en la Shield AVR ISP, indicándonos, que el
sketch fue cargado correctamente y ya esta corriendo, cabe destacar que
dicho led amarillo esta conectado al pin 13 o SCK (PB5) de nuestro
ATmega328P-PU, por eso actúa igual al led embebido en la propia placa Arduino
UNO R3.
El mismo procedimiento, con la variación de la elección de la placa
destino, seguiríamos para grabar, por ejemplo, el bootloader del Arduino
NANO, solo que en ese caso nos guiaríamos por las siguientes
conexiones:
|
| Quemando bootloader en Arduino NANO |
En mi experiencia con las placas Arduino NANO, el bootloader seleccionado
en el IDE de Arduino, a través de Herramientas> Procesador>
ATmega328P (Old Bootloader) es el cargador de arranque "ATmegaBOOT". Aquí hay un gran detalle a tener en cuenta: si tu Arduino NANO tiene cargado el bootloader "OPTIBOOT" o
"ATmegaBOOT".
Existen dos diferencias significativas entre los bootloader a utilizar:
Optiboot no entrará en un ciclo de reinicio sin fin después de un
reinicio del perro guardián. ATmegaBOOT SI lo hará.
Optiboot espera la comunicación de carga a 115200 baudios, ATmegaBOOT a
57600 baudios. Esta es la razón por la que algunas placas de NANO solo
funcionan con la selección Herramientas> Procesador> ATmega328P
Old Bootloader. Hay otra diferencia muy significativa entre los dos
bootloader: Optiboot cabrá en una sección de arranque de 0,5kB mientras
que ATmegaBOOT requiere una sección de arranque de 2kB y además el
optiboot permite sketch's mayores y carga más rápida. En pocas palabras, si tienes un Arduino NANO, actualiza su
bootloader a la ultima versión de Optiboot
utilizando lo aprendido y expuesto en este post.
Al momento de escribir este post la ultima versión de optiboot es la
8.0 que podemos cargar en el IDE de Arduino en el menú Archivo -
Preferencias y en gestor de URL's adicionales de tarjetas pegamos la
siguiente dirección:
https://github.com/Optiboot/optiboot/releases/download/v8.0/package_optiboot_optiboot-additional_index.json
y hacemos click en OK ahora vamos a herramientas - Placa - Gestor de
Tarjetas y nos deberá aparecer en el ultimo item optiboot, lo
seleccionamos y hacemos click en el botón Instalar. Con esto
cargaremos la ultima versión de optiboot para quemarla en nuestros
micros usando el IDE de Arduino y el método visto aquí de ArduinoISP.
|
| Quemando bootloader en Arduino MEGA |
Mismo procedimiento seguiremos para grabar el bootloader en un Arduino MEGA basado en el Microcontrolador ATmega2560, pero teniendo en cuenta que si es para un proyecto en placa, al ser este micro encapsulado en smd (montaje superficial) será necesario utilizar el conector ICSP de 6 pines que le añadí a la shield y la placa destino deberá contar también con dicho conector, esto lo lograremos utilizando una correa ribbon de 6 hilos o con jumpers dupont hembra-hembra.
Para restaurar el firmware del ATmega 16U2 que vimos en el post
de USB a Serial en Arduino - Generalidades
nos guiaremos por el siguiente pinout (aunque no publicare aun el
proceso, ya que todavía lo tengo pendiente por verificar, pero es un
hecho que funciona y se puede realizar):
Para determinar si un ATmega16U2 realmente necesita restaurar su
firmware, primero se debe hacer la prueba de
loop-back.
Acotar que esta es la URL que permite al gestor de tarjetas del IDE
de Arduino, añadir las placas MiniCore (ATmega8/48/88/168/328):
https://mcudude.github.io/MiniCore/package_MCUdude_MiniCore_index.json
/////////////////////////////////////////////////////////////////////////////////////////////
Video cortesía Domando Ingeniería
Ahora vamos a aprender a manejar algunos micros de la familia Attiny, los ATtiny son pequeños µControladores Atmel de 8 bits con poca memoria
flash y EEPROM, que presentan encapsulados que van desde los 6 pines el
más pequeño, hasta los 32 pines el más grande, lo que los convierte en los
cerebros ideales para pequeños proyectos de pocas características y cuyo
objetivo sea ser de bajo coste y pequeño tamaño.
Ahora vamos a realizar el procedimiento para el Microcontrolador
ATtiny85, primero que todo vamos a desconectar el Arduino UNO del puerto
USB del ordenador y quitaremos el microcontrolador ATmega que acabamos de
quemar el bootloader y probar, y vamos al menú Archivo - Preferencias y en
gestor de URL's adicionales de tarjetas, pegamos la siguiente
dirección:
https://raw.githubusercontent.com/damellis/attiny/ide-1.6.x-boards-manager/package_damellis_attiny_index.json
https://raw.githubusercontent.com/damellis/attiny/ide-1.6.x-boards-manager/package_damellis_attiny_index.json
y hacemos click en OK:
Ahora vamos a herramientas - Placa - Gestor de Tarjetas y nos deberá aparecer en el ultimo item attiny, la seleccionamos y hacemos click en el botón Instalar:
Ahora para probar vamos a cargar el sketch del blink en nuestro
ATtiny85 y para ello vamos a descargar gratis el archivo Blink_ATtiny25_45_85_13.ino
Una vez lo hayas descargado y lo tengas abierto, vamos a Herramientas -
Placa y seleccionamos ATtiny25/45/85:
Procedemos ahora a seleccionar en Herramientas - Procesador - ATtiny85 y en
Clock - Internal 1 MHz (por defecto el ATtiny85 funciona a 1MHz, por eso, cuando se selecciona la placa ATtiny25/45/85 el "Clock" se selecciona "1MHz internal", para que funcione a 8MHz se debería quemar un nuevo bootloader, para ello en el menú "Herramientas" seleccionaríamos "8MHz internal" en la opción "Clock" y luego, en el mismo menú, haríamos click en "Quemar Bootloader"):
No olvidemos verificar que en Herramientas - Programador siga
seleccionado Arduino as ISP, recuerda lo que hablamos en el proceso con
el ATmega328P-PU (es altamente aconsejable que el Arduino ya este como "ArduinoISP" y
este desconectado al momento de armar el circuito o conectar la shield)
en este momento del proceso, instalamos el micro ATtiny85 en la base DIP
de 8 pines con la disposición indicada en la serigrafia, conectamos la
shield y conectamos el Arduino UNO al puerto USB de la PC y procedemos a
darle Herramientas - Quemar Bootloader,
en realidad esto solo cargara la configuración porque el
ATtiny no tiene bootloader,
es decir, lo que ha cargado son los fuses. Hecho esto, ahora si procederemos a programarle el sketch Blink_ATtiny24_45_85_13.ino dándole en el Menú Programa - Subir usando
Programador:
Después de cargado este sketch en el micro, el led amarillo de "Testing
Blink" comienza a parpadear en la Shield, indicándonos, que el sketch
fue cargado correctamente y ya esta corriendo, cabe destacar que dicho led amarillo esta conectado al pin SCK (PB2) de
nuestro ATtiny. A continuación una pequeña simulación en wokwi gratuito y online:
Recuerda que esta shield permite grabar tanto el bootloader como sketch's
en los Microcontroladores de Atmel ATmega8/48/88/168/328P/PU, ATtiny
25/45/85/13A, ATmega2560 y ATmega16U2, también permite la configuración de fuses mediante el software AVRdude, aunque gracias al conector ICSP de la shield, se puede programar cualquier micro AVR que soporte ISP, actualmente se trabaja en modificar el circuito para poder añadir Programación de Alto Voltaje.
Acotar que esta es la URL que permite al gestor de tarjetas del IDE de Arduino, añadir la placa ATtiny13:
- Que diferencia hay entre un microcontrolador ATtiny13 y ATtiny13A?
El ATtiny13 es la versión original y utiliza una tecnología de proceso diferente a la ATtiny13A. Las partes con sufijo "A" se fabrican con un proceso de baja potencia comercializado como "picoPower", y la principal diferencia es que generalmente consumen menos energía con el mismo voltaje y frecuencia.
Pero que sucedería sino contamos con una placa Arduino en donde podamos
acoplar la shield? Pues podríamos entonces, utilizar un conversor FTDI y
conectárselo a la misma shield para no necesitar mas hardware adicional,
para ello anexaremos esto a nuestro pequeño diseño:
|
|
PCB Shield AVR ISP |
|
|
PROGRAMMER BOOTLOADER SHIELD AVR ISP FOR ARDUINO - Visor 3D - Cortesía Proteus |
La idea de hacer la tarjeta de la shield mas corta que la de Arduino, es
que las soldaduras inferiores no toquen el conector USB hembra tipo B del
Arduino uno, de esta forma la shield se acoplara perfectamente y no
presentara ninguna falla de diseño. Pronto estará a la venta, publicándola
en mercado libre para que puedas adquirirla si te interesa o vía
NEQUI.
|
|
Ejemplo de Shield mal diseñada, no se acopla bien y las soldaduras
inferiores harán corto cuando toquen el conector metálico USB hembra
tipo B de la placa Arduino, por eso lo forraron con cinta de
enmascarar. |
La programación de alto voltaje implica la aplicación de un voltaje de alto nivel a ciertos pines del microcontrolador AVR, lo que activa un mecanismo de seguridad en el chip que permite la programación o el borrado de la memoria Flash interna. Actualmente modifico el circuito para poder realizar programación de alto voltaje, la cual también permitirá el reseteo de fuses en microcontroladores AVR bloqueados. Si te interesa este pequeño proyecto, puedes apoyar con una colaboración voluntaria vía NEQUI al 3177295861.
 |
Ejemplo de Shield AVR-HV High voltage programmer, que demuestra que si se puede hacer y funciona en Arduino. Cortesía del proyecto HV Rescue Shield v2.1 |
Finalmente para saber el estado inicial de los bits de configuración y
bloqueo, de cualquier Microcontrolador AVR, es decir, los fuses,
recomiendo consultar y usar la siguiente pagina:
Quieres aportar algo que complemente este articulo? crees que hay algo
que se deba corregir?
Escríbenos este
blog es para todos.
Recuerda que en https://jorgechac.blogspot.com nos dedicamos a construir
una electrónica mejor! y apoyamos el proyecto
CTC GO!
(Creative Technologies in the Classroom) que es un programa de educación
steam personalizable.
Si te sirvió deja un comentario de agradecimiento, comparte el post en tus redes sociales o recomiéndale el blog a un amigo, eso me motiva a seguir realizando estos pequeños posts y espero que vuelvas a mi blog, publico nuevo material con base en los softwares y apps que utilizo y la experiencia que he adquirido. Por último si deseas colaborar voluntariamente y crees que mi trabajo y mi tiempo lo ameritan, considere hacer una pequeña donación a mi NEQUI +573177295861.
También te puede interesar:
