Archivo de la categoría: Hardware

Hardware Arduino

Los Arduino y en general los microcontroladores tienen puertos de entrada y salida y puertos de comunicación. En Arduino podemos acceder a esos puertos a través de los pines.

Otro aspecto importante es la memoria, Arduino tiene tres tipos de memoria:

  • SRAM: donde Arduino 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 o apagado. Las EEPROMs tienen un número limitado de lecturas/escrituras, tener en cuenta a la hora de usarla.
  • Flash: Memoria de programa. Usualmente desde 1 Kb a 4 Mb (controladores de familias grandes). Donde se guarda el sketch.

Veamos a fondo la placa Arduino Uno:

Especificaciones detalladas de Arduino UNO: http://arduino.cc/en/Main/ArduinoBoardUno

Microcontroller & USB-to-serial converter ATmega328P & Atmega16U2
Operating Voltage 5V
Input Voltage (recommended) 7-12V
Input Voltage (limits) 6-20V
Digital I/O Pins 14 (of which 6 provide PWM output)
Analog Input Pins 6
DC Current per I/O Pin 40 mA
DC Current for 3.3V Pin 50 mA
Flash Memory 32 KB (ATmega328) of which 0.5 KB used by bootloader
SRAM 2 KB (ATmega328)
EEPROM 1 KB (ATmega328)
Clock Speed 16 MHz

Aspectos más destacados de Arduino UNO.

  • No necesita de un cable FTDI para conectarse al MCU, en su lugar usa una MCU especialmente programado para trabajar como conversor de USB a serie.
  • Alimentación: vía USB, batería o adaptador AC/DC a 5V, seleccionado automáticamente. Arduino puede trabajar entre 6 y 20V, pero es recomendado trabajar entre 7 y 12V por las características del regulador de tensión.
  • Puerto Serie en los pines 0 y 1.
  • Interrupciones externas en los pines 2 y 3.
  • Built-in LED en el pin 13.
  • Bus TWI o I2C en los pines A4 y A5 etiquetados como SDA y SCL
  • El MCU ATmega328P tiene un bootloader precargado que permite cargar en la memoria flash el nuevo programa o sketch sin necesidad de un HW externo.
  • Arduino Uno dispone de un fusible autoreseteable que protege el puerto USB de nuestro ordenador de cortocircuitos y sobrecorrientes. Si se detectan más de 500mA salta la protección.

Placas Arduino

Arduino dispone de una amplia variedad de placas y shields para usar dependiendo de nuestras necesidades.

Arduino Uno

Web: http://arduino.cc/en/Main/ArduinoBoardUno

Es la placa estándar y posiblemente la más conocida y documentada. Salió a la luz en septiembre de 2010 sustituyendo su predecesor Duemilanove con varias mejoras de hardware que consisten básicamente en el uso de un USB HID propio en lugar de utilizar un conversor FTDI para la conexión USB. Es 100% compatible con los modelos Duemilanove y Diecimila. Viene con un Atmega328 con 32Kbytes de ROM para el programa.

Este es el Arduino que vamos a usar en el curso.

Esquematico: http://arduino.cc/en/uploads/Main/Arduino_Uno_Rev3-schematic.pdf

Microcontrolador: http://www.atmel.com/devices/atmega328p.aspx

Planos del Arduino UNO: https://www.arduino.cc/en/Main/ArduinoBoardUno#documentation

Arduino Mega

Web: http://arduino.cc/en/Main/ArduinoBoardMega2560

Es con mucha diferencia el más potente y el que más pines i/o tiene, apto para trabajos ya algo más complejos aunque tengamos que sacrificar un poco el espacio, cuenta con el microcontrolador Atmega2560 con más memoria para el programa, más RAM y más pines que el resto de los modelos.

Esquematico: http://www.arduino.cc/en/uploads/Main/arduino-mega2560_R3-sch.pdf

Microcontrolador: http://www.atmel.com/devices/atmega2560.aspx

Planos del Arduino MEGA: http://www.arduino.cc/en/Main/ArduinoBoardMega2560

Arduino Leonardo

Web: http://arduino.cc/en/Main/ArduinoBoardLeonardo

La diferencia de este arduino con el resto es que trae un único MCU ATmega32u4 que tiene integrado la comunicación USB, lo que elimina la necesidad de un segundo procesador. Esto tiene otras implicaciones en el compartimento del arduino al conectarlo al ordenador, lo que no lo hace apto para iniciarse con él.

Microcontrolador: http://www.atmel.com/devices/atmega32u4.aspx

Arduino Micro

Web: http://arduino.cc/en/Main/ArduinoBoardMicro

También basado en el ATmega32u4 pero mucho más compacto.

Ejemplo de placa para uso de Arduino pequeños: https://spiercetech.com/shop/home/17-arduino-nano-30-controller-terminal-breakout-board.html

Arduino 101

Web: https://www.arduino.cc/en/Main/ArduinoBoard101 es el sucesor del Arduino UNO con procesador Intel Curie Quark de 32 bit diseñado para ofrecer el mínimo consumo de energía, 384 KB de memoria flash, 80 KB de SRAM, un sensor DSP integrado, bluetooth de baja energía, acelerómetro y giroscopio de 6 ejes.

Genuino MKR1000

Web: https://www.arduino.cc/en/Main/ArduinoMKR1000 version para IoT con procesador Atmel ARM Cortex M0+ de 32bits ATSAMW25 que es el mismo procesador que Genuino Zero pero con wifi integrado, chip de cifrado y antena integrada.

Un listado con todos los Arduinos puede verse en: https://aprendiendoarduino.wordpress.com/2016/09/25/novedades-arduino/

Shields Arduino

Las shields son placas de circuitos modulares que se montan unas encima de otras para dar funcionalidad extra a un Arduino. Esta Shields son apilables.

Las shields se pueden comunicar con el arduino bien por algunos de los pines digitales o analógicos o bien por algún bus como el SPI, I2C o puerto serie, así como usar algunos pines como interrupción. Además estas shields se alimenta generalmente a través del Arduino mediante los pines de 5V y GND.

En muchos casos nos encontraremos que los shields vienen sin soldar las patillas o en algunos casos sin algunos componentes soldados.

Cada Shield de Arduino debe tener el mismo factor de forma que el estándar de Arduino con un espaciado de pines concreto para que solo haya una forma posible de encajarlo.

Debemos tener en cuenta que cuando instalemos un shield, habrá que leer su documentación que nos dirá si inhabilita algunas de los pines I/O o si usa un bus y que requisitos tiene para su utilización. Generalmente las shields vienen con un ejemplo o una librería para su uso.

Ethernet Shield

Web: http://arduino.cc/en/Main/ArduinoEthernetShield

La placa Arduino se comunica con el módulo W5100 y la micro-SD utilizando el bus SPI (mediante el conector ICSP). Esto se encuentra en los pines digitales 11, 12 y 13 en el modelo UNO y en los pines 50, 51 y 52 del modelo MEGA. En ambas placas, el pin 10 es utilizado para seleccionar el W5100 y el pin 4 para la micro-SD. Estos pines no pueden ser utilizados para otros fines mientras la Ethernet Shield esté conectada. El en MEGA, el pin SS (53) no es utilizado pero debe dejarse como salida para que el bus SPI funcione correctamente.

Para su funcionamiento usa la librería Ethernet: https://www.arduino.cc/en/Reference/Ethernet

Arduino WiFi Shield 101

Web: https://www.arduino.cc/en/Main/ArduinoWiFiShield101

Este nuevo shield es una mejora de la anterior wifi shield desarrollada junto con Atmel que usa el módulo WINC1500 y también añade funciones de cifrado hardware gracias al chip de cifrado ATECC508A diseñado para el mercado de IoT. Los pines 5 y 7 son usados por este shield.

Usa una nueva librería llamada WiFi101 https://www.arduino.cc/en/Reference/WiFi101 que también usan otros Arduinos con wifi integrado como el MKR1000. Esta librería es muy compleja y ocupa más del 60% de la memoria disponible en el Arduino UNO, dejando poco espacio para los sketches. Si se van a realizar programas complejos, este shield es recomendable usarlo con Arduino Zero, 101 o Mega.

Arduino Motor Shield

Web: http://arduino.cc/en/Main/ArduinoMotorShieldR3. Permite manejar dos motores DC, controlando su dirección y velocidad. Está basado en un chip de doble puente H L298:

Este shield usa dos canales y cada canal usa 4 pines, en total nos ocupa 8 pines del Arduino

Un módulo con el mismo puente H pero sin formato shield: http://tienda.bricogeek.com/motores/285-controlador-de-motores-doble-puente-h-l298.html

