Archivo por años: 2016

Bootloader

Cuando cargamos un programa en Arduino desde el USB con el IDE, estamos haciendo uso del bootloader, se trata de un pequeño programa que ha sido guardado 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 comienza el sketch que está cargado en la flash de Arduino y que hemos programado y subido a la placa.

El bootloader se ejecuta cuando el microcontrolador se enciende o se pulsa el botón reset, durante un corto espacio de tiempo espera que le llegue por el puerto serie un nuevo sketch desde el IDE de Arduino (este distingue un sketch de otra cosa porque tiene un formato definido). Si llega un sketch, este es guardado en la memoria flash y ejecutado, en caso contrario ejecuta el sketch anteriormente cargado.

La mayoría de los Arduinos tienen la función autoreset que permite al IDE de Arduino subir el código sin tener que pulsar el botón de reset.

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 bootloader de Arduino está programado en la memoria flash del ATMega328p y ocupa 0,5 KB de los 32KB disponibles. Este bootloader viene precargado en la memoria flash del microcontrolador y es lo que diferencia el ATMega328p de Arduino de otro que viene de fábrica.

El Arduino UNO viene con el microcontrolador ATMega328p 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 del protocolo STK500: 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.

Las MCUs AVR de 8bits ATMega con interfaz USB integrado como son el ATmega16U2 y ATmega8U2, vienen de fábrica 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 puerto serie durante el proceso de bootloader funciona a 19200 baudios.

El bootloader estándar de Arduino usa el protocolo STK500 versión 2 y por ese motivo es el valor que usamos en el IDE de Arduino.

Los comandos para “quemar” el bootloader en Arduino usan una herramienta open nsource llamada avrdude, de la que se hablará más tarde. Hay cuatro pasos a la hora de cargar el bootloader:

  • Desbloquear la sección de bootloader en el chip
  • Configurar los fuses en la MCU
  • Cargar el código del bootloader en el microcontrolador
  • Bloquear la sección del bootloader en la MCU

Todo esto es controlado por una serie de preferencia en el fichero de preferencias de Arduino: https://www.arduino.cc/en/Hacking/Preferences

