Tema 7 – Conceptos avanzados de Hardware

  • Diseño HW de un Arduino
  • Esquema lógico de Arduino
  • ICSP
  • Bootloader
  • Interrupciones (próximamente)
  • Microcontroladores. Registros de memoria. (próximamente)
  • Firmware USB to Serial Chip (próximamente)
  • Bit Banging vs Hardware dedicado (próximamente)
  • Conceptos avanzados de electrónica (próximamente)
  • Atmel Studio (próximamente)

Diseño HW de un Arduino

Como vimos anteriormente, Arduino es una plataforma para programar de forma sencilla algunos microcontroladores de la familia AVR de Atmel.

http://es.wikipedia.org/wiki/AVR

Pero además es un entorno de programación para estos microcontroladores, por lo tanto podemos utilizar todo lo aprendido para programar un microcontrolador solo sin necesidad de la plataforma Arduino y montarlo sobre una placa que hayamos hecho para un propósito específico.

Con un microcontrolador AVR y una serie de componentes electrónicos, podemos construir un arduino sobre una protoboard:

Si el microcontrolador no tiene bootloader cargada, entonces necesitaremos cargarlo de alguna forma, ya sea usando otro arduino o mediante hardware externo.

Por ejemplo con https://www.sparkfun.com/products/9716 que nos convierte de USB a serial y con funcionalidad de auto reset cuando un nuevo sketch es cargado al Arduino.

También podemos usar el mini USB adapter: http://arduino.cc/en/Main/MiniUSB

Regulador de tensión usado por el Arduino UNO: http://www.unihedron.com/projects/sqm-le/PDFspecs/NCP1117-D.PDF

Tenemos también el boarduino: https://learn.adafruit.com/boarduino-kits

Para cargar el bootloader en un microcontrolador atmega tenemos dos opciones:

Los pasos a seguir para “quemar” el bootloader están en: http://arduino.cc/en/Main/Standalone

Los pasos para cargar el bootloader desde un Arduino y como cargar un programa en una MCU de Atmel desde Arduino: http://arduino.cc/en/Tutorial/ArduinoToBreadboard

Pin mapping: http://arduino.cc/en/Hacking/PinMapping

Fijaros en el pequeño integrado que hay en la placa de Arduino uno, es un microcontrolador completamente funcional y no solo un conversor de USB a Serial. Podríamos usar ambos MCUs en la misma placa, pudiendo descargar trabajo de la MCU principal en la secundaria. Para ello usa el hoodloader2 en el Atmega16U2 o Atmega8U2 dependiendo de la versión de Arduino Uno que tengamos y comunicamos ambas MCUs por HW serial

Como usar el segundo MCU del Arduino UNO: http://www.freetronics.com/blogs/news/16053025-using-both-microcontrollers-on-your-arduino-uno-compatible-board#.VIg48zGG9B9

Web del proyecto: http://nicohood.wordpress.com/2014/11/30/hoodloader2-ready-to-use-usb-hid-for-arduino-unomega/

HoodLoader2: https://github.com/NicoHood/HoodLoader2

Diferencias entre las diversas versiones de HW de los Arduino: http://startingelectronics.com/articles/arduino/uno-r3-r2-differences/

HW arduino UNO a fondo: https://learn.adafruit.com/arduino-tips-tricks-and-techniques/arduino-uno-faq

Por supuesto si queremos saber más sobre el microcontrolador de Arduino disponemos de toda su documentación en: http://www.atmel.com/Images/doc8161.pdf.

Por ejemplo en la página 434 tenemos los 3 encapsulados posibles.

Y en la página 316 se pueden ver los consumos de Arduino y la dependencia entre la frecuencia máxima de reloj y el Vcc.

No solo debemos centrarnos en la AV· 328P, existen una amplia gama de MCUs de Atmel y de otros fabricantes que son las herramientas SW (IDE, compilador, etc…) adecuadas podemos programar con todo lo visto en el curso.

Familia de Microcontroladores de megaAVR Atmel de la que disponemos a AVR libc para poder programarlos como hemos visto hasta ahora:

Uso avanzado de memoria con AVR libc: http://www.atmel.com/webdoc/AVRLibcReferenceManual/malloc.html

Atmel Xplained son una placas de prototipado al estilo de Arduino fabricado por Atmel para sus MCUs de 8 y 32 bits que necesitan de Atmel Studio para programarlas. http://www.atmel.com/products/microcontrollers/avr/xplained.aspx

Un resumen de como funciona una MCU y como agrgar un programa: http://www.electronicaestudio.com/microcontrolador.htm