Nuevas Shields Oficiales

Arduino.org ha lanzado otras shields y nuevas versiones de las ethernet y GSM. Todas las shields de arduino.org en http://www.arduino.org/products/shields

Grove Shield

Web: http://www.seeedstudio.com/depot/Grove-Base-Shield-p-754.html. Un Shield para el sistema grove que facilita la conexión de sensores y actuadores.

Relay Shield

Web: http://www.seeedstudio.com/depot/relay-shield-v20-p-1376.html?cPath=132_134. Este shield proporciona 4 relés para manejar dispositivos que no pueden controlarse directamente con las I/O de Arduino. Dispone de unos indicadores de uso de los relés.

En este caso se usan 4 pines digitales para usar cada uno de los relés.

Existen muchísimos shields que seguro que se adaptan a nuestro proyecto. En cada web de los fabricantes tenemos variedad donde elegir.

Un listado completo donde encontrar cualquier tipo de shield: http://shieldlist.org/

Breakout Boards

Además de los Shield, también tenemos disponibles módulos independientes (breakout boards) para conectar directamente a Arduino:

Qué es Arduino

Arduino es una plataforma de hardware libre, basada en una placa con un microcontrolador y un entorno de desarrollo (software), diseñada para facilitar el uso de la electrónica en proyectos multidisciplinares.

Hardware Libre: http://es.wikipedia.org/wiki/Hardware_libre

Arduino es una plataforma abierta que facilita la programación de un microcontrolador. Los microcontroladores nos rodean en nuestra vida diaria, usan los sensores para escuchar el mundo físico y los actuadores para interactuar con el mundo físico. Los microcontroladores leen de los sensores y escriben sobre los actuadores.

El hardware de Arduino consiste en una placa con un microcontrolador generalmente Atmel AVR con puertos de comunicación y puertos de entrada/salida. Los microcontroladores más usados en las plataformas Arduino son el Atmega168, Atmega328, Atmega1280, ATmega8 por su sencillez, pero se está ampliando a microcontroladores Atmel con arquitectura ARM de 32 bits y también a microcontroladores de Intel.

Por otro lado Arduino nos proporciona un  software consistente en un entorno de desarrollo (IDE) que implementa el lenguaje de programación de arduino, las herramientas para transferir el firmware al microcontrolador y el bootloader ejecutado en la placa. La principal característica del software y del lenguaje de programación es su sencillez y facilidad de uso.

Arduino promete ser una forma sencilla de realizar proyectos interactivos para cualquier persona. Para alguien que quiere hacer un proyecto, el proceso pasa por descargarnos e instalar el IDE buscar un poco por internet y simplemente hacer “corta y pega” del código que nos interese y cargarlo en nuestro HW. Luego hacer los cableados correspondientes con los periféricos y ya tenemos interaccionando el software con el Hardware. Todo ello con una inversión económica mínima: el coste del Arduino y los periféricos.

¿Para qué sirve Arduino? Arduino se puede utilizar para crear elementos autónomos, conectándose a dispositivos e interactuar tanto con el hardware como con el software. Nos sirve tanto para controlar un elemento, pongamos por ejemplo un motor que nos suba o baje una persiana basada en la luz existente es una habitación, gracias a un sensor de luz conectado al Arduino, o bien para leer la información de una fuente, como puede ser un teclado o una página web, y convertir la información en una acción como puede ser encender una luz y escribir por un display lo tecleado.

el-universo-arduino

Con Arduino  es posible automatizar cualquier cosa para hacer agentes autónomos (si queréis podemos llamarles Robots). Para controlar luces y dispositivos, o cualquier otra cosa que se pueda imaginar, es posible optar por una solución basada en Arduino, especialmente en desarrollos de dispositivos conectados a Internet.

Arduino es una tecnología que tiene una rápida curva de aprendizaje con básicos conocimientos de programación y electrónica, que permite desarrollar proyectos en el ámbito de las Smart Cities, el Internet de las cosas, dispositivos wearables, salud, ocio, educación, robótica, etc…

Definición de Arduino en la web oficial: https://www.arduino.cc/en/Guide/Introduction

Otras definiciones de Arduino:

Que es arduino en un minuto (video): http://learn.onemonth.com/what-is-arduino

Hay otro factor importante en el éxito de Arduino, es la comunidad que apoya todo este desarrollo, comparte conocimiento, elabora librerías para facilitar el uso de Arduino y publica sus proyectos para que puedan ser replicados, mejorados o ser base para otro proyecto relacionado.

En resumen:

Arduino = HW + SW + Comunidad

Mitos sobre Arduino que todo el mundo cree y no son verdad: https://www.baldengineer.com/5-arduino-myths.html

Y otro mito sobre Arduino es que es una Raspberry Pi menos potente, pero no es así, son cosas diferentes: https://aprendiendoarduino.wordpress.com/2016/06/25/arduino-vs-raspberry-pi-2/

Primer Arduino:

arduino316

Arduino simplifica el trabajo con microcontroladores y ofrece las siguientes ventajas: barato, multiplataforma, entorno de programación sencillo, software libre y extensible mediante librerías en C++, hardware libre y extensible.

Al trabajar con Arduino, se manejan conceptos de diferentes tecnologías que a priori no tienen nada que ver entre ellos pero que los unifica: electronica digital y analogica, electricidad, programación, microcontroladores, tratamiento de señales, protocolos de comunicación, arquitectura de procesadores, mecánica, motores, diseño de placas electrónicas, etc…

Diez razones para usar Arduino: http://www.modulo0tutoriales.com/10-razones-para-usar-arduino/

Los dos Arduinos:

Importancia de Arduino en el mundo Hardware

Arduino y por extensión el hardware libre se ha convertido en un elemento importante no solo en el mundo maker sino también el la industria de fabricación de hardware.

En este enlace se hace un estudio del estado de la industria del hardware en 2016. Más empresas están desarrollando productos innovadores y tenemos disponibles mejores herramientas para el prototipado y fabricación. El acceso a esas herramientas y el conocimiento alrededor de ellas es cada vez más universal. De estas herramientas destaca Arduino, Raspberry Pi y las impresoras 3D.

Enlace: http://blog.fictiv.com/posts/2016-state-of-hardware-report

Cabe destacar de este estudio que el 56% de las empresas usan Arduino como herramienta eléctrica de prototipado y el 91% de las empresas usan impresoras 3D como herramienta mecanica de prototipado.

5701f09b71ffe15922d6a66c_stateofhardware-27

Otra encuesta de hackster.io que muestra la importancia de Arduino: https://blog.arduino.cc/2016/07/06/the-worlds-largest-maker-survey-results-are-out/

UART y USB en Arduino

Ya hemos visto  anteriormente que la UART o USART es el puerto serie hardware que todos los microcontroladores tienen al menos uno y la comunicación serie es la base de casi cualquiera de las comunicaciones de los microcontroladores.

El “Bus Universal en Serie”, en inglés: Universal Serial Bus más conocido por la sigla USB, es un bus estándar industrial que define los cables, conectores y protocolos usados en un bus para conectar, comunicar y proveer de alimentación eléctrica entre computadores, periféricos y dispositivos electrónicos.

Su desarrollo partió de un grupo de empresas del sector que buscaban unificar la forma de conectar periféricos a sus equipos, por aquella época poco compatibles entre si, entre las que estaban Intel, Microsoft, IBM, Compaq, DEC, NEC y Nortel. La primera especificación completa 1.0 se publicó en 1996, pero en 1998 con la especificación 1.1 comenzó a usarse de forma masiva.

La forma que tenemos de comunicar Arduino con el ordenador y para programarlo es mediante el USB. Casi todos los Arduinos y compatibles tienen un interfaz USB y sino usaremos un cable FTDI que nos hará la función de convertirnos el interfaz serie de la UART de Arduino a un interfaz USB. No confundir con lo visto anteriormente de uso del ICSP para programar, puesto que en ese caso programamos directamente la MCU sin necesidad de un bootloader.

El interfaz USB en el ordenador nos permite tener un puerto serie virtual que usamos para conectar con Arduino. Además de comunicación, USB es un interfaz de alimentación.

Físicamente un  USB tiene 4 pines:

Pin 1=> Alimentación con un voltaje de 5V DC
Pin 2 y 3 => Sirven para la transmisión de datos del BUS
Pin 4 = Masa o tierra

Aunque la mayoría de pc’s ya ofrecen protección interna se incorpora un fusible rearmable de intensidad máxima 500mA con la intención de proteger tanto la placa Arduino como el bus USB de sobrecargas y cortocircuitos. Si circula una intensidad mayor a 500mA por el bus USB (Intensidad máxima de funcionamiento), el fusible salta rompiendo la conexión de la alimentación. Podemos probar esto cortocircuitando GND y 5V en Arduino.