Cuando el Boot Reset Fuse (BOOTRST) está configurado, el contador de programa en la memoria flash es inicializado a una dirección de memoria de un bloque en el extremo superior de la memoria (esto depende de como se hayan configurado los fuses, ver https://www.arduino.cc/en/uploads/Main/Arduino_Uno_Rev3-schematic.pdf para más información). El código que comienza no puede hacer nada, si realmente se quiere se podría poner su propio programa de allí si se utiliza un ICSP (los bootloaders por lo general no puede sobrescribirse a sí mismos).

Funciones de la AVR-lib para bootloader: http://www.nongnu.org/avr-libc/user-manual/group__avr__boot.html

El bootloader se trata de un programa especial y puede leer datos de una fuente externa como UART, I2C, CAN, etc… para reescribir el programa guardado en la memoria flash del microcontrolador. El bootloader busca un evento especial que puede ser cualquier cosa, pero para el desarrollo es más conveniente algo en el bus de datos que será puesto en la flash de la MCU. Si el bootloader ve ese evento especial, entonces entra en modo bootloading en el que hace un reflash de la memoria de programa del microcontrolador, pero si no aparece el evento, pasa el control al código del usuario.

El bootloader no consume RAM y los únicos efectos que tiene son modificaciones en los registros del hardware periferivo, pero un buen bootloader no debe dejar ningún estado perjudicial en el que encienda periféricos que malgasten energía cuando pones la MCU en modo sleep. Es una buena práctica inicializar los periféricos que se usan, así aunque el bootloader haga algo extraño, habremos inicializado como queremos que se comporte.

Avrdude es un programa para descargar y cargar a la memoria de las 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

Para cargar un sketch con avrdude en Arduino en lugar de usar el IDE, simplemente conectar el cable USB y presionar el botón de reset antes de ejecutar avrdude. Luego ejecutar con estas opciones:

  • Use -b 19200 to set the baud rate to 19200
  • The device signature reads dont seem to work so you’ll want to use -F
  • The programmer type is avrisp
  • The device type is -p m168
  • The port is whatever the FTDI chip shows up as

Un tutorial de avrdude se encuentra en http://ladyada.net/learn/avr/index.html

Más información:

Reparar el bootloader de un ATTiny: https://learn.adafruit.com/introducing-trinket/repairing-bootloader

Auto Reset

Para cargar un nuevo sketch en un microcontrolador, es necesario hacer un reset para pausar 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 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 lo que hay en la flash y luego empieza a cargar el programa que está 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:

Bootloaders

Además del bootloader que disponemos desde el IDE de Arduino y el que viene precargado en los microcontroladores de Arduino, existen otros bootloaders con mejoras en algunos aspectos o para ofrecer nuevas características.

Codigo fuente del bootloader de Arduino: https://github.com/arduino/Arduino/tree/master/hardware/arduino/avr/bootloaders

Optiboot es un bootloader muy conocido que está más optimizado que el bootloader oficial de Arduino, permitiendo sketches mayores, carga más rápida.

Toda la información del optiboot:

HoodLoader2 te la opción de reprogramar el ATmega16u2 de un Arduino normal con sketcehs: https://github.com/NicoHood/HoodLoader2, se  trata de un proyecto muy intersante.

Como funciona el optiboot: https://code.google.com/archive/p/optiboot/wikis/HowOptibootWorks.wiki

Adaboot es otro bootloader optimizado cuyas mejoras ya las incluye optiboot. Más información: https://learn.adafruit.com/arduino-tips-tricks-and-techniques/bootloader

Optiloader es un sketch diseñado para automatizar las actualización de los bootloaders de Arduino usando otro Arduino como programador. Almacena múltiples copias de optiboot en la flash y cuando se inicia consulta al Arduino a cargar el bootloader y averigua la CPU que tiene e inicia la carga del bootloader ya programación adecuada de los fuses.

Interesante un TFTP bootloader: http://playground.arduino.cc/Code/TFTP_Bootloader_1

Más información: https://github.com/WestfW/OptiLoader

Cargar el Bootloader en Arduino

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). como USBtinyISP (https://learn.adafruit.com/usbtinyisp), un programador parallelo (http://arduino.cc/en/Hacking/ParallelProgrammer) u 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:

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 y 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, también 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.

Esto nos permite usar un arduino sin un bootloader y también es posible cargar el hex ya compilado en arduino con herramientas gráficas como XLoader: http://xloader.russemotto.com/ o con avrdude directamente como hemos visto anteriormente. La compilación puede ser con el IDE de Arduino o con cualquier otro compilador basado en avr-GCC

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

Ejemplos de programadores:

También es posible programar un ATtiny con una Raspberry Pi por SPI: http://www.instructables.com/id/Programming-the-ATtiny85-from-Raspberry-Pi/?ALLSTEPS

Ejercicios Bootloader

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

Usar un Arduino como pasarela para programar otro directamente sin bootloader.

ATENCIÓN –  esto eliminará el bootloader de Arduino

Tutoriales:

Solución: https://github.com/jecrespo/Aprendiendo-Arduino/tree/master/Ejercicio36-ArduinoISP

Alimentación Arduino

Una de la partes más importantes a la hora de afrontar un proyecto con Arduino o cualquier microcontrolador es como vamos a alimentarlo y en caso que haya que usar baterías que autonomía va a tener. Pero no solo es alimentar Arduino, sino que hay que tener en cuenta que además es posible que estemos alimentando a través del microcontrolador los sensores y actuadores y si no tenemos en cuenta las limitaciones eléctricas del microcontrolador, podemos encontrarnos que no funcione el proyecto.

Cuanto consume Arduino: http://www.prometec.net/consumos-arduino/

Métodos de Alimentar Arduino

USB

Cuando se trabaja con Arduino normalmente lo alimentas a través del cable USB que va al ordenador. Sin embargo, una vez programado, o bien se deja conectado al ordenador o bien se busca otra forma alimentar Arduino. Alimentar Arduino por USB tiene la desventaja de que solo es capaz de suministrar hasta 500 mA.

Adaptador de Corriente

El método más habitual de alimentar Arduino es mediante un adaptador de corriente (AC DC). Este alimentador debe de dar un voltaje adecuado al arduino que conectemos y la potencia suficiente. Un voltaje adecuado para el Arduino UNO es un alimentador de 7 o 7,5V puesto que por debajo de ese voltaje es posible que la salida 5V de Arduino esté por debajo y por encima el regulador de tensión se calentará innecesariamente. A partir de 12V es desaconsejable Alimentar Arduino porque el regulador de tensión se calienta mucho y puede acabar dañándose. Esta opción es la mejor si el proyecto no necesita moverse y si hay una toma de corriente accesible cerca de Arduino.

Fuente de Alimentación Regulable

Para propósitos de testeo y desarrollo, podríamos usar una fuente de alimentación regulable y usarla para alimentar Arduino, pero en un entorno de laboratorio.  

Baterías

Otra opción para alimentar Arduino es mediante baterías de 9V, pero apenas tienen duración en un Arduino, puesto que el diseño de un Arduino no está pensado en un bajo consumo, por lo que salvo para una pequeña demostración no es una solución válida. Estas pilas tienen una capacidad entorno a 300 mAh y un proyecto sencillo con Arduino puede consumir 200 MAh, por lo que no llegará a una hora de autonomía.

Las típicas pilas AA proporcionan 1,5V. Se pueden poner varias pilas en serie hasta llegar al voltaje necesario (lo ideal es poner 5 o 6) y alimentar Arduino con ellas. La diferencia entre utilizar estas pilas y utilizar las de 9V es enorme. Una sola pila alcalina AA tiene entre 2700-2900 mAh (por los 300 mAh de una recargable de 9V), por lo que son una muy buena opción. La única pega que tiene esta opción es que como pilas que son se gastan, y tendrás que comprar pilas a menudo. Aun así una opción muy recomendable.

Las baterías LiPo (Polimero de Litio). Esta batería tiene mucha duración (tienen muchos mAh). Tienen una vida útil bastante larga, lo que hace que compense utilizar este recurso aunque sean más caras que las pilas AA. Sin lugar a dudas son la mejor opción para alimentar un coche a radiocontrol, dron o cualquier dispositivo móvil que se te ocurra.Existen baterías LiPo de distintos voltajes y capacidades. En el caso de alimentar Arduino, la mejor opción es utilizar una batería de 7,4V y, al menos, 1600 mAh.

Las baterías LiPo se componen de celdas y cada celda es de 3,7V, por lo tanto los voltajes que podemos encontrar de estas baterías son múltiplos de 3,7V.

Estas baterías son recargables y debemos cargarlas adecuadamente para alargar su vida, para ello disponemos de módulos cargadores de baterías LiPo.

Más información sobre baterías:

Otra forma de alimentar un Arduino es mediante una placa solar y un acumulador, pero este tema se tratará un poco después en este post.

Más información en:

Fuente conmutada

Otra forma de alimentar un Arduino es usar una fuente conmutada como las fuentes ATX de los ordenadores. Una fuente conmutada es un dispositivo electrónico que transforma energía eléctrica mediante transistores en conmutación. Mientras que un regulador de tensión utiliza transistores polarizados en su región activa de amplificación, las fuentes conmutadas utilizan los mismos conmutándolos activamente a altas frecuencias (20-100 kilociclos típicamente) entre corte (abiertos) y saturación (cerrados). La forma de onda cuadrada resultante es aplicada a transformadores con núcleo de ferrita para obtener uno o varios voltajes de salida de corriente alterna (CA) que luego son rectificados (con diodos rápidos) y filtrados (inductores y condensadores) para obtener los voltajes de salida de corriente continua (CC).

Las ventajas de este método incluyen menor tamaño y peso del núcleo, mayor eficiencia y por lo tanto menor calentamiento. Las desventajas comparándolas con fuentes lineales es que son más complejas y generan ruido eléctrico de alta frecuencia que debe ser cuidadosamente minimizado para no causar interferencias a equipos próximos a estas fuentes.

Además con esta fuentes tenemos suficiente potencia para alimentar a Arduino y los componentes que conectemos como LEDs, motores, etc…

Ejemplo de fuente de alimentación conmutada: http://electronicaraya.com/?q=catalogo/753

Se podría hacer una fuente conmutada controlada por Arduino: http://es.slideshare.net/pablogindel/fuente-conmutada-con-arduino

Cómo gobernar una fuente ATX con Arduino: http://www.prometec.net/fuentes-atx/

Fuente de alimentación reciclada para uso con Arduino: https://sites.google.com/site/arduinoreciclar/fuente-de-energia

Fuente de alimentación con Arduino: http://www.urpmigeek.com/2012/06/diy-fuente-de-alimentacion-con-arduino.html

Más información de fuentes conmutadas

Este tipo de circuitos reciben el nombre de fuentes conmutadas, convertidores Buck (Buck converters), o fuentes Step Down (De escalón de bajada) y son la base de las fuentes ATX.

La virtud de los buck converters o fuentes de Step Down es que proporcionan un buen rendimiento en la conversión de energía de una batería por ejemplo, sin desperdiciarla en forma de calor, frente a los reguladores de tensión lineales. Estas fuentes son ideales si estamos alimentando un equipo con baterías 12V, como por ejemplo en un coche, y deseamos alimentar nuestro Arduino para cualquier invento. Nos permiten bajar la tensión de 12V de la batería a los 5 V que necesitamos en nuestra entrada Vin con garantías de no desperdiciar energía de la batería en forma de calor, y por tanto extender sensiblemente su duración, al contrario de los reguladores lineales que veremos después.

En general el mercado nos provee de multitud de circuitos montados con fuentes conmutadas y aunque son algo más caras que los simples reguladores lineales, los precios han caído tanto que por unos pocos euros se consigue un Buck converter de calidad.

Ejemplo de fuentes step-down conmutadas:

Un ejemplo de un conversor DC/DC conmutado step-down es el TRACO  TSR 1-2450. Datasheet: https://cdn-shop.adafruit.com/datasheets/tsr1.pdf. Consigue hasta un 96% de eficiencia sin necesidad de disipador y es el sustituto eficiente de un regulador lineal (LDO) como el LM7805. Además estos conversores tienen una salida más exacta (±2 %), menor corriente en standby (2mA) y no requiere de condensadores externos al contrario que los reguladores lineales (LDO). Son ideales para aplicaciones alimentadas con baterías. El problema de estos conversores es que son más caros que los reguladores lineales.

Para alimentar un Arduino con un TSR 1-2450, habría que inyectar la corriente al pin de 5V pero no dispondríamos de protección alguna.

Si lo alimentamos a Arduino a través del pin Vin, estaríamos pasando por el regulador NCP1117 del Arduino y perderíamos toda la eficiencia. Además en este caso necesitaríamos más de 6V y entonces habría que usar el TSR 1-2490.

Más información sobre TRACO power: http://www.tracopower.com/home/

También hay otros DC-DC converters pero aislados  usando un transformador como el THD 12-2412WI: http://docs-europe.electrocomponents.com/webdocs/0aca/0900766b80acafd9.pdf

Application note muy interesante que compara y aconseja en caso usar entre los reguladore lineales y las fuentes conmutadas: http://cds.linear.com/docs/en/application-note/AN140fa.pdf

Video que compara buck converter frente a un linear regulator como el 7805: https://www.youtube.com/watch?v=giGRrODKJSE

Linear vs switching regulator en aplicaciones industriales de 24V: : http://www.ti.com/lit/an/slyt527/slyt527.pdf

Más información: http://www.intersil.com/en/products/power-management/linear-vs-switching-regulators.html

Se podría alimentar también un arduino con un regulador de tensión lineal, pero lo vamos a ver en el siguiente apartado y este ya viene integrado en Arduino.

Fuente con un regulador lineal:

Ejemplo de alimentar un Arduino (ATmega328p) con un regulador lineal: http://www.instructables.com/id/5V-voltage-regulator-with-7805/

Regulador de Tensión

Los microcontroladores que hemos visto funcionan todos a 5V o a 3.3 V, pero como hemos visto anteriormente y según vemos en las especificaciones de Arduino UNO debemos alimentarlo al menos a 7V. Por este motivo, todos los Arduino tienen un regulador de tensión, cuya función es convertir el voltaje de alimentación al voltaje de los elementos electrónicos, principalmente al microcontrolador. Esta conversión tiene un gasto energético que se convierte en calor en el regulador de tensión.

El regulador de tensión necesita un voltaje mínimo para para proporcionar 5V que está entorno 6.5-7V pero todo lo que esté por encima de ese valor se desperdicia y supone una ineficiencia energética.

Como se puede ver en este esquema, Arduino es alimentado mediante un regulador de tensión, en este caso es un NCP1117 http://www.onsemi.com/pub_link/Collateral/NCP1117-D.PDF que alimenta al bus de 5V de Arduino.

A su vez el bus de 5V alimenta otro regulador de tensión LP2985-33 http://www.ti.com/lit/ds/symlink/lp2985-50.pdf del que se obtiene una salida de 3.3V

Además hay disponible una entrada al bus de 5V para la alimentación directa del cable USB.

Ver el esquema completo en:

El límite máximo de alimentación de un Arduino es 20V y viene del límite de alimentación del regulador NCP1117.

Como se ha visto anteriormente los reguladores lineales de tensión son altamente ineficientes y el exceso de voltaje sobre la salida nominal se convierte en calor, por lo tanto a cuando mayor voltaje alimentemos Arduino más se calentará el regulador de tensión NCP1117.

Podemos ver cual es la tensión mínima de funcionamiento del Arduino a partir de los componentes implicados. Supongamos que pedimos a la placa una corriente de 200mA. Respecto al regulador, el dato más importante para el cálculo es la tensión de dropout, esto es, la caída entre entrada y salida cuando funciona. El dropout depende de la corriente y la temperatura. Para 200mA y 25ºC, tenemos algo menos de 1V.

Ventajas y desventajas de los reguladores lineales frente a los conversores conmutados: http://www.digikey.com/en/articles/techzone/2012/may/understanding-the-advantages-and-disadvantages-of-linear-regulators. La principal ventaja de los reguladores lineales es su menor tamaño, menor complejidad de uso, bajo coste y menor ruido y ripple (https://en.wikipedia.org/wiki/Ripple_(electrical))

Debido al uso de los reguladores de tensión y otras protecciones que tiene Arduino, hace que esta placa sea poco eficiente, haciendo que tenga un consumo elevado entorno a los 46mA en reposo para el Arduino UNO. Más información en http://www.prometec.net/consumos-arduino/

Los reguladores de tensión también se le denomina LDO (https://en.wikipedia.org/wiki/Low-dropout_regulator). Un LDO es un regulador de voltaje lineal de CC que puede regular la tensión de salida incluso cuando la tensión de alimentación está muy cerca de la tensión de salida. Las ventajas de un regulador de tensión sobre otros conversores DC-DC conmutados es la ausencia de ruido de conmutación (se lleva a cabo conmutación), el tamaño del dispositivo más pequeño y la simplicidad diseño (por lo general consiste en una referencia, un amplificador, y un elemento de paso). Una desventaja importante es que, a diferencia de reguladores de conmutación, los reguladores de corriente continua lineal debe disipar toda la energía a través del dispositivo de regulación con el fin de regular la tensión de salida.

Un LDO, por su propia naturaleza siempre disminuye el nivel de tensión entrada y no puede usarse para que la tensión de salida sea mayor que la de entrada.

Más información:

Reguladores lineales VS fuentes conmutadas

Para decidir cómo alimentar los proyectos debes tener en cuenta un par de ideas básicas.

Es importante saber que la eficiencia típica de un regulador lineal suele ser de un 40% y puede caer hasta un 15% con facilidad, por eso nunca deberían usarse en proyectos que funcionan a baterías, frente a un 85% típico de una fuente conmutada. Las fuentes conmutadas son recomendables siempre que usemos circuitos alimentados por baterías, pero imprescindibles cuando el consumo aumenta por encima de más o menos medio amperio, porque el calor generado, y su evacuación,  empezaran a dar problemas que irán complicándose cada vez más.

Una fuente conmutada DC que dé a su salida una tensión mayor que a la entrada, es una fuente del tipo Boost, Boost converter, o también una fuente Step-up y esto no es posible con una LDO.

Linear Regulator Switching Regulator
Control    
Design Flexibility Buck Buck, Boost, Buck-Boost
Efficiency Normally low to medium-high for low difference between VIN-VOUT High
Complexity Low Medium to high
Size Small to medium, larger at high power Smaller at similar higher power (depending on the switching frequency)
Total Cost Low Medium to high – external components
Ripple/Noise/EMI Low Medium to high
VIN Range Narrow (depending on power dissipation) Wide

Otro regulador de voltaje muy utilizado es el LM7805: https://www.sparkfun.com/datasheets/Components/LM7805.pdf:

También podríamos hacer una versión de Arduino en protoboard con el LM7805: http://www.prometec.net/arduino-en-protoboard/

NerO es un Arduino UNO pero diseñado desde el punto de vista de la eficiencia energética, https://www.kickstarter.com/projects/1218034479/nero-an-energy-efficient-arduino-uno-compatible-de. NerO dispone de un regulador conmutado en lugar de un LDO, al igual que usa el Arduino Leonardo ETH el MPM3610 http://www.monolithicpower.com/DesktopModules/DocumentManage/API/Document/getDocument?id=3301

Cómo Funciona la Alimentación de Arduino

Este es el esquema de alimentación de un Arduino desde el jack de alimentación.

Esta es la parte del circuito que regula una salida a 5V desde el jack de alimentación.

Abajo a la izquierda tenemos el conector de alimentación Vin. Esta entrada está también disponible al final de la tiras de pines que se halla abajo a la derecha en la figura si no se desea usar este voluminoso conector. A la derecha del conector tenemos los dos condensadores electrolíticos de 47uF y, debajo de éstos, el diodo D1 (M7). Encima del conector de alimentación tenemos el regulador de tensión NCP1117.

Para el diodo M7, el datasheet muestra la siguiente figura para la relación corriente-tensión, tenemos algo más de 0,9V a 0,2 A de de corriente. En total, juntando regulador y diodo tenemos una caída de 1,8V, por tanto, para una alimentación de 5V necesitamos un valor de Vin mínimo de 6,8V.

La placa Arduino no funcinará fiablemente con menos de 7V, pero, dado que internamente funciona a 5V, la eficiencia máxima de la alimentación será del 71% (=5V/7V). Si alimentamos la placa a 9V la eficiencia cae hasta el 55%.

Adicionalmente la placa lleva otra circuitería paralela para gestionar tanto las tensiones de 3.3V como el caso en el que simultáneamente la placa esté alimentada vía jack y vía USB.

Cuando se enchufa la placa solo al cable USB, el micro y todo lo demás es alimentado por los 5V que suministra el conector USB. Si se conecta una alimentación en el rango de 7-12V al jack, el micro y todo lo demás es alimentado por el circuito de regulación.

Pero cuando se conecta la placa tanto vía USB como vía jack al mismo tiempo, la placa usa un transistor T1, para dar preferencia a la fuente de tensión regulada por el jack, anulando la suministrada vía USB. Este transistor es el que permite a la placa vigilar, en caso de que estando el Arduino alimentado de dos formas distintas,  qué sistema se ha desconectado, y cambiar de uno a otro sin que notemos ninguna interrupción. En este caso si la tensión Vin es inferior a 6,6V se alimenta mediante el USB y si es superior, mediante el circuito de regulación.

Además como podría pasar que la alimentación a través del jack tuviera la polaridad cambiada (recordemos que para alimentar correctamente la placa el jack debe tener la tensión positiva en el centro), el sistema actúa como si la placa no estuviera conectada, protegiendo así al Arduino.

Más información:

Esquemáticos de Arduino UNO:

Reguladores de Tensión de Arduino

Alimentación Otros Arduinos

Hemos visto cómo funciona la alimentación en el Arduino UNO y en otros similares como el MEGA, pero otros Arduinos se alimentan de forma diferente y cuando nos toque usarlos habrá que ver cómo funcionan. Veamos unos ejemplos.

Para el caso del Arduino Yun al no disponer de un sistema de regulación de tensión, sólo puede alimentarse mediante un cable micro-USB o mediante el pin Vin donde debemos aplicar exactamente 5V. Arduino Yun no puede alimentarse por el pin de 5V porque en el esquemático https://www.arduino.cc/en/uploads/Main/arduino-Yun-schematic.pdf se ve como hay un diodo que solo permite a la corriente salir.

El Arduino Yun usa el RT8010: http://www.richtek.com/assets/product_file/RT8010=RT8010A/DS8010A-10.pdf

Más información: http://www.open-electronics.org/the-power-of-arduino-this-unknown/

Arduino mejorado con selector de voltaje y un regulador más potente entre otras modificaciones: http://playground.arduino.cc/Main/Luigino328

Más información para alimentar Arduino a 5V:

Las placas Arduino Diecimila y Duemilanove usan el MC33269 como regulador de tensión para conseguir los 5V necesarios para su funcionamiento. Este regulador tiene un «DropOut» de 1V, esto es, que para conseguir los 5V necesita estar alimentado con 6V, como mínimo.

Datasheet MC33269 http://www.onsemi.com/pub_link/Collateral/MC33269-D.PDF

Arduino Leonardo ETH http://download.arduino.org/products/LEONARDOETH/Arduino_Leonardo_Eth_V1_sch.pdf usa un MPM3610 que es un Synchronous Step-Down Converter conmutado

Datasheet MPM3610: http://www.monolithicpower.com/DesktopModules/DocumentManage/API/Document/getDocument?id=3301

Ejemplo: Problema de alimentación con Arduino motor shield

Veamos un ejemplo real de problema en un proyecto por culpa de no tener claro como se alimenta Arduino y los shields. Se trata de un Arduino UNO con un motor shield para mover un coche con dos motores DC de 12V.

El problema radica que al alimentar todo el bloque desde las baterías de 12V de usadas por lo motores, Arduino se queda colgado porque al arrancar los motores baja la tensión que llega al ATmega328p por debajo de 5V y deja de funcionar. Sin embargo en las pruebas con el Arduino conectado al USB para programar y hacer debug esto no pasaba.

Esquema Motor Shield: https://www.arduino.cc/en/uploads/Main/arduino_MotorShield_Rev3-schematic.pdf

Esquema del Arduino UNO: https://www.arduino.cc/en/uploads/Main/arduino-uno-schematic.pdf

Al alimentar a 12V desde LSP5 (Borna marcada con Vin) en el motor shield, es el VMOT el que alimenta Vin del Arduino y al L298P (driver de motores). Lo que ocurre es que VMOT cae por debajo de los 6,5V necesarios para alimentar al Arduino e incluso es incapaz de alimentar al VSS (5V para la logica) L298P que lo recoge del regulador de tensión del Arduino a traves del bus de 5V como se ve en el esquema.

La causa de esa caída de tensión puede ser de los motores conectados al L298P están demandando mucho.

La solución es alimentar por separado los motores y el Arduino, que es precisamente lo que pasa cuando Arduino estaba conectado al USB, para ello hay que cortar el jumper en placa denominado Vin-Connect.

Cuando Arduino está alimentado por USB esto no pasa porque en ese caso te saltas la alimentación del regulador de tensión que tiene el Arduino. Es lo que se ve en el esquema de Arduino UNO como USBVCC y al ser Vin menor que 6.6V el mosfet FDN340P deja alimentar desde el USB en lugar de Vin.

Cómo decide la alimentación Arduino entre el USB o el Vin/adaptador

Eso sí, debemos tener en cuenta que al alimentar Arduino por el USB la corriente máxima será de 500 mA.

Mosfet:

Más información: http://arduino.stackexchange.com/questions/893/arduino-what-happens-if-i-power-the-arduino-with-both-the-usb-and-external-pow

Como arduino selecciona automáticamente entre USB y Vin:

Entradas de Alimentación de Arduino

Una vez visto cómo funciona la alimentación de Arduino, ya podemos entender las diferentes formas desde las que podemos alimentar la placa y los riesgos que tiene cada una de ellas.

Lugares desde donde se puede alimentar Arduino:

Arduino tiene 4 posibles entradas de alimentación:

  • Puerto USB: llega al bus de 5V, procedente del puerto USB de un ordenador o de cualquier fuente de alimentación que se proporciona con un puerto USB como una batería. Si la alimentación proviene de un ordenador, hay una limitación de corriente de 500 mA, si por el contrario está utilizando una fuente de alimentación externa, la corriente máxima de salida (independientemente de la garantizada por la misma fuente de alimentación, que en general es de un máximo de 1 A o 2 A) está limitada a 500 mA por el fusible de protección auto-restaurable.
  • JACK: una fuente de alimentación, por lo general, se debe conectar a esta toma, con el polo positivo en la parte central de la toma, y el valor debe que oscilar entre 6V y 20V, el recomendado es 7-12V, por lo que no es aconsejable utilizar tensiones inferiores a 7V o superiores a 12V.
  • Pin Vin: este conector tiene una doble función.
    • Entrada para alimentación externa, no está protegida por el diodo ante inversiones de polaridad. La conexión va directamente a la entrada del regulador. Por supuesto no se debe aplicar tensión al jack, de lo contrario podrían surgir conflictos peligrosos
    • Salida de la que extraer el voltaje aplicado a la toma de JACK, pero sin la caída del diodo de protección. Podría resultar útil para alimentar cargas pequeñas que requieran una tensión superior a 5 V e igual a la aplicada a la toma JACK (siempre teniendo en cuenta la caída de tensión del diodo).
      En ambos casos el polo negativo de voltaje se puede encontrar en los pines de GND. Algunos shields usan este pin para alimentarse.
  • Pin 5V: está conectado directamente a la salida del regulador y al bus de 5V que se usa para alimentar cargas externas a Arduino como los sensores. En el caso de no aplicar tensiones al puerto USB o al jack, la toma de 5V se puede utilizar para alimentar Arduino directamente, si es que tiene una fuente externa estabilizada de 5V. Uno tiene que tener en cuenta que, en general, los reguladores no les gustan los voltajes que se aplica a su salida, pero en este caso particular, esta situación resulta a ocurrir incluso cuando la alimentación de Arduino se hace desde el puerto USB, por lo tanto, se puede suponer que no es un gran problema. En este caso no hay ninguna forma de protección, ya que tanto el diodo y el fusible se encuentran por encima de este bus y por lo tanto no tienen ninguna función activa. Al igual que en el caso de la toma de Vin, el polo negativo de la tensión se puede encontrar en los pines GND


NOTA: Arduino tiene un conector de salida de 3,3V para las cargas eléctricas que operan en esta tensión, mediante un segundo regulador que se conecta directamente a la V. 5 Este pin no se puede utilizar como entrada.

Como Destruir un Arduino

Ahora que ya conocemos bien cómo funciona la alimentación en Arduino, será fácil entender las malas prácticas que pueden dañar o destruir un Arduino.

Veamos 10 formas de destruir un Arduino:

  • Cortocircuitar un pin de entrada/salida con tierra. Configuramos uno de los pines como salida, lo establecemos en alto y este está directamente conectado a tierra, sin ningún componente que cree resistencia entre estos dos puntos (el pin de salida y el pin GND). El Pin de entrada/salida se sobrecarga y se destruye.
    Según las especificaciones de Arduino,este puede entregar un máximo de 40mA por cada pin, pero sin nada que haga de resistencia entre el pin y tierra este entregará unos 200mA, suficiente para destruir el microcontrolador.

  • Dos pines que se cortocircuitan mutuamente. Configuramos ambos pines como entradas, uno tiene un valor alto, el otro un valor bajo. Ambos son conectados uno con otro sin que exista ningún componente entre ellos. En este caso, ambos pines se sobrecargan mutuamente y son destruidos.
    Por un motivo similar al de la forma 1. El pin que esta en baja en este caso haría las veces de tierra, y entregarían tensiones muy por encima del máximo del microcontrolador, lo que lo destruye.

  • Sobretensión en los pines de entrada/salida. El voltaje máximo recomendado para cualquier pin de entrada/salida es de 5V (Salvo las versiones que operan a 3.3V), si aplicamos cualquier tensión por encima de 5.5V destruiremos nuestro Arduino.
    Los pines de Arduino cuentan con un diodo que protege el microcontrolador cuando se recibe una tensión superior a 5V, pero esta proyección esta pensada para descargas cortas, producidas por ejemplo por una descarga electrostática o un pequeño pico de tensión al arrancar, si esta sobre tensión dura, más que eso el diodo se quema, deja de proteger el pin del microcontrolador y este se quema.

  • Invertir la polaridad al alimentar Arduino por su patilla Vin. Cuando queremos alimentar nuestro Arduino mediante su patilla Vin y por error conectamos Vin a tierra y GND a 5V.
    Arduino no cuenta con protección en caso de invertir su polaridad de alimentación, por lo que la corriente avanzará “en dirección contraria” por todo el circuito de Arduino, destruyendo el regulador de voltaje y probablemente el microcontrolador.

  • Aplicar más de 5V al bus de 5V Al aplicar 6V o más al pin de 5V de Arduino se queman muchos de los componentes de esta placa, incluso podría llegar la corriente al puerto USB del ordenador si este está conectado.
    No hay ningún tipo de protección ni regulador de voltaje en la pata 5V de Arduino, por lo que la electricidad correrá libremente por todos los componentes destruyéndolos a su paso.

  • Aplicar más de 3.3V en el pin de 3.3V de Arduino. Si aplicamos más de 3.6V en la patilla de 3.3V podría dañar varios componentes de Arduino y probablemente también cualquier Shield que este conectado en ese momento.  Si llegasen a entrar más de 9V se detruiria también el regulador de 3.3V y la tensión podría causar daños en el puerto USB del ordenador si estuviese conectado en ese momento.
    El pin de 3.3V no tiene circuitos de protección. La corriente entraría directamente al regulador de 3.3V y a cualquier componente conectado a esta tensión (Shield, módulos de bluetooth..etc). Si la tensión fuese de 9V o más el regulador sería destruido y la corriente llegaría también a los componentes alimentados normalmente por 5V.

  • Cortocircuitar Vin y GND. Si conectamos la alimentación a Vin y este está cortocircuitado con GND.
    Si esto ocurre, el diodo de protección de Arduino sería destruido, la tensión aumentaría de forma brusca y el calor disipado sería suficiente para dañar las pistas.

  • Utilizar Vin como salida de corriente. Al alimentar la placa mediante la patilla 5V y utilizar Vin para alimentar componentes.
    l regulador no tiene protección para evitar que la corriente circule a la inversa. Al realizar esta conexión estamos haciendo que la corriente circule hacia atrás, lo que destruirá el regulador.

  • Aplicar más de 13V en el reset. Si aplicamos más de 13 en la patilla de reset de Arduino dañaremos el microcontrolador.
    13V es el máximo que soporta la patilla de reset de microcontrolador de Arduino. Un voltaje superior daña el chip.

  • Superar la tensión total que pueden entregar la salidas. Si el consumo de los pines es superior a 20mA ( o la suma total de sus consumos supera los 200mA) se supera la carga máxima que es capaz de resistir el microcontrolador y este sufre daños.
    Se supera la tensión máxima que puede atravesar el microcontrolador y al no poder entregar más se daña.

Más información:

Clones de Arduino mejorados para ser más resistentes:

Videos de como destruir un Arduino:

Limitaciones de Alimentación del Microcontrolador

Hemos visto cómo alimentar arduino y es la alimentación de todos los componente que la placa, incluido el microcontrolador. A la hora de hacer un proyecto, debemos tener en cuenta cómo se alimentan los elementos externos a la placa como sensores o actuadores y las limitaciones de corriente de la propia placa de Arduino y del microcontrolador.

Cuando alimentamos varios sensores o servos al bus de 5V, debemos tener en cuenta la limitación del regulador de tensión NCP1117 de 1A para saber el máximo número de sensores en función de su consumo. En el caso de un relé si lo alimentamos directamente del pin de Arduino, hay que tener en cuenta la limitación del pin.

Para el microcontrolador ATmega328p los valores máximos absolutos son:

  • DC Current per I/O Pin → 40.0 mA
  • DC Current VCC and GND Pins → 200.0 mA

VCC current es la corriente que se puede dar (source) del pin Vcc del microcontrolador

GND current es la corriente que se puede obtener (sink) del pin GND del microcontrolador.

Aunque cada puerto I/O puede dar más corriente que en las condiciones normales (20 mA en VCC = 5 V, 10 mA en VCC = 3V) bajo condiciones de estado estable (no transitoria), hay que tener en cuenta lo siguiente.

  • La suma de toda la corriente en HIGH (source) para los puertos C0 – C5, D0 – D4, ADC7, RESET no debe exceder los 150 mA
  • La suma de toda la corriente en HIGH (source) para los puertos B0 – B5, D5 – D7, ADC6, XTAL1, XTAL2 no debe exceder los 150 mA.
  • Si la corriente en HIGH superar los valores nominales, el voltaje en HIGH puede superar los valores nominales. No se garantiza que los pines puedan dar (suorce) más corriente que la de los valores de test.
  • La suma de toda la corriente en LOW (sink) para los puertos C0 – C5, ADC7, ADC6 no debe exceder los 100 mA
  • La suma de toda la corriente en LOW (sink) para los puertos B0 – B5, D5 – D7, XTAL1, XTAL2 no debe exceder los 100 mA
  • La suma de toda la corriente en LOW (sink) para los puertos  D0 – D4, RESET no debe exceder los 100 mA
  • Si la corriente en LOW supera los valores de test, el voltaje de LOW puede exceder los valores nominales. No se garantiza que los pines puedan obtener (sink) más corriente que la de los valores de test.

Más información:

Limitaciones de potecia, corriente y voltaje: http://www.electricrcaircraftguy.com/2014/02/arduino-power-current-and-voltage.html

Alimentar Arduino con Baterías

La capacidad de las baterías se mide en mAh o Ah. Un miliamperio hora es el término que se utiliza para determinar la duración de una batería. Si una batería o pila tienen 1000 mAh, podrás alimentar algo que consuma 1000 mA durante una hora (o 100 mA durante 10 horas). En realidad esto solo se cumple en la teoría. En la práctica, cuanto más rápido se descargue la batería, más potencia se estará disipando en la resistencia interna que tiene. Eso quiere decir que si realmente durase 10 horas alimentando un dispositivo que consume 100 mA, probablemente no duraría una hora alimentando algo con un consumo de 1000 mA.

¿Cuanto consume Arduino? Un pequeño circuito con una placa de Arduino y un Display ya suponen un consumo por encima de los 200 mAh, mientras que una pila recargable de 9V tiene entorno a los 300 mAh apenas podremos alimentar Arduino durante poco más de una hora. Alimentar Arduino con una pila de 9V es una mala opción.

Actualmente las baterías más usadas para alimentar Arduino son las LiPo, son las que se utilizan en radiocontrol y similares. Pero también pueden usarse otras como las AA, batería de coche, o las USB para los teléfonos.

Además de la capacidad, estas baterías LiPo vienen con lo que llaman la tasa de descarga, es decir lo rápido que se puede descargar la batería. Esto se muestra con la letra C. De manera que si tienes 10C y 5000mAh puede dar 50000 mA en una hora. Claro que no va a llegar pero de pueden utilizar 50A durante el tiempo que te dure la batería, que vendría a ser la décima parte de 1 hora. 60 minutos entre 10 son 6 minutos. A mayor C más cara va a resultar la batería, tal vez solamente necesites 2A para algún momento puntual así que seguramente sea necesario tanta tasa de descarga.

El único problema a estas LiPo es la carga, hay que ser cuidadosos porque tienen sus propios cargadores, si te pasas de carga se queman. No debe de pasar nada pero si no se pone el voltaje correcto en el cargador puede que se queme.

Cargador de batería LiPo: https://www.adafruit.com/products/1904

Más información sobre baterías LiPo: http://www.educachip.com/cargar-baterias-lipo/

A la hora de alimentar un Arduino con batería además de conocer los diferentes tipos de baterías, debemos conocer las técnicas a nivel de programación y electrónica para que Arduino consuma menor y pueda tener una larga vida con batería.

Para conseguir más autonomía en un Arduino alimentado con batería:

  • Apagando el circuito. Seguramente no necesites que tu circuito esté todo el tiempo encendido. Si estás tomando datos de temperatura seguramente con tomar uno a la hora o a las dos horas te bastará. Si se trata de una alarma casera necesitarás encender el sistema una vez cada minuto o cada dos minutos para saber si hay alguien. Esto en Arduino se llama modo Sleep y lo que hace es hibernar y se queda en estado de baja energía hasta que lo enciendes. Este modo se verá más adelante.
  • Utilizando placas solares. Las hay para Arduino y las hay pequeñas que puedes añadir a tu proyecto. La electrónica consume poco así que esto puede ser una carga para tu batería y un extra para utilizar menos energía.
  • Elegir una placa que consuma poco. El Arduino UNO consume más que el Nano. Es normal, el UNO por ejemplo como acepta entre 7V y 12V, perdiendo energía en forma de calor. Y luego al ser más grande necesita más carga para alimentar a todos los elementos. Luego el Nano es tan poca cosa que consume muy poco, unos 15mA frente a los 46mA del UNO. Aún así, una placa que funcione a 3.3V aún consumirá menos. Hay varias así, de hecho ahora todas van en esa dirección ya que el consumo es algo que cada vez importa más.
  • Crear un código muy pulido. Ser fino programando tiene su recompensa ya que a más líneas más consumo tenemos. Esto pasa también con el tiempo. A más líneas más tiempo se pierde y eso puede suponer más consumo. En este enlace https://foro.hacklabalmeria.net/t/arduino-bajo-consumo/4230  e dedicaron a medir los mA utilizados en los sketches de Arduino y encontró una librería llamada JeeLib que lo que hace es reducir la corriente utilizada. Eso implica aumentar el número de horas de la batería.

Más información:

En realidad los Arduinos oficiales, son poco eficientes, pero disponemos de otros clones de Arduino fabricados para tener bajo consumo como los moteino: https://lowpowerlab.com/guide/moteino/ que además incluyen comunicación inalambrca y está basado en el ATMega328p.

También es posible modificar un Arduino Mini para alimentarlo con batería durante más de un año, combinado con la librería low power: http://www.home-automation-community.com/arduino-low-power-how-to-run-atmega328p-for-a-year-on-coin-cell-battery/

Más enlaces con proyectos de Arduinos bajo consumo:

Otra opción interesante para alimentar directamente el microcontrolador de Arduino sin la placa con una batería, de forma que sea mucho más eficiente, es alimentar directamente mediante el bus de 5V de la placa. La propuesta consiste en conectar el pack de 4 pilas a la placa Arduino usando un diodo en 1N4001 en serie. La caída de tensión en el diodo será de unos 0,7V por lo que la tensión que se verá en la línea interna de 5V de la placa Arduino será 5.3V. Dado que el micro ATmega328 que es el corazón de Arduino UNO puede ser alimentado hasta con tensiones de 5.5V, nos hallamos dentro del margen correcto de funcionamiento. Los dos condensadores son para filtrar un poco el ruido y el valor dependerá del uso que se dé a la placa.

La realización de la solución anterior tiene un problema potencial si conectamos la placa Arduino al PC a través de un puerto USB cuando aún está alimentada por el pack de pilas.

Si conectamos las pilas con diodo, que dá una tensión de 5.3V a la línea +5V de la placa. Dado que no hemos conectado nada en Vin, el transistor conducirá, por lo que al conectar la placa al puerto USB tendremos un conflicto entre los 5,3V de nuestras pilas y los 5V del puerto USB. En el mejor de los casos se dará una corriente en el sentido de las pilas hacia el PC que, cuando alcance 500mA, hará saltar el fusible que lleva la placa.

El uso de este tipo de alimentación requiere de desconectar el pack de pilas cuando se desee programar la placa Arduino usando el puerto USB.

Más información: http://aim65.blogspot.com.es/2012/03/legobot-alimentando-el-arduino.html

En este enlace lo explica muy bien la alimentación de Arduino para sistemas autónomos, resumiendo todo lo visto: http://www.homautomation.org/2014/04/03/best-ways-to-power-a-arduino-according-to-your-need/

Alimentación Arduino por energía solar:

Niveles de tensión 5V y 3.3V

Uno de los problemas principales que nos podemos encontrar cuando estás realizando un proyecto es que tus dispositivos no trabajan con el mismo voltaje. Un caso especialmente habitual como usuario de plataformas del tipo Arduino es que te encuentras con un dispositivo que trabaja a 3.3V teniendo una placa que trabaja a 5V, en cuyo caso te toca pasar de 5V a 3.3V.

Aunque en algunas ocasiones puedes conectar ambas cosas sin que nada se rompa no suele ser buena idea conectar los dispositivos directamente. Lo mejor que puedes hacer es utilizar algún tipo de interfaz o elemento que te permita realizar la conexión de forma segura.

5 formas de pasar de 5V a 3.3V para elegir la que mejor se adapte a tu proyecto. Son las siguientes:

  • Utilizando un divisor de tensión.
  • Añadiendo diodos 1N4148 (o similar) en serie.
  • Mediante un buffer CD4050 (o similar) alimentado a 3.3V.
  • Usando un regulador de voltaje variable LM317 (o similar).
  • Con un regulador de tensión LM7833 de 3.3V (o similar).

Más información: http://www.educachip.com/pasar-de-5v-a-3-3v/

También nos podemos encontrar con el caso contrario, cada vez es más habitual que los Arduinos tengan entradas y salidas a 3,3V en lugar de a 5V, pero mucho elementos que conectado a Arduino funcionan con lógica de 5V.

Más información: https://findeprehistoria.wordpress.com/2010/07/29/interfaz-de-3-3v-a-5v-y-visceversa/

Y también tenemos los conversores de niveles lógicos como http://tienda.bricogeek.com/herramientas-de-prototipado/82-conversor-de-niveles-logicos-33-5v.html

Ampliación Memoria Arduino

Cuando se desarrolla un proyecto con Arduino, es posible que a medida que crezca en tamaño y complejidad nos quedemos sin memoria, ya sea sin SRAM que es lo más sencillo, al ser un recurso escaso, y también lo más fácil de solucionar o sin EEPROM o sin memoria flash.

Si al compilar un sketch ocupa mucho espacio y no cabe en la memoria flash, lo primero que se debe hacer es optimizar el código siguiendo estas recomendaciones. https://learn.adafruit.com/memories-of-an-arduino/optimizing-program-memory. Hay que tener en cuenta que no es posible ampliar la memoria flash de Arduino con memoria externa. Una alternativa es que si el sketch tiene muchos strings de solo lectura, imágenes, ficheros, arrays de gran tamaño, etc…, una solución es mover toda esa gran cantidad de datos a una tarjeta SD externa y leer los valores sólo cuando se necesitan.

En caso de necesitar más EEPROM  de la que dispone el microcontrolador, es sencillo usar EEPROM externas conectadas por I2C o SPI, aunque también es posible almacenar los datos no volátiles en una tarjeta SD externa en lugar de la EEPROM.

Un buen ejemplo de uso de una EEPROM externa I2C, puede ser la EEPROM de microchip 24LC256 con una capacidad de 32K x 8 (256 Kbit). Datasheet: http://ww1.microchip.com/downloads/en/DeviceDoc/21203M.pdf. Tutoriales:

Otra alternativa para la expansión de memoria es dataflash https://en.wikipedia.org/wiki/DataFlash que es un protocolo serie desarrollado por Atmel para el acceso a memorias Flash http://www.mouser.es/Search/Refine.aspx?Keyword=dataflash.

Más información:

O también es posible usar SPI flash memory como 4MBIT W25X40CLSNIG que usa Moteino para almacenamiento de datos y la programación inalámbrica. La librería desarrollada es https://github.com/LowPowerLab/SPIFlash.

En caso de quedarnos sin memoria SRAM, lo primero es seguir estos consejos para optimizar su uso y mover a la memoria flash (si queda espacio) todas los strings y datos que no se modifican en tiempo de ejecución (read-only):  https://learn.adafruit.com/memories-of-an-arduino/optimizing-sram.

Si con esto no es suficiente, entonces podemos ampliar la memoria SRAM. Obtener más SRAM es en realidad bastante sencillo. Hay módulos de SPI RAM (memoria volatil) como el microchip 23K256, data sheet: http://ww1.microchip.com/downloads/en/DeviceDoc/22100D.pdf. Dispone de 32k de SRAM con un interfaz SPI. Se accede a ellos a través de SPI y hay la biblioteca SpiRAM para ayudar a su uso. Debe tenerse en cuenta que opera a 3,3V y no 5V y que no es posible usarla con Arduino Mega.

Dado que no es posible ampliar la memoria flash de Arduino, ampliando la memoria SRAM, podríamos reestructurar el sketch y reducir el tamaño del código a expensas de aumentar el tamaño de los datos, haciéndolo un poco más lento.

Más información:

Uso de tarjetas SD en Arduino

Una forma ampliar la capacidad de almacenamiento de un Arduino es añadir una memoria externa y la forma más sencilla y barata es mediante un lector de tarjetas SD. Esto nos permite añadir un almacenamiento local no volátil para por ejemplo guardar un log de temperaturas o los datos de configuración de nuestro programa.

Como hemos visto anteriormente, tanto si nos quedamos sin memoria SRAM, flash o EEPROM podríamos recurrir al uso de una tarjeta SD para tratar de solucionar el problema directa o indirectamente.

En teoría, se podría ir tan lejos como traducir todo el sketch en algún lenguaje interpretado, almacenar esa versión del sketch en una tarjeta SD, y luego escribir un intérprete para que el lenguaje que se ejecute en Arduino y recoja, interprete y ejecute esas instrucciones de la tarjeta SD. Por ejemplo http://playground.arduino.cc//CommonTopics/ForthOnArduino que puede ser usado como una shell para ejecutar comando interactivos.

Veamos el uso de tarjetas SD con Arduino. Para ello lo primero que necesitamos es un HW externo que nos proporcione un lector de tarjetas y luego una librería adecuada para usar ese HW adicional.

Con la Ethernet shield disponemos de un lector de tarjetas micro SD y es accesible gracias a la librería SD: https://www.arduino.cc/en/Reference/SD

Otros shield interesante es el Adafruit datalogger shield que dispone de un lector de tarjetas SD, un RTC (Real Time Clock), una zona de prototipado para soldar componentes adicionales y dos LEDs indicadores configurables.

Más información: https://learn.adafruit.com/adafruit-data-logger-shield/overview

Otro HW para tarjetas SD:

La librería para manejar los lectores de tarjetas SD es la librería SD, el reference está disponible en http://arduino.cc/en/Reference/SD.Casi todos los módulos usan esta librería porque el acceso a la tarjeta SD es mediante el bus SPI directamente a la tarjeta o mediante un voltage level shifter.

La librería SD está basada en la librería SDfat: https://github.com/greiman/SdFat. Es compatible con sistemas de archivos FAT16 y FAT32 entarjetas SD estándar y tarjetas SDHC. Utiliza cortos 8.3 nombres de los ficheros. Los nombres de los archivos pasados a las funciones de la librería SD pueden incluir la ruta usando el caracter “/”, por ejemplo «directory/filename.txt». El directorio de trabajo siempre es el root de la tarjeta SD.

Cuestiones a tener en cuenta cuando se usa la librería SD: https://www.arduino.cc/en/Reference/SDCardNotes

Tutoriales disponibles

  • Card Info: Obtiene información de la tarjeta SD.
  • Datalogger: Log data de tres entradas analógicas a la tarjeta SD.
  • Dump File: Lee un fichero de la SD card.
  • Files: Crea y borra un fichero de la SD card.
  • List Files: Imprime el listado de fichero en un directorio de la SD card.
  • Read Write: Lee y escribe datos de una SD card.

La librería SD tiene dos clases: SD que ofrece funciones para acceder a la tarjeta SD y manipular sus directorios y ficheros y la clase File que tiene los métodos para leer y escribir de ficheros individuales de la tarjeta SD.

Ver todos los métodos en https://www.arduino.cc/en/Reference/SD

Pineado de tarjetas SD:

Pin – Name – Description
1 – NC – not connected
2 – CS – Chip Select/Slave Select (SS)
3 – DI – Master Out/Slave In (MOSI)
4 – VDD – Supply voltage
5 – CLK – Clock (SCK)
6 – VSS – Supply voltage ground
7 – DO – Master In/Slave Out (MISO)
8 – RSV – Reserved

A la hora de conectar con Arduino, solo debemos definir en Arduino el pin CS (Chip Select). Antes de empezar a leer y escribir datos en la tarjeta SD de Arduino hay que utilizar la instrucción SD.begin(), determinando en el paréntesis el pin CS de tu shield de SD o del pin de la tarjeta SD. Esto quiere decir que si se utiliza una placa de Arduino UNO (o similar) se utiliza la instrucción SD.begin(10) pero si (por ejemplo) se utiliza el shield de Ethernet debe ponerse SD.begin(4).

Antes de utilizar la tarjeta SD de Arduino debes abrir el archivo sobre el que vayas a trabajar (verás cómo más adelante). Si por cualquier motivo pierdes la comunicación con dicho archivo antes de cerrarlo, podrías perder tus datos. Los datos solo se guardan cuando cierras el archivo o usas la función flush().

Más información:

Ejercicios con SD

Ejercicio30-SD: Grabar y leer en una tarjeta SD

Basarse en los tutoriales.

Solución:  https://github.com/jecrespo/Aprendiendo-Arduino/tree/master/Ejercicio30-SD

Ejercicio50-DAQ_SD:  Leer y guardar en una tarjeta SD cada 30 segundos la temperatura y humedad de una sonda DHT22. Los datos son guardados en un fichero llamado datalog.csv. Los datos también son mostrados por en una pantalla LCD modelo https://www.sparkfun.com/products/9395

Para leer los datos de la SD y sacarlos por el puerto serie, usar el sketck: https://www.arduino.cc/en/Tutorial/DumpFile

Modificar el sketch para que funcione con la sonda y el display LCD del curso:

Solución: https://github.com/jecrespo/Aprendiendo-Arduino/tree/master/Ejercicio50-DAQ_SD

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. Además la velocidad de lectura y escritura en inferior que en la SRAM y Flash.

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 tarda unos 3,3 ms en completar una escritura y para Arduino se ha especificado una vida de 100000 ciclos de escritura/borrado.

Para grabar estructuras de datos en la EEPROM de una forma muy sencilla. 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:

El acceso entre la EEPROM y la CPU se hace mediante los registros:

  • EEPROM Address Registers: EEARH y EEARL
  • EEPROM Data Register: EEDR
  • EEPROM Control Register: EECR

Más información en la página 36 del http://www.atmel.com/Images/Atmel-42735-8-bit-AVR-Microcontroller-ATmega328-328P_datasheet.pdf

Cosas a tener en cuenta con la EEPROM: https://engineerzero.wordpress.com/2013/07/11/five-things-to-remember-pun-about-arduino-eeprom/

  • Los datos deben guardarse en formato byte para ser usados
  • EEPROM puede los datos de configuración de usuario
  • Dañar la EEPROM no es un problema grave
  • Dañar la EEPROM puede ser un problema si no se tiene cuidado
  • Dañar la EEPROM no es el fin del mundo

Comprobación de EEPROM no corrompida: https://www.arduino.cc/en/Tutorial/EEPROMCrc

Calculo CRC http://www.lammertbies.nl/comm/info/crc-calculation.html

Ejercicios EEPROM

Volcado EEPROM

Si estamos depurando un proyecto de Arduino usando EEPROM, es posible que queramos ver la EEPROM para entender lo que está pasando.

Si tenemos un programador ISP como el USBtinyISP de Adafruit, siempre se puede utilizar avrdude para volcar la EEPROM a un archivo. Por ejemplo, el siguiente código crea un archivo denominado e2data.ee con contenido de EEPROM.

$ avrdude -p m328p -c usbtiny -P usb -U eeprom:r:e2data.ee:r

Otra opción es usar un sketch que nos saque por el puerto serie el contenido de la EEPROM como los que hay en https://github.com/jecrespo/Aprendiendo-Arduino/tree/master/Ejercicio35-EEPROM

Ejercicio EEPROM

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/

Poner un LED con su resistencia en los pines 10 y 12 correspondientes a la configuración (setting) e[4] y e[5]. Estos leds se encenderán al inicar el sketch porque son los que están configurados en el programa y los graba la primera vez en la EEPROM. Son los valores de setting de a y b.

Cuando pongo a masa el pin 4 (e[0]), cambio a LOW los setting y guardo la configuración de la EEPROM, de forma que cuando reinicie los leds aparecen apagados al estar esa configuración guardada y la CONFIG_VERSION conicide con la del sketch «ls1». Al iniciar aunque el programa tiene que están encendidos, los apaga porque lee de la EEPROM el valor guardado al inicio.

Solución: https://github.com/jecrespo/Aprendiendo-Arduino/tree/master/Ejercicio35-EEPROM

EEPROM Externa

Ejemplo: Cómo 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.

Memoria Arduino

Arduino y todos los microcontroladores tienen varios tipos de memoria integradas, en el caso de Arduino y los microcontroladores AVR de Atmel usan tres tipos de memorias:

  • SRAM (static random access memory): Variables locales, datos parciales. Usualmente se trata como banco de registros y memoria volátil. Es la zona de memoria donde el sketch crea y manipula las variables cuando se ejecuta. Es un recurso limitado y debemos supervisar su uso para evitar agotarlo.
  • EEPROM:  Memoria no volátil para mantener datos después de un reset. Se puede grabar desde el programa del microcontrolador, usualmente, constantes de programa. Las EEPROMs tienen un número limitado de lecturas/escrituras, tener en cuenta a la hora de usarla. Esta memoria solo puede leerse byte a byte y su uso puede se un poco incómodo. También es algo más lenta que la SRAM. La vida útil de la EEPROM es de unos 100.000 ciclos de escritura
  • Flash: Memoria de programa. Usualmente desde 1 Kb a 4 Mb (controladores de familias grandes). Es donde se guarda el sketch ya compilado. Sería el equivalente al disco duro de un ordenador. En la memoria flash también se almacena del bootloader. Se puede ejecutar un programa desde la memoria flash, pero no es posible modificar los datos, sino que es necesario copiar los datos en la SRAM para modificarlos.
    La memoria flash usa la misma tecnología que las tarjetas SD, los pen drives o algunos tipos de SSD, esta memoria tiene una vida útil de unos 100.000 ciclos de escritura, así que cargando 10 programas al día durante 27 años podríamos dañar la memoria flash.

La memoria flash y la EEPROM son no volátiles, es decir, la información persiste tras el apagado del Arduino.

Memoria de Arduino UNO:

  • Flash  32k bytes (of which 0.5k is used for the bootloader)
  • SRAM   2k bytes
  • EEPROM 1k byte

Memoria de Arduino MEGA:

  • Flash  256k bytes (of which 8k is used for the bootloader)
  • SRAM   8k bytes
  • EEPROM 4k byte

Memoria de Arduino MKR1000:

  • Flash  256k bytes
  • SRAM   32k bytes
  • EEPROM no. Dispone de EEPROM emulation en la memoria flash (ver documentación del microcontrolador)

Memoria ESP8266:

  • 64 KiB of instruction RAM, 96 KiB of data RAM
  • External QSPI flash – 512 KiB to 4 MiB (no dispone de memoria Externa)

La memoria SRAM es un recurso escaso que debe gestionarse, especialmente si se usan los strings o cadenas de caracteres de forma intensiva. Si un Arduino se queda sin memoria SRAM, el sketch compilará bien y se cargará en el Arduino sin problema, pero se producirán efectos inesperados.

En caso de usar muchos strings, una técnica para evitar agotar la memoria SRAM es guardar en la memoria flash los strings que no se modifiquen en tiempo de ejecución, usando PROGMEM: https://www.arduino.cc/en/Reference/PROGMEM

Desde la versión 1.0 del IDE de Arduino, se introdujo la macro F(). Esta sintaxis se usa para almacenar strings en la memoria flash en lugar de en la memoria SRAM. No es necesario cargar ninguna librería para usar la macro F().

  • Serial.println(«This string will be stored in flash memory»); //este print ocupará 42 bytes de memoria SRAM con el contenido de la constante string
  • Serial.println(F(«This string will be stored in flash memory»)); //el string dentro de del println no se carga en la SRAM y se lee de la flash

En el caso que el sketch ocupe más memoria flash, el IDE te avisa de que no puede cargarlo en Arduino.

Desde las últimas versiones del IDE de Arduino tras compilar el sketch, aparece un resumen de la memoria flash que ocupa el programa y la memoria ocupada por las variables globales en la SRAM y el espacio que queda para las variables locales. Como recomendación, si se supera el 70%-75% de la  SRAM con las variables globales es muy probable que Arduino se quede sin memoria RAM.

Recordar que al incluir una librería, estoy añadiendo variables y tamaño al programa, lo que aumentará el uso de memoria SRAM y flash. Algunas librerías hacen un uso grande de la memoria SRAM y flash.

Memoria en Arduino:

Un buen tutorial para aprender como funcionan las memorias de Arduino: https://learn.adafruit.com/memories-of-an-arduino/you-know-you-have-a-memory-problem-when-dot-dot-dot

Toda la información de las memoria del ATMega328p está en la página 34 del datasheet http://www.atmel.com/Images/Atmel-42735-8-bit-AVR-Microcontroller-ATmega328-328P_datasheet.pdf

Más información de las memoria de Arduino

MCU vs CPU en funcion de la arquitectura de la memoria: https://learn.adafruit.com/memories-of-an-arduino/arduino-memory-architecture

Como medir la memoria libre que tenemos en Arduino: https://learn.adafruit.com/memories-of-an-arduino/measuring-free-memory

Como saber cuando me he quedado sin memoria: https://learn.adafruit.com/memories-of-an-arduino

Consumidores de Memoria en Arduino: https://learn.adafruit.com/memories-of-an-arduino/large-memory-consumers

Como optimizar la memoria flash: https://learn.adafruit.com/memories-of-an-arduino/optimizing-program-memory

Cómo optimizar la memoria SRAM: https://learn.adafruit.com/memories-of-an-arduino/optimizing-sram

Memoria SRAM

Al ser el recurso más escaso en Arduino hay que entender bien cómo funciona. La memoria SRAM puede ser leída y escrita desde el programa en ejecución.

La memoria SRAM es usada para varios propósitos:

  • Static Data: Este bloque de memoria reservado en la SRAM para todas las variables globales y estáticas. Para variables con valores iniciales, el sistema copia el valor inicial desde la flash al iniciar el programa.
  • Heap: Es usado para las variables o elementos que asignan memoria dinámicamente. Crece desde el final de la zona de Static Data a medida que la memoria es asignada. Usada por elementos como los objetos y los Strings.
  • Stack: Es usado por las variables locales y para mantener un registro de las interrupciones y las llamadas a funciones. La pila crece desde la zona más alta de memoria hacia el Heap. Cada interrupción, llamada de una función o llamada de una variable local produce el crecimiento de la memoria.
    La mayor parte de los problemas ocurren cuando la pila y el Heap colisionan. Cuando esto ocurre una o ambas zonas de memoria se corrompen con resultados impredecibles. En uno casos se produce un “cuelgue” del programa y en otros casos la corrupción de memoria puede notarse un tiempo después.

A partir de la versión 1.6 del IDE al compilar un sketch nos da el tamaño que va a ocupar en la flash el proyecto y el espacio que va a ocupar en la SRAM las variables globales, es decir, la zona de static data.

Como ya se ha visto anteriormente, en la memoria SRAM también se encuentran los registros que ocupan las primeras 256 direcciones de memoria. Por lo tanto la SRAM empieza a partir de la dirección 0x0100.

Los registros al estar en la SRAM son volátiles y no conservan su valor después de un reset. Mirando la documentación del microcontrolador se puede ver cuales son los valores por defectos de los registros.

ram-map

Si vemos a fondo la memoria SRAM de Arduino.

  • .data variables is the first RAM section and it is used to store program static data, such as strings, initialized structures and global variables.
  • .bss variables is the memory allocated for uninitialized global and static variables.
  • heap is the dynamic memory area, and this is the playground area for malloc (and alike). The heap can grow (when new allocation is made) or «possibly» decrease in size (when memory is released, as for example when using free) based on the requirements.
  • stack is the memory area located at the end of the RAM and it grows towards the heap area. The stack area is used for function calls, storing values for local variables. Memory occupied by local variables is reclaimed when the function call finished.
  • external RAM is only available to some of the MCUs and it means that it is possible to add RAM in a kind of similar way that we do for a PC. Usually this is expensive (a few KB of external RAM costs in general more than the MCU) and requires also advanced hardware and software skills.
  • free available memory is the area between heap and stack and this is what we need to measure in order to detect problems caused by not enough RAM resources.When this area is either too small for the required tasks, or is missing at all (heap meets stack), our MCU starts to missbehave or to restart itself.

El siguiente código permite calcular la memoria libre en bytes para un Arduino y funciona tanto con el IDE de Arduino como con Atmel Studio:

extern unsigned int __bss_end;
extern unsigned int __heap_start;
extern void *__brkval;

uint16_t getFreeSram() {
  uint8_t newVariable;
  // heap is empty, use bss as start memory address
  if ((uint16_t)__brkval == 0)
    return (((uint16_t)&newVariable) - ((uint16_t)&__bss_end));
  // use heap end as the start of the memory address
  else
    return (((uint16_t)&newVariable) - ((uint16_t)__brkval));
};

PROGMEM

PROGMEM se usa para guardar en la memoria flash en lugar de en la SRAM. La palabra PROGMEM en un modificador de variable que debe usarse solo con los tipos de datos definidos en pgmspace.h. Al usarlo le dice al compilador que ponga la información de la variable en la memoria flash en lugar de la SRAM, donde iría normalmente.ç

PROGMEM es parte de la librería pgmspace.h http://www.nongnu.org/avr-libc/user-manual/group__avr__pgmspace.html que solo está disponible para la arquitectura AVR, así que para usarlo hay que inclirla al principio del sketch con #include <avr/pgmspace.h>

Más información:

  • sizeof() – devuelve el número de bytes en una variable o el número de bytes ocupados por un array.
  • PROGMEM

En muchos casos, una gran cantidad de RAM es ocupada por la memoria estática, como resultado del uso de variables globales (tales como cadenas o números). Siempre que estos datos no se vayan a cambiar, puede ser fácilmente almacenado en la llamada PROGMEM (memoria de programa o flash) Esto representa trozo de la memoria flash, y es bueno saber que, en general, la memoria flash es mucho más grande que la memoria RAM (por ejemplo, Atmega2560 tiene 8 KB de RAM y flash de 256 KB). La desventaja de usar PROGMEM es la velocidad de lectura, que es más lento en comparación con la lectura de los mismos datos de la RAM.

Más información sobre memoria en Arduino:

Práctica: Uso de Memoria en Arduino

Para entender el uso de la memoria, hagamos una práctica añadiendo y quitando elementos del sketch y viendo la ocupación de memoria.

Funciones para calcular memoria libre en Arduino:

int freeRam () {
  extern int __heap_start, *__brkval; 
  int v; 
  return (int) &v - (__brkval == 0 ? (int) &__heap_start : (int) __brkval); 
}

Enunciado: Calcula memoria RAM de tu Arduino UNO sin ejecutar ningún programa con la función freeRam() y comparalo con el dato que da al compilar otro programa, también averigua cuánto ocupa la memoria Flash de los programas. Luego calcula la memoria RAM y la Flash utilizada con un programa que cada loop saque por puerto serie cada 5 segundos el siguiente texto:

“Arduino es una plataforma de hardware libre, basada en una placa con un microcontrolador y un entorno de desarrollo, diseñada para facilitar el uso de la electrónica en proyectos multidisciplinares. El hardware consiste en una placa con un microcontrolador Atmel AVR y puertos de entrada/salida. Los microcontroladores más usados son el Atmega168, Atmega328, Atmega1280, ATmega8 por su sencillez y bajo coste que permiten el desarrollo de múltiples diseños. Por otro lado el software consiste en un entorno de desarrollo que implementa el lenguaje de programación Processing/Wiring y el cargador de arranque que es ejecutado en la placa.Desde octubre de 2012, Arduino se usa también con microcontroladoras CortexM3 de ARM de 32 bits,5 que coexistirán con las más limitadas, pero también económicas AVR de 8 bits. ARM y AVR no son plataformas compatibles a nivel binario , pero se pueden programar con el mismo IDE de Arduino y hacerse programas que compilen sin cambios en las dos plataformas. Eso sí, las microcontroladoras CortexM3 usan 3,3V, a diferencia de la mayoría de las placas con AVR que generalmente usan 5V. Sin embargo ya anteriormente se lanzaron placas Arduino con Atmel AVR a 3,3V como la Arduino Fio y existen compatibles de Arduino Nano y Pro como Meduino en que se puede conmutar el voltaje.”

Luego haz que aumente la RAM con el modificador F y compruebalo.

Resultado:

Ejemplo de cálculo de la velocidad de la memoria: https://github.com/jecrespo/Aprendiendo-Arduino/tree/master/Otros/velocidadMemoria

Ejemplo de como llenar la memoria de Arduino: https://github.com/jecrespo/Aprendiendo-Arduino/tree/master/Otros/llenarMemoria

  • Opción todo a 0: solo ocupa la memoria de las variables globales definidas pero no inicializadas. 822 bytes libres.
  • Opción todo a 0 y eliminar el array de 100 Strings global: Dispongo de toda la memoria.
  • Opción LOCAL = 1: defino una nueva variable local en el loop pero al inicializarla en cada loop no aumenta la memoria.
  • Opción STRINGS = 1: tengo un array de 100 objetos Strings y a medida que los voy inicializando con 10 bytes lleno el heap y acabo llenando la memoria
  • Opción GLOBAL = 1: en el momento que inicalizo el array de 1000 long asignando un valor me ocupa 4000 bytes en la RAM y ya de un error de compilación.