Para usar un microcontrolador ATmega8  de la familia AVR de 8 bits de Atmel, sin usar el IDE de Arduino, podemos programarlos usando C y C++ mediante una versión muy extendida de GCC (http://es.wikipedia.org/wiki/GNU_Compiler_Collection) denominda AVR-GCC http://winavr.sourceforge.net/ y http://sourceforge.net/projects/winavr/files/.

Una vez compilado el programa de C/C++ en un binario para AVR con AVR-GCC, necesitaremos “quemarlo” en el microcontrolador. Esto puede hacerse con AVRDUDE http://www.nongnu.org/avrdude/ o UISP http://www.nongnu.org/uisp/ o Atmel Studio http://www.atmel.com/tools/atmelstudio.aspx

Para Linux son necesarias estas herramientas:

  • gcc-avr
  • binutils-avr
  • gdb-avr
  • avr-libc
  • avrdude

Para ello necesitamos HW adicional para conectar nuestro ordenador a los cinco pines del In-System Programmer del microcontrolador. Por ejemplo el AVRISP mkII: http://www.digikey.com/product-detail/es/ATAVRISP2/ATAVRISP2-ND/898891 o https://www.sparkfun.com/products/8702

Más información en:  http://upvector.com/atmega/

El proceso en el IDE es el siguiente:

  • source -(compile)-> ELF -(link)-> hex
  • hex -(flash programmer)-> target board

El fichero hex es el formato usado para guardar el lenguaje del MCU codificado en formato hexadecimal. Es el que se transfiere a la RAM.

El fichero elf (Executable and Linking Format), es el formato estándar para ficheros ejecutables, objetos de código y librerías compartidas. Elf es como una dll y consiste en unos enlaces simbólicos y tablas que pueden cargarse en una zona de memoria. Los fichero elf tienen varias secciones como datos, textos, etc.. Este fichero se suele usar para debug con emuladores.

Operaciones en reloj en Arduino:

  • Internamente, el reloj de entrada es dividido por cuatro.
  • Un ciclo de instrucción equivale a cuatro periodos del reloj de entrada.
  • En Q1, se lee la siguiente instrucción y en Q4 es almacenada en el registro

Captura

En el siguiente ciclo es ejecutada.

Captura

La importancia  de conocer el ciclo de ejecución de instrucciones en un micro controlador estriba en que en ocasiones es necesario calcular de forma precisa el tiempo de ejecución de los bucles para actuar en tiempo real

EEPROM

La EEPROM es una memoria no volátil que dispone el microcontrolador de Arduino que nos permite guardar datos para poder recuperar en caso de pérdida de alimentación de nuestro dispositivo.

La gran desventaja que tiene la EEPROM es que tiene un número limitado de escrituras, por lo que debemos calcular cuántas veces se va a escribir en ella para calcular su vida útil con nuestro programa.

Más información en: http://en.wikipedia.org/wiki/EEPROM

Las celdas de memoria de una EEPROM están constituidas por un transistor MOS, que tiene una compuerta flotante (estructura SAMOS), su estado normal está cortado y la salida proporciona un 1 lógico.

Aunque una EEPROM puede ser leída un número ilimitado de veces, sólo puede ser borrada y reprogramada entre 100.000 y un millón de veces.

Estos dispositivos suelen comunicarse mediante protocolos como I²C, SPI y Microwire. En otras ocasiones, se integra dentro de chips como microcontroladores y DSPs para lograr una mayor rapidez.

La memoria flash es una forma avanzada de EEPROM.

La librería EEPROM nos permite leer y escribir bytes de la EEPROM de Arduino. La EEPROM en cada MCU tiene un tamaño diferente, en nuestro caso con el Arduino UNO es de 1024 bytes. Esta librería solo me permite leer y escribir a nivel de byte, por lo que si quiero guardar variables cuyo tamaño sea mayor de 1 byte, deberemos hacer operaciones.

 Librería http://arduino.cc/en/Reference/EEPROM

Método read() – http://arduino.cc/en/Reference/EEPROMRead

Método write() – http://arduino.cc/en/Reference/EEPROMWrite

Una EEPROM tarde unos 3,3 ms en completar una escritura y para Arduino se ha especificado una vida de 100000 ciclos de escritura/borrado.

Tutorial lectura EEPROM: http://en.wikipedia.org/wiki/EEPROM

Tutorial escritura EEPROM: http://arduino.cc/en/Tutorial/EEPROMWrite

Tutorial limpiado EEPROM: http://arduino.cc/en/Tutorial/EEPROMClear

Para grabar estructuras de datos en la EEPROM. http://playground.arduino.cc/Code/EEPROMWriteAnything

Ver que AVR Libc dispone de métodos de la librería <avr/eeprom.h> para manejar la EEPROM: http://www.atmel.com/webdoc/AVRLibcReferenceManual/group__avr__eeprom.html

La librería EEPROMex es una extensión de la librería EEPROM que amplía sus funcionalidades:

Ejercicio35-EEPROM: Hacer un ejemplo en el que se guarde y luego se lea configuraciones de la EEPROM.

ejemplo: http://playground.arduino.cc/Code/EEPROMLoadAndSaveSettings

struct: http://www.cplusplus.com/doc/tutorial/structures/

Solución: https://github.com/jecrespo

Ejemplo: Como proteger un arduino que queremos comercializar y que no se pueda replicar el programa en otros microcontroladores Atmel.

Un ejemplo es usar una EEPROM externa usado como “mochila” donde guardamos un número único. Este mismo módulo lo podríamos usar como contador o con otras funcionalidades.

Por ejemplo : http://datasheets.maximintegrated.com/en/ds/DS2430A.pdf

Ver como trabajar con ella: http://playground.arduino.cc/Learning/OneWire

Como poner un arduino a dormir: http://playground.arduino.cc/Learning/ArduinoSleepCode

Es posible poner un arduino en un estado de sleep para reducir el consumo en usos con batería, para ello necesita el uso de interrupciones de puerto equipadas en los pines 2 y 3.

Para ello es necesario usar los métodos de la librería avr/power.h:

Ejemplo de uso: http://rubenlaguna.com/wp/2008/10/15/arduino-sleep-mode-waking-up-when-receiving-data-on-the-usart/

Listado muy interesante como comuicar Arduino mediante HW con un montón de dispositivos: http://playground.arduino.cc/Main/InterfacingWithHardware

Arduino at heart or certified program:

http://arduino.cc/en/ArduinoAtHeart/HomePage

¿Puedo fabricar y vender un producto comercial basado en arduino?

Sí­, con las siguientes condiciones:

  • Utilizar una placa Arduino dentro de un producto comercial no requiere que reveles o liberes ninguna de las partes de su diseño.
  • Diseñar un producto comercial a partir de los planos de la placa Arduino requiere que publiques los planos modificados bajo la misma licencia Creative Commons Attribution Share-Alike.
  • Cualquier modificación del núcleo y bibliotecas de Arduino debe ser publicado bajo la LGPL. Pero utilizar el núcleo y las bibliotecas de Arduino para el firmware de un producto comercial no requiere que publiques el código fuente de tu firmware, sólo los ficheros objeto. Así, en caso de actualizaciones del núcleo de  Arduino será posible una recompilación.
  • El código fuente del ambiente Arduino está cubierto bajo la GPL, que requiere que cualquier modificación sea de código libre bajo la misma licencia. No previene la venta de software derivado o su incorporación en productos comerciales.

Más información en: http://arduino.cc/en/Main/FAQ

Esquema lógico de Arduino

Diagrama de bloques de un microcontrolador AVR de Atmel.

Para el caso de un PIC:

Captura

ICSP

ICSP es un método de programar directamente los microcontroladores de AVR, PIC y otros.

Como los microcontroladores suelen ir soldados a las placas, la forma de poder programarlos en mediante el conector ICSP y para programarlos es necesario un HW adicional denominado programador.

El pineado de las señales ICSP cambia en función de cada fabricante y del microcontrolador.:

El conector ICSP tiene dos versiones:

Más información: http://en.wikipedia.org/wiki/In-circuit_serial_programming

ICSP es un conector para programar Arduino consistente en 6 señales: MOSI, MISO, SCK, RESET, VCC, GND.

Frecuentemente nos referimos como SPI, el cual se puede considerar una expansión de la salida, pero realmente ICSP es un “esclavo” del master del bus SPI.

En referencia a los integrados AVR, es la forma que tenemos de programarlos de forma in-system, conectando un programador a estos 6 pines. El programador puede mandar el fichero hex al microcontrolador.

La forma en que programamos Arduino en mediante el puerto serie gracias al bootloader que se comunica con el puerto serie. Al mandar los comandos correctos, lee los datos del puerto serie de Arduino que es convertido a USB por el ATmega8u2 o ATmega16u2 y guarda todos los datos recibidos en la memoria Flash.

Por otro lado la programación ISP primero resetea el Arduino y lo mantiene, mientras el reset esta mantenido Arduino no funciona y ningún programa que tenga. En su lugar el programa codificado en hexadecimal se comunica a través de los pines MOSI (Master Out, Slave In) and MISO (Master In, Slave Out) y temporizándolo con el CLOCK.

Por lo tanto, la programación normal solo funciona con el bootloader y la programación ISP va directamente al HW. Mediante ISP puede cargar cualquier programa, es como si quiere grabar datos en un servidor y lo puede hacer mediante una web que permite hacerlo o grabarlo directamente en el disco duro.

Un ejemplo de como usar ICSP con un PIC: http://tecbolivia.com/index.php/articulos-y-tutoriales-microcontroladores/19-icsp-como-usar-qprogramacion-serial-en-circuitoq-con-microcontroladores-pic

Como usar un programador externo: http://arduino.cc/en/Hacking/Programmer

Ejemplo de programador externo: http://www.pololu.com/product/1300

Construir un programador paralelo: http://arduino.cc/en/Hacking/ParallelProgrammer

Ejemplo: Usar un Arduino como pasarela para programar otro

Bootloader

Cuando cargamos un programa en Arduino, estamos haciendo uso del bootloader, se trata de un pequeño programa que ha sido cargado previamente en el microcontrolador de la placa y que nos permite cargar código sin necesidad de hardware adicional. El bootloader solo está activo unos segundos cuando se resetea el Arduino y después comenza el sketch que está cargado en la flash de Arduino.

El bootloader hace que parpadee el pin 13 (led integrado en la placa) cuando se ejecuta.

La mayoría de los microcontroladores de AVR pueden reservar una zona de la memoria flash (entre 256B a 4 KB) para el bootloader. El programa bootloader reprograma el microcontrolador para guardar en la memoria flash el código binario a través de cualquier interface disponible.

El Arduino uno viene con el microcontrolador ATmega328 precargado con un bootloader que permite cargar nuevo código sin un programador. El bootloader se comunica usando el protocolo STK500.

El protocolo STK500 http://www.atmel.com/Images/doc2525.pdf es propio de Atmel. Es un protocolo serie y los programadores emulan este protocolo sobre un puerto serie virtual en un USB. Originalmente STK500 fue un programador fabricado por Atmel y a raíz de ello liberaron el protocolo STK500.

En este enlace es posible obtener el código en C: http://www.atmel.com/dyn/resources/prod_documents/avr061.zip

Arduino decidió usar avrdude y STK500 serial bootloader para programar o cargar nuevos programas en Arduino sin necesidad de HW adicional. El bootloader de Arduino es esencialmente el bootloader STK500 de Atmel.

Los MCUs AVR de 8bits atmega con interfaz USB integrado como son el ATmega16U2 y ATmega8U2, vienen de fabrica un USB bootloader en la sección de arranque de la flash.

Este bootloader USB permite hacer In-System programming desde USB host controller sin la necesidad de un HW externo.

En este documento se describe las funcionalidades del USB bootloader: http://www.atmel.com/Images/doc7618.pdf

El chip FTDI hace esa mismas función cuando no existe un interfaz USB integrado.

Avrdude es un programa para descargar y cargar las memorias de los MCUs AVR de Atmel. Puede programar la Flash y la EEPROM y es soportado por el puerto serie.

Avrdude funciona mediante la línea de comandos y soporta los siguientes tipos de programadores:

  • Atmel’s STK500
  • Atmel’s AVRISP and AVRISP mkII devices
  • Atmel’s STK600
  • Atmel’s JTAG ICE (both mkI and mkII, the latter also in ISP mode)
  • appnote avr910
  • appnote avr109 (including the AVR Butterfly)
  • serial bit-bang adapters
  • PPI (parallel port interface)

Avrdude junto con otras herramientas se encuentran en: C:\Program Files (x86)\Arduino\hardware\tools\avr

Más información sobre Avrdude en: http://www.nongnu.org/avrdude/ y https://omegav.no/wiki/index.php/AVR/avrdude y https://learn.adafruit.com/usbtinyisp/avrdude

Y aquí un manual de AVRdude: http://www.ladyada.net/learn/avr/avrdude.html

Optiboot bootloader: https://code.google.com/p/optiboot/

Auto Reset

Para cargar un nuevo sketch en un microcontrolador, es necesario hacer un reset para parar la ejecución de su programa y poder cargar el nuevo.

En el caso de los Arduinos, tienen la funcionalidad de auto-reset que está diseñado de forma que permite ser reseteado vía software conectado a un ordenador como el IDE de arduino.

Una de las líneas de hardware flow control (DTR) del ATmega8U2/16U2 está conectada a la línea de reset de ATmega328 a través de un condensador de 100 nF.

El SW de Arduino usa esta capacidad para cargar el código simplemente pulsando el botón de carga en el IDE. De esta forma se sincroniza perfectamente el envío del nuevo sketch junto con el reset del microcontrolador.

Al resetear se lo primero que arranca es el bootloader y puede comenzar la carga del sketch. El bootloader espera unos segundos para ver si un nuevo sketch se está cargando y en ese caso borra todo lo que hay en la flash y luego el bootloader comienza a cargar lo que haya en la flash.

Arduino Uno dispone de un jumper soldado que se puede cortar para deshabilitar el auto-reset y luego estos se pueden soldar de nuevo para habilitarlo.

Más información en: http://playground.arduino.cc/Main/DisablingAutoResetOnSerialConnection

Más información sobre el reset en Arduino:http://playground.arduino.cc/Main/ArduinoReset

Cargar el bootloader

Antes de cargar el bootloader, debemos asegurarnos la placa seleccionada en el IDE para que al realizar el “quemado” del bootloader se configure el bootloader adecuado para cada placa y los comandos de carga del bootloader.

  • Arduino Uno y mini posee auto reset usando el optiboot bootloader
  • Arduino mega  posee auto reset y usa el stk500v2 bootloader

Para cargar o “quemar” el bootloader, necesitaremos un programador externo (in-system programmer). un USBtinyISP (https://learn.adafruit.com/usbtinyisp), un programador parallelo (http://arduino.cc/en/Hacking/ParallelProgrammer) o otro arduino con un programa adecuado cargado.

El programador se conecta a ICSP y debemos asegurarnos que lo conectamos correctamente y asegurarnos que hemos seleccionado la placa correcta, luego lanzar el comando herramientas > grabar secuencia de inicio desde el IDE de arduino. Este proceso tarda 15 o más segundos.

Más información: http://arduino.cc/en/Hacking/Bootloader

En el fichero de preferencias están todos los datos para la carga del bootloader un función del modelo de bootloader: http://arduino.cc/en/Hacking/Preferences

Ver los ficheros boards.txt y programmers.txt en C:\Program Files (x86)\Arduino\hardware\arduino

Ver es esa misma ruta los bootloader.

Más información en: https://code.google.com/p/arduino/wiki/Platforms

Para el Arduino mini hay diferencias a la hora de cargar el bootloader: http://arduino.cc/en/Hacking/MiniBootloader

Cargar sketches con un programador externo

Con un programador externo, además de cargar el bootloader a un microcontrolador, podemos cargar los sketchs en la MCU sin necesidad del bootloader.

Esto nos permite usar el espacio completo de la memoria flash del microcontrolador, además de ahorrarnos el retraso que hay en el arranque cuando tenemos el bootloader.

Para usar el programador externo debemos modificar ligeramente el fichero de preferencias del IDE de Arduino y debemos hacerlo con el IDE cerrado.

Para encontrar el fichero de preferencias: http://arduino.cc/en/Hacking/Preferences

Debemos cambiar la línea  upload.using=bootloader por el identificador de uno de los programadores que tenemos en el fichero programmers.txt. Por ejemplo avrispmkii.

Después de hechos estos cambios, puedes cargar los sketches a la placa con el botón normal de upload, pero no es necesario pulsar el botón de reset, puesto que Arduino ya tiene la configuración de auto-reset.

Para volver a programar usando el bootloader, debemos volver a la configuración upload.using=bootloader en el fichero de preferencias y por supuesto el bootloader de nuevo en la placa.

Más información: http://arduino.cc/en/Hacking/Programmer

Un programador para AVR: https://www.sparkfun.com/products/9825

Tutorial para cargar el bootloader: https://learn.sparkfun.com/tutorials/installing-an-arduino-bootloader

Un programador ofical de Atmel: http://www.atmel.com/tools/AVRISPMKII.aspx

Y el manual: http://www.atmel.com/webdoc/avrispmkii/index.html

Atmel 328 con bootloader: http://www.adafruit.com/products/123

Ejercicio36-ArduinoISP: Usar un Arduino para hacer In-Sytem Programming a otro Arduino.

Cómo hacerlo:

Para hacerlo sobre un micro directamente sin Arduino:http://www.open-electronics.org/arduino-isp-in-system-programming-and-stand-alone-circuits/

Solución: https://github.com/jecrespo/Aprendiendo-Arduino

Anuncios

2 pensamientos en “Tema 7 – Conceptos avanzados de Hardware

  1. Pingback: Cómo conseguir un “Arduino” Gratis | Aprendiendo Arduino

  2. Pingback: Cómo conseguir un “Arduino” Gratis – aprendiendoarduino

Los comentarios están cerrados.