En el caso del USB el 0 y 1 se distingue por la diferencia de voltaje entre D+ y D-

Más información de USB:

Y para saber todo sobre USB ver “USB in a nutshell”: http://www.beyondlogic.org/usbnutshell/usb1.shtml

Para que un Arduino tenga un interfaz USB, necesita de un chip que ofrezca un interfaz USB, en algunos casos el propio microcontrolador ya dispone de ese interfaz y en otros caso utiliza un segundo microcontrolador con interfaz USB.

Tutorial USB:

Cuando conectamos un USB al ordenador, necesitamos un driver o trozo de software que nos  implemente la comunicación con el USB y nos monte un puerto serie virtual. Estos drivers deben estar certificados por http://www.usb.org/home y pagar las correspondientes licencias de uso. En el caso de Arduino los drivers ya están incluidos desde windows 8.1 y tienen su licencia de uso, por ese motivo cuando conectamos Arduino, automáticamente nos reconoce el dispositivo.

Todos los dispositivos USB tienen un USB vendor ID (VID) que identifica al fabricante y que es otorgado por http://www.usb.org/developers/vendor/ y un product ID (PID) que identifica el producto de ese vendedor. De esta forma es posible identificar un dispositivo USB por el ordenador. Más información: http://www.oshwa.org/2013/11/19/new-faq-on-usb-vendor-id-and-product-id/

Listado de VID:

Como sabemos hay dos Arduinos (arduino.cc y arduino.org) y por lo tanto hay dos VID para Arduino:

  • 2a03  dog hunter AG (arduino.org)
  • 2341  Arduino SA (arduino.cc)

Ejemplo de problemas con el uso de los drivers USB según el chip que lleve Arduino: http://blog.make-a-tronik.com/instalando-drivers-usb-serial-ch340g-para-arduino/

Cada dispositivo necesita tener unico product id y vendor id. Los VID son vendidos a los fabricantes y los PID son elegidos por cada compañía. Por ejemplo FTDI es el propietadior del VID #0403 y ellos dan a sus chips los IDs entre #0000 y #FFFF (65536 PIDs). Arduino tiene su propio VID y para el Arduino UNO el PID es el #0001

Si quisiéramos hacer cuenta propia placa compatible con Arduino hay varias opciones:

  • Usar un chip FTDI en lugar del 16u4 que ya tiene un VID
  • Si quieres hacer más de una placa y comercializar, tendrás que comprar un VID a usb.org en http://www.usb.org/developers/vendor/ y pagar la licencia
  • Si es para hacer una placa como experimento, puedes elegir un VID/PID que no interfiera con ninguno de los dispositivos del ordenador.
  • También es posible comprar licencias para un VID/PID de empresas que desarrollen dispositivos USB.

Sin embargo no es posible usar el VID de Arduino cuando quieres distribuir tu propia placa compatible con Arduino. Leer: http://electronics.stackexchange.com/questions/16665/arduino-uno-usb-vid-pid

En linux es posible ver mejor el proceso de reconocimiento de un dispositivo USB, leer: http://playground.arduino.cc/Linux/All

Tester de VID y PID basado en Arduino: https://learn.adafruit.com/simple-arduino-based-usb-vid-and-pid-tester/lets-do-this-thing

Para actualizar el firmware del Atmega16u2 que nos hace de interfaz entre el USB y el microcontrolador principal del Arduino UNO, seguir este procedimiento: http://arduino.cc/en/Hacking/DFUProgramming8U2.

Para comprobar la versión de firmware ir al gestor de dispositivos en Windows y buscar el Arduino, luego botón derecho y propiedades y buscar en driver details el VID, PID y el revision number.

La última versión del firmware está en https://github.com/arduino/Arduino/tree/master/hardware/arduino/avr/firmwares/atmegaxxu2 y usar un programador DFU como flip http://www.atmel.com/tools/flip.aspx para cargar el nuevo firmware.

Cuando usamos un Arduino basado en el microcontrolador ATmega32u4 como el leonardo, nos encontramos con que se hace una re-enumeración del puerto serie en el reset.

Puesto que estas placas no tienen un chip dedicado para manejar la comunicación serie y tienen un interfaz USB integrado, eso significa que el puerto serie es virtual, es una implementación software tanto en el ordenador como en la placa. Así como el ordenador crea una instancia del puerto serie cuando lo enchufas, el Arduino Leonardo crea una instancia serie cuando se ejecuta el bootloader. La placa es una instancia de un USB driver Connected Device Class (CDC), esto significa que cada vez que reseteas la placa, la conexión USB serie es rota y restablecida de nuevo. La placa desaparecerá de la lista de puertos serie y la lista se re-enumerará. Cualquier programa que tenga una conexión serie abierta con el Arduino Leonardo perderá su conexión. En el caso del Arduino cuando se resetea la placa se está reseteando el procesador principal ATmega328p sin cerrar la conexión USB que es mantenida por el microcontrolador secundario ATmega16u2. Esta diferencia de comportamiento tiene implicaciones en la carga y comunicación con el microcontrolador.

Los Arduinos basados en el ATmega32u4 aparecen también como un dispositivo genérico USB de teclado y ratón, y puede ser programado para controlar estos dispositivos usando las clases MouseKeyboard https://www.arduino.cc/en/Reference/MouseKeyboard, de forma que Arduino puede conportarse como un teclado u un ratón.

Más información: https://en.wikipedia.org/wiki/USB_communications_device_class

Cuando usamos un Arduino basado en el ATmega32u4 debemos usar la función if(serial) https://www.arduino.cc/en/Serial/IfSerial que indica si el puerto serie está preparado y en el caso del Leonardo, indica si la USB CDC serial connection está abierta. De esta  forma nos aseguramos que arranca el programa de Arduino cuando ya hay conexión entre el Arduino y el ordenador, sino podríamos perder los primeros envíos del Arduino al ordenador.

En el Arduino Leonardo, la clase Serial se refiere a la comunicación USB CDC, para la comunicación por TTL en los pines 0 y 1, se debe usar la clase Serial1.

En los Arduino basados en Atmega32u4 como el Arduino Leonardo usar:

void setup() { 
 //Initialize serial and wait for port to open:
  Serial.begin(9600); 
  while (!Serial) {
    ; // wait for serial port to connect. Needed for native USB
  }
} 

V_USB es una implementación software de un dispositivo USB para microcontroladores USB, haciendo posible construir hardware USB con casi cualquier MCU AVR, sin necesidad de un chip adicional. Se trata de un puerto USB software. Más información:

USART Arduino

La USART es el puerto serie de los microcontroladores que en el caso de Arduino están conectadas a los pines 0 y 1.

UART: http://es.wikipedia.org/wiki/Universal_Asynchronous_Receiver-Transmitter. Las funciones principales de la UART son de manejar las interrupciones de los dispositivos conectados al puerto serie y de convertir los datos en formato paralelo, transmitidos al bus de sistema, a datos en formato serie, para que puedan ser transmitidos a través de los puertos y viceversa.

Arduino se conecta a nuestro ordenador a través del puerto USB, pero el puerto USB se debe conectar al microcontrolador a través del puerto serie, por ello debemos entender cómo están relacionados el puerto USB y el puerto serie.

En un Arduino usamos el puerto USB para tres funciones: cargar nuestro programa ya compilado en la memoria flash, conectarnos al puerto Serie (UART) predefinido en cada Arduino para comunicarnos durante la ejecución del programa y adicionalmente alimentar a Arduino. Todo ello se puede hacer sin la necesidad del puerto USB, pero dada la facilidad de uso y que todos los ordenadores disponen de un puerto USB, nos facilita mucho hacer estas operaciones.

El puerto serie conectado al USB lo usamos como puerto de consola o puerto de debug.

La UART normalmente no genera o recibe directamente las señales externas entre los diferentes módulos del equipo. Usualmente se usan dispositivos de interfaz separados para convertir las señales de nivel lógico del UART hacia y desde los niveles de señalización externos, como puede ser RS232 o RS485. Una UART está normalmente en un circuito integrado usado para comunicaciones serie sobre un ordenador u otro dispositivo periférico.

Los microcontroladores como el ATmega328p tiene USART (Universal Syncronous Asyncronous Receiver Transmitter). Una USART puede trabajar igual que una UART, pero tiene la capacidad adicional de actuar como síncrona, esto significa que los datos van sincronizados con una señal de reloj. El reloj es recuperado desde los propios datos o enviado como como una señal externa. En ese caso no se usan los bits de start y stop, lo que permite una velocidad en baudios mayor al operar en modo síncrono porque la temporización de los bits tienen una cierta garantía y más bits pueden ser usados para datos en lugar de cabeceras.

Por el contrario la UART dispone de una señal de reloj interno y los datos en el bus pueden tener una temporización más irregular. Las UART requieren bits de start y stop y los datos asíncronos sólo se sincronizan con los bits de start y stop. La palabra asíncrono indica que la UART recupera la temporización de los caracteres desde el flujo de datos, usando el bit de start y el de stop para indicar el marco de cada carácter.

En la transmisión síncrona, la señal de reloj es recuperada de forma separada del stream de datos, esto mejora la eficiencia de la transmisión al haber más bits de datos en la transmisión. Una conexión asíncrona no manda nada cuando el dispositivo que transmite no tiene nada que mandar, pero un interfaz síncrono debe mandar caracteres para mantener el sincronismo entre emisor y receptor, normalmente el carácter ASCII “SYN” se encarga de rellenar este hueco y esto puede ser hecho automáticamente por el dispositivo transmisor.

Diferencia entre UART y USART:

Para saber todo sobre la USART de Arduino y la comunicación serie ver:

La configuración de la UART de los microcontroladores AVR necesita acceder a unos registros:

  • USART Band Rate Register – UBRRH &UBRRL
  • USART Control and Status Register A – UCSRA
  • USART Control and Status Register B – UCSRB
  • USART Control and Status Register C – UCSRC
  • USART Data Buffer Register – UDA

UART es un módulo de hardware que traduce los datos de paralelo a serial para ser transmitidos, las UARTs son usadas comúnmente en conjunto con estándares de comunicación como EIA, RS-232, RS-422 o RS-485. la designación “universal” indica que el formato de los datos y las velocidades de transmisión pueden ser configuradas.

UART es normalmente un circuito integrado individual usado para comunicaciones de un sistema de cómputo, son normalmente incluidas en microcontroladores. Actualmente estos circuitos pueden comunicarse de manera sincrónica y asincrónica y son conocidos como USART. Las funciones principales de chip UART son: manejar las interrupciones de los dispositivos conectados al puerto serie y convertir los datos en formato paralelo, transmitidos al bus de sistema, a datos en formato serie, para que puedan ser transmitidos a través de los puertos y viceversa.

La USART de Arduino es un puerto de comunicaciones muy versátil (UNIVERSAL SYNCHRONUS and ASYNCHRONUS serial RECEIVER and TRANSMITTER). Se puede configurar como síncrono o como asíncrono. Los pines de conexión de la placa UNO que se utilizan con este periférico interno son los siguientes:

  • PIN 0 (RXD)   – Puerto D del microcontrolador  PD0
  • PIN 1 (TXD)   – Puerto D del microcontrolador  PD1
  • PIN 13 (SCK) – Puerto B del microcontrolador  PB15 (Sólo para el modo síncrono)

Para poder realizar la comunicación, los dispositivos que se vayan a comunicar deben conocer varios aspectos de ésta. El primero es la velocidad a la que se va a realizar, es decir a qué baudios se va a realizar la transmisión.

La comunicación comienza con una señal de Start, seguida de los bits a enviar, y se pueden seleccionar entre 5 y 9 bits a mandar, después tenemos que seleccionar si va a haber un bit de paridad para comprobar errores y por último si tenemos uno o dos bits de Stop. Estos parámetros han de estar configurados de igual manera en los dos dispositivos que se van a comunicar.

En la placa UNO se utiliza la USART para que el Atmega328  se comunique con el otro microcontrolador ATmega16U2 que hace la interface al puerto USB. Los leds (TX LED y RX LED) parpadean para indicar actividad en el puerto serie a través de la USART.

El baudio es una unidad de medida utilizada en telecomunicaciones, que representa el número de símbolos por segundo en un medio de transmisión digital. Cada símbolo puede codificar 1 o más bits dependiendo del esquema de modulación, un bit siempre representa dos estados, por lo tanto baudios por segundo no siempre es equivalente a bits por segundo, los símbolos son las unidades de información estas se representan en bits, de manera que la tasa de bits será igual a la tasa de baudios sólo cuando sea 1 bit por símbolo.

Principales características del módulo USART, para mayor información ver datasheet del microcontrolador.

  • Full Duplex Operation (Independent Serial Receive and Transmit Registers)
  • Asynchronous or Synchronous Operation
  • Master or Slave Clocked Synchronous Operation
  • High Resolution Baud Rate Generator
  • Supports Serial Frames with 5, 6, 7, 8, or 9 Data bits and 1 or 2 Stop Bits.

Antes de continuar es importante resaltar que AVR UART y USART son totalmente compatibles en términos de registros, generación de tasa de baudios, operaciones de buffer y funcionalidad de buffer en el transmisor/receptor. A continuación un resumen rápido de la configuración del módulo UART.

  1. Establecer la velocidad de transmisión en emisor y receptor debe ser la misma para poder realizar la comunicación.
  2. Establecer el número de bits de datos que deben ser enviados.
  3. Mantener el buffer listo, si es una transmisión cargarlo con el dato a transmitir, si es una recepción almacenar el dato recibido para poder recibir mas datos sin perder información
  4. Por último habilitar el transmisor/receptor de acuerdo con el uso que se le desee dar.

En el caso de la transmisión sincrónica (USART) es necesario enviar el reloj del sistema el microcontrolador que envía esta señal se llama Maestro y el otro se denomina esclavo; para transmisión Asíncrona no se hace esta denominación para los transmisores/receptores.

La tasa de baudios se establece en el registro de 16 bits UBRR:

Más información: http://sistdig.wikidot.com/wiki:usart  

Más información sobre la USART del MCU ATmega328p, ver página 170 de http://www.atmel.com/images/Atmel-8271-8-bit-AVR-Microcontroller-ATmega48A-48PA-88A-88PA-168A-168PA-328-328P_datasheet_Complete.pdf

Estándares de comunicación serie que definen las características eléctricas de los drivers y los receptores:

Explicación de la diferencia entre comunicación RS232 y TTL: RS-232 vs. TTL Serial Communication y http://www.atmel.com/Images/doc4322.pdf

USB to Serial en Arduino

Cuando conectamos Arduino a un ordenador mediante un cable USB, el ordenador instala un puerto serie virtual (COM) desde el cual podemos acceder al puerto serie de Arduino. Por este motivo es necesario instalar en el ordenador los drivers de interfaz USB de los microcontroladores de Atmel, esto se hace automáticamente al instalar el IDE de Arduino.

Arduino UNO como otros Arduinos disponen de microcontroladores que no tienen un interfaz USB incorporado, por lo tanto no se pueden conectar directamente a un Ordenador. Para ello usan un segundo microcontrolador que hace de intermediario, generalmente un ATmega16u2 que dispone de un interfaz USB. Este microcontrolador dispone de un firmware especial que facilita la carga del programa en la flash del Arduino y comunicar posteriormente por el USB.

Este firmware y su código se puede ver en https://github.com/arduino/Arduino/tree/master/hardware/arduino/avr/firmwares/atmegaxxu2/arduino-usbserial

Los microcontroladores de 8 bits mega AVR con interfaz USB están configurados de fábrica con un bootloader USB, este permite hacer un In-System Programming desde el interfaz USB sin eliminar la parte del sistema o sin una aplicación preprogramada y sin un un interfaz externo de programación.

USB DFU (Device Firmware Update) Bootloader: http://www.atmel.com/Images/doc7618.pdf

Más información del microcontrolador en: http://www.atmel.com/Images/Atmel-7766-8-bit-AVR-ATmega16U4-32U4_Datasheet.pdf

Niveles lógicos

Los niveles lógicos de los microcontroladores, son los niveles físicos de voltaje por los que se interpreta un microcontrolador un 1 y un 0. Niveles lógicos: https://en.wikipedia.org/wiki/Logic_level

En el caso de los ATmega AVR usan Tecnología TTL: http://es.wikipedia.org/wiki/Tecnolog%C3%ADa_TTL. Su tensión de alimentación característica se halla comprendida entre los 4,75V y los 5,25V (como se ve, un rango muy estrecho). Normalmente TTL trabaja con 5V. Los niveles lógicos vienen definidos por el rango de tensión comprendida entre 0,0V y 0,8V para el estado L (bajo) y los 2,2V y Vcc para el estado H (alto). La velocidad de transmisión entre los estados lógicos es su mejor base, si bien esta característica le hace aumentar su consumo siendo su mayor enemigo. Motivo por el cual han aparecido diferentes versiones de TTL como FAST, LS, S, etc y últimamente los CMOS: HC, HCT y HCTLS. En algunos casos puede alcanzar poco más de los 400 MHz.

TTL logic levels: https://learn.sparkfun.com/tutorials/logic-levels/ttl-logic-levels

Interesante nota de TI sobre como elegir la solución más adecuada para la conversión de niveles lógicos.

Niveles lógicos de Arduino: https://learn.sparkfun.com/tutorials/logic-levels/arduino-logic-levels

A medida que la tecnología avanza se crean dispositivos que necesitan menor consumo eléctrico y usan un menor voltaje de base (Vcc = 3.3 V en lugar de 5V). La técnica de fabricación es también diferente para dispositivos de 3.3V que permiten una huella menor y costes más pequeños. Para asegurar la compatibilidad de los dispositivos a 3.3V, se puede ver que la mayoría de los niveles de voltaje son casi los mismos para dispositivos de 3.3V y los de 5V. Un dispositivo de 3.3V puede interactuar con uno de 5V sin componentes adicionales. Por ejemplo un 1 lógico (HIGH) de un dispositivo de 3.3V será al menos 2.4V, esto sigue siendo interpretado como un 1 lógico en un dispositivo de 5V porque está por encima  de VIH que es 2V.

Sin embargo hay que tener en cuenta que un dispositivo de 3.3V es tolerante a señales de 5V, esta especificación es el “maximum input voltage” del dispositivo. En ciertos dispositivos de 3.3V, cualquier voltaje supuerior a 3.6V provocará un daño permanente en el chip, para evitar esto se puede usar un simple divisor de tensión (https://learn.sparkfun.com/tutorials/voltage-dividers) como una resistencia de 1KΩ y una de 2KΩ para bajar los 5V o usar un logic level shifter como https://www.sparkfun.com/products/12009

Voltaje 5V vs 3.3V http://jeelabs.org/2010/12/16/voltage-3-3-vs-5/

Cable FTDI

Cable FTDI es la forma más fácil de conectar el microcontrolador a un ordenador por USB. Consiste en un chip de conversión USB a Serie. Como ocurre con Arduino cuando lo conectamos, necesitamos los drivers de windows, cuando conectamos un cable FTDI también necesita sus drivers. Los driver FTDI vienen integrados en el IDE de Arduino.

FTDI es el fabricante más popular de chips conversores de USB a serie.

Drivers: https://web.archive.org/web/20141005060035/http://www.ftdichip.com/Drivers/VCP.htm

Productos de FTDI:

Chip FTDI:

FT231X tiene un buffer de comunicación mayor comparado con el FT232R. El FT231X tiene los niveles lógicos de 3.3 V y con entradas tolerantes a 5V. FTDI provee de drivers para los dispositivos USB incluyendo driver certificados para Windows, incluido Windows 10.

Interesante artículo sobre la comunicación serie con MCUs AVR: http://www.evilmadscientist.com/2009/basics-serial-communication-with-avr-microcontrollers/

Cable par comunicar con dispositivos de 3.3V: https://www.sparkfun.com/products/9873

Al comprar un cable FTDI hay que estar atento al pineado que no es el que usan los Arduino Ethernet y otros elementos, es posible que para conectarlo a un Arduino haya que intercambiar algunos pines. Este es el pineado correcto y los colores de los cables para un FTDI para Arduino:

ftdi

Existen en el mercado cable con otros colores y el pineado desordenado. Estos son los colores del cable y a que corresponde:

  • Red wire: 5V
  • Black wire: GND
  • White wire: RXD
  • Green wire: TXD
  • Yellow wire: RTS
  • Blue wire: CTS

Y el pineado bueno para arduino queda así:

ftdi luis

Los pines CTS y RTS es el flow control (control de flujo). El pin RTS es una salida y debe conectarse al pin de entrada CTS del otro dispositivo de la conexión a la UART.

  • Si el pin RTS está a 0, indica que puede aceptar más datos en el pin RXD
  • Si el pin RTS está a 1, indica que no puede aceptar más datos.

Los cambios de estado del pin RTS ocurren cuando el buffer del chip alcanza los últimos 32 bytes de espacio para dejar tiempo al dispositivo externo para que pare el envío de datos.

El pin CTS es una entrada y debe ser conectado a la salida RTS del dispositivo al otro extremo.

  • Si el pin CTS está a 0, indica que el dispositivo externo puede aceptar más datos y transmitirá por el pin TXD.
  • Si el pin CTS está a 1, indica que el dispositivo externo no puede aceptar más datos y parará la transmisión de datos en los siguientes 0 – 3 caracteres, dependiendo de lo que haya en el buffer de salida. Se debe tener en cuenta que al ser un dispositivo USB opera en base a paquetes y no a bytes.

CTS y RTS en RS232: https://en.wikipedia.org/wiki/RS-232#RTS.2C_CTS.2C_and_RTR

También en algunos dispositivos serie nos podemos encontrar con el pin DTR que es el control de flujo https://en.wikipedia.org/wiki/Data_Terminal_Ready. El DTR permite a Arduino hacer el auto reset cuando un nuevo sketch es cargado a la memoria flash. Esto permite cargar un sketch sin tener que pulsar el botón de reset.

Una de las líneas del hardware flow control (DTR) del ATmega8U2/16U2, están conectadas a la línea de reset del MCU ATmega328P a través de un condensador de 100 nanofaradios. Cuando esta línea se pone a 0 V, es capaz de resetear el MCU de Arduino. El IDE de Arduino usa esta capacidad para permitir cargar código a Arduino simplemente presionando el botón upload y hace que el el timeout del bootloader pueda ser menor y estar mejor coordinado con el comienzo de la carga del sketch.

Cuando se detecta un flujo de datos a través del interfaz USB conectando un ordenador al Arduino, automáticamente se resetea la MCU de Arduino y durante el siguiente medio segundo, el bootloader se ejecuta en Arduino. Como el bootloader está programado para ignorar datos malformados (cualquier cosa que no sea nuevo código de un sketch), interceptará los primeros bytes de los datos enviados a la placa tras la conexión. Por este motivo si un sketch está programado para recibir una comunicación por el puerto serie tras iniciarse, hay que asegurarse que el software que manda esa información espera al menos un segundo después de que se abra la conexión hasta que se manden los primeros datos.

Ojo con los chips FTDI falsos: http://hackaday.com/2016/02/01/ftdi-drivers-break-fake-chips-again/

Diferencia entre programadores AVR o adaptadores FTDI:

  • Los programadores AVR son más poderosos puesto que permite programar cualquier AVR, incluso los que vienen son bootloader de fábrica, pero también significa que es posible brickear el chip. Usando un programador se debe tener en cuenta que se sobreescribirá el bootloader.
  • Los adaptadores FTDI pueden enviar cualquier dato por puerto serie, incluyendo programar AVRs con un bootloader en ellos.

Más información de uso de un FTDI: https://cdn-learn.adafruit.com/downloads/pdf/ftdi-friend.pdf

Para las prácticas del curso disponemos de esta placa FTDI para programar tanto dispositivos a 5v como a 3.3 (los que habitualmente hay dispobles suelen ser a 5V), con selector de voltaje: http://www.tinyosshop.com/index.php?route=product/product&product_id=600, además este tiene DTR para conectar al reset y poder programar un arduino.

El FTDI usado usa el chip FT232 con características:

  • Interfaz estándar compatible con el tipo de controlador oficial de Arduino
  • Chipset FT232 original, funcionamiento estable, indicador de transmisión y recepción.
  • opción de fuente de alimentación 5V/3.3V
  • Chip de FT232R es la solución de un solo chip, con oscilador de cristal

FT232R tiene algunas funciones útiles:

Los microcontroladores AVR de Arduino para programarlos directamente por puerto serie, van a 5V, aunque si se usa un programador de 3.3v funciona porque el rx de arduino toma 0 cuando el voltaje es inferior a 0.7V y 1 cuando es superior a 2,4V.

Tal y como indica en las características del Arduino UNO en https://www.arduino.cc/en/main/arduinoBoardUno: “The Uno has a number of facilities for communicating with a computer, another Uno board, or other microcontrollers. The ATmega328 provides UART TTL (5V) serial communication, which is available on digital pins 0 (RX) and 1 (TX).”

Pero no solo se puede programar Arduino mediante el USB o por el puerto ICSP, sino que también es posible hacerlo mediante un cable FTDI conectado al puerto serie de Arduino. Para programar con el adaptador FTDI, necesitaré de un bootloader, con ICSP no.

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

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.

 

ICSP

En resumidas cuentas, el núcleo de cualquier placa Arduino se compone simplemente de un microcontrolador AVR. En el caso de la placa Arduino UNO, su microcontrolador es el ATMega328.

Conforme uno se va adentrando en el mundo de Arduino y los proyectos se vayan haciendo cada vez más grandes y complicados, puede presentarse la necesidad de recurrir al uso de un segundo microcontrolador, para lo cual, es mejor conseguir un microcontrolador AVR por separado puesto que es mucho más barato y/o rentable que volver a comprar una nueva placa Arduino.

Un inconveniente de comprar un nuevo microcontrolador AVR es que éste vendrá de fábrica completamente “limpio” (sin ningún programa cargado), como consecuencia, habrá que grabar por primera vez el Bootloader (Gestor de arranque) para que éste pueda cargar y hacer funcionar los sketches programados con el software de Arduino.

La placa Arduino posee una entrada ICSP (In Chip Serial Programmer) que tiene acceso a la memoria de programa del AVR (Flash), ésto es, que puede grabar directamente desde el PC al microcontrolador cualquier programa sin usar el puerto USB. Uno de ellos, el mismo Bootloader de Arduino.

Programación serial en circuito (ICSP por las siglas del inglés : In-Circuit Serial Programming), es la habilidad de algunos dispositivos lógicos programables, microcontroladores y otros circuitos electrónicos, de ser programados mientras están instalados en un sistema completo, en lugar de requerir que el chip sea programado antes de ser instalado dentro del sistema.

Típicamente, los chips que soportan ISP tienen circuitería interna que les permite generar el voltaje de programación necesario desde la línea de alimentación convencional y comunicarse con el dispositivo programador mediante un protocolo serie. Muchos dispositivos lógicos programables usan una variante del protocolo JTAG para el ISP, esto es para facilitar la integración con procedimientos de prueba automatizada. Otros dispositivos usan protocolos propietarios o protocolos definidos por antiguos estándares.

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.:

En el caso de ATMega328p:

En el caso de Arduino va al conector:

Estos pines sirven para la programación del ATMEGA328P-PU a través del puerto serie, de ahí las siglas ICSP (In Circuit Serial Programming), se utilizan para grabar el bootloader en el microcontrolador o modificar el programa a través de este puerto sin necesidad de sacarlo del zócalo. El bootloader ya viene grabado de fábrica en este microcontrolador. Podemos identificar el pin1 del ISCP en la placa fijándonos el pequeño punto blanco que está grabado sobre ella, ese punto nos indica que se trata del pin número 1, igual ocurre en los chips, microcontroladores y otros circuitos integrados.

El conector ICSP tiene dos versiones:

Más información:

Pero no solo se puede programar Arduino mediante USB o como acabamos de ver por el puerto ICSP, sino que también es posible hacerlo mediante un cable FTDI conectado al puerto serie de Arduino. Este tema se explicará profundamente en siguientes capítulos.

ICSP es un conector consistente en 6 señales: MOSI, MISO, SCK, RESET, VCC, GND y además de ser un puerto para programar Arduino, también es el conector de expansión del bus SPI mediante el que también podemos comunicar periféricos y es usado en algunos casos para comunicar Arduino con los shields. Se puede considerar el ICSP como un “esclavo” del master del bus SPI del microcontrolador.

En referencia a los microcontroladores AVR, el ICSP es la forma que tenemos de programarlos de forma in-system, conectando un programador a estos 6 pines. El programador manda el fichero hex ya compilador al microcontrolador mediante un protocolo concreto como puede ser el STK500.

La forma en que programamos Arduino generalmente es mediante el puerto serie gracias al bootloader cargado en el microcontrolador que se comunica con el puerto serie para copiar el fichero compilado en la flash. 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 este motivo necesitamos un bootloader para programar Arduino a través del USB.

Por otro lado la programación ISP primero resetea el Arduino y lo mantiene, mientras el reset está mantenido Arduino no funciona y ningún programa que tenga. En su lugar el programa codificado en hexadecimal se transmite a través de los pines MOSI (Master Out, Slave In) and MISO (Master In, Slave Out) y temporizado con el CLOCK. por lo tanto en este caso no necesitamos del bootloader.

Más información: http://www.vwlowen.co.uk/arduino/icsp/page3.htm

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

En el caso de usar un programador externo en lugar de USB para cargar un sketch, el procedimiento es el mismo pero seleccionando el programador adecuado en el IDE.

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

En la ruta C:\Program Files (x86)\Arduino\hardware\arduino\avr\programmers.txt, tenemos la configuración de los programadores que podemos usar con el IDE de Arduino. En este fichero se especifica la comunicación, protocolo, herramienta y parámetros. Esto sirve para decir al la herramienta de programación avrdude qué parámetros usar para cargar el programa.

Ejemplo de uso de un Arduino nano como programador ISP: http://www.martyncurrey.com/arduino-nano-as-an-isp-programmer/

HW Arduino a Fondo

Los Arduino y en general los microcontroladores tienen puertos de entrada y salida y de comunicación. En Arduino podemos acceder a esos puertos a través de los pines.

Otro aspecto importante es la memoria, Arduino tiene tres tipos de memoria:

  • SRAM: donde Arduino 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 o apagado. Las EEPROMs tienen un número limitado de lecturas/escrituras, tener en cuenta a la hora de usarla.
  • Flash: Memoria de programa. Usualmente desde 1 Kb a 4 Mb (controladores de familias grandes). Donde se guarda el sketch.

Más información en:

Placa Arduino Uno a fondo:

Especificaciones detalladas de Arduino UNO: http://arduino.cc/en/Main/ArduinoBoardUno

Microcontroller & USB-to-serial converter ATmega328P & Atmega16U2
Operating Voltage 5V
Input Voltage (recommended) 7-12V
Input Voltage (limits) 6-20V
Digital I/O Pins 14 (of which 6 provide PWM output)
Analog Input Pins 6
DC Current per I/O Pin 40 mA
DC Current for 3.3V Pin 50 mA
Flash Memory 32 KB (ATmega328) of which 0.5 KB used by bootloader
SRAM 2 KB (ATmega328)
EEPROM 1 KB (ATmega328)
Clock Speed 16 MHz

Veamos todos los componentes del Arduino UNO:

Pin mapping Arduino UNO:

Componentes en la placa:

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

Componentes:

  • No necesita de un cable FTDI para conectarse al MCU, en su lugar uso una MCU ATMEGA16U2 especialmente programado para trabajar como conversor de USB a serie.
  • Alimentación: vía USB, batería o adaptador AC/DC a 5V, seleccionado automáticamente. Arduino puede trabajar entre 6 y 20V, pero es recomendado trabajar entre 7 y 12V por las características del regulador de tensión.
  • Puerto Serie en los pines 0 y 1.
  • Interrupciones externas en los pines 2 y 3.
  • Built-in LED en el pin 13.
  • Bus TWI o I2C en los pines A4 y A5 etiquetados como SDA y SCL o pines específicos
  • El MCU ATmega328P tiene un bootloader precargado que permite cargar en la memoria flash el nuevo programa o sketch sin necesidad de un HW externo.
  • Fusible rearmable de intensidad máxima 500mA. Aunque la mayoría de pc’s ya ofrecen protección interna se incorpora un fusible con la intención de proteger tanto la placa Arduino como el bus USB de sobrecargas y cortocircuitos. Si circula una intensidad mayor a 500mA por el bus USB(Intensidad máxima de funcionamiento), el fusible salta rompiendo la conexión de la alimentación.
  • Regulador de voltaje LP2985 de 5V a 3.3V que proporciona una corriente de alimentación máxima de 150 mA.
  • Regulador de voltaje NCP1117 que proporciona un valor estable de 5V a la placa y soporta por encima de 1 A de corriente. Datasheet:  http://www.onsemi.com/pub_link/Collateral/NCP1117-D.PDF
  • ATMEGA16U2 => Es el chip encargado de convertir la comunicación del puerto USB a serie.
  • Condensadores de 47µF de capacidad
  • Diodo M7 en la entrada de alimentación de la placa. Con este diodo conseguimos establecer el sentido de circulación de la intensidad, de esta forma si se produce una contracorriente debido a la apertura de un relé u otros mecanismos eléctricos, el diodo bloquea dicha corriente impidiendo que afecte a la fuente de alimentación.
  • DFU-ICSP. Puerto ICSP para el microcontrolador ATMEGA16U2, como en el caso del ATMEGA328P-PU se emplea para comunicarnos con el microcontrolador por el serial, para reflashearlo con el bootloader, hacer algunas modificaciones, ponerlo en modo DFU, etc..
  • JP2. Pines libres del ATMEGA16U2, dos entradas y dos salidas para futuras ampliaciones.
  • Encapsulados de resistencias.
  • RESET-EN: Significa Reset enabled o reset habilitado. Está habilitado el auto-reset, para deshabilitar por cualquier tipo de seguridad (por ejemplo un proyecto que tenemos funcionando y no queremos que nadie lo reinicie al conectar un USB y detecte un stream de datos) debemos desoldar los pads RESET-EN y limpiarlos de forma que estén aislados el uno del otro.
  • Cristal oscilador de 16MHz necesario para el funcionamiento del reloj del microcontrolador ATMEGA16U2.
  • Resonador cerámico de 16 Mhz para el microcontrolador ATMEGA328P-PU. Los resonadores cerámicos son menos precisos que los cristales osciladores, pero para el caso hace perfectamente la función y ahorramos bastante espacio en la placa. Se trata del pequeño, porque el cristal grande es para el 16U2

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

Más información:

MCU ATmega16u2 en Arduino

Si nos fijamos en el pequeño integrado que hay en la placa de Arduino UNO junto al conector USB, se trata de un ATmega16u2 cuya misión es dar el interfaz USB al Arduino UNO y comunicar los datos con el ATmega328p mediante el puerto serie. Se podría usar como microcontrolador completamente funcional y no solo un conversor de USB a Serial con ciertas modificaciones. Podríamos usar ambas 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

atmega16u2

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

Esquemático Arduino UNO

En este pdf podemos ver el esquema de un Arduino UNO, muy importante conocerlo para evitar hacer maniobras que lo dañen: http://arduino.cc/en/uploads/Main/Arduino_Uno_Rev3-schematic.pdf

Los dos microcontroladores:

Partes del esquemático:

Conexión de los puertos serie de loas os MCUs de un Arduino UNO

También es importante conocer cómo están distribuidos los pines del MCU en Arduino:

Para saber todo sobre el HW de Arduino ver este tutorial donde desglosa todo el HW de Arduino para construir un Arduino UNO desde cero y crear tu propio clon: https://rheingoldheavy.com/category/education/fundamentals/arduino-from-scratch-series/

Diseño PCB Arduino

La placa de Arduino:

Están disponible los esquemas y diseño en formato Eagle para Arduino UNO en http://arduino.cc/en/uploads/Main/arduino_Uno_Rev3-02-TH.zip. Por supuesto para el resto de Arduinos también disponemos de sus diseños de PCB.

Para ver los esquemas podemos usar Eagle, se trata de un programa de diseño de diagramas y PCBs con autoenrutador:

La versión freeware de Eagle es perfecta para diseños pequeños y sencillos, se trata de una licencia para uso no comercial y gratuita para todos. La versión freeware tienen todas las funcionalidades de la versión de pago pero tiene ciertas limitaciones:

  • El área de la placa está limitada a 100 x 80 mm
  • Solo pueden usarse dos capas (Top y Bottom)
  • El editor del esquemático solo puede tener dos hojas.
  • Soporte solo disponible vía email o foro
  • Su uso está limitado a aplicaciones no comerciales o para evaluación
  • Se puede cargar, ver e imprimir diseños que superen esos límites.

Una opción opensource para diseño de PCB es kicad: http://kicad-pcb.org/

Microcontroladores Arduino

Un microcontrolador es un integrado capaz de ser programado desde un ordenador y seguir la secuencia programada.

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 y también microcontroladores Atmel ARM Cortex-M0+, Intel http://www.intel.com/content/dam/support/us/en/documents/boardsandkits/curie/intel-curie-module-datasheet.pdf y con la aparición de arduino.org también microcontroladores de ST microelectronics.

Pero también Arduino y su entorno de programación se está convirtiendo en un estándar de facto para la programación de cualquier tipo de placas de desarrollo y prototipado, es decir, de otro tipo de microcontroladores no incluidos en los productos de Arduino.

Puesto que Arduino es una plataforma open source disponemos de toda la documentación de los microcontroladores usados.

Por ejemplo, el microcontroaldor de Arduino UNO es el ATmega 328p y toda la documentación la tenemos en http://www.atmel.com/devices/atmega328p.aspx. El data sheet completo es un documento de 444 páginas que podemos ver en http://www.atmel.com/Images/Atmel-42735-8-bit-AVR-Microcontroller-ATmega328-328P_datasheet.pdf. Cuando necesitemos más información o cómo funciona este microcontrolador debemos ir a este documento.

Como muestra de la documentación que tenemos disponible:

  • Página 34 tenemos el detalle de cómo se distribuye la memoria en el ATmega328p
  • Página 97 tiene en detalle los puertos digitales I/O y página 100 donde da el código para definir un pines a high y low y también como input pullup.
  • Página 436 tenemos los 3 encapsulados posibles para este microcontrolador
  • Página 316 nos muestra que este microcontrolador tiene un sensor de temperatura integrado y que es posible habilitarlo para leer su temperatura, al igual que los procesadores de nuestros ordenadores.
  • Página 378 se pueden ver los consumos de Arduino y la dependencia entre la frecuencia máxima de reloj y el Vcc.
  • Página 428 hay un resumen de todos los registros del microcontrolador y su dirección de memoria.

Cuando el microcontrolador ejecuta una instrucción que definimos en el sketch, internamente hace muchas operaciones y cada una de esas operaciones se ejecuta en un ciclo de reloj. Para el ATmega 328p que tiene una frecuencia de 16 MHz, es decir, cada ciclo tarda 0,0000000625 segundos = 0,0625 microsegundos = 62,5 nanosegundos

Así se ejecutaría una instrucción, en cada ciclo de reloj se ejecuta cada subinstrucción.

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.

Cálculos de la velocidad de las operaciones en Arduino: http://forum.arduino.cc/index.php?topic=200585.0

El método para calcular estas tablas está en http://forum.arduino.cc/index.php?topic=200585.0

Diferencia entre los microcontroladores de 8 bits, 16, y 32 bits, es tamaño de palabra que manejan e influye en los registros y direccionamiento de memoria: http://es.wikipedia.org/wiki/Palabra_(inform%C3%A1tica)

Este mismo análisis hecho con el ATmega328P, podemos hacerlo con otros microcontroladores:

Dentro de los microcontroladores la tendencia es a usar MCUs de 32 bits con arquitectura ARM.  La arquitectura ARM es el conjunto de instrucciones de 32 y 64 bits más ampliamente utilizado en unidades producidas. Concebida originalmente por Acorn Computers para su uso en ordenadores personales, los primeros productos basados en ARM eran los Acorn Archimedes, lanzados en 1987.

La relativa simplicidad de los procesadores ARM los hace ideales para aplicaciones de baja potencia. Como resultado, se han convertido en dominante en el mercado de la electrónica móvil e integrada, encarnados en microprocesadores y microcontroladores pequeños, de bajo consumo y relativamente bajo costo. En 2005, alrededor del 98% de los más de mil millones de teléfonos móviles vendidos utilizaban al menos un procesador ARM. Desde 2009, los procesadores ARM son aproximadamente el 90% de todos los procesadores RISC de 32 bits integrados.

La arquitectura ARM es licenciable. Esto significa que el negocio principal de ARM Holdings es la venta de núcleos IP, estas licencias se utilizan para crear microcontroladores y CPUs basados en este núcleo.

ARM Cortex M es un grupo de procesadores RISC de 32 bits licenciados por ARM Holdings. La web oficial es http://www.arm.com/products/processors/cortex-m. Además existen otras familias de ARM: https://en.wikipedia.org/wiki/List_of_ARM_microarchitectures

Más información:

Para saber más de microcontroladores, ver estos recursos:

AVR vs PIC:

Esquema lógico de Arduino

El funcionamiento interno de un microcontrolador se puede explicar con un diagrama de bloques o esquema lógico, donde se ven en cada bloque cada unidad interna del microcontrolador y cómo se comunica con el restos de unidades.

Arquitectura de microcontroladores: http://sistdig.wikidot.com/wiki:arquitectura

Diagrama de bloques simplificado de un microcontrolador. Se compone de tres bloques fundamentales: la CPU ( central Processing Unit), memoria (RAM y ROM) y las entrada y salidas. Los bloques se conectan entre sí mediante grupos de líneas eléctricas denominadas buses o pistas. Los buses pueden ser de direcciones (si transportan direcciones de memoria o entrada y salida), de datos (si transportan datos o instrucciones) o de control (si transportan señales de control diversas). La CPU es el cerebro central del microprocesador y actúa bajo control del programa almacenado en la memoria. La CPU se ocupa básicamente de traer las instrucciones del programa desde la memoria, interpretarlas y hacer que se ejecuten. La CPU también incluye los circuitos para realizar operaciones aritméticas y lógicas elementales con los datos binarios, en la denominada Unidad Aritmética y Lógica (ALU: Aritmetic and Logic Unit).

Diagramas de bloques de un microcontrolador PIC:

Diagrama de bloques de un microcontrolador AVR de Atmel, incluido el ATmega328p:

El sistema de reloj determina la velocidad de trabajo del microcontrolador. Con 16 MHZ se ejecuta una instrucción en 62,5 nanosegundos (1/16 Mhz), correspondiente a 1 ciclo de máquina. El microcontrolador tiene diferentes opciones de circuito de reloj tal como lo muestra la siguiente imagen:

En un registro interno del microcontrolador se encuentran 5 opciones diferentes de reloj que son seleccionadas por medio de un Multiplexor. De este multiplexor sale la señal de reloj, la cual pasa a través de un prescaler, este prescaler se puede utilizar para reducir la frecuencia, reducir el consumo de energía y mejorar la estabilidad de la señal de reloj.El factor del prescaler va de 1 a 256, en potencias de 2. En Arduino, por defecto está desactivado, por consiguiente trabaja a la frecuencia del resonador externo.

La señal de reloj es distribuida por la unidad de control a los diferentes bloques existentes: la CPU, las memorias, los módulos de entrada/salida, los contadores/timers, el SPI y la USART, al igual que el conversor Análogo Digital ADC.

El microcontrolador ATmega328  tiene tres timers (timer 0, timer 1, timer 2) que también se pueden usar como contadores. Los timers 0 y 2 son de 8 bits y el timer 1 de 16. Estos timers tienen un módulo de preescalado para su propia señal de reloj que puede provenir de su sistema de reloj interno o por pines externos (modo contador). Son módulos que funcionan en paralelo a la CPU y de forma independiente a ella. El funcionamiento básico consiste en aumentar el valor del registro del contador al ritmo que marca su señal de reloj.

Usando el reloj interno o un cristal externo puede ser utilizado para medir tiempos puesto que utiliza una señal periódica, precisa y de frecuencia conocida; mientras que si la señal viene de un pin externo puede contar eventos que se produzcan en el exterior y que se reflejen en cambios de nivel de tensión de los pines.

Estos contadores también forman parte del generador de señales PWM y permiten configurar tanto la frecuencia como el ciclo de trabajo.

Registros de memoria

Todos los microcontroladores tienen un conjunto de instrucciones que suele ser un conjunto pequeño al tratarse de arquitectura RISC. La CPU cuenta con ese número de instrucciones que sabe ejecutar.

El conjunto de instrucciones para los microcontroladores Atmel de 8 bits es: http://www.atmel.com/Images/Atmel-0856-AVR-Instruction-Set-Manual.pdf

En el caso del ATmega328p, tiene una arquitectura RISC con 131 instrucciones, la mayoría de ellas ejecutadas en un solo ciclo de reloj.

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

Los registros son unas zonas concretas de la memoria RAM accesibles directamente desde la CPU o desde otros elementos del microcontrolador que permite hacer operaciones directamente y de forma más rápida.

Trabajar con registros de memoria puede ser difícil si sólo se escribe un programa en lenguaje ensamblador. Al utilizar el lenguaje de programación de alto nivel como es C basta con escribir el nombre del registro y su dirección de memoria, a partir de esa información, el compilador selecciona el registro necesario. Las instrucciones apropiadas para la selección del registro serán incorporadas en el código durante el proceso de la compilación.

Más información: https://en.wikipedia.org/wiki/Processor_register

La memoria RAM en el ATmega328p se divide en varias partes, todos los grupos de registros se ponen a cero al apagar la fuente de alimentación. La SRAM del 328p se distribuye de la siguiente forma:

ram-map

Las primeras 32 localizaciones de la memoria son el fichero de registros (Register File). Las siguientes 64 localizaciones de memoria es la standard I/O memory y después las 160 siguientes localizaciones son la Extended I/O memory. Por último las siguientes 2K localizaciones son la memoria interna SRAM.

Las 5 diferentes modos de direccionamiento para los datos de memoria son:

  • Direct – The direct addressing reaches the entire data space.
  • Indirect with Displacement – The Indirect with Displacement mode reaches 63 address locations from the base address given by the Y- or Z-register.
  • Indirect – In the Register File, registers R26 to R31 feature the indirect addressing pointer registers.
  • Indirect with Pre-decrement – The address registers X, Y, and Z are decremented.
  • Indirect with Post-increment – The address registers X, Y, and Z are incremented.

The 32 general purpose working registers, 64 I/O Registers, 160 Extended I/O Registers, and the 2K bytes of internal data SRAM in the device are all accessible through all these addressing modes.

Los registros de propósito general se utilizan para almacenar los datos temporales y los resultados creados durante el funcionamiento de la ALU. Los 32 General Purpose Working Registers están directamente conectados a la ALU, permitiendo ser accedidos dos registros de forma independiente en una sola instrucción ejecutada en un ciclo de reloj.

Six of the 32 registers can be used as three 16-bit indirect address register pointers for Data Space addressing – enabling efficient address calculations. One of the these address pointers can also be used as an address pointer for look up tables in Flash program memory. These added function registers are the 16-bit X-, Y-, and Z-register. Más información en la página 28 de http://www.atmel.com/Images/Atmel-42735-8-bit-AVR-Microcontroller-ATmega328-328P_datasheet.pdf

register-file

Para más información ver página 35 de http://www.atmel.com/Images/Atmel-42735-8-bit-AVR-Microcontroller-ATmega328-328P_datasheet.pdf

All I/O locations may be accessed by the LD/LDS/LDD and ST/STS/STD instructions, transferring data between the 32 general purpose working registers and the I/O space. I/O Registers within the address range 0x00-0x1F are directly bit-accessible using the SBI and CBI instructions. In these registers, the value of single bits can be checked by using the SBIS and SBIC instructions

Los I/O registers localizados en las direcciones 0x20 a 0xFF y a diferencia de los registros de propósito general, su propósito es predeterminado durante el proceso de fabricación y no se pueden cambiar. Como los bits están conectados a los circuitos particulares en el chip (convertidor A/D, módulo de comunicación serial, etc), cualquier cambio de su contenido afecta directamente al funcionamiento del microcontrolador o de alguno de los circuitos. Esta es la forma en que a bajo nivel se interactúa por ejemplo con los pines del microcontrolador.

Un resumen de todos los registros I/O del ATmega328p se puede ver en la página 428 de http://www.atmel.com/Images/Atmel-42735-8-bit-AVR-Microcontroller-ATmega328-328P_datasheet.pdf

Registros para:

Más información sobre registros y su uso en:

Ejercicio: Registros Arduino

Veamos algunos valores de los registros de Arduino con el sketch ShowInfo de http://playground.arduino.cc/Main/ShowInfo

Este sketch dispone de un menú que nos permite hacer varias operaciones, pulsar opción i (Show Information) y t (Timer Register Dump) para ver datos de los registros.

Solución: https://github.com/jecrespo/Aprendiendo-Arduino/tree/master/Ejercicio58-Manipular_Registros

La mayoría de los nuevos chips AVR (utilizados en el Arduino) tienen un sensor de temperatura interno. No suele utilizarse, ya que no es exacta. Sin embargo, hay varias situaciones en las que se puede utilizar este sensor.

La temperatura interna es la temperatura dentro del chip, al igual que la temperatura de la CPU de un ordenador. Si el Arduino no está durmiendo, esta temperatura aumentará. Si los pines de salida se utilizan para dar corriente (por ejemplo encender leds) la temperatura interna aumenta más. Esta temperatura no puede usarse para medir la temperatura ambiente.

En situaciones con altas temperaturas una lectura de temperatura calibrada podría evitar daños. La mayoría de los chips AVR más recientes tienen un rango de temperatura de hasta 85 grados Celsius. El Arduino podría utilizarse para apagarse a 80 grados Celsius.

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

Ejecutar el sketch leer y entender lo que hace y probarlo. Comparar con otros Arduinos y calibrar.

Ver en la página 306 y 316 de la documentación del microcontrolador http://www.atmel.com/Images/Atmel-42735-8-bit-AVR-Microcontroller-ATmega328-328P_datasheet.pdf

Solución: https://github.com/jecrespo/Aprendiendo-Arduino/tree/master/Ejercicio58-Manipular_Registros