Objetivos

El objetivo de este curso es ampliar conocimientos sobre la plataforma Arduino a los alumnos
que han realizado el curso de Arduino de http://www.aprendiendoarduino.com/ o aquellos que
ya tienen conocimientos sobre la plataforma y experiencia en la realización de proyectos con
Arduino.

Al finalizar el curso el alumno será capaz de realizar proyectos complejos, conocer la

programación de Arduino más allá del core de Arduino, interactuar con el mundo exterior a
través de órdenes enviadas desde un ordenador o desde un dispositivo móvil y comunicarse a
través de Internet. También será capaz de crear sus propias librerías o modificar las existentes
para mejorar las funcionalidades.

Requisitos

Para la realización de este curso es necesario haber realizado la primera parte de este curso o
tener conocimientos y experiencia en la creación de proyectos con Arduino. También es
necesario conocimientos de programación (especialmente C++), redes TCP/IP y protocolos de
comunicación, microcontroladores, electrónica, uso de sensores, actuadores, motores, etc…

Es recomendable un conocimiento medio de Inglés puesto que gran parte de la

documentación está en Inglés.

Metodología

El curso se compone de una combinación de teoría y práctica donde se profundiza en el

conocimiento de la plataforma Hardware y Software de Arduino y otros hardware compatibles,
con una duración total de 30 horas. Al final del curso se realizarán proyectos donde se
pondrán en práctica los conocimientos y habilidades adquiridas, aplicando los conceptos
aprendidos durante el curso.

Los recursos utilizados para la realización de este curso son:

 La documentación del curso se publicará en formato web en la

dirección: http://www.aprendiendoarduino.com/arduino-avanzado-2016/ y se usará
para realizar el seguimiento del curso.
 Todo el código de las prácticas utilizado en el curso está disponible
en: https://github.com/jecrespo/Aprendiendo-Arduino
 El código de los proyectos final de curso está disponible
en: https://github.com/jecrespo/Aprendiendo-Arduino-Proyectos
 Las publicaciones del curso y otros recursos interesantes que se comentarán a lo largo
del curso se podrán seguir a través de:
 Publicaciones de la programación diaria del curso en el
blog http://www.aprendiendoarduino.com/.
 Twitter con hashtag #aprendiendoarduino
 Cuenta twitter: https://twitter.com/jecrespom

Además están disponibles otros recursos para ampliar información:

 Otros cursos, documentación, talleres y publicaciones en:

 http://www.aprendiendoarduino.com/
  https://aprendiendoarduino.wordpress.com/
 Cuenta github con más código: https://github.com/jecrespo
 Lista de
correo: http://list.aprendiendoarduino.com/mailman/listinfo/aprendiendoarduino.com.not
icias

Es posible interactuar en el curso mediante:

 Twitter con el hashtag #aprendiendoarduino

 Comentarios en los post con la documentación del curso
 Correo a aprendiendoarduino@gmail.com

Para realizar las prácticas de este curso se usará:

 Arduino Starter Kit (https://www.arduino.cc/en/Main/ArduinoStarterKit) que contiene un

Arduino Uno, una serie de sensores y actuadores y diversos elementos electrónicos
necesarios para realizar las prácticas y proyectos.
 Ethernet Shield: https://www.arduino.cc/en/Main/ArduinoEthernetShield
 Otros módulos:
 Módulo Ultra low power 2.4GHz RF
nRF24L01+: https://www.seeedstudio.com/item_detail.html?p_id=1394
 Módulo Wifi ESP8266: https://www.seeedstudio.com/WiFi-Serial-Transceiver-Module-
w%26-ESP8266-1MB-Flash-p-2485.html
 Módulo IMU MPU6050: http://www.miniinthebox.com/es/la-ultima-mpu-6050-modulo-
6000-de-6-ejes-giroscopio-acelerometro_p4348915.html
 Programador
FTDI: http://www.tinyosshop.com/index.php?route=product/product&product_id=600
 Módulo bluetooth HC-05: http://www.prometec.net/producto/modulo-bluetooth-hc-05/
 Kit XBee: http://www.digikey.es/product-detail/en/digi-international/XKB2-AT-
WWC/602-1551-ND/5305247

Toda la documentación será on-line con el objetivo de mantenerla actualizada y no con un

documento físico que se queda obsoleto rápidamente. Después de finalizar el curso toda la
documentación on-line seguirá estando disponible de forma pública.

El repositorio de código usando en el curso está en https://github.com/jecrespo/Aprendiendo-

Arduino y aumenta continuamente con nuevos ejemplos y prácticas que se van añadiendo.

Todo el material entregado es en préstamo y debe cuidarse al máximo, a la hora del montaje
de las prácticas se seguirán las instrucciones para evitar dañar los componentes.

Toda la documentación está liberada con licencia Creative Commons.

Reconocimiento – NoComercial – CompartirIgual (by-nc-sa): No se permite un uso comercial

de la obra original ni de las posibles obras derivadas, la distribución de las cuales se debe
hacer con una licencia igual a la que regula la obra original.
Aprendiendo Arduino by Enrique Crespo is licensed under a Creative Commons
Reconocimiento-NoComercial-CompartirIgual 4.0 Internacional License.

Organización del curso

Duración total de 30 horas. El curso se celebra del 7 al 18 de noviembre de 2016 de Lunes a

Viernes en horario de 18.00 a 21.00. Se hará un descanso de 10 minutos aproximadamente a
mitad de la sesión antes de empezar con la parte práctica.

Capítulos del curso:

 Repaso Conceptos de Arduino

 Hardware Arduino Avanzado
 Programación Avanzada Arduino
 Manejo Avanzado Arduino
 Comunicaciones Arduino
 Internet de las Cosas
 Arduino en la Industria
 Proyectos Fin de Curso

Detalle del temario: http://www.aprendiendoarduino.com/arduino-avanzado-2016/

Programación diaria del curso en: http://www.aprendiendoarduino.com/

Cada día de curso de compone de 4 partes diferenciadas:

 Saber más: Al principio de la clase se verán durante 10-15 minutos temas

relacionados con Arduino propuestos por los alumnos o que hayan surgido durante la
clase.
 Contenidos Teóricos
 Contenidos Prácticos
 Opcional: Si da tiempo se verán contenidos adicionales

Aclaraciones sobre el curso

Arduino es una plataforma ampliamente usada por aficionados (makers) y para prototipado y
puede verse como un “juguete”, pero en este curso vamos a usarlo para implantarlo en
cualquier aplicación que necesitemos tanto para un uso profesional como personal/aficionado.
Veremos cómo aplicar su uso en diversos entornos como prototipado, robótica, fabricación,
eficiencia energética, domótica, IoT, comunicaciones, DAQ, monitorización, educación, etc… y
especialmente en este curso su aplicación a la industria.

La principal ventaja de usar una plataforma de este tipo es el rápido despliegue de una nueva
aplicación y la facilidad de programación. A lo largo del curso se van a ver muchos conceptos
de diferentes tecnologías como electrónica digital y analogica, electricidad, programación,
microcontroladores, tratamiento de señales, bases de datos, protocolos de comunicación,
arquitectura de procesadores, mecánica, motores, diseño de placas electrónicas etc… todo
ello con Arduino como nexo de unión
No se va a seguir el índice en el orden que está en la documentación, sino que se van a
mezclar los capítulos para ser más pedagógico. Cada día del curso se publicará un post con el
listado de temas y prácticas en http://www.aprendiendoarduino.com/.

Presentaciones

Arduino tiene muchos ámbitos de aplicación, desde el sector agrícola, fabricación, eficiencia
energética, robótica, monitorización, educación, etc…

 Experiencia con Arduino?

 Conocimientos de electrónica?
 Conocimientos de programación?
 Entorno de uso de Arduino?
 Proyectos con Arduino?

Programación Arduino
1 respuesta

El lenguaje de programación de Arduino es C++. No es un C++ puro sino que es una

adaptación que proveniente de avr-libc que provee de una librería de C de alta calidad para
usar con GCC(compilador de C y C++) en los microcontroladores AVR de Atmel y muchas
utilidades opensource específicas para las MCU AVR de Atmel como
avrdude: https://learn.sparkfun.com/tutorials/pocket-avr-programmer-hookup-guide/using-
avrdude

Las herramientas necesarias para programar los microcontroladores AVR de Atmel son avr-
binutils, avr-gcc y avr-libc y ya están incluidas en el IDE de Arduino, pero cuando
compilamos y cargamos un sketch estamos usando estas herramientas.

Aunque se hable de que hay un lenguaje propio de programación de Arduino, no es cierto, la

programación se hace en C++ pero Arduino ofrece unas librerías, también llamado core, que
facilitan la programación de los pines de entrada y salida y de los puertos de comunicación,
así como otras librerías para operaciones específicas. El propio IDE ya incluye estas librerías
de forma automática y no es necesario declararlas expresamente. Otra diferencia frente a C++
standard es la estructuctura del programa ya que no usa la función main(), sino que usa las
funciones setup() y loop().
En el 99% de los casos se puede hacer un proyecto de Arduino de cierta complejidad con la
librería que nos ofrece el core de Arduino y no es necesario añadir más instrucciones ni tipos
de datos que los que hay en el core. Toda la información para programar con el core de
Arduino se encuentra en el reference de la web de
Arduino: https://www.arduino.cc/en/Reference/HomePage

Una buena chuleta para tener a mano cuando programemos. Cheat

Sheet: https://dlnmh9ip6v2uc.cloudfront.net/learn/materials/8/Arduino_Cheat_Sheet.pdf

Lenguaje de programación C++

Es posible usar comandos estándar de C++ en la programación de Arduino siempre que estén
incluidos en el avr libc:

 Reference: http://www.atmel.com/webdoc/AVRLibcReferenceManual/
 Módulos http://www.atmel.com/webdoc/AVRLibcReferenceManual/ch20.html
 Standard
Library: http://www.atmel.com/webdoc/AVRLibcReferenceManual/group__avr__stdlib.h
tml
 String
Module: http://www.atmel.com/webdoc/AVRLibcReferenceManual/group__avr__string.
html
 Free software project: http://www.nongnu.org/avr-libc/
 Módulos: http://www.nongnu.org/avr-libc/user-manual/modules.html

En Internet hay muchas webs de referencia donde consultar dudas a la hora de programar en
C++:

 Libro gratuito: http://cslibrary.stanford.edu/101/EssentialC.pdf

 http://www.cplusplus.com/
 http://en.cppreference.com/w/cpp
 http://www.c.conclase.net/
 http://www.tutorialspoint.com/cplusplus/

Un manual sencillo de entender para la programación es el “arduino programming notebook”

de brian w. Evans. Puedes consultarlo o descargarlo desde:

 http://playground.arduino.cc/uploads/Main/arduino_notebook_v1-1.pdf
 Y su traducción: http://www.ardumania.es/wp-
content/uploads/2011/10/Arduino_programing_notebook_ES.pdf

Cuando compilamos y cargamos el programa en Arduino esto es lo que ocurre:

Variables

Una variable puede ser declarada al inicio del programa antes de la parte de configuración
setup(), a nivel local dentro de las funciones, y, a veces, dentro de un bloque, como para los
bucles del tipo if.. for.., etc. En función del lugar de declaración de la variable así se
determinará el ámbito de aplicación, o la capacidad de ciertas partes de un programa para
hacer uso de ella.

Una variable global es aquella que puede ser vista y utilizada por cualquier función y
estamento de un programa. Esta variable se declara al comienzo del programa, antes de
setup().

Recordad que al declarar una variable global, está un espacio en memoria permanente en la
zona de static data y el abuso de variables globales supone un uso ineficiente de la memoria.

Una variable local es aquella que se define dentro de una función o como parte de un bucle.
Sólo es visible y sólo puede utilizarse dentro de la función en la que se declaró. Por lo tanto,
es posible tener dos o más variables del mismo nombre en diferentes partes del mismo
programa que pueden contener valores diferentes, pero no es una práctica aconsejable
porque complica la lectura de código.

En el reference de Arduino hay una muy buena explicación del ámbito de las
variables: http://arduino.cc/en/Reference/Scope

El modificador de variable static, es utilizado para crear variables que solo son visibles dentro
de una función, sin embargo, al contrario que las variables locales que se crean y destruyen
cada vez que se llama a la función, las variables estáticas mantienen sus valores entre las
llamadas a las funciones.

Los tipos de variables en Arduino son:

Además de usar este tipo de datos que son los que aparecen en el reference de Arduino
(https://www.arduino.cc/en/Reference/HomePage), es posible usar cualquier tipo de variable
de C++ estándar con las limitaciones propias de cada micorcontrolador.

Tipos de variables estándar en C++:

 https://en.wikipedia.org/wiki/C_data_types
 http://www.cplusplus.com/doc/tutorial/variables/
 https://msdn.microsoft.com/en-us/library/cc953fe1.aspx

Más información sobre los tipos de variable Arduino

en: https://aprendiendoarduino.wordpress.com/2016/06/29/tipos-de-datos-2/

Arrays

Un array es un conjunto de valores a los que se accede con un número índice. Cualquier valor
puede ser recogido haciendo uso del nombre de la matriz y el número del índice. El primer
valor de la matriz es el que está indicado con el índice 0, es decir el primer valor del conjunto
es el de la posición 0. Un array tiene que ser declarado y opcionalmente asignados valores a
cada posición antes de ser utilizado.
Para manejar arrays en C++ dispones de las funciones
estándar: http://www.cplusplus.com/reference/array/array/

string (char array)

Un string es un array de chars. Cuando se trabaja con grandes cantidades de texto, es

conveniente usar un array de strings. Puesto que los strings son en si mismo arrays de chars.

Reference de Arduino para string: https://www.arduino.cc/en/Reference/String

Para manejara strings (char array) disponemos de las funciones de string.h que define
diversas funciones para manipular strings y arrays http://www.cplusplus.com/reference/cstring/

También es posible usar la clase string de

C++: http://www.cplusplus.com/reference/string/string/

Más información para aclarar la diferencia entre string y la clase

string: https://www.tutorialspoint.com/cplusplus/cpp_strings.htm

String (Objeto)

Se trata de una clase que permite usar y manipular cadenas de texto de una forma más
sencilla que los strings. Puedes concatenar, añadir, buscar, etc… usando los
métodos/funciones que ofrece esta clase.

Toda la información de la clase String en el reference de

Arduino https://www.arduino.cc/en/Reference/StringObject

Los Strings tienen un uso intensivo de memoria, pero son muy útiles y se van a utilizar mucho
en el apartado de comunicación, por ese motivo es importante aprender a manejar los Strings.

Tener en cuenta que al no ser un tipo de dato propiamente dicho sino una clase, tienes unas
funciones asociadas (métodos), operadores y unas propiedades. Es una abstracción del dato
y para aprender a usarlo hay que leerse la documentación correspondiente.

Operadores

El core de Arduino ofrece una serie de operadores según su reference:

 Aritméticos:
 Asignación: http://arduino.cc/en/Reference/Assignment
 +, -, *, /: http://arduino.cc/en/Reference/Arithmetic
 Módulo: http://arduino.cc/en/Reference/Modulo
 Compuestos:
 ++, –: http://arduino.cc/en/Reference/Increment
 += , -= , *= , /= : http://arduino.cc/en/Reference/IncrementCompound
 Comparación:
 ==, !=, <, >, <=, >=: http://arduino.cc/en/Reference/If
 Booleanos: http://arduino.cc/en/Reference/Boolean
Pero además es posible usar los operadores estnándar de C /C++ y más
información: http://es.wikipedia.org/wiki/Anexo:Operadores_de_C_y_C%2B%2B

Estructuras de control

Las estructuras de control en Arduino según el reference son:

 Estructuras de decisión
 if: http://arduino.cc/en/Reference/If
 else: http://arduino.cc/en/Reference/Else
 switch case: http://arduino.cc/en/Reference/SwitchCase
 Estructuras de repetición
 for: http://arduino.cc/en/Reference/For
 while: http://arduino.cc/en/Reference/While
 do .. while: http://arduino.cc/en/Reference/DoWhile

Funciones definidas por usuario

Una función es un bloque de código que tiene un nombre y un conjunto de instrucciones que
son ejecutadas cuando se llama a la función. Son funciones setup() y loop() de las que ya se
ha hablado.

Las funciones de usuario pueden ser escritas para realizar tareas repetitivas y para reducir el
tamaño de un programa. Segmentar el código en funciones permite crear piezas de código
que hacen una determinada tarea y volver al área del código desde la que han sido llamadas.
Más información sobre las funciones en C++: http://www.cplusplus.com/doc/tutorial/functions/

Ejercicio: http://jecrespo.github.io/PrimerosPasosArduino/
Anuncios
REPORT THIS AD

REPORT THIS AD

Compártelo:

 Twitter
 Facebook3
 Google

Relacionado
Lenguaje de programación de Arduino, estructura de un programaEn "Arduino"
Programación ArduinoEn "Arduino"
Programación ArduinoEn "Arduino"
Esta entrada se publicó
en Arduino, arrays, C++, Funciones, operadores, Programación, Sketch, Software, String, strings, Variables
y está etiquetada con Arduino, arrays, AVR, C++, estructuras de control, Funciones, herramientas de
programación, IDE, lenguaje de programación, operadores, Variables en 16 octubre, 2016.

Librerías Arduino
Deja un comentario

Las librerías son trozos de código hechos por terceros que usamos en nuestro sketch. Esto
nos facilita mucho la programación y hace que nuestro programa sea más sencillo de hacer y
de entender. En este curso no veremos como hacer o modificar una librería pero en este curso
debemos ser capaces de buscar una librería, instalarla, aprender a usar cualquier librería y
usarla en un sketch.
Las librerías normalmente incluyen los siguientes archivos comprimidos en un archivo ZIP o
dentro de un directorio. Estas siempre contienen:

 Un archivo .cpp (código de C++)

 Un archivo .h o encabezado de C, que contiene las propiedades y métodos o
funciones de la librería.
 Un archivo Keywords.txt, que contiene las palabras clave que se resaltan en el IDE
(opcional).
 Muy posiblemente la librería incluye un archivo readme con información adicional de lo
que hace y con instrucciones de como usarla.
 Directorio denominado examples con varios sketchs de ejemplo que nos ayudará a
entender cómo usar la librería (opcional).

Como instalar librerías: http://arduino.cc/en/Guide/Libraries

Hay varios métodos de instalar librerías:

 Mediante el IDE de Arduino de forma automática. Admite la instalación desde un

fichero zip o desde una carpeta ya descomprimida.
 Instalación Manual. Descomprimiendo en un directorio la librería y copiandolo en el
directorio de librerías. Generalmente Mi Documentos – Arduino – libraries. Aquí se
guardan las librerías contribuidas por el usuario como lo denomina el IDE.
 Desde el gestor de librerías. A partir de la versión 1.6.2 del IDE de Arduino se
incorpora el gestor de librerías que facilita el trabajo. Esta herramienta es accesible
desde Programa → Incluir Librería → Gestionar Librerías. Desde aquí podemos ver las
librerías instaladas, buscar librerías disponibles, instalar librerías y actualizarlas.
Esta herramienta también nos permite gestionar las librerías instaladas manualmente.
Desde C:\Users\nombre_usuario\AppData\Local\Arduino15, podemos ver en formato
json el listado de librerías y placas disponibles desde el gestor de librerías y tarjetas.
La librerías instaladas se guardan en el directorio indicado desde las preferencias del IDE.
IMPORTANTE: Para añadir una librería a nuestro proyecto simplemente se añade a nuestro
código la palabra clave #include seguido del nombre de la librería.
Práctica: Instalación de Librerías

Instalar varias librerías como las del siguiente

capítulo https://aprendiendoarduino.wordpress.com/2016/06/28/instalacion-librerias/

Compara el funcionamiento y limitaciones de las librerías MsTimer2.h y Timer.h con el

ejemplo https://github.com/jecrespo/Aprendiendo-Arduino/tree/master/Otros/compara_timers
Anuncios
REPORT THIS AD

REPORT THIS AD

Compártelo:

 Twitter
 Facebook5
 Google

Relacionado
LibreríasEn "Arduino"
Librerías ArduinoEn "Arduino"
Librerías ArduinoEn "Arduino"
Esta entrada se publicó en Arduino, Librerías Arduino, Programación y está etiquetada
con Arduino, Librerías Arduino, Programación en 6 noviembre, 2016.

Manejo Arduino
Deja un comentario

La estructura básica de un sketch de Arduino es bastante simple y se compone de al menos

dos partes. Estas dos partes son obligatorios y encierran bloques que contienen
declaraciones, estamentos o instrucciones.

 setup() – http://arduino.cc/en/Reference/Setup
 loop() – http://arduino.cc/en/Reference/Loop

setup() es la parte encargada de recoger la configuración y loop() es la que contiene el

programa que se ejecuta cíclicamente (de ahí el término loop –bucle-). Ambas funciones son
necesarias para que el programa trabaje.
La función de configuración (setup) debe contener la inicialización de los elementos y esta
función sólo se ejecuta una vez justo después de hacer el reset y no se vuelve a ejecutar
hasta que no haya otro reset. Es la primera función a ejecutar en el programa y se utiliza para
configurar, inicializar variables, comenzar a usar librerías, etc…

La función bucle (loop) contiene el código que se ejecutará continuamente (lectura de

entradas, activación de salidas, etc). Esta función es el núcleo de todos los programas de
Arduino y se usa para el control activo de la placa. La función loop se ejecuta justo después de
setup.

La estructura del sketch está definida en el siguiente

enlace: http://arduino.cc/en/Tutorial/Sketch

Los componentes principales de un sketch de Arduino son:

 Variables, son un espacio en memoria donde se almacenan datos y estos datos

pueden variar.
 Funciones, son un trozo de código que puede ser usado/llamado desde cualquier
parte del sketch. A la función se le puede llamar directamente o pasarle unos
parámetros, en función de cómo esté definida.
 setup() y loop(), son dos funciones especiales que es obligatorio declarar en cualquier
sketch.
 Comentarios, fundamentales para documentar el proyecto

Se puede resumir un sketch de Arduino en los siguientes diagramas de flujo:

Entradas y Salidas Digitales en Arduino

En arduino los pines digitales se describen y tienen la propiedades

siguientes: http://arduino.cc/en/Tutorial/DigitalPins

En arduino para tratar las entradas y salidas digitales usamos las siguientes funciones:

 pinMode() – configura en el pin especificado si se va a comportar como una entrada o

una salida. http://arduino.cc/en/Reference/PinMode
 digitalWrite() – Escribe un valor HIGH o LOW en el pin digital especificado. Si el pin
está configurado como OUTPUT pone el voltaje correspondiente en el pin
seleccionado. Si el pin está configurado como INPUT habilita o deshabilita la
resistencia interna de pull up del correspondiente
pin. http://arduino.cc/en/Reference/DigitalWrite
 digitalRead() – lee el valor del pin correspondiente como HIGH o
LOW. http://arduino.cc/en/Reference/DigitalRead

En la imagen siguiente se muestra el estado por defecto de una I/O digital en un

microcontrolador de Arduino. Se ha simplificado con interruptores la compleja electrónica que
hay dentro. Por defecto los digital I/O pins están configurados como inputs en un estado
de alta impedancia (equivalente a una resistencia de 100 Mohms en frente del pin), es decir,
SW3 a ON y no hace falta llamar a la función pinMode() aunque es recomendable para aclarar
el código.

 PinMode(x, INPUT) –> SW3 = ON (resto a OFF). Los valores leídos serán aleatorios si
el pin de Arduino está al aire. El pin está en un estado de alta impedancia (resistencia
de 100 Mohms).
 PinMode(x,INPUT_PULLUP) –> SW3 = ON & SW4 = ON (resto a OFF). Los valores
leídos sin nada conectado al pin es HIGH. La Resistencia R1 tiene un valor
dependiendo del microcontrolador, pero tiene un valor entre 20kOhm y 150kOhm.
 PinMode(x, OUTPUT) & digitalWrite(x,HIGH) –> SW2 = ON & SW1 = +5V (resto a
OFF). Estado de baja impedancia, no hay resistencia interna y es necesario poner una
resistencia adecuada a la salida el pin para no superar los 40mA (source) máximos
admitidos
 PinMode(x, OUTPUT) & digitalWrite(x,LOW) –> SW2 = ON & SW1 = GND (resto a
OFF). Estado de baja impedancia, no hay resistencia interna y es necesario poner una
adecuada para no superar los 40mA (sink) máximos admitidos

Entradas y Salidas Analógicas en Arduino

Los microcontroladores de Arduino contienen en la placa un conversor analógico a digital de 6

canales. El conversor tiene una resolución de 10 bits, devolviendo enteros entre 0 y 1023. Los
pines analógicos de Arduino también tienen todas las funcionalidades de los pines digitales.
Por lo tanto, si necesitamos más pines digitales podemos usar los pines analógicos. La
nomenclatura para los pines analógicos es A0, A1, etc…

En arduino los pines analógicos se definen y tienen las propiedades

siguientes: http://arduino.cc/en/Tutorial/AnalogInputPins

En arduino para tratar las entradas y salidas digitales usamos las siguientes funciones:
  analogReference() – configura la referencia de voltaje usada para la entrada
analógica. http://arduino.cc/en/Reference/AnalogReference
 analogRead() – lee el valor del pin analógico
especificado. http://arduino.cc/en/Reference/AnalogRead
 analogWrite() – escribe un valor analógico (onda PWM) al pin especificado. No en
todos los pines digitales se puede aplicar
PWM. http://arduino.cc/en/Reference/AnalogWrite

Otras funciones interesantes con entradas/salidas analóicas:

 map(value, fromLow, fromHigh, toLow, toHigh) http://arduino.cc/en/Reference/Map

 constrain(x, a, b) http://arduino.cc/en/Reference/Constrain

PWM

Arduino Uno tiene entradas analógicas que gracias a los conversores analógico digital puede
entender ese valor el microcontrolador, pero no tiene salidas analógicas puras y para
solucionar esto, usa la técnica de PWM.

Las Salidas PWM (Pulse Width Modulation) permiten generar salidas analógicas desde pines
digitales. Arduino Uno no posee salidas analógicas puras.

La modulación por ancho de pulsos (también conocida como PWM, siglas en inglés de pulse-
width modulation) de una señal o fuente de energía es una técnica en la que se modifica el
ciclo de trabajo de una señal periódica (una senoidal o una cuadrada, por ejemplo), ya sea
para transmitir información a través de un canal de comunicaciones o para controlar la
cantidad de energía que se envía a una carga.

El ciclo de trabajo de una señal periódica es el ancho relativo de su parte positiva en relación
con el período. duty cycle = (tiempo que la salida está a uno o HIGH)/ (periodo de la función)
En Arduino la frecuencia de PWM es de 500Hz. Pero es un valor que puede modificarse en
caso que lo necesitemos. Definición de PWM en la web de
Arduino: http://arduino.cc/en/Tutorial/PWM

Práctica: Ejemplos Básicos con Arduino

Ejemplos básicos con Arduino: http://jecrespo.github.io/ArduinoBasicExamples/

Primeros pasos con Arduino: http://jecrespo.github.io/PrimerosPasosArduino/

Detectar flanco: https://github.com/jecrespo/Aprendiendo-Arduino/tree/master/Ejercicio52-

Detectar_Alarma
Anuncios
REPORT THIS AD

REPORT THIS AD

Compártelo:

 Twitter
 Facebook1
  Google

Relacionado
Estructura sketch ArduinoEn "Arduino"
Estructura sketch en ArduinoEn "Arduino"
Manejo Arduino BásicoEn "Arduino"
Esta entrada se publicó en Arduino, Entradas Analógicas, Entradas Digitales, PWM y está etiquetada
con Arduino, Entradas Analógicas, Entradas Digitales, PWM en 6 noviembre, 2016.

Electrónica, Sensores, Actuadores y Periféricos

1 respuesta

Conceptos Elementales

Corriente Continua

La corriente continua (CC en español, en inglés DC, de Direct Current) se refiere al flujo
continuo de carga eléctrica a través de un conductor entre dos puntos de distinto potencial,
que no cambia de sentido con el tiempo. A diferencia de la corriente alterna (CA en español,
AC en inglés, de Alternating Current), en la corriente continua las cargas eléctricas circulan
siempre en la misma dirección. Aunque comúnmente se identifica la corriente continua con
una corriente constante, es continua toda corriente que mantenga siempre la misma polaridad,
así disminuya su intensidad conforme se va consumiendo la carga (por ejemplo cuando se
descarga una batería eléctrica). También se dice corriente continua cuando los electrones se
mueven siempre en el mismo sentido, el flujo se denomina corriente continua y va (por
convenio) del polo positivo al negativo.

Ley de Ohm

La ley de Ohm, postulada por el físico y matemático alemán Georg Simon Ohm, es una ley de
la electricidad. Establece que la intensidad de la corriente I que circula por un conductor es
proporcional a la diferencia de potencial V que aparece entre los extremos del citado
conductor. Ohm completó la ley introduciendo la noción de resistencia eléctrica R; esta es el
coeficiente de proporcionalidad que aparece en la relación entre I y V.

Pulsador

Un botón o pulsador es un dispositivo utilizado para realizar cierta función. Los botones son de
diversas formas y tamaños y se encuentran en todo tipo de dispositivos, aunque
principalmente en aparatos eléctricos y electrónicos. Los botones son por lo general activados,
al ser pulsados con un dedo. Permiten el flujo de corriente mientras son accionados. Cuando
ya no se presiona sobre él vuelve a su posición de reposo.

Puede ser un contacto normalmente abierto en reposo NA o NO (Normally Open en Inglés), o

con un contacto normalmente cerrado en reposo NC.

Cuando nos de desenvolvemos en el entorno de los microcontroladores, nos encontramos con

un término poco común, me refiero a la polarización de una E/S, debemos saber que hay dos
tipos de polarización, polarización alta la resistencia (término inglés Pullup) va conectada a +
(5V) o polarización baja la resistencia (término inglés Pulldown) va conectada a masa – (0V).
Siguen dos esquemas de estos términos:
Al trabajar con botones nos vamos a encontrar el problema de los rebotes o bouncing. La
solución pasa por leer el estado del botón cuando se produce el borde ascendente de la
tensión a extremos de los contactos del pulsador e introducir inmediatamente la salida con ese
estado, el resto de entradas (se llama ruido) se inhiben o anulan mediante un lapsus de
tiempo. Véase la imagen de debajo para entender mejor lo dicho.
Para solucionar el problema de los rebotes podemos hacerlo vía hardware o software:

 Hardware: aquí se pueden utilizar diferentes técnicas, pero la más común es utilizar un
condensador conectado en paralelo al pulsador. El condensador tardará cierto tiempo
en cargarse y una vez que esté cargado, la señal de salida será igual a la señal de
entrada.
 Software: puede utilizarse solamente cuando tratemos la señal con un procesador, es
decir, hay algún programa que lea la señal emitida por el pulsador. La técnica más
utilizada consiste en ignorar las conmutaciones del valor del sensor si desde la última
conmutación válida no ha pasado suficiente tiempo.

Sensores

Un sensor es un dispositivo capaz de detectar magnitudes físicas o químicas, llamadas

variables de instrumentación, y transformarlas en variables eléctricas. Las variables de
instrumentación pueden ser por ejemplo: temperatura, intensidad lumínica, distancia,
aceleración, inclinación, desplazamiento, presión, fuerza, torsión, humedad, movimiento, pH,
etc. Una magnitud eléctrica puede ser una resistencia eléctrica (como en una RTD), una
capacidad eléctrica (como en un sensor de humedad o un sensor capacitivo), una tensión
eléctrica (como en un termopar), una corriente eléctrica (como en un fototransistor), etc.

Los sensores se pueden clasificar en función de los datos de salida en:

 Digitales
 Analógicos

Y dentro de los sensores digitales, estos nos pueden dar una señal digital simple con dos
estados como una salida de contacto libre de tensión o una salida en bus digital.
A la hora de elegir un sensor para Arduino debemos tener en cuenta los valores que
puede leer las entradas analógicas o digitales de la placa para poder conectarlo o sino
adaptar la señal del sensor a los valores que acepta Arduino.

Una vez comprobado que el sensor es compatible con las entradas de Arduino, hay que
verificar cómo leer el sensor mediante la programación, comprobar si existe una librería
o es posible leerlo con los métodos disponibles de lectura de entrada analógica o
digital.

Por último verificar cómo alimentar el sensor y comprobar si podemos hacerlo desde el
propio Arduino o necesitamos una fuente exterior. Además, en función del número de
sensores que queramos conectar es posible que Arduino no pueda alimentar todos.
Para saber si podremos alimentar los sensores, debemos conocer las limitaciones de
alimentación de Arduino que veremos en el capítulo 2 del
curso http://www.aprendiendoarduino.com/arduino-avanzado-2016/

Características de los sensores

 Rango de medida: dominio en la magnitud medida en el que puede aplicarse el

sensor.
 Precisión: es el error de medida máximo esperado.
 Offset o desviación de cero: valor de la variable de salida cuando la variable de
entrada es nula. Si el rango de medida no llega a valores nulos de la variable de
entrada, habitualmente se establece otro punto de referencia para definir el offset.
 Linealidad o correlación lineal.
 Sensibilidad de un sensor: suponiendo que es de entrada a salida y la variación de la
magnitud de entrada.
 Resolución: mínima variación de la magnitud de entrada que puede detectarse a la
salida.
 Rapidez de respuesta: puede ser un tiempo fijo o depender de cuánto varíe la
magnitud a medir. Depende de la capacidad del sistema para seguir las variaciones de
la magnitud de entrada.
 Derivas: son otras magnitudes, aparte de la medida como magnitud de entrada, que
influyen en la variable de salida. Por ejemplo, pueden ser condiciones ambientales,
como la humedad, la temperatura u otras como el envejecimiento (oxidación,
desgaste, etc.) del sensor.
 Repetitividad: error esperado al repetir varias veces la misma medida.

Más información: http://es.wikipedia.org/wiki/Sensor#Caracter.C3.ADsticas_de_un_sensor

Tipos de sensores: http://es.wikipedia.org/wiki/Sensor#Tipos_de_sensores

Ejemplos Sensores para Arduino

 ACS714: http://www.allegromicro.com/~/Media/Files/Datasheets/ACS714-
Datasheet.ashx
 Sensor 4 en 1: http://elcajondeardu.blogspot.com.es/2016/04/review-4-sensores-en-1-
modulo-medicion.html
 DHT22: http://wiki.seeedstudio.com/wiki/Grove_-
_Temperature_and_Humidity_Sensor_Pro
 DS18B20: https://www.seeedstudio.com/One-Wire-Temperature-Sensor-p-1235.html
  Sensor ultrasonico de distancia: http://hackarobot.com/how-to-use-ultrasonic-distance-
sensor-with-arduino/
 Sensor de presion barometrica y altura (I2C): https://www.adafruit.com/products/1603
 Sensor laser distancia: http://tienda.bricogeek.com/sensores-distancia/792-escaner-
laser-360-grados-rplidar.htm
 Sensor temperatura
kit: https://www.arduino.cc/en/uploads/Main/TemperatureSensor.pdf
 Caudalimetro: http://miarduinounotieneunblog.blogspot.com.es/2016/04/caudalimetro-
con-sensor-de-flujo-yf.html

Actuadores y Periféricos

Un actuador es un dispositivo capaz de transformar energía hidráulica, neumática o eléctrica

en la activación de un proceso con la finalidad de generar un efecto sobre elemento externo.
Este recibe la orden de un regulador, controlador o en nuestro caso un Arduino y en función a
ella genera la orden para activar un elemento final de control como, por ejemplo, una válvula.

Existen varios tipos de actuadores como son:

 Electrónicos
 Hidráulicos
 Neumáticos
 Eléctricos
 Motores
 Bombas

Periférico es la denominación genérica para designar al aparato o dispositivo auxiliar e

independiente conectado a la unidad central de procesamiento o en este caso a Arduino. Se
consideran periféricos a las unidades o dispositivos de hardware a través de los cuales
Arduino se comunica con el exterior, y también a los sistemas que almacenan o archivan la
información, sirviendo de memoria auxiliar de la memoria principal.

Ejemplos de periféricos:

 Pantallas LCD
 Teclados
 Memorias externas
 Cámaras
 Micrófonos
 Impresoras
 Pantalla táctil
 Displays numéricos
 Zumbadores
 Indicadores luminosos, etc…

Para cada actuador o periférico, necesitamos un “driver” o manejador para poder

mandar órdenes desde Arduino.

 Recordad que los pines de Arduino solo pueden manejar un máximo de 40mA y
recomendable usar 20mA de forma continua.
  Recordar que Arduino solo puede manejar un total de 200 mA de salida. Es decir que
la corriente máxima que admite Vcc y GND son 200 mA.

 Recordar que los pines Arduino solo pueden tener los valores de 5V (3.3V en algunos
modelos) y 0V. No es posible cualquier otro valor de tensión.

 La alimentación máxima del pin de 5V y del pin de 3.3V dependerá del regulador de
tensión que tenga la placa, en el caso de Arduino UNO la limitación es 1 A para 5V y
150 mA para 3.3V

A la hora de seleccionar un actuador o periférico para usar con arduino habrá que ver sus
características y cómo hacer el interface con arduino. En el playground de Arduino existe una
gran base de datos de conocimiento para conectar Arduino con casi cualquier
HW: http://playground.arduino.cc/Main/InterfacingWithHardware

Tutoriales para conectar Arduino con diversos

dispositivos: http://playground.arduino.cc/Learning/Tutorials

Ejemplos de Actuadores y Periféricos para Arduino

 Sacar por TV datos de Arduino, librería TV

OUT: http://real2electronics.blogspot.com.es/2010/11/libreria-tvout.html
 Relés: http://www.geeetech.com/wiki/index.php/2-Channel_Relay_module
 Actuadores lineales: http://www.trossenrobotics.com/linear-actuators.aspx
 Displays: https://www.sparkfun.com/categories/76
 Dimmer AC: http://miarduinounotieneunblog.blogspot.com.es/2016/03/control-del-brillo-
de-una-bombilla.html
 Motores: https://aprendiendoarduino.wordpress.com/2016/07/04/motores/

Práctica: Sensores y Actuadores

Smoothing: https://aprendiendoarduino.wordpress.com/2016/07/02/smoothing/

Sensor de Temperatura: https://aprendiendoarduino.wordpress.com/2016/07/02/sensor-de-

temperatura/

Display LCD: https://aprendiendoarduino.wordpress.com/2016/07/03/display-lcd/

Motores: https://aprendiendoarduino.wordpress.com/2016/09/16/uso-de-motores-2/
Anuncios
REPORT THIS AD

REPORT THIS AD

Compártelo:

 Twitter
 Facebook1
 Google

Relacionado
Sensores y ActuadoresEn "Actuadores"
Tema 3 – Conceptos básicos de microcontroladores y electrónica (4)En "Arduino"
Componentes ElectrónicosEn "Arduino"
Esta entrada se publicó en Arduino, Electronica, Hardware, Motores, Pantalla LCD, Periféricos, Sensoresy
está etiquetada con Actuadores, Arduino, Periféricos, Sensores en 6 noviembre, 2016.

Comunicación Serie Arduino

Deja un comentario

La comunicación serie es muy importante porque casi todos los protocolos utilizados
actualmente son serie y además muchos dispositivos de comunicación inalámbrica usan la
comunicación serie para hablar con Arduino como los módulos bluetooth y los módulos Xbee.
También la comunicación serie es la que se usa generalmente para comunicar el Arduino con
el Ordenador.

Para manejar el puerto serie en Arduino, disponemos de la librería

Serial http://arduino.cc/en/Reference/Serial que hereda los métodos de la librería
Stream https://www.arduino.cc/en/Reference/Stream

Todas las placas Arduino tienen al menos un puerto serie disponible en los pines digitales 0
(RX) y 1 (TX) compartido con el USB. El Arduino mega dispone de tres puertos adicionales
Serial1 on pins 19 (RX) and 18 (TX), Serial2 on pins 17 (RX) and 16 (TX), Serial3 on pins 15
(RX) and 14 (TX). Estos pines no están conectados al interfaz USB del Arduino.

El Arduino Due tiene tres puertos adicionales y todos los puestos serie tienen niveles de 3.3V
TTL.

Métodos más importantes de la librería Serial:

 begin() – estable la velocidad de la UART en baudios para la transmisión serie,

también es posible configurar el número de bits de datos, la paridad y los bits de stop,
por defecto es 8 bits de datos, sin paridad y un bit de
stop. https://www.arduino.cc/en/Serial/Begin
 read() – lee el primer byte entrante del buffer
serie. https://www.arduino.cc/en/Serial/Read
 write() – escribe datos en binario sobre el puerto serie. El dato es enviado como un
byte o serie de bytes.
 print() – imprime datos al puerto serie como texto ASCII, también permite imprimir en
otros formatos. https://www.arduino.cc/en/Serial/Print
 available() – da el número de bytes (caracteres) disponibles para leer en el puerto
serie, son datos que han llegado y se almacenan en el buffer serie que tiene un
tamaño de 64 bytes. https://www.arduino.cc/en/Serial/Available
 find() – lee datos del buffer serie hasta encontrar el string
buscado. https://www.arduino.cc/en/Serial/Find
 parseInt() – busca el siguiente entero válido en el stream de datos del puerto
serie. https://www.arduino.cc/en/Serial/ParseInt
 readBytes() – lee datos del buffer serie y lo guarda en una variable
buffer. https://www.arduino.cc/en/Serial/ReadBytes
 setTimeout() – configura el máximo de milisegundos de espera para la lectura del
puerto serie. Por defecto es un segundo. https://www.arduino.cc/en/Serial/SetTimeout
  readString() – lee caracteres del buffer serie y los guarda en un string. La función
termina cuando se produce un timeout. https://www.arduino.cc/en/Serial/ReadString

Resto de funciones disponible para usar con el puerto serie y ejemplos de uso pueden verse
en: https://www.arduino.cc/en/Reference/Seria

Buffer Serial: los puertos serie de los microcontroladores tienen un buffer que se va llenando
hasta que nosotros lo vamos leyendo con la función read() que lo vamos vaciando, es una pila
FIFO. El tamaño del buffer serie en el Arduino Uno es de 64 bytes, cuando se llena ese buffer
el resto de elementos recibidos se pierden.

Toda la información del puerto seríe del microcontrolador del arduino UNO la tenemos en la
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

Software Serial

Cada microcontrolador tiene un número de puertos serie hardware (UART), pero se ha

desarrollado la librería SoftwareSerial para permitir la comunicación serie sobre otros pines
digitales de Arduino, usando software para replicar las funcionalidades de la comunicación
serie. Es posible tener varios puertos software serial con velocidades de hasta 115200 bps.

Reference de la librería Software Serial, limitaciones y ejemplos

en: http://arduino.cc/en/Reference/SoftwareSerial

Práctica: Puerto Serie

Hacer esta práctica de un chat por el puerto serie entre dos ordenadores usando dos
Arduinos: https://aprendiendoarduino.wordpress.com/2016/07/02/chat-serie/

Práctica: Menú interactivo con Arduino.

Para unir todo lo visto en una práctica, hacer un ejemplo de un menú interactivo donde se dan
varias opciones y pulsando cada una de ellas se ejecuta una acción concreta. Si el valor
pulsado no es ninguna de las opciones avisar y volver a mostrar el menú hasta que se pulse
una opción correcta.

Solución: https://github.com/jecrespo/Aprendiendo-Arduino/tree/master/Ejercicio46-
Estructuras_de_Control

Modificar el programa para que haga la pregunta de forma continua.

Anuncios
REPORT THIS AD

REPORT THIS AD

Compártelo:

 Twitter
 Facebook3
 Google

Cargando...
Relacionado
Comunicación Serie ArduinoEn "Arduino"
Comunicación Serie ArduinoEn "Arduino"
Chat SerieEn "Arduino"
Esta entrada se publicó en Arduino, Comunicación Serie, Estructuras de decisión, Estructuras de
repetición, Programación, Puerto Serie y está etiquetada con Arduino, Comunicación
Serie, Programación, Puerto Serie en 6 noviembre, 2016.

Comunicaciones IP
Deja un comentario

Capas OSI

Según la clasificación OSI, la comunicación de varios dispositivos se puede estudiar

dividiéndola en 7 niveles, que son expuestos desde su nivel más alto hasta el más bajo:

Nivel Nombre Categoría

Capa 7 Nivel de aplicación

Capa 6 Nivel de presentación

Capa 5 Nivel de sesión

Capa 4 Nivel de transporte Aplicación

Capa 3 Nivel de red

Capa 2 Nivel de enlace de datos

Capa 1 Nivel físico Transporte de datos

Protocolo TCP/IP

El modelo TCP/IP describe un conjunto de guías generales de diseño e implementación de

protocolos de red específicos para permitir que un equipo pueda comunicarse en una red.
TCP/IP provee conectividad de extremo a extremo especificando como los datos deberían ser
formateados, direccionados, transmitidos, enrutados y recibidos por el destinatario.

La importancia del modelo TCP/IP es que es el modelo usado para acceder a Internet o a
redes internas (Intranet) de ordenadores. Arduino va a permitir conectarse a Internet o a una
red interna mediante TCP/IP y poder realizar múltiples operaciones o usarse como pasarela
para conectar a Internet dispositivos que no tienen esa capacidad. La implementación de la
pila de protocolos de TCP/IP en Arduino se hace mediante un shield o HW adicional que nos
da la capa de acceso a red (ethernet o WiFi), internet (IP) y transporte. La capa de aplicación
deberemos implementarla dentro de Arduino ya sea directamente o mediante una librería.

En el caso del protocolo TCP/IP la pila OSI se simplifica:

Capa de Invoca programas que acceden servicios en la red. Interactúan con uno o más protocolos de transporte para

Aplicación. enviar o recibir datos, en forma de mensajes o bien en forma de flujos de bytes.

Provee comunicación extremo a extremo desde un programa de aplicación a otro. Regula el flujo de

información. Puede proveer un transporte confiable asegurándose que los datos lleguen sin errores y en la

secuencia correcta. Coordina a múltiples aplicaciones que se encuentren interactuando con la red

simultáneamente de tal manera que los datos que envíe una aplicación sean recibidos correctamente por la

Capa de aplicación remota, esto lo hace añadiendo identificadores de cada una de las aplicaciones. Realiza además

Transporte. una verificación por suma, para asegurar que la información no sufrió alteraciones durante su transmisión.
 Controla la comunicación entre un equipo y otro, decide qué rutas deben seguir los paquetes de información

para alcanzar su destino. Conforma los paquetes IP que será enviados por la capa inferior. Desencapsula los

Capa Internet. paquetes recibidos pasando a la capa superior la información dirigida a una aplicación.

Capa de

Interfaz de Emite al medio físico los flujos de bit y recibe los que de él provienen. Consiste en los manejadores de los

Red. dispositivos que se conectan al medio de transmisión.

Más información en: http://www.uca.edu.sv/investigacion/tutoriales/tcp-ip.html

Conexión y desconexión TCP/IP

El proceso de establecimiento de una conexión TCP se denomina “three way handshake”

Durante el establecimiento de la conexión, se configuran algunos parámetros tales como el
número de secuencia con el fin de asegurar la entrega ordenada de los datos y la robustez de
la comunicación.

Aunque es posible que un par de entidades finales comiencen una conexión entre ellas
simultáneamente, normalmente una de ellas abre un socket en un determinado puerto TCP y
se queda a la escucha de nuevas conexiones. Es común referirse a esto como apertura
pasiva, y determina el lado servidor de una conexión. El lado cliente de una conexión realiza
una apertura activa de un puerto enviando un paquete SYN inicial al servidor como parte de la
negociación en tres pasos. En el lado del servidor (este receptor también puede ser una PC o
alguna estación terminal) se comprueba si el puerto está abierto, es decir, si existe algún
proceso escuchando en ese puerto, pues se debe verificar que el dispositivo de destino tenga
este servicio activo y esté aceptando peticiones en el número de puerto que el cliente intenta
usar para la sesión. En caso de no estarlo, se envía al cliente un paquete de respuesta con el
bit RST activado, lo que significa el rechazo del intento de conexión. En caso de que sí se
encuentre abierto el puerto, el lado servidor respondería a la petición SYN válida con un
paquete SYN/ACK. Finalmente, el cliente debería responderle al servidor con un ACK,
completando así la negociación en tres pasos (SYN, SYN/ACK y ACK) y la fase de
establecimiento de conexión. Es interesante notar que existe un número de secuencia
generado por cada lado, ayudando de este modo a que no se puedan establecer conexiones
falseadas (spoofing).

Más información:

 http://www.tcpipguide.com/free/t_TCPConnectionEstablishmentProcessTheThreeWay
Handsh-3.htm
 https://lwn.net/Articles/508865/

La fase de finalización de la conexión utiliza una negociación en cuatro pasos (four-way

handshake), terminando la conexión desde cada lado independientemente. Sin embargo, es
posible realizar la finalización de la conexión en 3 fases; enviando el segmento FIN y el ACK
en uno solo. Cuando uno de los dos extremos de la conexión desea parar su “mitad” de
conexión transmite un segmento con el flag FIN en 1, que el otro interlocutor asentirá con un
ACK. Por tanto, una desconexión típica requiere un par de segmentos FIN y ACK desde cada
lado de la conexión.

Una conexión puede estar “medio abierta” en el caso de que uno de los lados la finalice pero
el otro no. El lado que ha dado por finalizada la conexión no puede enviar más datos pero la
otra parte si podrá.

Es importante conocer este apartado porque a pesar que esta negociación la hace el shield de
Ethernet o Wifi y no se programa en Arduino, sirve para saber qué está pasando cuando
Arduino actúa como cliente o servidor y poder hacer depuración cuando tenemos errores.

Librería Ethernet

La librería Ethernet es la usada para manejar el Ethernet Shield que implementa la pila de
protocolos TCP/IP y dentro de Arduino se implementan los protocolos en la capa de
aplicación. La librería se usa entre otras cosas para mandar por Ethernet el protocolo
programado en Arduino.

Para manejar el Ethernet Shield deberemos conocer todos los métodos que nos ofrece la
librería Ethernet y así poder usarla.

Reference de librería Ethernet: http://arduino.cc/en/Reference/Ethernet

La librería ethernet se compone de 5 clases, cada una con sus métodos

Ethernet Class

Inicializa la librería ethernet y las configuraciones de red.

 begin() – Inicializa la librería Ethernet (Constructor)

 localIP() – Obtiene la dirección IP. Útil al usar DHCP
 maintain() – Solicita una renovación al servidor DHCP
IPAddress Class

Trabaja con IPs locales y remotas. Facilita el trabajo con direcciones IPs.

 IPAddress() – Define una dirección IP

Server Class

Crea un servidor que puede mandar y recibir datos de los clientes conectados.

 Server() – Constructor de la clase server. No se usa directamente

 EthernetServer() – Crea un servidor que escucha por las conexiones entrantes del
puerto definido.
 begin() – Le dice al servidor que comience a escuchar.
 available() – Devuelve el cliente que está conectado al servidor y tiene datos
disponibles a leer.
 write() – Escribe datos a todos los cliente conectados al servidor.
 print() – Escribe datos a todos los cliente conectados al servidor.
 println() – Escribe datos a todos los cliente conectados al servidor seguido de una
nueva línea.

Client Class

Crea un cliente que se conecta a un servidor y puede mandar y recibir datos.

 Client – Constructor de la clase client. No se usa directamente

 EthernetClient() – Crea un cliente que se conecta a una determinada IP y puerto
 if (EthernetClient) – Indica si el cliente Ethernet está preparado
 connected() – Devuelve si el cliente está o no conectado
 connect() – Conecta a una IP y puerto especificado. Soporta DNS lookup. Devuelve
unos códigos en función del éxito o fallo de la conexión.
 write() – Escribe datos al servidor al que está conectado.
 print() – Escribe datos al servidor al que está conectado
 println() – Escribe datos al servidor al que está conectado, seguido de una nueva línea
 available() – Devuelve el número de bytes disponibles para leer.
 read() – Lee el siguiente byte recibido desde el servidor.
 flush() – Borrar todos los bytes que han sido escritos en el cliente pero no leidos
 stop() – Desconecta el cliente del servidor

Arduino nos ofrece varios ejemplo para comprender el uso de la librería:

 ChatServer: set up a simple chat server.

 WebClient: make a HTTP request.
 WebClientRepeating: Make repeated HTTP requests.
 WebServer: host a simple HTML page that displays analog sensor values.
 BarometricPressureWebServer: outputs the values from a barometric pressure sensor
as a web page.
 UDPSendReceiveString: Send and receive text strings via UDP.
 UdpNtpClient: Query a Network Time Protocol (NTP) server using UDP.
 DnsWebClient: DNS and DHCP-based Web client.
 DhcpChatServer: A simple DHCP Chat Server
  DhcpAddressPrinter: Get an IP address via DHCP and print it out
 TelnetClient: A simple Telnet client

Protocolo HTTP

Hypertext Transfer Protocol o HTTP (en español protocolo de transferencia de hipertexto) es el

protocolo de comunicación que permite las transferencias de información en la WWW. Se trata
de un protocolo de capa 7 de aplicación.

En arduino con la librería ethernet solo trabajamos con la capa de aplicación, todas las otras
capas de TCP/IP ya están implementadas por Hardware, ya sea con la ethernet shield o el
módulo WiFi. Aunque si queremos realizar algunas funciones de capas inferiores, podemos
hacerlo con los comandos adecuados comunicándonos con el chip ethernet o wifi via SPI.

HTTP define la sintaxis y la semántica que utilizan los elementos de software de la

arquitectura web (clientes, servidores, proxies) para comunicarse. Es un protocolo orientado a
transacciones y sigue el esquema petición-respuesta entre un cliente y un servidor. Al cliente
que efectúa la petición (un navegador web) se lo conoce como “user agent” (agente del
usuario). A la información transmitida se la llama recurso y se la identifica mediante un
localizador uniforme de recursos (URL).

HTTP es un protocolo sin estado, es decir, que no guarda ninguna información sobre
conexiones anteriores. El desarrollo de aplicaciones web necesita frecuentemente mantener
estado. Para esto se usan las cookies, que es información que un servidor puede almacenar
en el sistema cliente. Esto le permite a las aplicaciones web instituir la noción de “sesión”, y
también permite rastrear usuarios ya que las cookies pueden guardarse en el cliente por
tiempo indeterminado.

Una transacción HTTP está formada por un encabezado seguido, opcionalmente, por una
línea en blanco y algún dato. El encabezado especificará cosas como la acción requerida del
servidor, o el tipo de dato retornado, o el código de estado. El uso de campos de encabezados
enviados en las transacciones HTTP le dan gran flexibilidad al protocolo. Estos campos
permiten que se envíe información descriptiva en la transacción, permitiendo así la
autenticación, cifrado e identificación de usuario. Ejemplos de encabezados: HTTP_ACCEPT
y HTTP_USER_AGENT.
Líneas de encabezado o headers, son muy importantes y dan información adicional de la
conexión y el comportamiento puede cambiar en función de ellas:

 http://trevinca.ei.uvigo.es/~txapi/espanol/proyecto/superior/memoria/node51.html
 http://powercps.readthedocs.io/zh_CN/latest/sdk/http-headers.en/

Métodos de petición HTTP

Lo más importante para comunicar arduino por HTTP con otros dispositivos, ya sean
servidores, ordenadores, otros Arduinos, etc… es conocer los métodos GET y POST del
protocolo HTTP. HTTP define 8 métodos que indica la acción que desea que se efectúe sobre
el recurso identificado. Lo que este recurso representa, si los datos pre-existentes o datos que
se generan de forma dinámica, depende de la aplicación del servidor. A menudo, el recurso
corresponde a un archivo o la salida de un ejecutable que residen en el servidor.

GET

GET: Pide una representación del recurso especificado. Por seguridad no debería ser usado
por aplicaciones que causen efectos ya que transmite información a través de la URI
agregando parámetros a la URL. La petición puede ser simple, es decir en una línea o
compuesta de la manera que muestra el ejemplo.

Ejemplo:

GET /images/logo.png HTTP/1.1 obtiene un recurso llamado logo.png

Ejemplo con parámetros:

/index.php?page=main&lang=es

POST

POST: Envía los datos para que sean procesados por el recurso identificado. Los datos se
incluirán en el cuerpo de la petición. Esto puede resultar en la creación de un nuevo recurso o
de las actualizaciones de los recursos existentes o ambas cosas.

Más información:

 http://www.w3schools.com/tags/ref_httpmethods.asp
 http://en.wikipedia.org/wiki/Hypertext_Transfer_Protocol
 http://en.wikipedia.org/wiki/POST_(HTTP)

Entender los métodos get y post:

 http://blog.micayael.com/2011/02/09/metodos-get-vs-post-del-http/

Un explicación muy buena de HTTP también se puede encontrar

en: http://www.ntu.edu.sg/home/ehchua/programming/webprogramming/HTTP_Basics.html

HTTP request

Un cliente HTTP debe formar una petición HTTP al servidor de una forma determinada para
que sea entendida por el servidor. Cuando Arduino trabaja como cliente hay que programar
esta petición correctamente.

Formación de un HTTP request, esta petición habrá que programar en Arduino:

 http://www.w3.org/Protocols/rfc2616/rfc2616-sec5.html
 https://tools.ietf.org/html/rfc2616#section-9.5
Trama en HTTP, fijaros en el uso de cr (retorno de carro – carriage return – ASCII 13) y lf (line
feed – nueva linea – ASCII
10): http://www1.ju.edu.jo/ecourse/abusufah/cpe532_Spr06/notes/BookOnLine/HTTP%20Requ
est%20Message.htm

HTTP/1.1 se definió en el estándar RFC2616,que es la más usada actualmente. En junio de

2014 RFC2616 se retiró y HTTP/1.1 se redefinió en RFCs 7230, 7231, 7232, 7233, 7234, and
7235, HTTP/2 está en proceso de definición.

 https://tools.ietf.org/html/rfc2616 (ver página 35)

 https://tools.ietf.org/html/rfc7230 (ver página 19)

Y cuando usar GET o POST?: http://www.w3.org/2001/tag/doc/whenToUseGet.html#checklist

HTTP response

Después de recibir e interpretar el servidor un HTTP request, el servidor debe responder con
un mensaje de respuesta:

 http://es.wikipedia.org/wiki/Hypertext_Transfer_Protocol#C.C3.B3digos_de_respuesta
 http://www.w3.org/Protocols/rfc2616/rfc2616-sec6.html
 http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html
Para cumplir con el protocolo HTTP, arduino debe implementar estas respuestas cuando lo
uso como servidor web.

Veamos esto gráficamente:

Práctica: Comunicaciones IP

Ver diferencia de configuración en Arduino entre DHCP e IP fija:

 https://github.com/jecrespo/Aprendiendo-Arduino/tree/master/Otros/DHCP_Arduino
 https://github.com/jecrespo/Aprendiendo-Arduino/tree/master/Otros/IP_fija_Arduino

Realizar las prácticas de Arduino Web

Client: https://aprendiendoarduino.wordpress.com/2016/07/05/arduino-web-client/

Realizar las prácticas de Arduino Web

Server: https://aprendiendoarduino.wordpress.com/2016/07/06/arduino-web-server/
Anuncios
REPORT THIS AD
 REPORT THIS AD

Compártelo:

 Twitter
 Facebook4
 Google

Relacionado
TCP/IPEn "Arduino"
Protocolos IoT Capa AplicaciónEn "CoAP"
Conceptos básicos de comunicacionesEn "Arduino"
Esta entrada se publicó en Arduino, Comunicación, Ethernet, Ethernet Shield, HTTP, TCP/IP y está
etiquetada con Arduino, Ethernet, HTTP, Librería Ethernet, TCP/IP en 6 noviembre, 2016.

Elementos HW del curso

2 respuestas

Conocer el HW que vamos a usar en el curso. Cada alumno tiene su propio kit con el número
de kit. Recordad este número porque se usará durante las prácticas.

Arduino UNO

Arduino UNO: https://www.arduino.cc/en/Main/ArduinoBoardUno

Arduino Ethernet Shield

Ethernet Shield: https://www.arduino.cc/en/Main/ArduinoEthernetShield

Arduino Starter Kit
Documentación Arduino Starter Kit: http://arduino.cc/en/Main/ArduinoStarterKit

Componentes:

 1 Arduino / Genuino Uno

 1 USB cable
 1 Breadboard 400 points
 70 Solid core jumper wires
 1 Easy-to-assemble wooden base,
 1 9v battery snap
 1 Stranded jumper wires (black)
 1 Stranded jumper wires (red)
 6 Photoresistor [VT90N2 LDR]
 3 Potentiometer 10kOhms y potentiometer
 10 Pushbuttons
 1 Temperature sensor [TMP36]
 1 Tilt sensor
 1 alphanumeric LCD (16×2 characters)
 1 LED (bright white)
 1 LED (RGB)
 8 LEDs (red)
 8 LEDs (green)
 8 LEDs (yellow)
 3 LEDs (blue)
 1 Small DC motor 6/9V
 1 Small servo motor
 1 Piezo capsule [PKM17EPP-4001-B0] y piezo
 1 H-bridge motor driver [L293D]
 1 Optocouplers [4N35]
  2 Mosfet transistors [IRF520]
 5 Capacitors 100uF
 5 Diodes [1N4007]
 3 Transparent gels (red, green, blue)
 1 Male pins strip (40×1)
 20 Resistors 220 Ohms
 5 Resistors 560 Ohms
 5 Resistors 1 kOhms
 5 Resistors 4.7 kOhms
 20 Resistors 10 kOhms
 5 Resistors 1 MOhms
 5 Resistors 10 MOhms

Actualmente hay un Arduino Basic Kit https://www.arduino.cc/en/Main/ArduinoBasicKit que da

acceso a project ignite https://projectignite.autodesk.com/shop/product/arduino-basic-
kit/?pageTitle=Shop

Con este kit hay 15 proyectos muy interesantes propuestos:

 GET TO KNOW YOUR TOOLS an introduction to the basics

 SPACESHIP INTERFACE design the control panel for your starship
 LOVE-O-METER measure how hot-blooded you are
 COLOR MIXING LAMP produce any color with a lamp that uses light as an input
 MOOD CUE clue people in to how you’re doing
 LIGHT THEREMIN create a musical instrument you play by waving your hands
 KEYBOARD INSTRUMENT play music and make some noise with this keyboard
 DIGITAL HOURGLASS a light-up hourglass that can stop you from working too much
 MOTORIZED PINWHEEL a colored wheel that will make your head spin
 ZOETROPE create a mechanical animation you can play forward or reverse
 CRYSTAL BALL a mystical tour to answer all your tough questions
 KNOCK LOCK tap out the secret code to open the door
 TOUCHY-FEEL LAMP a lamp that responds to your touch
 TWEAK THE ARDUINO LOGO control your personal computer from your Arduino
 HACKING BUTTONS create a master control for all your devices!

En esta lista de youtube hay varios video tutoriales de los proyecto propuestos por el Arduino
Starter Kit: https://www.youtube.com/playlist?list=PLT6rF_I5kknPf2qlVFlvH47qHvqvzkknd

Otros módulos

 Módulo Ultra low power 2.4GHz RF

nRF24L01+: https://www.seeedstudio.com/item_detail.html?p_id=1394
 Datasheet: http://www.seeedstudio.com/document/pdf/DS_nRF24L01.pdf
 Módulo Wifi ESP8266: https://www.seeedstudio.com/WiFi-Serial-Transceiver-Module-
w%26-ESP8266-1MB-Flash-p-2485.html
 Datasheet: http://bbs.espressif.com/viewtopic.php?f=21&t=225
 Módulo: http://espressif.com/sites/default/files/documentation/esp-wroom-
s2_datasheet_en.pdf
 Módulo IMU MPU6050: http://www.miniinthebox.com/es/la-ultima-mpu-6050-modulo-
6000-de-6-ejes-giroscopio-acelerometro_p4348915.html
 Datasheet: https://www.invensense.com/wp-content/uploads/2015/02/MPU-6000-
Datasheet1.pdf
  Programador
FTDI: http://www.tinyosshop.com/index.php?route=product/product&product_id=600
 Módulo bluetooth HC-05: http://www.prometec.net/producto/modulo-bluetooth-hc-05/
 Especificaciones: http://biblioteca.geekfactory.mx/Bluetooth_Bee_Pro/datasheet_hc-
05.pdf
 Kit XBee: http://www.digikey.es/product-detail/en/digi-international/XKB2-AT-
WWG/602-1550-ND/5271212
 Datasheet: http://media.digikey.com/pdf/Data%20Sheets/Digi%20International%20PDF
s/XBee_Arduino_Compatible_Coding_Platform.pdf

Cómo leer un datasheet: http://rufianenlared.com/como-leer-datasheet/

Ejercicio: Medir valor de un Condensador

Ver: https://www.arduino.cc/en/Tutorial/CapacitanceMeter

Esquema de conexión:
¡ATENCIÓN! Poner un condensador de 100uF y asegurarse de poner correctamente la
polaridad. Símbolo – (patilla corta) a masa.

La resistencia R tiene un valor de 10Kohms

Explicación del sketch:

 Configurar el pin de descarga a INPUT (alta impedancia de modo que no pueda

descargar el condensador). Pin 11.
 Registre el tiempo de inicio con millis ()
 Establecer el pin de carga en OUTPUT y ponerlo a HIGH. Pin 13.
 Compruebe la tensión repetidamente en un bucle hasta que llegue a 63.2% de la
tensión total.
 Después de cargar, restar el tiempo actual de la hora de inicio para averiguar cuánto
tiempo le costó al condensador para cargar.
 Dividir el Tiempo en segundos por la resistencia de carga en ohmios para encontrar la
Capacitancia.
 Imprimir por serial el valor con serial.print
 Descargue el condensador. Para hacer esto:
  Establezca el pin de carga en la entrada
 Configurar el de descarga en OUTPUT y haga que sea LOW
 Leer el voltaje para asegurarse de que el condensador está completamente
descargado
 Loop y hacerlo de nuevo

Para asegurarse que el condensador está descargado, asegurarse de quitar alimentación

cuando lo indique el sketch por pantalla.

Solución: https://github.com/jecrespo/Aprendiendo-Arduino/tree/master/Ejercicio57-
Medidor_Condensadores
Anuncios
REPORT THIS AD

REPORT THIS AD

Compártelo:

 Twitter
 Facebook1
 Google

Relacionado
Material Curso IoTEn "Arduino"
Kit de PrácticasEn "Arduino"
Saber Más...En "Arduino"
Esta entrada se publicó en Arduino, Ethernet Shield, Hardware, Práctica y está etiquetada
con Arduino, ESP8266, Ethernet Shield, FTDI, IMU, Práctica, Xbee en 6 noviembre, 2016.

Microcontrolador vs Microprocesador
1 respuesta

Diferencia principal entre un microcontrolador (Arduino) y un microprocesador (Raspberry Pi)

son las capacidades de entradas y salidas, así como el rendimiento de la CPU.

Analogía: Arduino es un Autómata programable, Raspberry Pi es un Ordenador, así que a la

hora de decidirse que utilizar para un proyecto pensar que usaríamos un autómata o un
Ordenador.

Un resumen de como funciona una MCU y como agregar un

programa: http://www.electronicaestudio.com/microcontrolador.htm que es diferente a como
funciona un microprocesador como los que tenemos en nuestro ordenador o portatil.

Para programación en tiempo real el HW a utilizar es el Arduino, para programación intensiva

con gran cantidad de datos usaríamos una Raspberry Pi o un PC.

En un proyecto grande la elección es usar ambos, cada uno en la tarea que mejor hace. Por
ejemplo, la recolección de datos, supervisión del entorno, envío de alarmas, accionar motores,
etc.. lo dejaremos para el arduino, el tratamiento de los datos recogidos, el interfaz gráfico de
usuario, envío de correos, etc… lo dejaremos para un ordenador o una raspberry pi o similar.

Diferencias entre el microprocesador y el microcontrolador, características al usarlos en la

implementación de sistemas digitales programables:

 CPU
 Memorias RAM y ROM
 Velocidad de Operación
 Tamaño
 Costes
 Interferencias (ruido)
 Tiempo de desarrollo

El uso de una u otra tecnología depende del fin que se espera, pues debido a sus
características propias, los microcontroladores y los microprocesadores pueden adquirir
variados y diferentes espacios de implementación, por ejemplo, los microprocesadores se han
desarrollado fundamentalmente orientados al mercado de los ordenadores personales y las
estaciones de trabajo, pues allí se requiere una elevada potencia de cálculo, el manejo de
gran cantidad de memoria y una gran velocidad de procesamiento. Mientras que los
microcontroladores están concebidos fundamentalmente para ser utilizados en aplicaciones
puntuales, es decir, aplicaciones donde el microcontrolador debe realizar un pequeño número
de tareas, al menor costo posible. En estas aplicaciones el microcontrolador ejecuta un
programa almacenado permanentemente en su memoria, el cual trabaja con algunos datos
almacenados temporalmente e interactúa con el exterior a través de las líneas de entrada y
salida de que dispone.

Microprocesadores Microcontroladores

El microprocesador tiene mucha más potencia de

cálculo, por lo cual solamente realiza sus funciones

con lo que tiene (datos) y su algoritmo o programa Es una de sus partes principales, la cual se encarga de

CPU establecida. dirigir sus operaciones.

Memorias Son dispositivos externos que lo complementan

RAM y ROM para su óptimo funcionamiento. Las incluye en un solo circuito integrado.

Velocidad de

Operación Rápida Lenta en comparación con la de un microprocesador

 La configuración mínima básica de un

Microprocesador está constituida por un El Microcontrolador incluye todo estos elementos en

Microprocesador, una memoria RAM, una un solo Circuito Integrado por lo que implica una gran

memoria ROM, un decodificador de direcciones, lo ventaja en varios factores, como por ejemplo, la

cual lo convierte en un circuito bastante disminución en el tamaño del circuito impreso por la

Tamaño engorroso. reducción de los circuitos externos.

Para el Microprocesador, el costo es muy alto en la El costo para un sistema basado en Microcontrolador

Costos actualidad. es mucho menor.

Son más susceptibles a la interferencia

electromagnética debido a su tamaño y a su

cableado externo que lo hace más propenso al El alto nivel de integración reduce los niveles de

Interferencias ruido. interferencia electromagnética

Tiempo de El tiempo de desarrollo de un microprocesador es

desarrollo lento. Por el contrario, el de un microcontrolador es rápido.

Un buen curso sobre microcontroladores es accesible

desde http://www.itescam.edu.mx/portal/asignatura.php?clave_asig=MTF-
1021&carrera=IMCT-2010-229&id_d=206. Se trata de una asignatura de
microcontroladores.

Más información sobre

microcontroladores: https://sites.google.com/site/electronicscience20/Micro/pic-asembler/2-
microcontroladores

Raspberry Pi es un ordenador de placa reducida o (placa única) (SBC) de bajo coste,

desarrollado en Reino Unido por la Fundación Raspberry Pi. El diseño incluye un System-on-
a-chip Broadcom BCM2835, que contiene un procesador central (CPU) ARM1176JZF-S a 700
MHz, un procesador gráfico (GPU) VideoCore IV, y 512 MiB de memoria RAM.

Los sistemas operativos soportados son distribuciones Linux para arquitectura ARM, Raspbian
(derivada de Debian), RISC OS 5, Arch Linux ARM (derivado de Arch Linux) y Pidora
(derivado de Fedora)

Web principal: http://www.raspberrypi.org/

Especificaciones
técnicas: http://es.wikipedia.org/wiki/Raspberry_Pi#Especificaciones_t.C3.A9cnicas

El System-on-a-chip Broadcom BCM2835: http://www.raspberrypi.org/wp-

content/uploads/2012/02/BCM2835-ARM-Peripherals.pdf

GPIO:
También intel saca su alternativa a raspberry: http://www.intel.es/content/www/es/es/do-it-
yourself/edison.html

Más información: https://aprendiendoarduino.wordpress.com/2016/06/25/arduino-vs-raspberry-

pi-2/

Un sketch de Arduino no es un sistema

operativo: https://es.wikipedia.org/wiki/Sistema_operativo. Un sistema operativo es un
programa o conjunto de programas de un sistema informático que gestiona los recursos de
hardware y provee servicios a los programas de aplicación de software, ejecutándose en
modo privilegiado respecto de los restantes (aunque puede que parte de él se ejecute en
espacio de usuario)
Se puede decir que el sketch de Arduino es la aplicación que gestiona directamente los
recursos de HW sin necesidad de un SO o un kernel intermedio.

En el caso de raspberry Pi, el programa o sketch se ejecuta como una aplicación sobre un
sistema operativo y para interaccionar con el HW necesita de la interacción con el sistema
operativo.

Para entender qué es el microcontrolador dentro de Arduino,

leer: https://aprendiendoarduino.wordpress.com/2015/02/25/como-conseguir-un-arduino-gratis/

¿Podría convertir un arduino en un ordenador? ¿Cómo? ¿Es práctico?. Arduino como un

ordenador:

 Salida TV:
 https://code.google.com/p/arduino-tvout/
  http://playground.arduino.cc/Main/TVout
 https://code.google.com/archive/p/arduino-tvout/wikis/FunctionalDescription.wiki
 http://www.instructables.com/id/TV-Out-with-Arduino/
 Pantalla tactil: http://tienda.bricogeek.com/shields-arduino/521-arduino-tft-touch-shield-
v20.html
 Teclado: http://playground.arduino.cc/code/Keypad,http://abedulengenharia.blogspot.c
om.es/2011/07/arduino-y-teclado-3×4.html
 Separar los procesos en diferentes MCUs, mejor con chips específicos, pero se puede
hacer usando varios microcontroladores, uno ejecuta el SO, otros acceso a disco
(controladora), otro muestra datos por pantalla (tarjeta gráfica), tarjeta de sonido, etc…
 Disco Duro, leer y escribir ficheros. Acceso a una tarjeta SD. El sketch compilado se
podría guardar en una tarjeta SD y un bootloader adecuado podría leer de la tarjeta
SD y cargarlo en la memoria de programa para ejecutarlo. Ver
ejemplo http://baldwisdom.com/bootdrive/
 Sistema Operativo: un sketch diseñado para interaccionar con el HW y poder correr
aplicaciones sobre el. Ver http://antipastohw.blogspot.com.es/2009/11/4-operating-
systems-for-arduino.html

También es posible convertir un ordenador en un

microcontrolador http://www.instructables.com/id/HackTurn-PC-into-a-microcontroller-for-
free/?ALLSTEPS

Microcontroladores 8 bits, 16 bits, 32 bits

El tamaño de la palabra es un aspecto importante en la arquitectura de procesadores.

La mayoría de los registros de un Microprocesador/Microcontrolador tienen el tamaño de la

palabra y las operaciones que hace la ALU es manejando operandos cuyo tamaño es el
tamaño de la palabra, así como la cantidad de datos transferidos a memoria y dirección
utilizada para designar una localización de memoria a menudo ocupa una palabra.

El tamaño de palabra de un microprocesador/microcontrolador influye principalmente en el

tamaño de datos que puede manejar y la cantidad de memoria RAM que puede usar, así
como la velocidad de procesamiento.

También los valores que pueden tomar las variables dependen del tamaño de la
palabra: http://es.wikipedia.org/wiki/Palabra_%28inform%C3%A1tica%29

Arduinos con procesadores de 8 bits:

 Arduino UNO: https://www.arduino.cc/en/Main/ArduinoBoardUno

 Genuino MICRO: https://www.arduino.cc/en/Main/ArduinoBoardMicro
 Genuino MEGA: https://www.arduino.cc/en/Main/ArduinoBoardMega2560

Arduinos con procesadores de 32 bits:

 Arduino Due: http://www.arduino.org/products/boards/4-arduino-boards/arduino-due

 Arduino 101: https://www.arduino.cc/en/Main/ArduinoBoard101
 Genuino ZERO: https://www.arduino.cc/en/Main/ArduinoBoardZero
 Genuino MKR1000: https://www.arduino.cc/en/Main/ArduinoMKR1000
 ADVERTISEMENT
Anuncios
REPORT THIS AD

REPORT THIS AD

Compártelo:

 Twitter
 Facebook1
 Google

Relacionado
Arduino vs Raspberry PiEn "Arduino"
Arduino vs Raspberry PiEn "Arduino"
Arduino vs Raspberry Pi.En "Arduino"
Esta entrada se publicó en Arduino, Hardware, Microcontrolador, microprocesador, Raspberry Pi y está
etiquetada con Arduino, Microcontroladores, Microprocesadores, Raspberry Pi en 6 noviembre, 2016.

HW Arduino a Fondo
1 respuesta

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.

 Pines digitales: http://www.arduino.cc/en/Tutorial/DigitalPins, pueden configurarse

como entrada (para leer, sensores) o como salida (para escribir, actuadores)
 Pines analógicos de entrada: https://www.arduino.cc/en/Tutorial/AnalogInputPins,
usan un conversor analógico/digital y sirven para leer sensores analógicos como
sondas de temperatura.
 Pines analógicos de salida (PWM): https://www.arduino.cc/en/Tutorial/PWM, la
mayoría de Arduino no tienen conversor digital/analógico y para tener salidas
analógicas se usa la técnica PWM. No todos los pines digitales soportan PWM.
 Puertos de comunicación: USB, serie, I2C y SPI

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:

 http://arduino.cc/en/Tutorial/Memory
 https://aprendiendoarduino.wordpress.com/2015/03/29/memoria-flash-sram-y-eeprom/
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:

 http://tallerarduino.com/2013/06/28/arduino-pinout-y-conexiones-basicas/
 https://learn.adafruit.com/arduino-tips-tricks-and-techniques/arduino-uno-faq

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

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:

 Pin Mapping: http://arduino.cc/en/Hacking/PinMapping168

 http://www.umsats.ca/wp-content/uploads/2013/02/Arduino_uno_Pinout.pdf
 http://pighixxx.com/atmega328v3_0.pdf
 http://pighixxx.com/unov3pdf.pdf
 Y más pinout de diversas placas, MCUs, etc… http://www.pighixxx.com/test/pinoutspg/

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:

 http://www.cadsoftusa.com/eagle-pcb-design-software/product-overview/
 Versión Freeware http://www.cadsoftusa.com/download-eagle/freeware/

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:

 ATmega2560 del Mega: http://www.atmel.com/devices/atmega2560.aspx

 ATmega32U4 del Leonardo: http://www.atmel.com/devices/atmega32u4.aspx
 ATSAMD21G18 del Zero: http://www.atmel.com/devices/ATSAMD21G18.aspx
 ATSAMW25 del MKR1000: http://www.atmel.com/devices/ATSAMW25.aspx
  Intel Curie del Arduino
101: http://www.intel.com/content/dam/support/us/en/documents/boardsandkits/curie/in
tel-curie-module-datasheet.pdf
 STM32F469BI del STAR-
OTTO: http://www.st.com/content/st_com/en/products/microcontrollers/stm32-32-bit-
arm-cortex-mcus/stm32f4-series/stm32f469-479/stm32f469bi.html

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:

 https://es.wikipedia.org/wiki/Arquitectura_ARM
 https://en.wikipedia.org/wiki/ARM_architecture
 https://en.wikipedia.org/wiki/ARM_Cortex-M

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

 http://learn.mikroe.com/ebooks/microcontroladorespicc/
 http://learn.mikroe.com/ebooks/piccprogramming/
 http://web.ing.puc.cl/~mtorrest/downloads/pic/tutorial_pic.pdf
 http://www.monografias.com/trabajos103/introduccion-microcontroladores/introduccion-
microcontroladores.shtml
 Manual PIC http://www.unioviedo.es/ate/alberto/manualPic.pdf

AVR vs PIC:

 http://hackaday.com/2016/06/28/avr-vs-pic-round-223-fight/
 https://hackaday.io/project/11796-avr-vs-pic-the-case-of-the-candle
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:

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

 ATmega328p: https://www.safaribooksonline.com/library/view/arduino-microcontroller-
processing/9781627052535/xhtml/appendixa.html
 ATmega2580: https://www.safaribooksonline.com/library/view/arduino-microcontroller-
processing/9781627052535/xhtml/appendixc.html

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

 http://courses.cs.washington.edu/courses/csep567/10wi/lectures/Lecture6.pdf
 http://www.instructables.com/id/Microcontroller-Register-Manipulation/?ALLSTEPS
 https://en.wikipedia.org/wiki/Special_function_register
 http://www.atmel.com/images/avr_3_04.pdf
 http://learn.mikroe.com/ebooks/microcontroladorespicc/chapter/principales-registros-
sfr/
 http://www.monografias.com/trabajos14/micros/micros.shtml
 http://www.unioviedo.es/ate/alberto/manualPic.pdf

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
Anuncios
REPORT THIS AD

REPORT THIS AD

Compártelo:

 Twitter
 Facebook2
 Google

Relacionado
Entradas y Salidas Analógicas Arduino. PWMEn "Arduino"
Descripción de HW ArduinoEn "Arduino"
Arduino Uno a fondo. Mapa de pinesEn "Arduino"
Esta entrada se publicó en Arduino, Hardware, Memoria, Microcontrolador y está etiquetada
con Arduino, esquemas eléctricos, Hardware, Microcontroladores, PCB, registros en 6 noviembre, 2016.

ICSP
9 respuestas

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:

 http://en.wikipedia.org/wiki/In-circuit_serial_programming
 http://allaboutee.com/2011/05/11/how-to-program-an-avr-microcontroller/

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 SPImediante 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/

PUBLICIDAD
Anuncios
REPORT THIS AD

REPORT THIS AD

Compártelo:

 Twitter
 Facebook14
 Google

Relacionado
Arduino.cc y Arduino.org. Los dos ArduinosEn "Arduino"
Cómo conseguir un “Arduino” GratisEn "Arduino"
Novedades en Arduino. Arduino.cc y Arduino.orgEn "Arduino"
Esta entrada se publicó en Arduino, Hardware, ICSP, Microcontrolador y está etiquetada
con Arduino, Hardware, ICSP, Microcontroladores en 6 noviembre, 2016.

Otros IDEs
Deja un comentario

La forma habitual de trabajar con Arduino es usar el propio entorno de programación de

Arduino, por su sencillez y facilidad de uso. Ya hemos visto anteriormente y con bastante
detalle como es el IDE de Arduino, como instalarlo y como configurarlo:

 https://aprendiendoarduino.wordpress.com/2016/06/26/entorno-de-programacion-2/
 https://aprendiendoarduino.wordpress.com/2016/06/26/instalacion-software-y-
configuracion/

Pero es posible que por unas razones u otras queramos usar otro IDE, para ello vamos a
plantear varias opciones.

Arduino Create

Además del IDE original, los creadores de Arduino están trabajando en un IDE on-line llamado
Arduino Create.

Es un IDE online que actualmente está accesible desde https://create.arduino.cc/.

Un IDE online te permite tener siempre la versión actualizada del propio IDE, librerías y cores
de las MCUs, así como guardar online los sketches en la nube.

Más información de Arduino Create:

 https://blog.arduino.cc/2015/05/05/sneak-peak-arduino-create/
 https://blog.arduino.cc/2015/12/02/the-next-steps-of-the-arduino-create-betatesting/

Para usarlo es necesario usar un agente e instalarlo en el ordenador. Código fuente del
agente: https://github.com/arduino/arduino-create-agent

Además el entorno de Arduino Create no solo tiene un IDE online, sino que también está
disponible el “Arduino Project Hub” https://create.arduino.cc/projecthub apoyado por la
plataforma https://www.hackster.io/ donde podemos encontrar proyectos de Arduino.

También en el entorno Arduino create hay una plataforma para

IoT https://create.arduino.cc/iot/ con una herramienta para conectar dispositivos a la nube
llamada Arduino Cloud https://create.arduino.cc/iot/ que aun está en beta.
Arduino Studio

Por su parte arduino.org también está trabajando en un rediseño desde cero del clásico IDE
llamado Arduino Studio.

Es un nuevo entorno de desarrollo open source, se encuentra en versión Alpha. Es totalmente

diferente al IDE original y creado desde cero. Está escrito en Javascript y basado en
Brackets: http://brackets.io/

 Descarga en: http://www.arduino.org/software#studio

 Guía de inicio: http://labs.arduino.org/Arduino+Studio+for+Windows
 Como usar Arduino Studio: http://labs.arduino.org/How+to+use+Arduino+Studio

De momento es una versión en prueba, pero habrá que seguir su evolución. Su filosofía es:
“Just one editor for all the environments”

 Más información en: http://labs.arduino.org/Arduino%20Studio

 Código fuente: https://github.com/arduino-org/ArduinoStudio

Esta imagen define la estrategia de arduino.org en cuanto a los IDEs:

Con la nueva unificación de arduino.org y arduino.cc, veremos si estos IDEs se unifican.

Herramientas de desarrollo e IDEs no oficiales

Notepad++

El IDE de arduino es muy sencillo y fácil de manejar, pero cuando los proyectos se hacen más
complejos, es posible que necesitemos algo más.

El IDE de Arduino no es el único entorno de trabajo ni posiblemente tampoco sea el mejor

aunque sea una herramienta muy buena.

Una herramienta de programación es notepad++ sencilla y alternativa al IDE de Arduino. Es

una herramienta muy interesante por los complementos que tiene.
Además podemos añadir al uso de notepad++ las herramientas avr-gcc y avrdude para
compilar y cargar el sketch en Arduino, e incluso el uso de makefiles.

Ejercicio: Instalacion de notepad++ y complementos

Pasos:

 Instalar notepad++
 Instalar los complementos: compare y narduino.
 Activar la opción de autocompletar.
 Ejecutar los programas de notepad++ con el IDE de Arduino.

Enlaces:

 Notepad++: http://notepad-plus-plus.org/
 Notepad++ Arduino plugin: http://sourceforge.net/projects/narduinoplugin/
 Tutorial paso a paso: http://stonez56.blogspot.com.es/2015/04/a-better-arduino-ide-
notepad.html
 Tutorial: http://sriramiyer.net/blog/2014/02/12/using-notepad-plus-plus-instead-of-the-
arduino-ide/

Sublime Text

Otra opción al Arduino (IDE) es el famoso editor Sublime Text.

Web oficial: https://www.sublimetext.com/

Uso de Sublime Text con Arduino: http://panamahitek.com/sublime-text-y-stino-una-opcion-

para-programar-en-arduino/

Si se usa sublime, hay un astyle formattter para C y

C++: https://github.com/timonwong/SublimeAStyleFormatter

Eclipse

Eclipse es uno de los IDE más utilizados y conocidos en el mundo y también podemos usarlo
para trabajar con Arduino, solo recomendado para usuarios avanzados.

Web oficial: https://eclipse.org/

Uso de eclipse:

 http://kig.re/2014/08/02/arduino-ide-alternatives.html
 http://www.instructables.com/id/How-to-get-started-with-Eclipse-and-AVR/?ALLSTEPS
 Instalación de avr-gcc y avr-dude http://www.instructables.com/id/How-to-get-started-
with-Eclipse-and-AVR/step4/Install-AVR-GCC-and-AVR-Dude/

Para más información: http://playground.arduino.cc/Code/Eclipse

Sloeber

Se trata de una versión de Eclipse paquetizada para usar con Arduino totalmente libre.

Web oficial: http://www.baeyens.it/eclipse/

Visual Micro

Visual Micro, es una extensión o plugin para microsoft Visual Studio y Atmel Studio

 Web: http://www.visualmicro.com/
 Como usarlo: http://playground.arduino.cc/Code/VisualMicro
 Tutorial: http://rduinostar.com/noticias/programar-arduino-en-visual-studio/
 Arduino para Visual Studio 2015: https://www.unocero.com/2015/09/01/arduino-para-
visual-studio-2015/
 http://www.visualmicro.com/post/2015/10/06/Three-new-useful-things-in-Visual-Studio-
2015.aspx
 https://www.unocero.com/2015/09/01/arduino-para-visual-studio-2015/

Otros IDEs

 Programino: http://programino.com/ (de pago)

 Codebender: https://codebender.cc/ (on-line)
 PlatformIO: http://platformio.org/platformio-ide (IDE para IoT con soporte para Arduino)
 Ardublock: http://blog.ardublock.com/ (IDE con entorno gráfico de programación)
 Uecide: http://uecide.org/

Interesante, como programar Arduino desde

Android: http://www.instructables.com/id/Program-your-Arduino-with-a-Android-device/

Y más alternativas en http://playground.arduino.cc/Main/DevelopmentTools

Artículos con más alternativas al IDE de Arduino:

 http://mithatkonar.com/blog/2015/02/22/arduino-ide-alternatives/
 http://www.intorobotics.com/alternatives-standard-arduino-ide-one-choose/
 https://learn.sparkfun.com/tutorials/alternative-arduino-interfaces
 http://kig.re/2014/08/02/arduino-ide-alternatives.html
 https://learn.sparkfun.com/tutorials/alternative-arduino-interfaces
 http://www.arduinostarterkits.com/resources/arduino-ide-windows-mac/

ADVERTISEMENT
Anuncios
REPORT THIS AD

REPORT THIS AD

Compártelo:

 Twitter
 Facebook2
 Google
 
Relacionado
Arduino.cc y Arduino.org. Los dos ArduinosEn "Arduino"
Arduino en IoTEn "Arduino"
Novedades en Arduino. Arduino.cc y Arduino.orgEn "Arduino"
Esta entrada se publicó en Arduino, IDE, Programación y está etiquetada con Arduino, herramientas de
programación, IDE en 6 noviembre, 2016.

Entradas y Salidas Arduino

3 respuestas

La mayoría de los pines de los microcontroladores son multipropósito, es decir, en función de

su configuración se comportan de una forma u otra, tal y como se muestra en la figura.

El ATmega328p como cualquier otro microcontrolador tiene registros, algunos de estos

registros están relacionados con los puertos de entrada/salida, cada puerto tiene un nombre
específico y sus registros asociados, de hecho, el 328p tiene el puerto B, C y D, y cada puerto
un diferente número de pines (Esta es una restricción del paquete de 28 pines PDIP y no
desde el microcontrolador, ya que un PDIP 40 pines, por ejemplo, tiene 4 puertos con los 8
bits cada uno), el único puerto que tiene el total de sus 8 pines de entradas/salidas es PORTD.

Cada pin puede tener múltiples funciones, como la generación de PWM, o las capacidades de
ADC, los pines 6 y 7 del PORTB son los pines de entrada para el oscilador de cristal, y pin 6
del PORTC le corresponde al botón de reinicio. En esta imagen se puede ver todas las
funciones alternativas que cada pin puede tener.
Entradas y Salidas Digitales a Fondo

Para interactuar con los pines digitales de Arduino ya conocemos las funciones que nos ofrece
Arduino en https://www.arduino.cc/en/Tutorial/DigitalPins como digitalRead() y digitalWrite().

Pero a bajo nivel estas funciones están manejando registros. Para empezar hay un registro
dedicado para cada puerto que define si cada pin es una entrada o una salida, que es el
registro de DDRX, donde x es la letra del puerto que queremos configurar, en el caso de la
Arduino hay DDRB, DDRC y DDRD. Como toda variable lógica, cada bit en los registros
DDRX puede ser 1 ó 0, poner un bit específico de DDRX a 1 configura el pin como salida y
ponerla a 0 configura el pin como una entrada.

Los pines usados en la placa Arduino poseen tres puertos en el caso de ATmega328p
(Arduino Uno):

 B (pines digitales del 8 al 13)

 C (entradas analógicas)
 D (pines digitales del 0 al 7)

El Arduino Mega presenta varios puertos B,C,D,E,F, etc.

Cada puerto es controlado por tres registros, los cuales también están definidos como
variables en el lenguaje del Arduino.

 El registro DDR, determina si el pin es una entrada o una salida (1 salida, 0 entrada).
 El registro PORT controla si el pin está en nivel alto (1) o en nivel bajo (0).
 El registro PIN permite leer el estado de un pin. (solo lectura)
Cada bit de estos registros corresponden con un solo pin; por ejemplo el bit menos
significativo de los registros DDRB, PORTB, y PINB hace referencia al pin PB0 (pin digital 8)

Dentro de la avr-libc tenemos un fichero de definición de los registros para cada

microcontrolador. Estos fichero se pueden encontrar en la ruta: C:\Program Files
(x86)\Arduino\hardware\tools\avr\avr\include\avr

Para ATmega328p ver el fichero iom328p.h donde se encuentran las definiciones para el
microcontrolador. Ver que las direcciones de los registros van desplazados 0x20 posiciones de
memoria por los registros de propósito general.

Probar con este código (Ejercicio 59):

void setup() {
1
//PORTD maps to Arduino digital pins 0 to 7
2
pinMode(2, INPUT_PULLUP);
3
pinMode(3, OUTPUT);
4 digitalWrite(3, HIGH);
5 pinMode(4, INPUT_PULLUP);
6 pinMode(5, OUTPUT);

7 digitalWrite(5, HIGH);

8 pinMode(6, INPUT_PULLUP);

pinMode(7, OUTPUT);
9
digitalWrite(7, HIGH);
10
Serial.begin(9600);
11
}
12
void loop() {
13 Serial.println("PIND - The Port D Input Pins Register. Lectura INPUT");
14 Serial.println(PIND, DEC);
15 Serial.println(PIND, HEX);

16 Serial.println(PIND, BIN);

17 Serial.println("DDRD - The Port D Data Direction Register. DDRX 1 OUTPUT 0 INPUT"

Serial.println(DDRD, DEC);
18
Serial.println(DDRD, HEX);
19
Serial.println(DDRD, BIN);
20
Serial.println("PORTD - The Port D Data Register. Escritura OUTPUT");
21
Serial.println(PORTD, DEC);
22 Serial.println(PORTD, HEX);

23 Serial.println(PORTD, BIN);

delay(10000);
24
}
25

26

27

28

El fichero <avr/sfr_defs.h> está incluido en todos los ficheros <avr/ioxxxx.h> que usan unas
macros definidas en sfr_defs.h que hacen que los special function registers parezcan variables
de C a las que podemos llamar para obtener su valor:

#define PORTA _SFR_IO8(0x02)

#define EEAR _SFR_IO16(0x21)
#define UDR0 _SFR_MEM8(0xC6)
#define TCNT3 _SFR_MEM16(0x94)
#define CANIDT _SFR_MEM32(0xF0)

Referencia de <avr/sfr_defs.h> Special Function Registers:

 http://www.nongnu.org/avr-libc/user-manual/group__avr__sfr.html
 http://www.nongnu.org/avr-libc/user-manual/group__avr__sfr__notes.html
 http://www.atmel.com/webdoc/AVRLibcReferenceManual/group__avr__sfr__notes.html

Las limitaciones eléctricas en el microcontrolador son por puerto y por pin:

Un ejemplo que configura pines 0,1,2,3 como entradas digitales y los pines 4,5,6,7 como
salidas digitales: DDRD = 0b11110000; y todos los pin como salidas: DDRD = 0b11111111;

Al utilizar Registros DDR tenemos la ventaja de que con solo una instrucción podemos
declarar el pin como entrada o salida, sin embargo con pinMode() necesitaríamos 8
instrucciones.
Ya podemos decir al Atmega cómo serán utilizados sus pines, pero queremos saber cómo leer
y escribir datos en dichos pines, de modo que para escribir datos en un determinado puerto,
se utiliza el registro PORTx, éste es fácil de recordar, donde x es el nombre del puerto, y
después de la configuración de un pin como salida es sólo una cuestión de poner 0 o 1 en
el registro PORTx para controlar que el pin de este en estado alta o baja.

Un ejemplo sería:

DDRD = 0b11111111; // Todos los pines de PORTD son salidas.

PORTD = 0b11111111; // Todos los pines de PORTD están en estado alto.
DDRD = 0b11111111; // Todos los pines de PORTD son salidas.
PORTD = 0b00000000; // Todos los pines de PORTD están estado bajo.

Se debe tener cuidado cuando se utiliza PORTD y el puerto serie porque los pines 0 y 1 del
PORTD son los utilizados por la USART y si se pone estos dos como entradas o salidas, la
USART será incapaz de leer o escribir datos en los pines. Este es un ejemplo de cuidado que
se debe tener al usar esta programación en lugar de la capa de programación que nos ofrece
Arduino.

Para leer en el pin y poder leer los datos de los sensores o cuando se pulsa un botón de un
pin digital configurado como entrada, vamos a utilizar un tercer registro llamado PINX, donde
de nuevo x es el nombre del puerto donde se encuentra el pin, así que primero con DDRX
decimos al microcontrolador que queremos algunos pines como entradas digitales, y luego
usando PINX leemos sus valores

Ejemplo:

DDRD = 0b00000000; // Todos los pines del PORTD son entradas

char my_var = 0; // variable para guardar la información leída en PORTD
my_var = PIND; // Lee PORTD y pone la información en la variable
Es casi tan fácil como puede ser usar el digitalWrite o digitalRead de Arduino, pero con acceso
directo al puerto se puede ahorrar espacio en el la memoria flash y también puede ganar
mucha velocidad, porque las funciones Arduino puede tomar más de 40 ciclos de reloj para
leer o escribir un solo bit en un puerto, además para leer un solo bit el código es bastante
complejo con un montón de líneas que ocupan por lo menos unos 40 bytes, que podría ser un
pequeño ahorro en flash y es un gran paso para acelerar cualquier programa.

No es normal que se necesite leer o escribir en un puerto completo en cada momento, por
ejemplo, si queremos encender un LED, o leer un botón sólo tendrá que utilizar un pin, y
escribir todos los bits uno a uno cada vez que queremos cambiar un valor en un puerto, es
una tarea aburrida, pero la librería C de AVR tiene algunas pocas palabras definidas como
Px(0..7), donde x es de nuevo el puerto que desea utilizar y 0..7 es el valor del pin individual
de dicho puerto, por lo que para iluminar un LED debemos hacer algo como esto:

DDRD = (1<<PD2); // Configura el pin 2 de PORTD como salida.

PORTD = (1<<PD2); // El pin 2 de PORTD tiene ahora un valor lógico 1.

La operación << es un operador binario que desplaza hacia la izquierda el número de

posiciones especificadas.

Para leer el estado de un botón:

DDRD = 0b11111101; //Configura pin 1 de PORTD como entrada y el resto salida

char my_var = 0; //Variable para guardar la información leída en PORTD
my_var = (PIND & (1<<PD1)); /* Le el pin 1 de PORTD y lo coloca en la variable. */

Explicación de la operación binaria bit a bit: https://www.arduino.cc/en/Reference/Bitshift

También se puede utilizar la macro Px0..7 varias veces en una misma instrucción,
por ejemplo, en este código, se ejecutará algo de código sólo si se pulsa dos botones al
mismo tiempo:

DDRD = 0b11111100; // Los pines 0 y 1 de PORTD son entradas, y el resto salidas.

if (PIND & ((1<<PD0) | (1<<PD1))) {
/* Algún código dentro del if() que se ejecutará solo si los dos botones se
encuentran activados. */
}

Ver ejemplo Leer_pin en https://github.com/jecrespo/Aprendiendo-

Arduino/tree/master/Ejercicio59-Puertos_Digitales/

Mediante los registros también podemos controlar las resistencias internas de pullup. Cuando
hay un botón que puede tener dos estados, uno es desconectado, y cuando se presiona hará
una conexión entre los pines del microcontrolador y permite por ejemplo, conectarse a masa,
pero cuando se desconecta, no hay nada que fuerce un valor estable en el pin de entrada, y el
pin puede leer 1 ó 0 ya que el pin es muy sensible al ruido electromagnético, como una
pequeña antena. Se puede resolver este problema de dos maneras similares, una es para
conectar una resistencia de 10 Kohms o más entre el Vcc (+5 v) y el pin de entrada, o usar los
pull-ups del microcontrolador que tienen integrados, también hace más simples los circuitos.

Para habilitar las resistencias pullup tenemos que hacer algo que puede resultar un poco
extraño, no existe un registro dedicado para activar o desactivar el pull-ups, estos son
activados o desactivados escribiendo 1 o 0 respectivamente en el registro PORTx cuando el
registro DDRX se configuran como entradas. Ejemplo:

DDRD = 0b00000000; // Todos los pines de PORTD son entradas.

PORTD = 0b00001111; // Habilito las Pull-ups de los pines 0,1,2 y 3
char my_var = 0; // Creo una variable para guardar la información leída en PORTD.
my_var = PIND; // Leo PORTD y colocó la información en la variable.

Si se ejecuta este código, sin tener nada conectado a PORTD, los cuatro bits más altos de la
variable my_var puede ser 0 ó 1, cualquier combinación posible de ellos porque son flotantes
(actúan como pequeñas antenas), pero los cuatro bits más bajos leerá todos un 1 debido a
que el pull-ups imponen una señal de 5V débil que se lee como un valor lógico 1.

En un sentido básico esto es todo lo que se necesita saber para dominar la manipulación
directa de los puertos. La manipulación de bits enseña cosas más ingeniosas como las
máscaras de bits, las operaciones AND, OR, NOT y XOR y cómo configurar y limpiar los bits
en un registro y algunos buenos trucos con los operaciones de desplazamiento derecho e
izquierdo, todas cosas bueno a saber, ya que puede acelerar un sketch y son muy útiles
cuando se utilizan los puertos digitales.

Debemos ser conscientes de que un botón no da una buena y transición limpia entre 0 a 1 o
de 1 a 0, pero en su lugar la señal puede tener problemas de rebote, esto es debido a las
propiedades mecánicas del botón y no un defecto de diseño. Hay dos maneras, mediante un
condensador pequeño cerca de la botón para el rebote del valor, o que esta eliminación de
rebotes esté en el mismo código, que es más fácil de hacer cuando tenemos un montón de
botones y es más barato que la adición de una gran cantidad de componentes a nuestro
circuito. La forma más simple de de hacer esto es sólo insertar un pequeño retraso entre las
consecutivas lecturas de un botón, esto es un método de bloqueo, porque el microcontrolador
se detendrá por algunos milisegundos, hay otras formas más inteligentes que usar
temporizadores, pero para proyectos de 2 ó 3 botones que no requieren una
sincronización muy precisa se trata de una método de uso común.

Ventajas y Desventajas que nos ofrece al utilizar los registros:

 Desventajas:
 El código es mucho más difícil de depurar y mantener, y es mucho más difícil de
entender. Solo lleva algunos microsegundos al procesador ejecutar código, pero
podría llevar horas descubrir por qué no funciona y arreglarlo.
 Es mucho más fácil causar mal funcionamiento no intencionado usando el acceso
directo a un puerto. Con DDRD = B11111110, el pin 0 se debe dejar como una
entrada. El pin 0 la línea de recepción (RX) en el puerto serial. Podría ser muy fácil
causar el puerto serial deje de funcionar por cambiar el pin 0 a una salida.
 Ventajas:
 Se puede cambiar los pines de estado muy rápido, en fracciones de microsegundos.
Las funciones digitalRead() y digitalWrite() se componen cada una de ellas de cerca
de una docena de líneas de código, lo cual se convierte en unas cuantas instrucciones
máquina.
 Cada instrucción máquina necesita un ciclo de reloj a 16MHz, lo cual puede sumar
mucho tiempo en aplicaciones muy dependientes del tiempo. El Registro PORT
(Puerto) puede hacer el mismo trabajo en muchos menos ciclos de trabajo.
 Algunas veces necesitamos configurar muchos pines exactamente al mismo tiempo.
Por lo que usar las funciones digitalWrite (10,HIGH), seguida de la función digitalWrite
 (11,HIGH), causará que el pin 10 se ponga en nivel alto varios microsegundos
después que el pin 11, lo cual puede confundir circuitos digitales conectados al
Arduino, cuyo funcionamiento dependa del tiempo preciso del cambio de esos bits.
 Si te estás quedando sin memoria, se pueden usar estos trucos para hacer que tu
código sea más pequeño. Usando este método se necesitan muchos menos bytes de
código compilado que si se hace un bucle para que se vaya cambiando cada pin uno
por uno.

En las librerías podemos ver que usan la manipulación de registros en lugar de las
instrucciones que nos ofrece el core de Arduino lo que las hace más rápidas.

Más información en:

 https://www.arduino.cc/en/Reference/PortManipulation
 https://hekilledmywire.wordpress.com/2011/02/23/direct-port-manipulation-using-the-
digital-ports-tutorial-part-3/
 https://maxembedded.wordpress.com/2011/06/10/port-operations-in-avr/
 http://panamahitek.com/registro-port-puerto/
 http://sistdig.wikidot.com/wiki:puertos
 http://rufianenlared.com/mascaras-arduino/
 http://siatienfalla.altervista.org/atmega328p-port-registers/
 http://courses.cs.washington.edu/courses/csep567/10wi/lectures/Lecture6.pdf (página
44)
 http://wittyrobo.com/mcu328p/c01_p09.html
 https://coolcapengineer.wordpress.com/2012/07/31/avr-configuring-and-using-ports-in-
c/
 http://thepiandi.blogspot.com.es/2016/01/programming-atmega328p-registers-
from.html

Ejercicio Entradas y Salidas Digitales

Ver ejercicio simple con los registros PORT, PIN y DDR y sacarlos por pantalla.

Ejercicio Registros_PORT_simple y leer_pin de https://github.com/jecrespo/Aprendiendo-

Arduino/tree/master/Ejercicio59-Puertos_Digitales/

Para demostrar que la operación digitalRead() es lenta hacer un ejercicio que lea 1000, 10000
y 100000 veces el puerto 9 configurado como entrada, mediante digitalRead() y mediante
PIND y saque el tiempo que ha costado cada operación.

Solución: ejercicio Velocidad_Read de https://github.com/jecrespo/Aprendiendo-

Arduino/tree/master/Ejercicio59-Puertos_Digitales/

Entradas y Salidas Analógicas a Fondo

Ya hemos visto cómo manejar con registros las entradas y salidas de Arduino, pero nos
centrado en las digitales. Para el caso de las entradas y salidas analógicas hay algunos
detalles adicionales que no se han visto. La forma de manejar con registros las entradas
analógicas correspondientes al puerto C con POR y PIN es para usar esos pines como I/O
digitales, puesto que los pines de los microcontroladores son multipropósito como se ha dicho
anteriormente.
En las entradas analógicas entran en juego los conversores Analógico Digital (ADC) y en las
salidas analógicas entra el PWM que usa uno de los timers de microcontrolador para hacer la
forma de onda PWM.

Toda la información de ADC para entradas analógicas se encuentra en la página 305 y la

información de PWM para salidas analógicas está en la página 125, 149 y 189
de http://www.atmel.com/Images/Atmel-42735-8-bit-AVR-Microcontroller-ATmega328-
328P_datasheet.pdf

PWM

Las Salidas PWM (Pulse Width Modulation) permiten generar salidas analógicas desde pines
digitales. Arduino Uno no posee salidas analógicas puras. El arduino due, posee dos salidas
analógicas puras mediante dos conversores digital a analógico. Estos pines pueden usarse
para crear salidas de audio usando la librería correspondiente.

Definición de PWM en la web de Arduino: http://arduino.cc/en/Tutorial/PWM

La modulación por ancho de pulsos (también conocida como PWM, siglas en inglés de pulse-
width modulation) de una señal o fuente de energía es una técnica en la que se modifica el
ciclo de trabajo de una señal periódica (una senoidal o una cuadrada, por ejemplo), ya sea
para transmitir información a través de un canal de comunicaciones o para controlar la
cantidad de energía que se envía a una carga.

El ciclo de trabajo de una señal periódica es el ancho relativo de su parte positiva en relación
con el período. duty cycle = (tiempo que la salida está a uno o HIGH)/ (periodo de la función)
En Arduino la frecuencia de PWM es de 500Hz. Pero es un valor que puede modificarse en
caso que lo necesitemos.

PWM tiene varios usos en los microcontroladores:

 Dimming un LED
 Obtener una salida analógica
 Ofrecer un voltaje analógico entre el 0% y el 100% de Vcc
 Generar señales de audio
 Controlar velocidad de motores
 Generar una señal modulada, por ejemplo para manejar un LED infrarrojo de un
mando a distancia.

Para generar la señal PWM se utiliza los timers configurándose varias formas de trabajo. La
forma de onda PWM, en el modo de trabajo más sencillo (Fast PWM), se genera de la forma
mostrada en la siguiente gráfica:
 1. El registro del contador se pone en marcha desde cero y cuenta de modo ascendente.
En el momento de empezar la cuenta se activa el pin de salida del PWM.
2. Cuando el valor de este registro se iguala al de otro registro de comparación se
conmuta el pin de salida. El registro del contador sigue contando en forma normal.
3. Cuando el valor del registro del contador llega al final (TOP) vuelve a comenzar
(BOTTOM). El pin de salida vuelve a cambiar.
4. El tiempo que tarda el contador en llegar al final fija el periodo de la señal.

Los microcontroladores usan varios modos de PWM, uno de ellos el el Fast PWM que puede
ser generado con 8, 9 y 10 bits, una resolución mayor de 8 bits solo es posible usando un
timer de 16 bits. Otro modo de PWM es Phase Correct PWM que es el que debería usarse
para el control de motores. Otro modo es Frequency and Phase Correct PWM.

Esta imagen explica cómo funciona el phase correct PWM, en este caso el timer cuenta hacia
arriba y luego hacia abajo:

En los microcontroladores AVR, el PWM está disponible con todos los timers. Timer 0 y timer
2 dan una resolución de 8 bit mientras que el timer 1 ofrece una resolución de 16 bits. Con 8
bits hay 256 pasos individuales y en 16 bit hay una resolución de 65536 pasos.

La forma de generar la onda PWM es diferente en cada uno de los modos y la señal obtenida
es diferente.
Puesto que las ondas generadas son diferentes, el centro de la parte en HIGH no es constante
en el fast PWM y sí en el phase correct PWM, esa es la principal diferencia entre ambos
modos y la razón de porque para control de motores es mejor usar el phase correct PWM.

El modo PWM en el AVR se controla por hardware. Esto significa que todo, se lleva a cabo por
la CPU AVR. Todo lo que necesita hacer es inicializar e iniciar el temporizador, y establecer el
ciclo de trabajo. El ATmega328p tiene 3 timers PWM para controlar 6 salidas PWM. Estos
temporizadores generan interrupciones cuando alcanzan el overflow o cuando alcanzan el
registro de comparación. Los registros de control del timer/counter n (n va de 0 a 2) son
TCCRnA y TCCRnB y tienen los principales controles de los temporizadores.

Estos registros tienen varios grupos de bits:

 Waveform Generation Mode bits (WGM): these control the overall mode of the timer.
(These bits are split between TCCRnA and TCCRnB.)
 Clock Select bits (CS): these control the clock prescaler
 Compare Match Output A Mode bits (COMnA): these enable/disable/invert output A
 Compare Match Output B Mode bits (COMnB): these enable/disable/invert output B

Los registros de comparación de salida OCRnA y OCRnB establece los niveles en los que las
salidas A y B se verán afectados. Cuando el valor del temporizador coincide con el valor del
registro, la salida correspondiente será modificado como se especifica en el modo.
TCCR0B – Timer/counter0 Control Register

Los registros para el control de PWM con el timer 0 son TCCR0A y TCCR0B y dentro de ellos
los bits WGM02, WGM01 y WGM00:
Para utilizar fast PWM rápido dos modos para elegir, los modos 3 y 7, la principal diferencia
entre estos dos modos es que en el modo 3 TOP se fija en 0xFF y en el modo de 7 TOP es
definido por el registro TOP, esto significa que si existe la necesidad, podemos cambiar el
número máximo que el temporizador hará hasta que haga overflow, así que esto significa que
podemos controlar la frecuencia y el ciclo de trabajo.

Más información sobre PWM:

 https://www.arduino.cc/en/Tutorial/SecretsOfArduinoPWM
 http://playground.arduino.cc/Main/TimerPWMCheatsheet
 http://maxembedded.com/2011/08/avr-timers-pwm-mode-part-i/
 http://maxembedded.com/2012/01/avr-timers-pwm-mode-part-ii/
 https://hekilledmywire.wordpress.com/2011/08/03/introduction-to-pwm-part-7/
 https://maxembedded.wordpress.com/2011/07/14/avr-timers-ctc-mode/
 http://www.microcontroller-project.com/generating-variable-frequency-with-arduino.html

Para cambiar la frecuencia de PWM que por defecto en Arduino UNO está a 500 HZ, se puede
usar la función definida en http://playground.arduino.cc/Code/PwmFrequency, donde indicando
el pin y el divisor de frecuencia. Esta función cambia los registros TCCRnB en el timer
correspondiente en función del pin, con el divisor que queramos.
O simplemente en el setup() del sketch inicializar los bits CS00, CS01 y CS02 como se indica
en este enlace: https://arduino-info.wikispaces.com/Arduino-PWM-Frequency, pero teniendo
en cuenta que estos cambios en los timers 0, 1 y 2 puede tener efectos en otras funciones que
usen los timers como delay(), millis() o la librería servo:

 Changes on pins 3, 5, 6, or 11 may cause the delay() and millis() functions to stop
working. Other timing-related functions may also be affected.
 Changes on pins 9 or 10 will cause the Servo library to function incorrectly.

La frecuencia resultante de PWM es la resultante de la división de la frecuencia base entre el

divisor.

 The base frequency for pins 3, 9, 10, and 11 is 31250 Hz.

 The base frequency for pins 5 and 6 is 62500 Hz.
 The divisors available on pins 5, 6, 9 and 10 are: 1, 8, 64, 256, and 1024.
 The divisors available on pins 3 and 11 are: 1, 8, 32, 64, 128, 256, and 1024.

También se puede hacer PWM en todos los pins, programando nosotros en lugar de dejarlo a
la CPU del microcontrolador: http://playground.arduino.cc/Main/PWMallPins
ADC

El microcontrolador de Arduino UNO contiene en la placa un conversor analógico a digital de 6

canales. El conversor tiene una resolución de 10 bits, devolviendo enteros entre 0 y 1023. Los
pines analógicos de Arduino también tienen todas las funcionalidades de los pines digitales.
Por lo tanto, si necesitamos más pines digitales podemos usar los pines analógicos.

En arduino los pines analógicos se definen y tienen las propiedades

siguientes: http://arduino.cc/en/Tutorial/AnalogInputPins

El datasheet de ATmega advierte de hacer lecturas rápidas entre pines analógicos

(analogRead). Esto puede causar ruido eléctrico e introducir jitter en el sistema analógico. Se
aconseja que después de manipular pines analógicos (en modo digital), añadir un pequeño
retraso antes de usar analogRead () para leer otros pines analógicos.

Un microcontrolador solo entiende señales digitales (1’s y 0’s), por lo tanto para poder leer
señales analógicas necesitamos los convertidores Analógico a Digital (ADC). Esta conversión
consiste en la transcripción de señales analógicas en señal digital, con el propósito de facilitar
su procesamiento (codificación, compresión, etcétera) y hacer la señal resultante (digital) más
inmune al ruido y otras interferencias a las que son más sensibles las señales analógicas.
Para el ATMega328p toda la información del conversor analógico a digital se encuentra en la
página 305 de http://www.atmel.com/Images/Atmel-42735-8-bit-AVR-Microcontroller-
ATmega328-328P_datasheet.pdf

El ATMega328p, al igual que toda la gama ATMega de Atmel y otros microcontroladores,

tienen un ADC integrado y no necesita ningún hardware adicional, esto nos permite
simplemente conectar un sensor analógico. El ADC interno del microcontrolador tiene una
resolución de 10 bits, esto significa que la tensión analógica de entrada se convierte en un
valor numérico entre 0 y 1023.

Aunque el ATmega328P tiene 6 pines que son capaces de ser utilizados como pines de
entrada analógicos (Port C), sólo hay un ADC en el microcontrolador, pero entre el ADC y los
pines hay un multiplexor analógico, esto permite que podamos elegir qué pin está conectado
al ADC, esto significa que aunque podemos utilizar todos los pines, sólo se puede leer el valor
de uno de ellos a la vez, para casi todas las aplicaciones esto es más que suficiente, pero en
algunos casos limitados que necesitan lecturas ADC de alta velocidad se podría necesitar el
uso de ADC externos. En el caso de la ATmega328P los pines que se pueden utilizar una
entrada analógica son todos los del puerto C.

También se puede cambiar la tensión máxima (siempre por debajo de Vcc) que utiliza el ADC,
es la llamada tensión de referencia y es la tensión contra la que todas las entradas analógicas
hacen las conversiones. Esta tensión de referencia se toma del pin Aref. Reducir el voltaje
máximo del ADC tiene sentido para mejorar la resolución del ADC. Con 5V la resolución es de
5/1023 = 4,88 mV para cada valor, pero para un sensor que no pasa de 3.3V la resolución es
de 3.3/1023 = 3.22mV.

El ADC interno también se puede utilizar en un modo de 8 bits, donde sólo se utilizan los 8 bits
más significativos de la resolución de 10 bits completa, esto podría ser útil cuando se trabaja
en ambientes ruidosos y sólo necesita 8 bits de resolución, el uso de este modo es un plus
debido a que no es necesario dedicar más tiempo de CPU calculando los 10 bits completos. El
ADC también puede configurarse para que lleve a cabo una conversión y detenerse o puede
ser configurado para funcionar en un modo de funcionamiento libre, la primera opción es la
mejor opción cuando queremos leer diferentes pines, y el segundo es mejor cuando sólo
tenemos que leer un pin y esto puede ahorrar algo de tiempo entre las conversiones.

También tenemos que tener cuidado de la frecuencia máxima de trabajo del ADC, este valor
se especifica en la ficha técnica y es de 200 kHz, este es el valor del reloj interno de la
circuitería del ADC y se genera dividiendo el reloj principal ATmega, que en el caso del UNO
es 16 MHz, este divisor del reloj se realiza mediante pre-escaladores y sólo hay un rango
limitado de valores, por lo que la frecuencia máxima que podemos utilizar y estar dentro de la
frecuencia máxima de trabajo es 125 kHz. El siguiente pre-escalador supone usar el ADC a
250 kHz, en este caso no se puede garantizar la resolución de 10 bits, pero si una resolución
de 8 bits. De todas formas en caso de necesitar un ADC más rápido se podría usar uno
externo.

El ADC puede trabajar en dos modos: single conversion mode y free running mode. En
modo single conversion el ADC hace una sola conversión y para, pero en modo free running el
ADC está continuamente convirtiendo, es decir, hace una conversión y luego comienza con la
siguiente.

El ADC en microcontroladores AVR utiliza una técnica conocida como aproximación sucesiva
mediante la comparación de la tensión de entrada con la mitad de la tensión de referencia
generada internamente. La comparación continúa dividiendo de nuevo la tensión y
actualizando cada bit del registro ADC a 1 si el voltaje es HIGH en la comparación o 0 en el
otro caso. Este proceso tiene dura 10 veces (por cada bit de resolución del ADC) y genera
como resultado la salida binaria.

Los registros utilizados en el manejo de las entradas analógicas son:

 ADMUX: ADC Multiplexer Selection Register. Selector del canal del multiplexor del
ADC y el voltaje de referencia.
 ADCSRA: ADC Control and Status Register A. Control del ADC y su estado.
 ADCSRB: ADC Control and Status Register B.
 ADCL: ADC Data Register Low. Cuando la conversión ADC ha finalizado, el resultado
se deja en estos dos registros.
 ADCH: Data Register High
 DIDR0: Digital Input Disable Register 0. Para deshabilitar la entrada digital de los pines
analógicos.

Más información:

 https://hekilledmywire.wordpress.com/2011/03/16/using-the-adc-tutorial-part-5/
 http://www.luisllamas.es/2014/09/entradas-analogicas-en-arduino/
 http://microcontrollerslab.com/analog-to-digital-adc-converter-working/
 http://www.electroschematics.com/10053/avr-adc/
 https://es.wikipedia.org/wiki/Conversi%C3%B3n_anal%C3%B3gica-digital
Anuncios
REPORT THIS AD

REPORT THIS AD

Compártelo:

 Twitter
 Facebook2
 Google

Relacionado
Puertos Digitales Arduino AvanzadoEn "Arduino"
Entradas y Salidas Analógicas Arduino. PWMEn "Arduino"
Entradas y Salidas ArduinoEn "Arduino"
Esta entrada se publicó en Arduino, Entradas Analógicas, Entradas
Digitales, Microcontrolador, PWM, Salidas Analógicas, Salidas Digitales y está etiquetada
con Arduino, Entradas Analógicas, Entradas Digitales, PWM, Salidas Analógicas, Salidas Digitales en 8
noviembre, 2016.

Memoria Arduino
2 respuestas

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:

 http://arduino.cc/en/Tutorial/Memory
 http://playground.arduino.cc/Learning/Memory

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.

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:

1
extern unsigned int __bss_end;
2
extern unsigned int __heap_start;
3
extern void *__brkval;
4

5 uint16_t getFreeSram() {
6 uint8_t newVariable;
7 // heap is empty, use bss as start memory address

8 if ((uint16_t)__brkval == 0)

9 return (((uint16_t)&newVariable) - ((uint16_t)&__bss_end));

// use heap end as the start of the memory address

10
else
11
return (((uint16_t)&newVariable) - ((uint16_t)__brkval));
12
};
13

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:

 http://web-engineering.info/node/30
 http://www.nongnu.org/avr-libc/user-manual/malloc.html
 http://www.atmel.com/webdoc/AVRLibcReferenceManual/malloc.html
 http://www.hackshed.co.uk/programming-the-arduino-memory-management-part-2/

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:

 http://playground.arduino.cc/Code/AvailableMemory
 MemoryFree: https://github.com/maniacbug/MemoryFree
 MemoryFree revisada: https://github.com/McNeight/MemoryFree
 Función freeRam:

1 int freeRam () {
2 extern int __heap_start, *__brkval;

3 int v;

4 return (int) &v - (__brkval == 0 ? (int) &__heap_start : (int) __brkval);

}
5
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:

 https://github.com/jecrespo/Aprendiendo-Arduino/tree/master/Ejercicio05-
Memoria/Memoria1
 https://github.com/jecrespo/Aprendiendo-Arduino/tree/master/Ejercicio05-
Memoria/Memoria2

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.

Anuncios
REPORT THIS AD
 REPORT THIS AD

Compártelo:

 Twitter
 Facebook2
 Google

Relacionado
Memoria Flash, SRAM y EEPROMEn "Arduino"
Memoria Flash, SRAM y EEPROMEn "Arduino"
Memoria Flash, SRAM y EEPROMEn "Arduino"
Esta entrada se publicó en Arduino, Avanzado, Hardware, Memoria y está etiquetada
con Arduino, Memoria, Memoria Flash, SRAM en 8 noviembre, 2016.

EEPROM
Deja un comentario

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

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

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

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

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

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

La memoria flash es una forma avanzada de EEPROM.

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

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

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

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

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

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

 Tutorial escritura EEPROM: http://arduino.cc/en/Tutorial/EEPROMWrite
 Tutorial limpiado EEPROM: http://arduino.cc/en/Tutorial/EEPROMClear
Para grabar estructuras de datos en la EEPROM de una forma muy
sencilla. http://playground.arduino.cc/Code/EEPROMWriteAnything

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

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

funcionalidades:

 http://playground.arduino.cc/Code/EEPROMex
 http://thijs.elenbaas.net/downloads/?did=6
 http://thijs.elenbaas.net/2012/07/extended-eeprom-library-for-arduino
 https://github.com/thijse/Arduino-Libraries/tree/master/EEPROMEx

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

 EEPROM Address Registers: EEARH y EEARL

 EEPROM Data Register: EEDR
 EEPROM Control Register: EECR

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

Microcontroller-ATmega328-328P_datasheet.pdf

Cosas a tener en cuenta con la

EEPROM: https://engineerzero.wordpress.com/2013/07/11/five-things-to-remember-pun-
about-arduino-eeprom/

 Los datos deben guardarse en formato byte para ser usados

 EEPROM puede los datos de configuración de usuario
 Dañar la EEPROM no es un problema grave
 Dañar la EEPROM puede ser un problema si no se tiene cuidado
 Dañar la EEPROM no es el fin del mundo

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

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

Ejercicios EEPROM

Volcado EEPROM

Si estamos depurando un proyecto de Arduino usando EEPROM, es posible que queramos

ver la EEPROM para entender lo que está pasando.

Si tenemos un programador ISP como el USBtinyISP de Adafruit, siempre se puede utilizar

avrdude para volcar la EEPROM a un archivo. Por ejemplo, el siguiente código crea un archivo
denominado e2data.ee con contenido de EEPROM.

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

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

Ejercicio EEPROM

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

de la EEPROM.

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

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

Poner un LED con su resistencia en los pines 10 y 12 correspondientes a la configuración

(setting) e[4] y e[5]. Estos leds se encenderán al inicar el sketch porque son los que están
configurados en el programa y los graba la primera vez en la EEPROM. Son los valores de
setting de a y b.

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

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

EEPROM Externa

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

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

 EEPROM externa : http://datasheets.maximintegrated.com/en/ds/DS2430A.pdf

 Como trabajar con ella: http://playground.arduino.cc/Learning/OneWire
Anuncios
REPORT THIS AD

REPORT THIS AD

Compártelo:

 Twitter
 Facebook2
 Google

Relacionado
EEPROMEn "Arduino"
Memoria Flash, SRAM y EEPROMEn "Arduino"
Memoria Flash, SRAM y EEPROMEn "Arduino"
Esta entrada se publicó en Arduino, EEPROM, Memoria y está etiquetada
con Arduino, EEPROM, Memoria en 9 noviembre, 2016.

Ampliación Memoria Arduino

1 respuesta

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

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

En caso de necesitar más EEPROM de la que dispone el microcontrolador, es sencillo usar

EEPROM externas conectadas por I2C o SPI, aunque también es posible almacenar los datos
no volátiles en una tarjeta SD externa en lugar de la EEPROM.

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

 Tutorial de uso: http://www.hobbytronics.co.uk/arduino-external-eeprom

 Guardar strings largos: http://www.hobbytronics.co.uk/eeprom-page-write

Otra alternativa para la expansión de memoria es

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

Más información:

 http://playground.arduino.cc/Code/Dataflash
 Librería: https://github.com/asynclabs/dataflash

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

En caso de quedarnos sin memoria SRAM, lo primero es seguir estos consejos para optimizar
su uso y mover a la memoria flash (si queda espacio) todas los strings y datos que no se
modifican en tiempo de ejecución (read-only): https://learn.adafruit.com/memories-of-an-
arduino/optimizing-sram.
Si con esto no es suficiente, entonces podemos ampliar la memoria SRAM. Obtener más
SRAM es en realidad bastante sencillo. Hay módulos de SPI RAM (memoria volatil) como el
microchip 23K256, data
sheet: http://ww1.microchip.com/downloads/en/DeviceDoc/22100D.pdf. Dispone de 32k de
SRAM con un interfaz SPI. Se accede a ellos a través de SPI y hay la biblioteca SpiRAM para
ayudar a su uso. Debe tenerse en cuenta que opera a 3,3V y no 5V y que no es posible usarla
con Arduino Mega.

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

Más información:

 http://playground.arduino.cc/Main/SpiRAM
 Librería: https://github.com/jscrane/SpiRAM
 SPI RAM con ethernet
shield: http://playground.arduino.cc/Main/SpiRAMWithEthernetShield

Uso de tarjetas SD en Arduino

Una forma ampliar la capacidad de almacenamiento de un Arduino es añadir una memoria

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

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

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

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

Con la Ethernet shield disponemos de un lector de tarjetas micro SD y es accesible gracias a

la librería SD: https://www.arduino.cc/en/Reference/SD
Otros shield interesante es el Adafruit datalogger shield que dispone de un lector de tarjetas
SD, un RTC (Real Time Clock), una zona de prototipado para soldar componentes adicionales
y dos LEDs indicadores configurables.

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

Otro HW para tarjetas SD:

 SD Card Shield V4: https://www.seeedstudio.com/SD-Card-Shield-V4-p-1381.html

 Micro SD Module: https://www.cooking-hacks.com/documentation/tutorials/arduino-
micro-sd/
 Micro SD card
module: https://www.dfrobot.com/wiki/index.php/MicroSD_card_module_for_Arduino_(
SKU:DFR0229)
 Modulo barato: http://www.miniinthebox.com/es/slot-modulo-sd-card-socket-reader-
para-arduino-arm-mcu_p903302.html y
ejemplo http://arduinolearning.com/learning/basics/sd-card-example.php

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

La librería SD está basada en la librería SDfat: https://github.com/greiman/SdFat. Es

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

Cuestiones a tener en cuenta cuando se usa la librería

SD: https://www.arduino.cc/en/Reference/SDCardNotes
Tutoriales disponibles

 Card Info: Obtiene información de la tarjeta SD.

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

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

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

Pineado de tarjetas SD:

Pin – Name – Description
1 – NC – not connected
2 – CS – Chip Select/Slave Select (SS)
3 – DI – Master Out/Slave In (MOSI)
4 – VDD – Supply voltage
5 – CLK – Clock (SCK)
6 – VSS – Supply voltage ground
7 – DO – Master In/Slave Out (MISO)
8 – RSV – Reserved
A la hora de conectar con Arduino, solo debemos definir en Arduino el pin CS (Chip Select).
Antes de empezar a leer y escribir datos en la tarjeta SD de Arduino hay que utilizar la
instrucción SD.begin(), determinando en el paréntesis el pin CS de tu shield de SD o del pin de
la tarjeta SD. Esto quiere decir que si se utiliza una placa de Arduino UNO (o similar) se utiliza
la instrucción SD.begin(10) pero si (por ejemplo) se utiliza el shield de Ethernet debe
ponerse SD.begin(4).

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

Más información:

 Tutorial adafruit: https://learn.adafruit.com/adafruit-micro-sd-breakout-board-card-

tutorial/intro
 http://www.allaboutcircuits.com/projects/reading-and-writing-files-from-an-sd-card-with-
an-arduino/
 https://oscarliang.com/sd-card-arduino/
 http://www.educachip.com/como-leer-y-escribir-datos-en-la-tarjeta-sd-de-arduino/
 Tutorial para hacer un datalogger: https://computers.tutsplus.com/tutorials/how-to-add-
an-sd-card-data-logger-to-an-arduino-project–cms-21713
 Data logging to Excel: http://howtomechatronics.com/tutorials/arduino/arduino-sd-card-
data-logging-excel-tutorial/
 Tutorial sparkfun: https://learn.sparkfun.com/tutorials/microsd-shield-and-sd-breakout-
hookup-guide
 https://arduino-info.wikispaces.com/SD-Cards

Ejercicios con SD

Ejercicio30-SD: Grabar y leer en una tarjeta SD

Basarse en los tutoriales.

 http://arduino.cc/en/Tutorial/Datalogger
 http://arduino.cc/en/Tutorial/DumpFile

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

Ejercicio50-DAQ_SD: Leer y guardar en una tarjeta SD cada 30 segundos la temperatura y

humedad de una sonda DHT22. Los datos son guardados en un fichero llamado datalog.csv.
Los datos también son mostrados por en una pantalla LCD
modelo https://www.sparkfun.com/products/9395

Para leer los datos de la SD y sacarlos por el puerto serie, usar el

sketck: https://www.arduino.cc/en/Tutorial/DumpFile

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

 https://aprendiendoarduino.wordpress.com/2016/07/02/sensor-de-temperatura/
 https://aprendiendoarduino.wordpress.com/2016/07/03/display-lcd/
Solución: https://github.com/jecrespo/Aprendiendo-Arduino/tree/master/Ejercicio50-DAQ_SD
Anuncios
REPORT THIS AD

REPORT THIS AD

Compártelo:

 Twitter
 Facebook1
 Google

Relacionado
EEPROMEn "Arduino"
Memoria Flash, SRAM y EEPROMEn "Arduino"
Memoria Flash, SRAM y EEPROMEn "Arduino"
Esta entrada se publicó en Arduino, EEPROM, Memoria, SD y está etiquetada
con Arduino, DAQ, EEPROM, Memoria, SD en 9 noviembre, 2016.

Alimentación Arduino
21 respuestas

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

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

 https://learn.sparkfun.com/tutorials/battery-technologies
 http://blog.bricogeek.com/noticias/modelismo/todo-sobre-las-baterias-lipo/

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:

 https://learn.sparkfun.com/tutorials/how-to-power-a-project
 http://www.educachip.com/alimentar-arduino/
 http://soloarduino.blogspot.com.es/2014/12/regulacion-de-tension-explicacion.html
 https://www.modmypi.com/blog/how-do-i-power-my-arduino
 http://txapuzas.blogspot.com.es/2009/12/alimentacion-para-paperduino-5v-12v.html

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

  https://es.wikipedia.org/wiki/Fuente_conmutada
 Fuentes de alimentación:http://www.prometec.net/fuentes-de-alimentacion/
 http://www.electan.com/fuente-alimentacion-conmutada-12v-21a-25w-p-2891.html
 http://www.prometec.net/fuentes-de-alimentacion-conmutadas/
 Fuente de alimentación conmutada step-down o buck
converters: http://www.prometec.net/fuentes-step-down/
 Buck converter:https://es.wikipedia.org/wiki/Convertidor_Buck
 Fuente de alimentación step-up: http://www.prometec.net/boost-converters/

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:

 http://www.prometec.net/producto/regulador-lm2596s-dc-dc-step-down/
 http://www.prometec.net/producto/fuente-conmutada-lm2596s-step-down/
  https://www.pololu.com/category/133/step-up-step-down-voltage-regulators

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:

 https://www.arduino.cc/en/uploads/Main/Arduino_Uno_Rev3-schematic.pdf
 http://download.arduino.org/products/UNO/Arduino-UNO-SMD-Rev3e-SCH.pdf
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:

 https://en.wikipedia.org/wiki/Low-dropout_regulator
 http://www.linear.com/products/ldo_linear_regulators
 http://www.ti.com/lsds/ti/power-management/linear-regulators-ldo-overview.page

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

Normally low to medium-high for low difference

Efficiency between VIN-VOUT High

Complexity Low Medium to high

Smaller at similar higher power (depending on the switching

Size Small to medium, larger at high power 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:

 como funciona: http://www.electronicshub.org/understanding-7805-ic-voltage-regulator/

 familia de reguladores https://es.wikipedia.org/wiki/78xx
 http://practica16c03.blogspot.com.es/2011/03/el-regulador-7805.html

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:

 https://soloarduino.blogspot.com.es/2014/12/regulacion-de-tension-explicacion.html
 Fusibles reseteables: https://soloarduino.blogspot.com.es/2014/12/fusibles-con-
reset.html
 http://aim65.blogspot.com.es/2012/03/legobot-alimentando-el-arduino.html
 http://electronics.stackexchange.com/questions/26484/how-arduino-power-supply-
works

Esquemáticos de Arduino UNO:

 https://www.arduino.cc/en/uploads/Main/Arduino_Uno_Rev3-schematic.pdf
 http://download.arduino.org/products/UNO/Arduino-UNO-SMD-Rev3e-SCH.pdf

Reguladores de Tensión de Arduino

 Regulador de tensión en Arduino para bus

3,3V: http://www.onsemi.com/pub_link/Collateral/MC33269-D.PDF
 El regulador de tensión es el que marca la tensión que alimenta a la
MCU: http://www.onsemi.com/pub_link/Collateral/NCP1117-D.PDF

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:

 http://electronics.stackexchange.com/questions/65576/arduino-uno-r3-directly-supply-
regulated-5v-to-5v-pin
 http://forum.arduino.cc/index.php?topic=18630.0
 http://forum.arduino.cc/index.php?topic=271158.0

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
ETHhttp://download.arduino.org/products/LEONARDOETH/Arduino_Leonardo_Eth_V1_sch.pd
f usa un MPM3610 que es un Synchronous Step-Down Converter conmutado

Datasheet
MPM3610: http://www.monolithicpower.com/DesktopModules/DocumentManage/API/Documen
t/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:

 https://es.wikipedia.org/wiki/MOSFET
 https://www.fairchildsemi.com/datasheets/FD/FDN340P.pdf
 http://es.rs-online.com/web/p/transistores-mosfet/6710435/

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:

 http://forum.arduino.cc/index.php?topic=141776.0
 http://forum.arduino.cc/index.php?topic=53627.0
 http://arduino.stackexchange.com/questions/893/arduino-what-happens-if-i-power-the-
arduino-with-both-the-usb-and-external-pow
 http://electronics.stackexchange.com/questions/401/switch-between-5v-power-supplies
 https://forums.adafruit.com/viewtopic.php?f=25&t=12406

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:

 http://www.rugged-circuits.com/ruggeduino/
 Artículo original http://www.ruggedcircuits.com/10-ways-to-destroy-an-arduino/
 Traducción: http://www.trastejant.com/2013/07/03/10-formas-de-destruir-un-arduino/

Clones de Arduino mejorados para ser más resistentes:

 Ruggeduino-SE “Special Edition”:

 http://www.rugged-circuits.com/microcontroller-boards/ruggeduino-se-special-edition
 http://www.rugged-circuits.com/ruggeduino-1
 Rugged MEGA:
 http://www.rugged-circuits.com/microcontroller-boards/rugged-mega
 http://www.rugged-circuits.com/mega-tech

Videos de como destruir un Arduino:

 https://www.youtube.com/watch?v=WmcMrKELkcs&feature=youtu.be
 https://www.youtube.com/watch?v=P_fb6njcaoU

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:

 http://playground.arduino.cc/Main/ArduinoPinCurrentLimitations
 http://arduino-info.wikispaces.com/ArduinoPinCurrent

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:

 http://rufianenlared.com/bateria-arduino/
 Consumos Arduino: http://www.prometec.net/consumos-arduino/

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:

 https://openhomeautomation.net/arduino-battery/
 https://github.com/petervojtek/diy/wiki/Arduino-with-Very-Low-Power-Consumption
 http://www.instructables.com/id/Arduino-low-Project-and-code/

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:

 http://tienda.bricogeek.com/shields-arduino/520-arduino-solar-charger-shield.html
 http://wiki.seeedstudio.com/wiki/Solar_Charger_Shield_V2.2

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
Anuncios
REPORT THIS AD

REPORT THIS AD

Compártelo:

 Twitter
 Facebook14
 Google

Relacionado
Cómo conseguir un “Arduino” GratisEn "Arduino"
Arduino.cc y Arduino.org. Los dos ArduinosEn "Arduino"
IDE Arduino y ConfiguraciónEn "Arduino"
Esta entrada se publicó en Arduino, Avanzado, Electronica, Hardware y está etiquetada
con Arduino, Avanzado, Electronica, Hardware en 9 noviembre, 2016.

Bootloader
2 respuestas

Cuando cargamos un programa en Arduino desde el USB con el IDE, estamos haciendo uso
del bootloader, se trata de un pequeño programa que ha sido guardado previamente en el
microcontrolador de la placa y que nos permite cargar código sin necesidad de hardware
adicional. El bootloader solo está activo unos segundos cuando se resetea el Arduino y
después comienza el sketch que está cargado en la flash de Arduino y que hemos
programado y subido a la placa.
El bootloader se ejecuta cuando el microcontrolador se enciende o se pulsa el botón reset,
durante un corto espacio de tiempo espera que le llegue por el puerto serie un nuevo sketch
desde el IDE de Arduino (este distingue un sketch de otra cosa porque tiene un formato
definido). Si llega un sketch, este es guardado en la memoria flash y ejecutado, en caso
contrario ejecuta el sketch anteriormente cargado.

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

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

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

El bootloader de Arduino está programado en la memoria flash del ATMega328p y ocupa 0,5
KB de los 32KB disponibles. Este bootloader viene precargado en la memoria flash del
microcontrolador y es lo que diferencia el ATMega328p de Arduino de otro que viene de
fábrica.

El Arduino UNO viene con el microcontrolador ATMega328p precargado con un bootloader

que permite cargar nuevo código sin un programador. El bootloader se comunica usando el
protocolo STK500.

El protocolo STK500 http://www.atmel.com/Images/doc2525.pdf es propio de Atmel. Es un

protocolo serie y los programadores emulan este protocolo sobre un puerto serie virtual en un
USB. Originalmente STK500 fue un programador fabricado por Atmel y a raíz de ello liberaron
el protocolo STK500.

En este enlace es posible obtener el código en C del protocolo

STK500: http://www.atmel.com/dyn/resources/prod_documents/avr061.zip

Arduino decidió usar avrdude y STK500 serial bootloader para programar o cargar nuevos
programas en Arduino sin necesidad de HW adicional. El bootloader de Arduino es
esencialmente el bootloader STK500 de Atmel.
Las MCUs AVR de 8bits ATMega con interfaz USB integrado como son el ATmega16U2 y
ATmega8U2, vienen de fábrica un USB bootloader en la sección de arranque de la flash. Este
bootloader USB permite hacer In-System programming desde USB host controller sin la
necesidad de un HW externo. En este documento se describe las funcionalidades del USB
bootloader: http://www.atmel.com/Images/doc7618.pdf

El puerto serie durante el proceso de bootloader funciona a 19200 baudios.

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

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

 Desbloquear la sección de bootloader en el chip

 Configurar los fuses en la MCU
 Cargar el código del bootloader en el microcontrolador
 Bloquear la sección del bootloader en la MCU

Todo esto es controlado por una serie de preferencia en el fichero de preferencias de

Arduino: https://www.arduino.cc/en/Hacking/Preferences

Cuando el Boot Reset Fuse (BOOTRST) está configurado, el contador de programa en la

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

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

manual/group__avr__boot.html

El bootloader se trata de un programa especial y puede leer datos de una fuente externa como
UART, I2C, CAN, etc… para reescribir el programa guardado en la memoria flash del
microcontrolador. El bootloader busca un evento especial que puede ser cualquier cosa, pero
para el desarrollo es más conveniente algo en el bus de datos que será puesto en la flash de
la MCU. Si el bootloader ve ese evento especial, entonces entra en modo bootloading en el
que hace un reflash de la memoria de programa del microcontrolador, pero si no aparece el
evento, pasa el control al código del usuario.
El bootloader no consume RAM y los únicos efectos que tiene son modificaciones en los
registros del hardware periferivo, pero un buen bootloader no debe dejar ningún estado
perjudicial en el que encienda periféricos que malgasten energía cuando pones la MCU en
modo sleep. Es una buena práctica inicializar los periféricos que se usan, así aunque el
bootloader haga algo extraño, habremos inicializado como queremos que se comporte.

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

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

programadores:

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

Avrdude junto con otras herramientas se encuentran en: C:\Program Files

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

 Use -b 19200 to set the baud rate to 19200

 The device signature reads dont seem to work so you’ll want to use -F
 The programmer type is avrisp
 The device type is -p m168
 The port is whatever the FTDI chip shows up as

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

Más información:

 https://www.arduino.cc/en/Hacking/Bootloader
 Cargar bootloader en Arduino Mini: https://www.arduino.cc/en/Hacking/MiniBootloader
 https://learn.adafruit.com/arduino-tips-tricks-and-techniques/bootloader
 http://stackoverflow.com/questions/3652233/arduino-bootloader
 http://www.avr-developers.com/bootloaderdocs/

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

bootloader

Auto Reset

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

En el caso de los Arduinos, tienen la funcionalidad de auto-reset que está diseñado de forma
que permite ser reseteado vía software conectado a un ordenador como el IDE de arduino.
Una de las líneas de hardware flow control (DTR) del ATmega8U2/16U2 está conectada a la
línea de reset de ATmega328 a través de un condensador de 100 nF.

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

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

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

Más información en:

 http://playground.arduino.cc/Main/DisablingAutoResetOnSerialConnection
 http://playground.arduino.cc/Main/ArduinoReset

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

Codigo fuente del bootloader de

Arduino: https://github.com/arduino/Arduino/tree/master/hardware/arduino/avr/bootloaders

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

Toda la información del optiboot:

 Optiboot: https://github.com/Optiboot/optiboot
 Wiki: https://github.com/Optiboot/optiboot/wiki
 Optiboot anterior: https://code.google.com/p/optiboot/

HoodLoader2 te la opción de reprogramar el ATmega16u2 de un Arduino normal con

sketcehs: https://github.com/NicoHood/HoodLoader2, se trata de un proyecto muy intersante.

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

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

Optiloader es un sketch diseñado para automatizar las actualización de los bootloaders de

Arduino usando otro Arduino como programador. Almacena múltiples copias de optiboot en la
flash y cuando se inicia consulta al Arduino a cargar el bootloader y averigua la CPU que tiene
e inicia la carga del bootloader ya programación adecuada de los fuses.

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

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

Cargar el Bootloader en Arduino

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

 Arduino Uno y mini posee auto reset usando el optiboot bootloader

 Arduino mega posee auto reset y usa el stk500v2 bootloader

Para cargar o “quemar” el bootloader, necesitaremos un programador externo (in-system

programmer). como USBtinyISP (https://learn.adafruit.com/usbtinyisp), un programador
parallelo (http://arduino.cc/en/Hacking/ParallelProgrammer) u otro arduino con un programa
adecuado cargado.

El programador se conecta a ICSP y debemos asegurarnos que lo conectamos correctamente

y asegurarnos que hemos seleccionado la placa correcta, luego lanzar el comando
herramientas > grabar secuencia de inicio desde el IDE de arduino. Este proceso tarda 15 o
más segundos.

Más información:

 http://arduino.cc/en/Hacking/Bootloader
 https://learn.sparkfun.com/tutorials/installing-an-arduino-bootloader

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

Ver los ficheros boards.txt y programmers.txt en C:\Program Files

(x86)\Arduino\hardware\arduino y ver es esa misma ruta los bootloader.

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

Para el Arduino mini hay diferencias a la hora de cargar el

bootloader: http://arduino.cc/en/Hacking/MiniBootloader

Cargar sketches con un programador externo

Con un programador externo, además de cargar el bootloader a un microcontrolador, también

podemos cargar los sketchs en la MCU sin necesidad del bootloader.

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

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

Para usar el programador externo debemos modificar ligeramente el fichero de preferencias

del IDE de Arduino y debemos hacerlo con el IDE cerrado. Para encontrar el fichero de
preferencias: http://arduino.cc/en/Hacking/Preferences

Debemos cambiar la línea upload.using=bootloader por el identificador de uno de los

programadores que tenemos en el fichero programmers.txt. Por ejemplo avrispmkii.

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

Para volver a programar usando el bootloader, debemos volver a la

configuración upload.using=bootloader en el fichero de preferencias y por supuesto el
bootloader de nuevo en la placa.

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

Ejemplos de programadores:
  Pololu: https://www.pololu.com/product/1300
 Programador para AVR: https://www.sparkfun.com/products/9825
 Programador ofical de Atmel: http://www.atmel.com/tools/AVRISPMKII.aspx y
manual: http://www.atmel.com/webdoc/avrispmkii/index.html
 AVRISP mkII: http://www.digikey.com/product-detail/es/ATAVRISP2/ATAVRISP2-
ND/898891
 https://www.sparkfun.com/products/8702
 https://www.seeedstudio.com/AVR-USB-Programmer-p-696.html
 http://www.fischl.de/usbasp/
 https://learn.adafruit.com/usbtinyisp

También es posible programar un ATtiny con una Raspberry Pi por

SPI: http://www.instructables.com/id/Programming-the-ATtiny85-from-Raspberry-
Pi/?ALLSTEPS

Ejercicios Bootloader

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

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

ATENCIÓN – esto eliminará el bootloader de Arduino

Tutoriales:
  http://arduino.cc/en/Tutorial/ArduinoISP
 http://zygzax.com/2013/03/13/cargar-bootloader-en-arduino-usando-una-segunda-
placa/
 https://learn.sparkfun.com/tutorials/installing-an-arduino-bootloader/connecting-the-
programmer
 http://phaq.phunsites.net/2013/09/12/use-arduino-micro-as-isp-with-atmega-on-a-
breadboard/
 Para hacerlo sobre un micro directamente sin Arduino: http://www.open-
electronics.org/arduino-isp-in-system-programming-and-stand-alone-circuits/

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

REPORT THIS AD

Compártelo:

 Twitter
 Facebook3
 Google

Relacionado
Cómo conseguir un “Arduino” GratisEn "Arduino"
IDE Arduino y ConfiguraciónEn "Arduino"
Instalación Software y ConfiguraciónEn "Arduino"
Esta entrada se publicó en Arduino, Avanzado, bootloader, Hardware Libre y está etiquetada
con Arduino, Avanzado, bootloader, Hardware en 9 noviembre, 2016.

UART y USB en Arduino

3 respuestas

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:

 https://es.wikipedia.org/wiki/Universal_Serial_Bus
 https://en.wikipedia.org/wiki/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:

 http://codeandlife.com/2012/01/22/avr-attiny-usb-tutorial-part-1/
 http://codeandlife.com/2012/01/25/avr-attiny-usb-tutorial-part-2/
 http://codeandlife.com/2012/01/29/avr-attiny-usb-tutorial-part-3/
 http://codeandlife.com/2012/02/04/avr-attiny-usb-tutorial-part-4/

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:

 http://www.linux-usb.org/usb.ids
 https://usb-ids.gowdy.us/
 USB ID Database:http://www.the-sz.com/products/usbid/
 Product ID de Arduino: https://usb-ids.gowdy.us/read/UD/2341
 http://electronics.stackexchange.com/questions/108409/how-to-check-the-vendor-id-
for-your-company

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

1
void setup() {
2 //Initialize serial and wait for port to open:
3 Serial.begin(9600);

4 while (!Serial) {

5 ; // wait for serial port to connect. Needed for native USB

}
6
}
7

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:

 https://www.obdev.at/products/vusb/index.html
 http://vusb.wikidot.com/
 http://vusb.wikidot.com/hardware
 Código fuente: https://github.com/obdev/v-usb
 Más de V-USB: http://codeandlife.com/2012/02/22/v-usb-with-attiny45-attiny85-without-
a-crystal/
 Un ejemplo interesante: http://codeandlife.com/2013/08/27/retronics-usb-joystick-
adapter-and-other-coolness-with-v-usb/

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:

 http://www.edn.com/electronics-blogs/embedded-basics/4440395/USART-vs-UART–
Know-the-difference
 http://www.firmcodes.com/difference-uart-usart/

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

 http://maxembedded.com/2013/09/the-usart-of-the-avr/
 http://maxembedded.com/2013/09/serial-communication-introduction/
 https://hekilledmywire.wordpress.com/2011/01/05/using-the-usartserial-tutorial-part-2/
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:

 RS232 – http://en.wikipedia.org/wiki/RS-232
 RS885 – https://en.wikipedia.org/wiki/RS-485
 RS422 – https://en.wikipedia.org/wiki/RS-422

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.ht
m

Productos de FTDI:

 http://www.ftdichip.com/FTProducts.htm
 http://www.ftdichip.com/Products/Cables/USBTTLSerial.htm
 USB: http://www.ftdichip.com/USB.html
Chip FTDI:

 Gama de ICs: http://www.ftdichip.com/Products/ICs.htm

 Serie to USB: http://www.ftdichip.com/Products/ICs/FT232R.htm
 Serie to USB mejorado:http://www.ftdichip.com/Products/ICs/FT231X.html

 http://www.ftdichip.com/Support/Documents/DataSheets/ICs/DS_FT232R.pdf
 http://es.rs-online.com/web/p/products/406580/

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

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:

 Descarga Dirección: http://www.ftdichip.com/Products/ICs/FT232R.htm

 Drivers http://www.ftdichip.com/Drivers/VCP.htm

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.

Anuncios
REPORT THIS AD

REPORT THIS AD

Compártelo:
  Twitter
 Facebook10
 Google

Relacionado
USB to SerialEn "Arduino"
ICSPEn "Arduino"
Alimentación ArduinoEn "Arduino"
Esta entrada se publicó en Arduino, Hardware, Puerto Serie, USB y está etiquetada
con Arduino, Avanzado, FTDI, Hardware, Puerto Serie, USB en 9 noviembre, 2016.

Software Arduino a fondo

3 respuestas

Programación Arduino
El lenguaje de programación de Arduino es C++, aunque es posible programarlo en otros
lenguajes. No es un C++ puro sino que es una adaptación que proveniente de avr-libc que
provee de una librería de C de alta calidad para usar con GCC (compilador de C y C++) en los
microcontroladores AVR de Atmel, denominado avr-gcc, y otras muchas funciones específicas
para las MCU AVR de Atmel.

El lenguaje de los AVR es un entorno C para programar los chips de Atmel, la mayor parte del
lenguaje o core de Arduino está escrito con constantes y funciones AVR y hay bastantes
cosas que no son fáciles de hacer con el lenguaje de Arduino sin el uso de código AVR de la
avr-libc.

Como el entorno de Arduino usa GCC para compilar el código, todas las variables de los
puertos y de los registros de una MCU de Atmel son soportadas por el IDE de Arduino.

Las herramientas necesarias para programar los microcontroladores AVR de Atmel son avr-
binutils, avr-gcc y avr-libc y ya están incluidas en el IDE de Arduino, cuando compilamos y
cargamos un sketch estamos usando estas herramientas.

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

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

Para Linux son necesarias estas herramientas:

 gcc-avr
 binutils-avr
  gdb-avr
 avr-libc
 avrdude

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

Un ejemplo de uso de funciones AVR que no dispone el entorno de Arduino es cuando

queremos hacer delays muy pequeños. La función delayMircoseconds() puede hacer el delay
más pequeño con el lenguaje de Arduino que es de 2 microsegundos.

Para delays menores es necesario usar ensamblador y en concreto la función ‘nop’ (no
operation. Cada llamada a ‘nop’ ejecuta un ciclo de reloj que para 16 MHz es un retraso de
62,5 ns.

__asm__(“nop\n\t”);
__asm__(“nop\n\t””nop\n\t””nop\n\t””nop\n\t”); \\ gang them up like this

También como hemos visto anteriormente, manipular los puertos y pines con el código AVR es
más rápido que usar digitalWrite(). Más
información https://www.arduino.cc/en/Reference/PortManipulation

Otro ejemplo es el uso de los métodos AVR cbi y sbi que se usan para hacer set o clear de
bits el PORT y otras variables. Puedes encontrar estos métodos de código AVR en muchos
sitios y ambos deben ser definidos en el sketch de Arduino para ser usados. Pegar este
código al inicio del sketch y para usarlo simplemente poner una variable del puerto y el pin
para hacer set o clear.

#ifndef cbi
#define cbi(sfr, bit) (_SFR_BYTE(sfr) &= ~_BV(bit))
#endif
#ifndef sbi
#define sbi(sfr, bit) (_SFR_BYTE(sfr) |= _BV(bit))
#endif

Pero para programar el 99% de lo que necesitemos en proyectos sencillos con Arduino, todo
esto se puede resumir en que para programar nuestro lenguaje de programación de Arduino
es el “Arduino Reference”, que es donde debemos recurrir para cualquier duda de
programación que surja. Puesto que Arduino provee de unas librerías que facilitan la
programación del microcontrolador. http://arduino.cc/en/Reference/HomePage

A medida que nuestro programa se hace más complejo o necesitamos que sea más rápido o
queremos que tenga un uso de memoria más eficiente, entonces es cuando tendremos que
recurrir a los comando AVR de la avr-libc.

El gran éxito de Arduino en parte se debe a que el IDE nos permite programar una MCU sin
tener que saber todo lo anterior y nos da unas herramientas sencillas y específicas para
programar los microcontroladores que suministra en sus placas. Por ejemplo veamos las
funciones que nos ofrece para comunicar por el puerto
serie: http://arduino.cc/en/Reference/Serial

El IDE de Arduino está basado en Processing: https://processing.org/, es un lenguaje de

programación y entorno de desarrollo integrado de código abierto basado en Java, de fácil
utilización, y que sirve como medio para la enseñanza y producción de proyectos multimedia e
interactivos de diseño digital.

La librería Arduino está basada en wiring: http://wiring.org.co/ y es de donde nacieron las

funciones que conocemos como digitalRead(), Serial.println(), etc…

Web del proyecto de Proccesing: https://processing.org/

Processing en github: https://github.com/processing/processing

Web del proyecto Wiring: http://wiring.org.co/

Wiring en github: https://github.com/WiringProject

Processing es útil cuando queremos comunicar Arduino con un ordenador y mostrar datos o
guardar datos, pero también podemos usar python, .NET o cualquier otro lenguaje de
programación que conozcamos.

Arduino trae algunos ejemplos para trabajar con Processing en el apartado communication,
por ejemplo para hacer una gráfica de datos en http://arduino.cc/en/Tutorial/Graph

Ver el reference y la librería Serial de

processing: https://processing.org/reference/ y https://processing.org/reference/libraries/serial/

También disponemos de una librería de Arduino para processing que nos permite interactuar
entre processing y arduino: http://playground.arduino.cc/interfacing/processing

Por supuesto Arduino se puede programar en otros lenguajes y desde otros entornos de
programación. Cabe destacar scratch como un lenguaje visual que hace innecesario saber
programación o Atmel Studio que es la herramienta que proporciona Atmel. Más información
en: https://aprendiendoarduino.wordpress.com/2014/11/20/tema-4-conceptos-basicos-de-
programacion/

Más información: http://wittyrobo.com/mcu328p/c01_p01.html

Fuses

Los fuses son una parte muy importante en la programación de un microcontrolador. Solo es
necesario configurarlos una vez, pero si no se hace correctamente podemos tener problemas.
Ya sabemos lo que es la flash, EEPROM y RAM como parte de la MCU, pero no se ha
mencionado anteriormente que hay 3 bytes de memoria permanente llamados fuses. Los
fuses determinan cómo se va a comportar el microcontrolador, si tiene bootloader, a que
velocidad y voltaje va a funcionar, etc… Notar que a pesar de llamarse fuses (fusibles) puede
configurarse una y otra vez y no tienen nada que ver con la protección de sobrecorrientes.

Los fuses están documentados en los datasheets, para el Arduino UNO ver página 348
de http://www.atmel.com/Images/Atmel-42735-8-bit-AVR-Microcontroller-ATmega328-
328P_datasheet.pdf

Con los fuses seleccionamos el comportamiento de:

 Clock Source: puede ser un reloj externo, un reloj interno o un cristal externo.
 Clock Startup: es el tiempo que necesita la fuente de reloj para estabilizarse.
 Clock Output: habilita una salida de reloj en el PORT C2
 Clock Divide: Divide por 8 el reloj
 Reset Disable: convierte el pin de reset en un pin normal, habilitar este fuse hace que
no se pueda programar por ISP
 Brown-out Detect (BOD): selecciona a que voltaje hace disparar la protección de
brownout. Para una MCU brownout es el voltaje al que es demasiado bajo para que
funcione de una forma fiable a la velocidad de reloj.
 Selecciona si se usa bootloader o no.
 Selecciona cuánta memoria se reserva para el bootloader
 Deshabilitar programación por el puerto serie

Con los fuses podemos bloquear algunos aspectos importamte de la MCU y podríamos
brickearlo.

Los 3 bytes de los fuses son:

 low byte fuse

 high byte fuse
 extended fuse

También hay un cuarto byte que se usa para programar los lock bits. Los lock bits pueden ser
usados para restringir la lectura/escritura en la memoria de programa (flash), la zona de boot y
la de aplicación tienen sus propios lock bits y es posible controlar el acceso a ellos de forma
separada.

Para los fuses el 1 significa no usado y 0 usado.

Low Byte Fuses

High Byte Fuses

Extended Fuse Bits

Los valores por defecto el ATmega328p son:

 Low fuse = 0x62 (B01100010)

 High fuse = 0xD9 (B11011001)
 Extended fuse = 0xFF (B11111111)
Los valores de los fuses de Arduino con el ATmega328p son:

 Low fuse = 0xFF (B11111111)

 High fuse = 0xDA (B11011110)
 Extended fuse = 0x05 (B00000101)
En caso de usar el Optiboot bootloader, cambia el valor en el high byte fuse porque el tamaño
del bootloader es inferior.
Más información de cada fuse en: http://www.martyncurrey.com/arduino-atmega-328p-fuse-
settings/

Pero la mejor forma de ver los fuses es examinar AVR fuse

calculator: http://www.engbedded.com/fusecalc/

Luego con los datos de los 3 bytes de los fuses, se pasan como argumento en el avr-dude al
cargar el sketch y configurar los fuses. La configuración de los fuses es parte del proceso de
cargar un bootloader. Editando el fichero boards.txt en la carpeta del IDE de Arduino en la ruta
C:\Program Files (x86)\Arduino\hardware\arduino\avr se puede configurar el valor de los fuses.

Discusion en foro sobre el uso de fuses para proteger el binario de un

sketch: http://www.todopic.com.ar/foros/index.php?topic=44794.0. Es tan simple como
agregar “-Ulock :w:03c:h” al final del comando que se le envía a avrdude.exe. Se configuran
los lock bits como 1100 0011 (ojo que cambian los bits más significativos y menos
significativos)
Cargar un programa desde el ide de arduino al microcontrolador. Luego desde el programa
que mencionado ejecutar el mismo comando enviado por el ide de arduino a avrdude, pero
cambiando la ruta del archivo .hex por un programa distinto y agregando al final “-Ulock
:w:03c:h” Avrdude muestra en pantalla el avance en el proceso, pero al tratar de verificar el
archivo enviado con el que recibe del microcontrolador, la comprobación falla. El
microcontrolador se reinicia y ejecuta el programa nuevo correctamente, lo que demuestra que
el Arduino no entregará el programa y que avrdude no es capaz de extraerlo del
microcontrolador, ni tampoco con esta configuración es posible cargar ningún programa.

Ver el estado de los fuses de un Arduino se puede hacer con avr-dude y un programador, para
ello hay que ejecutar el comando “avrdude -c arduino -p m328p -P COM3 -b 19200 -v”

Con AVR studio se puede leer y escribir los valores de los fuses. Pero si queremos cambiar
los valores de los fuses con el IDE de Arduino podemos hacerlo de dos formas:

 Option 1. El “quemado del bootloader” configura los fuses. Para configurar los fuses el
ATmega328p se puede hacer en el proceso de cargar bootloader y toma la
configuración de los fuses que hay en el fichero boards.txt de la placa correspondiente.
 Option 2. Configurar los fuses manualmente, sin cargar un bootloader. Para ello
necesitaremos la herramienta avr-dude mediante el comando.
“avrdude -c stk500v2 -p m328p -P /dev/ttyACM0 -b 19200 -U lfuse:w:0xFF:m -
U hfuse:w:0xDE:m -U efuse:w:0x05:m”

Más información en:

 http://ladyada.net/learn/avr/fuses.html
 http://www.martyncurrey.com/arduino-atmega-328p-fuse-settings/
 Como cambiar los fuse bits a un ATmega328p: http://www.instructables.com/id/How-
to-change-fuse-bits-of-AVR-Atmega328p-8bit-mic/?ALLSTEPS
 https://voidyourwarranty.wordpress.com/2014/08/17/using-arduino-as-an-isp-to-
program-a-standalone-atmega-328p-including-fuses/
 http://www.hackersworkbench.com/intro-to-bootloaders-for-avr
 http://www.radiolocman.com/review/article.html?di=148456

IDE Arduino

El IDE de Arduino es open source y por lo tanto tenemos su código fuente y también podemos
hacer nuestra propia versión del IDE. El proyecto del IDE de Arduino en github
es: https://github.com/arduino/Arduino y las instrucciones para construir el binario desde el
fuente está en https://github.com/arduino/Arduino/wiki/Building-Arduino

El software de Arduino se puede descargar en https://www.arduino.cc/en/Main/Software

Para actualizar Arduino y mantener las configuraciones, en Windows simplemente ejecutar el

instalador, este desinstala la versión anterior y mantiene las librerías y sketchs siempre y
cuando no hayamos guardado o modificado algo en el directorio de instalación.

También es posible tener varias versiones del IDE instaladas, simplemente usar la instalación
manual con el archivo .zip

Para añadir al IDE Arduino soporte de placas de terceros: https://learn.adafruit.com/add-

boards-arduino-v164?view=all

Lista no oficial de placas de terceros soportadas por el IDE de Arduino:

https://github.com/arduino/Arduino/wiki/Unofficial-list-of-3rd-party-boards-support-urls#list-of-
3rd-party-boards-support-urls, que son ficheros json para añadir en el IDE y dar soporte con el
nuevo gestor de placas.

Ruta donde se instalan los cores: C:\Users\enrique\AppData\Local\Arduino15\packages

La explicación de cada parámetro en configuración

IDE: https://code.google.com/archive/p/arduino/wikis/Platforms.wiki, en la ruta: C:\Program
Files (x86)\Arduino\hardware\arduino\avr

 boards.txt: The Arduino environment supports multiple target boards with different
chips (currently, only AVRs), CPU speeds, or bootloaders. These are defined
in boards.txt. A board is specified by multiple variables prefixed with the same keyword
(shown here as BOARD). The file consists of multiple lines with the format key=value.
Lines that start with a # are comments and ignored.
 programmers.txt: Programmers may be specified in the programmers.txt file in a
platform. This file has a format similar to the boards.txt file, but with the other variables.
 The bootloaders sub-folder of a platform contains the bootloaders for the boards in the
platform. These should appear as .hex files in a sub-folder of the bootloaders folder.
Often, the source code for the bootloader is also included, along with a Makefile for
building the .hex file.
 A core is a set of .c, .cpp, and .h files that implement the basic Arduino functions for a
platform. Each core appears as a sub-folder of thecores sub-folder of a platform.

Guia para cambiar estilo IDE Arduino:

 Dark Theme: https://github.com/jeffThompson/DarkArduinoTheme

 http://www.jeffreythompson.org/blog/2013/01/15/dark-arduino-ide/
 http://mitat.tuu.fi/?p=117

AVR libc

Es posible usar comandos estándar de C++ en la programación de Arduino siempre que estén
incluidos en el avr libc, así como otros comandos propios para las MCUs AVR tambiñen
incluidos en en avr-libc:

 Reference: http://www.atmel.com/webdoc/AVRLibcReferenceManual/
 Toolchain: http://www.atmel.com/webdoc/AVRLibcReferenceManual/overview.html
 Módulos http://www.atmel.com/webdoc/AVRLibcReferenceManual/ch20.html
 Standard
Library: http://www.atmel.com/webdoc/AVRLibcReferenceManual/group__avr__stdlib.h
tml
 String
Module: http://www.atmel.com/webdoc/AVRLibcReferenceManual/group__avr__string.
html
 Tratamiento de la memoria de la MCU por avr-
libc: http://www.atmel.com/webdoc/AVRLibcReferenceManual/malloc_1malloc_intro.ht
ml
 Free software project: http://www.nongnu.org/avr-
libc/ y http://savannah.nongnu.org/projects/avr-libc/
 Módulos de open source project: http://www.nongnu.org/avr-libc/user-
manual/modules.html
Dispositivos soportados por avr-
libc: http://www.atmel.com/webdoc/AVRLibcReferenceManual/index_1supp_devices.html

Cuando creamos un programa en Arduino, automáticamente carga varios módulos como

stdlib.h, math.h, etc…

Por ejemplo math.h:

 https://www.arduino.cc/en/Math/H
 http://www.nongnu.org/avr-libc/user-manual/group__avr__math.html

El equivalente para linux de avr-libc es la glibc:

 http://www.gnu.org/software/libc/index.html
 manual: https://www.gnu.org/software/libc/manual/html_node/index.html
 Wiki: https://sourceware.org/glibc/wiki/HomePage

glibc como se puede ver tiene versiones para diferentes arquitecturas de los ordenadores
como i386, i686, etc… para usar las instrucciones de cada una de sus arquitecturas.

Más información sobre MCUs AVR:

 http://www.avr-tutorials.com/
 http://playground.arduino.cc/Main/AVR

WinAVR

WinAVR es una herramienta importante para el desarrollo de MCUs AVR, incluso después de
instalar Atmel Studio como IDE, es recomendable instalar WinAVR.

WinAVR (pronunciado “whenever”) es una suite compuesta de herramientas de desarrollo

opensource para los microcontroladores AVR sobre plataforma Windows. Incluye el
compilador GNU GCC para C y C++.

Herramientas WinAVR:

 avr-gcc (compiler)
 avrdude (programmer)
 avr-gdb (debugger)
 avr-libc (with a good HTML help Documentation)
 and more …..

Web del proyecto:

 https://sourceforge.net/projects/winavr/
 http://winavr.sourceforge.net/

Más información:

 FAQ de avr-libc: http://www.nongnu.org/avr-libc/user-manual/FAQ.html

  Tutorial AVR: http://ladyada.net/learn/avr/index.html
 http://winavr.scienceprog.com/

Tutoriales de programación AVR:

 http://ocw.mit.edu/courses/media-arts-and-sciences/mas-962-special-topics-new-
textiles-spring-2010/readings-lectures-tutorials/tut06_avr1/
 http://ocw.mit.edu/courses/media-arts-and-sciences/mas-962-special-topics-new-
textiles-spring-2010/readings-lectures-tutorials/tut06_avr2/
 Tutoriales para trabajar con AVR: http://playground.arduino.cc/Main/TutorialList#AVR

Interesante información sobre avr-lib en Wiring y

Arduino: https://ccrma.stanford.edu/~juanig/articles/wiriavrlib/wiriavrlib.html

Proceso de compilación

GCC es un conjunto de compiladores que se considera el estándar para los Sistemas

Operativos derivados de UNIX y requiere de un conjunto de aplicaciones conocidas como
binutils que son unas herramientas de programación para la manipulación de código de objeto.

GCC soporta varios lenguajes y diferentes arquitecturas de HW::

 Proyecto GCC: https://gcc.gnu.org/

 Como usar GCC: https://gcc.gnu.org/onlinedocs/gcc/
 Wiki GCC: https://gcc.gnu.org/wiki/HomePage
 Lenguajes soportados por GCC: https://gcc.gnu.org/onlinedocs/gcc/G_002b_002b-
and-GCC.html
 HW options: https://gcc.gnu.org/onlinedocs/gcc/Submodel-Options.html
 AVR options: https://gcc.gnu.org/onlinedocs/gcc/AVR-Options.html
 ARM options: https://gcc.gnu.org/onlinedocs/gcc/ARM-Options.html
 Ensamblador en C: https://gcc.gnu.org/onlinedocs/gcc/Using-Assembly-Language-
with-C.html
 Instrucciones de instalación de avr-gcc: http://www.akafugu.jp/posts/resources/avr-gcc/

Como GCC está construido para ejecutarse en un sistema como Linux, Windows o mac OS,
pero para generar código para un microcontrolador AVR, entonces se denomina avr-gcc que
es una versión de GCC solo para arquitecturas AVR. avr-gcc es el compilador que usa el IDE
de arduino para convertir el sketch en C++ a un fichero binario (.hex) que es el que se carga
en la flash del MCU y que ejecuta.

avr-gcc se puede usar directamente o a través de un IDE como el de Arduino o el Atmel

Studio.

En el caso de Arduino el proceso de construcción para que el código escrito llegue a la placa
es el siguiente:

 El IDE verifica el código y comprueba que la sintaxis del código es correcta en C y C++
 Luego pasa al compilador avr-gcc, que convierte el código en C++ en instrucciones
que entiende el microcontrolador.
 Después el código es combinado con las librerías estándar de Arduino, que son las
que ofrecen las funciones básicas como digitalWrite() o Serial.println().
  El resultado es un fichero hex que contiene los bytes que van a ser grabado en la
memoria flash de Arduino.
 Finalmente el fichero es cargado en la placa Arduino transmitiendolo sobre el USB o la
conexión serie si hay un bootloader cargado o sino con un hardware externo
(programador).

Cuando un sketch contiene múltiples ficheros, es compilado y los ficheros con extensiones .c o
.cpp se compilan de forma separada y los ficheros con otras extensiones se concatenan juntos
al fichero del sketch principal antes de pasarlo al compilador. Para usar ficheros con extensión
.h, es necesario incluirlos con #include usando “comillas dobles” y no <>

El entorno de Arduino, antes de compilar también hace algunas modificaciones como añadir al
principio del sketch #include “Arduino.h”. También el entorno de Arduino busca las definiciones
de las funciones en el sketch principal y crea las declaraciones (prototypes) para ellas, estas
se insertan después de los comentarios y las directivas de preprocesamiento, pero antes del
resto de código, esto significa que si se quiere usar un tipo de dato como argumento de una
función, debe declararse dentro de un fichero de cabecera separado.

El entorno de Arduino soporta múltiples placas con diferentes MCUs (no solo AVR), todo los
datos de la placa están definidos en el fichero boards.txt en C:\Program Files
(x86)\Arduino\hardware\arduino\avr. A la hora de compilar las opciones se toman del
fichero boards.txt en la opción de build.

Cuando se compila desde el IDE de Arduino cono avr-gcc, las rutas donde se busca cuando
se hace un include son:

 El directorio del core de la placa <ARDUINO>/hardware/core/<CORE>/

 El directorio de avr include <ARDUINO>/hardware/tools/avr/avr/include/
 Cualquiera de los directorios de librerías <ARDUINO>/hardware/libraries/ o
C:\Users\<USER>\Documents\Arduino\libraries

Cuando un sketch se verifica, se genera el fichero compilador en un directorio temporal del

SO. Todos los ficheros .c y .cpp son compilados y la salida es un fichero .o (object file), tanto
el del sktech final como otros que haya en el directorio del sketch o los de las librerías
incluidas. Los fichero .o son enlazados todos juntos en una librería estática y el fichero del
sketch principal. Solo las partes de las librerías necesitadas para el sketch son incluidas en el
fichero final .hex, reduciendo el tamaño de la mayoría de los sketches.

El fichero .hex es la salida final de la compilación y es cargado en la memoria flash de

Arduino. Este .hex es cargado en Arduino mediante avrdude y este proceso es controlado por
las variables de las placas en el fichero de boards.txt dentro de las opciones “upload”

Para que me guarde los hex en una carpeta

concreta: http://forum.arduino.cc/index.php?topic=142706.0

Durante el proceso de compilación se genera un fichero intermedio con extensión .elf que
contiene el código máquina y otra información relacionado con información de la memoria y
debug. El fichero elf (Executable and Linking Format), es el formato estándar para ficheros
ejecutables, objetos de código y librerías compartidas. Elf es como una dll y consiste en unos
enlaces simbólicos y tablas que pueden cargarse en una zona de memoria. Los fichero elf
tienen varias secciones como datos, textos, etc.. Este fichero se suele usar para debug con
emuladores.
Durante el proceso de compilación y carga, el IDE de Arduino muestra mucha información
(hay que activarlo antes,
ver https://aprendiendoarduino.wordpress.com/2016/06/26/instalacion-software-y-
configuracion/) que puede resultar de ayuda para saber lo que está pasando durante el
proceso. La herramienta que convierte el fichero .elf a .hex es avr-objcopy.

Más información:

 http://arduino.cc/en/Hacking/BuildProcess
 https://balau82.wordpress.com/2011/03/29/programming-arduino-uno-in-pure-c/
 http://openhardwareplatform.blogspot.com.es/2011/03/inside-arduino-build-
process.html
 Formato Intel HEX https://en.wikipedia.org/wiki/Intel_HEX
 Arduino en línea de comandos: http://www.mjoldfield.com/atelier/2009/02/arduino-
cli.html y http://johanneshoff.com/arduino-command-line.html
 makefile para sketches Arduino: https://github.com/sudar/Arduino-Makefile/

Cómo compilar un sketch de Arduino con makefile:

 http://hardwarefun.com/tutorials/compiling-arduino-sketches-using-makefile
 https://github.com/sudar/Arduino-Makefile
 http://sudarmuthu.com/blog/why-you-should-open-source-your-next-pet-project/
 http://stackoverflow.com/questions/13260508/using-the-arduino-libraries-for-regular-
avr-code

Opciones de compilación:

 http://www.atmel.com/webdoc/AVRLibcReferenceManual/using_tools_1using_sel_gcc
_opts.html
 http://www.atmel.com/webdoc/AVRLibcReferenceManual/using_tools_1using_avr_gcc
_mach_opt.html

Esta imagen muestra todo el proceso:

Información sobre las
binutils: http://www.atmel.com/webdoc/AVRLibcReferenceManual/overview_1overview_binutils
.html

Arduino también nos ofrece la posibilidad de una herramienta de línea de comandos para
compilar los sketches de Arduino llamada Arduino Builder: https://github.com/arduino/arduino-
builder, siendo uan herramienta muy intersante para hacer integración
continua https://github.com/arduino/arduino-builder/wiki/Doing-continuous-integration-with-
arduino-builder o testeo de nuestro softwatre (TDD).

También hay interfaces gráficos para GCC:

 http://www.instructables.com/id/Simple-Graphic-Interface-for-Linux-GCC-
Compiler/?ALLSTEPS
 Compilar usando GCC desde visual studio: http://www.instructables.com/id/Compile-
Using-GNU-GCC-from-Visual-Studio/?ALLSTEPS

Probar/Ejercicio: El compilador de avr-gcc cuando detecta lineas iguales de Serial.print() no

aumenta la memoria del static data porque lo reconoce y la guarda una sola vez en RAM y la
repite al llamarla. Tampoco aumenta el tamaño del hex.

Ensamblador

Ensamblador es un lenguaje de bajo nivel. Consiste en una lista de instrucciones que no son
de ninguna manera comparable a cualquier otro lenguaje como C, Basic o Pascal. El AVR
tiene alrededor de 130 instrucciones, dependiendo del tipo, periféricos y tamaño del
microcontrolador. En este link está el manual de las instrucciones con su respectiva
explicación, y en este otro link se encuentra la guia de usuario de AVR Assembler. Se puede
encontrar más información en http://www.avrbeginners.net/ y en http://www.avrfreaks.net/

Como ya hemos visto Arduino podemos programarlo en C puro, pero también podríamos
programarlo en ensamblador, aunque no es una opción recomendable. Sin embargo como
veremos podremos obtener el código en ensamblador de nuestro sketch.

Sin embargo, podría ser útil en determinadas situaciones insertar código en ensamblador
dentro de nuestro sketch de Arduino. El compilador GNU C para procesadores Atmel AVR
RISC procesadores permite incrustar el código de lenguaje ensamblador en programas C.
Esta característica se puede utilizar para optimizar manualmente las partes críticas de tiempo
del software o utilizar una instrucción de procesador específico, que no están disponibles en el
lenguaje C.

Las instrucciones de cada procesador se pueden ver en los datasheet correspondientes y para
el caso de los AVR de 8 bit en:

 http://www.atmel.com/Images/Atmel-0856-AVR-Instruction-Set-Manual.pdf
 Instrucciones de código máquina o ensamblador de los MCU
AVR: http://www.atmel.com/webdoc/avrassembler/avrassembler.wb_instruction_list.ht
ml

AVR Assembler User Guide: http://www.atmel.com/Images/doc1022.pdf

Para insertar instrucciones de ensamblador en C ver: Inline assembler

cookbook: http://www.nongnu.org/avr-libc/user-manual/inline_asm.html, simplemente poner en
el código C la instrucción asm volatile(); pasando como parámetro el código entre comillas.

Más información:
  http://www.atmel.com/webdoc/avrassembler/
 http://www.atmel.com/webdoc/avrassembler/avrassembler.wb_Syntax.html
 http://www.avr-asm-download.de/beginner_en.pdf

Proceso de Carga del Sketch

Una vez compilado y obtenido el fichero binario, hay que cargarlo en la memoria flash de
Arduino, para ello el IDE de Arduino usa una herramienta llamada avr-dude.

Cuando tenemos problemas al cargar un sketch de Arduino, el problema suele venir de

avrdude y en este enlace habla de los problemas y sus
soluciones http://elcajondeardu.blogspot.com.es/2016/03/avrdude-nos-lo-explica-rufian-rufian-
en.html

Página del proyecto avr-dude:

 http://savannah.nongnu.org/projects/avrdude
 http://www.nongnu.org/avrdude/

Manual del AVRdude:

 http://www.nongnu.org/avrdude/user-manual/avrdude_1.html
 http://mirrors.fe.up.pt/pub/nongnu//avrdude/avrdude-doc-5.10.pdf
 https://omegav.no/wiki/index.php/AVR/avrdude

Hay versiones con GUI para avr-dude que nos permiten cargar el sketch con la opciones que
queramos.

 AVRDRDESS: http://blog.zakkemble.co.uk/avrdudess-a-gui-for-
avrdude/ y https://blog.adafruit.com/2013/02/19/avrdudess-a-gui-for-avrdude/
 avrdude-gui: https://sourceforge.net/projects/avrdude-gui/
 Introducción a avrdude
GUI http://embeddedtechi.blogspot.com.es/2016/06/introduction-to-avrdude-gui.html

Usar avr-dude con atmel studio y Arduino: http://wittyrobo.com/mcu328p/c04_p01.html

Uso de Arduino uploader:

 http://arduinodev.com/arduino-builder-tutorial/
 http://arduinodev.com/arduino-uploader/
 code: https://github.com/stanleyhuangyc/ArduinoUploader
 ejecutable https://sourceforge.net/projects/arduinodev/

Tutorial para usar AVRdude:

 http://www.ladyada.net/learn/avr/avrdude.html
 https://learn.adafruit.com/usbtinyisp/avrdude
 https://learn.sparkfun.com/tutorials/pocket-avr-programmer-hookup-guide/using-
avrdude
 https://learn.adafruit.com/introducing-trinket/programming-with-avrdude
Adicionalmente se disponen de otras herramientas para la MCUs de AVR:

 simulavr, en un simulador para MCUs de

AVR http://savannah.nongnu.org/projects/simulavr/
 GDB, es un debugger http://www.sourceware.org/gdb/
 AVaRICE, es un programa para hacer interfaz entre GDB y el AVR JTAG
ICE https://sourceforge.net/projects/avarice/ y http://avarice.sourceforge.net/

Soporte a tarjetas no oficiales con IDE Arduino

Al igual que hemos visto las herramientas necesarias para programar los microcontroladores
AVR de Atmel y que necesitamos de una librería avr-libc, un compilador avr-gcc y un
programa para cargar el .hex al microcontrolador, lo que compone el soporte en el IDE de
Arduino para estos microcontroladores, en caso de querer programar otras MCUs,
necesitaremos instalar las correspondientes herramientas para estos microcontroladores.

El proceso de dar soporte a otras tarjetas/microcontroladores en el IDE de Arduino se ha

facilitado mucho, disponiendo de unos ficheros json que se descarga el IDE de Arduino y con
ellos el IDE se descarga las herramientas necesarias y configura el IDE de Arduino para esas
MCUs.

Instalar soporte IDE a otras placas:

 Directorio donde se guarda el core de Arduino C:\Program Files

(x86)\Arduino\hardware
 Instalar soporte para ESP8266: https://github.com/esp8266/Arduino
 Listado de URLs para soporte de tarjetas no
oficiales: https://github.com/arduino/Arduino/wiki/Unofficial-list-of-3rd-party-boards-
support-urls
 Ruta donde se guarda el core instalado:
C:\Users\<USER>\AppData\Local\Arduino15\packages que es lo mismo que meterlo
en C:\Program Files (x86)\Arduino\hardware pero se hace para que no lo machaque la
actualizar el IDE de Arduino.

IMPORTANTE: especificaciones de formato a usar en el IDE de Arduino para soporte de

nuevas placas: https://github.com/arduino/Arduino/wiki/Arduino-IDE-1.5-3rd-party-Hardware-
specification

Arduino ARM

Por ejemplo las herramienta usadas por Arduino para las placas basadas en
microcontroladores ARM como el Arduino MKR1000, son las GNU ARM Embedded
Toolchain https://launchpad.net/gcc-arm-embedded que es mantenido por los empleados de
ARM. Usa gcc y newlib: https://sourceware.org/newlib/ y accesible el codigo fuente vía git
en https://sourceware.org/git/gitweb.cgi?p=newlib-htdocs.git y git://sourceware.org/git/newlib-
cygwin.git

Para programar la flash en los microcontroladores Atmel ARM de la familia SAM usar
BOSSA: http://www.shumatech.com/web/products/bossa y su código fuente está
en https://sourceforge.net/p/b-o-s-s-a/code/ref/master~/
También se usa otra herramienta llamada OpenOCD (Open On-Chip
Debugger) http://openocd.org/ y ofrece soporte a la programación y debug, soportando
muchos hardware debuggers.

Documentación: http://openocd.org/documentation/

Código fuente: https://sourceforge.net/p/openocd/code/ci/master/tree/

Anuncios
REPORT THIS AD

REPORT THIS AD

Compártelo:

 Twitter
 Facebook1
 Google

Relacionado
Lenguaje de programación de Arduino, estructura de un programaEn "Arduino"
Programación ArduinoEn "Arduino"
Programación ArduinoEn "Arduino"
Esta entrada se publicó en Arduino, ARM, Avanzado, IDE, Librerías, Programación y está etiquetada
con Arduino, ARM, avr-libc, avrdude, ensamblador, fuses, gcc, IDE, winAVR en 10 noviembre, 2016.

Wifi en Arduino
5 respuestas

El wifi es un mecanismo de conexión de dispositivos electrónicos de forma inalámbrica. Los

dispositivos habilitados con wifi como Arduino, pueden conectarse a internet a través de un
punto de acceso de red inalámbrica.

Wi-Fi es una marca de la Alianza Wi-Fi, la organización comercial que adopta, prueba y
certifica que los equipos cumplen con los estándares 802.11 relacionados a redes
inalámbricas de área local.
  Los estándares IEEE 802.11b, IEEE 802.11g e IEEE 802.11n disfrutan de una
aceptación internacional debido a que la banda de 2,4 GHz está disponible casi
universalmente, con una velocidad de hasta 11 Mbit/s, 54 Mbit/s y 300 Mbit/s,
respectivamente.
 En la actualidad ya se maneja también el estándar IEEE 802.11ac, conocido como
WIFI 5, que opera en la banda de 5 GHz y que disfruta de una operatividad con
canales relativamente limpios. La banda de 5 GHz ha sido recientemente habilitada y,
además, no existen otras tecnologías (Bluetooth, microondas, ZigBee) que la estén
utilizando, por lo tanto existen muy pocas interferencias. Su alcance es algo menor
que el de los estándares que trabajan a 2,4 GHz (aproximadamente un 10 %), debido
a que la frecuencia es mayor (a mayor frecuencia, menor alcance).

Existen otras tecnologías inalámbricas como Bluetooth que también funcionan a una
frecuencia de 2,4 GHz, por lo que puede presentar interferencias con la tecnología wifi. Debido
a esto, en la versión 1.2 del estándar Bluetooth actualizó su especificación para que no
existieran interferencias con la utilización simultánea de ambas tecnologías, además se
necesita tener 40 000 kbit/s.

Existen varias alternativas para garantizar la seguridad de estas redes. Las más comunes son
la utilización de protocolos de cifrado de datos para los estándares wifi como el WEP, el WPA,
o el WPA2 que se encargan de codificar la información transmitida para proteger su
confidencialidad, proporcionados por los propios dispositivos inalámbricos. La mayoría de las
formas son las siguientes:

 WEP, cifra los datos en su red de forma que sólo el destinatario deseado pueda
acceder a ellos. Los cifrados de 64 y 128 bits son dos niveles de seguridad WEP. WEP
codifica los datos mediante una “clave” de cifrado antes de enviarlo al aire. Este tipo
de cifrado no está recomendado debido a las grandes vulnerabilidades que presenta
ya que cualquier cracker puede conseguir sacar la clave, incluso aunque esté bien
configurado y la clave utilizada sea compleja.
 WPA: presenta mejoras como generación dinámica de la clave de acceso. Las claves
se insertan como dígitos alfanuméricos.
 WPA2 (estándar 802.11i): que es una mejora relativa a WPA. En principio es el
protocolo de seguridad más seguro para Wi-Fi en este momento. Sin embargo
requieren hardware y software compatibles, ya que los antiguos no lo son. Utiliza el
algoritmo de cifrado AES (Advanced Encryption Standard).
 IPSEC (túneles IP) en el caso de las VPN y el conjunto de estándares IEEE 802.1X,
que permite la autenticación y autorización de usuarios.
 Filtrado de MAC, de manera que solo se permite acceso a la red a aquellos
dispositivos autorizados. Es lo más recomendable si solo se va a usar con los mismos
equipos, y si son pocos.
 Ocultación del punto de acceso: se puede ocultar el punto de acceso (router) de
manera que sea invisible a otros usuarios.

Dispositivos de distribución o de red en wifi son:

 Los puntos de acceso son dispositivos que generan un set de servicio, que podría
definirse como una red wifi a la que se pueden conectar otros dispositivos. Los puntos
de acceso permiten, en resumen, conectar dispositivos de forma inalámbrica a una red
existente. Pueden agregarse más puntos de acceso a una red para generar redes de
cobertura más amplia, o conectar antenas más grandes que amplifiquen la señal.
  Los repetidores inalámbricos son equipos que se utilizan para extender la cobertura de
una red inalámbrica, éstos se conectan a una red existente que tiene señal más débil y
crean una señal limpia a la que se pueden conectar los equipos dentro de su alcance.
Algunos de ellos funcionan también como punto de acceso.
 Los enrutadores inalámbricos son dispositivos compuestos, especialmente diseñados
para redes pequeñas (hogar o pequeña oficina). Estos dispositivos incluyen, un
enrutador (encargado de interconectar redes, por ejemplo, nuestra red del hogar con
Internet), un punto de acceso (explicado más arriba) y generalmente un conmutador
que permite conectar algunos equipos vía cable (Ethernet y USB). Su tarea es tomar la
conexión a Internet, y brindar a través de ella acceso a todos los equipos que
conectemos, sea por cable o en forma inalámbrica.

Los estándares 802.11b y 802.11g utilizan la banda de 2,4 GHz. En esta banda se definieron
11 canales utilizables por equipos wifi, que pueden configurarse de acuerdo a necesidades
particulares. Sin embargo, los 11 canales no son completamente independientes (un canal se
superpone y produce interferencias hasta un canal a 4 canales de distancia). El ancho de
banda de la señal (22 MHz) es superior a la separación entre canales consecutivos (5 MHz),
por eso se hace necesaria una separación de al menos 5 canales con el fin de evitar
interferencias entre celdas adyacentes, ya que al utilizar canales con una separación de 5
canales entre ellos (y a la vez cada uno de estos con una separación de 5 MHz de su canal
vecino) entonces se logra una separación final de 25 MHz, lo cual es mayor al ancho de banda
que utiliza cada canal del estándar 802.11, el cual es de 22 MHz. Tradicionalmente se utilizan
los canales 1, 6 y 11, aunque se ha documentado que el uso de los canales 1, 5, 9 y 13 (en
dominios europeos) no es perjudicial para el rendimiento de la red.

Esta asignación de canales usualmente se hace sólo en el Punto de acceso, pues los
“clientes” automáticamente detectan el canal, salvo en los casos en que se forma una red “Ad-
Hoc” o punto a punto cuando no existe punto de acceso.
Canales en 802.11 (wifi) frente a 802.15.4 (zigbee):
Y dentro del espectro electromagnético:

ISM (Industrial, Scientific and Medical) son bandas reservadas internacionalmente para uso
no comercial de radiofrecuencia electromagnética en áreas industrial, científica y médica. En
la actualidad estas bandas han sido popularizadas por su uso en
comunicaciones WLAN (e.g. Wi-Fi) o WPAN (e.g. Bluetooth).

El uso de estas bandas de frecuencia está abierto a todo el mundo sin necesidad de licencia,
respetando las regulaciones que limitan los niveles de potencia transmitida. Este hecho fuerza
a que este tipo de comunicaciones tengan cierta tolerancia frente a errores y que utilicen
mecanismos de protección contra interferencias, como técnicas de ensanchado de espectro

El espectro de RF para las comunicaciones inalámbricas pertenecientes a dispositivos

compatibles con IEEE 802.11 opera en bandas de frecuencias de 2,4 GHz y 5 GHz y cada una
de estas bandas tiene su propio comportamiento único que tiene un impacto directo en el
rendimiento de la red.
Además, el 802.11n puede utilizar la banda de 5 GHz, que es casi siempre menos concurrida
y con menos interferencia que la banda de 2,4 GHz. Pero también funciona en 2,4 GHz, y los
clientes 802.11n pueden asociarse con facilidad allí. La Tabla 1 muestra las frecuencias
disponibles para los diferentes tipos de clientes inalámbricos.

IEEE 802.11ac (también conocido como WiFi 5G o WiFi Gigabit) es una mejora a la
norma IEEE 802.11n, se ha desarrollado entre el año 2011 y el 2013, y finalmente aprobada
en enero de 2014.
El estándar consiste en mejorar las tasas de transferencia hasta 433 Mbit/s por flujo de datos,
consiguiendo teóricamente tasas de 1.3 Gbit/s empleando 3 antenas. Opera dentro de la
banda de 5 GHz, amplía el ancho de banda hasta 160 MHz (40 MHz en las redes 802.11n),
utiliza hasta 8 flujos MIMO e incluye modulación de alta densidad (256 QAM).

Wi-Fi Direct es una norma que permite que varios dispositivos Wi-Fi se conecten entre sí sin
necesidad de un punto de acceso intermedio.

Wi-Fi Direct incrusta en esencia un punto de acceso en forma de software (Soft AP), en
cualquier dispositivo que deba soportar Direct. El soft AP proporciona una versión de Wi-Fi
Protected Setup al ser pulsado el botón o con la configuración basada en PIN. Cuando un
dispositivo ingresa al rango del anfitrión Wi-Fi Direct, éste se puede conectar usando el
protocolo ad hoc existente, y luego recolecta información de configuración usando una
transferencia del mismo tipo de la de Protected Setup. La conexión y configuración se
simplifica de tal forma que algunos sugieren que esto podría reemplazar al Bluetooth en
algunas situaciones. El estándar también incluye seguridad WPA2 y ofrece controlar el acceso
a redes corporativas. Los dispositivos certificados para Wi-Fi Direct se pueden conectar “uno a
uno” o “uno a muchos”, y no todos los productos conectados necesitan tener Wi-Fi Direct. Con
un solo dispositivo Wi-Fi Direct habilitado se pueden conectar dispositivos con el estándar
previo de Wi-Fi.

Además de funcionar en diferentes canales, varias redes Wi-Fi pueden compartir

canales. Un conjunto de servicios (Sevice Set) es el conjunto de todos los dispositivos
asociados con una red Wi-Fi particular. El conjunto de servicios puede ser local,
independiente, extendido o de malla. Cada conjunto de servicios tiene un identificador
asociado, el identificador de conjunto de servicios (SSID) de 32 bytes, que identifica la red en
particular. El SSID se configura dentro de los dispositivos que se consideran parte de la red, y
se transmite en los paquetes. Los receptores ignoran paquetes inalámbricos de redes con un
SSID diferente.

Los nodos Wi-Fi que funcionan en modo ad-hoc se refieren a dispositivos que hablan
directamente entre sí sin necesidad de hablar primero con un punto de acceso. Por ejemplo
las impresoras.

Cada vez más en los últimos años, se han incorporado módulos Wi-Fi embebidos que
incorporan un sistema operativo en tiempo real y proporcionan un medio simple de
comunicación sin cables para cualquier dispositivo que que disponga de un puerto serie. Esto
permite el diseño de dispositivos de monitorización simples. Un ejemplo es un dispositivo
portátil de electrocardiograma que monitorea a un paciente en casa. Este dispositivo habilitado
para Wi-Fi puede comunicarse a través de Internet usando la red wifi del paciente.

Estos módulos Wi-Fi están diseñados por OEMs para que los implementadores sólo necesiten
un conocimiento mínimo de Wi-Fi para proporcionar conectividad Wi-Fi para sus productos.

En junio de 2014, Texas Instruments presentó el primer microcontrolador ARM Cortex-M4 con
una MCU dedicada Wi-Fi embebida, el SimpleLink CC3200. Hace que los sistemas embebidos
con conectividad Wi-Fi sean posibles de construir como dispositivos de un solo chip, lo que
reduce su costo y tamaño mínimo, lo que hace más práctico para construir controladores de
red inalámbrica en objetos ordinarios de bajo costo
Otro ejemplo es el del Arduino MKR1000 que usa el microcontrolador ATSAMW25
(http://www.atmel.com/devices/ATSAMW25.aspx) con un módulo wifi y otro de
criptoauteticación incluido.

Más información:

 https://es.wikipedia.org/wiki/Wifi
 https://en.wikipedia.org/wiki/Wi-Fi
 https://es.wikipedia.org/wiki/IEEE_802.11

A Arduino es posible añadirle conectividad Wifi de forma muy sencilla y ampliar las
posibilidades de este microcontrolador con comunicación inalámbrica Wifi.

Hay varias formas de añadir hardware Wifi a Arduino, ya sea con un shield, una breakout
board específica, con microcontroladores que tenga wifi integrado o con placas Arduinos que
tenga chip wifi en la misma placa. Veamos varios casos de estos tipos, como conectarlos y
usarlos, así como las librerías a usar en cada caso.

Buena parte de los visto en Ethernet con Arduino, es válido para wifi, puesto que el protocolo
tcp/ip usado es el mismo y solo cambia el medio de comunicación. Trasladar un proyecto de
ethernet a wifi es sencillo, solo cambiando la librería para usar el hardware y adaptar los
comando en función de los métodos que tengan las librerías.

ESP8266

El ESP8266 es un chip Wi-Fi de bajo coste con pila TCP/IP completa y capacidad de MCU
(Micro Controller Unit) producida por el fabricante chino Espressif Systems, con sede en
Shanghai.

El chip primero llegó a la atención de los fabricantes occidentales en agosto de 2014 con el
módulo ESP-01. Este pequeño módulo permite a los microcontroladores conectarse a una red
Wi-Fi y realizar conexiones TCP/IP sencillas utilizando comandos de tipo Hayes. Sin embargo,
en ese momento casi no había documentación en inglés sobre el chip y los comandos que
aceptaba. El precio muy bajo y el hecho de que había muy pocos componentes externos en el
módulo que sugiere que podría ser muy barato en el volumen, atrajo a muchos hackers para
explorar el módulo, el chip y el software en él, así como para traducir La documentación china.

El ESP8285 es un ESP8266 con 1 MB de flash incorporado, lo que permite dispositivos de un

solo chip capaces de conectarse a Wi-Fi. Muchos encapsulados del ESP8266 viene con 1 MB
de flash.
El esp8266 es un módulo muy de moda que va alimentado a 3.3V y que hay mucha
documentación en internet. Este se presenta con muchos
encapsulados: http://www.esp8266.com/wiki/doku.php?id=esp8266-module-family

Características:

 32-bit RISC CPU: Tensilica Xtensa LX106 running at 80 MHz*

 64 KiB of instruction RAM, 96 KiB of data RAM
 External QSPI flash – 512 KiB to 4 MiB* (up to 16 MiB is supported)
 IEEE 802.11 b/g/n Wi-Fi
 Integrated TR switch, balun, LNA, power amplifier and matching network
 WEP or WPA/WPA2 authentication, or open networks
 16 GPIO pins
 SPI, I²C,
 I²S interfaces with DMA (sharing pins with GPIO)
 UART on dedicated pins, plus a transmit-only UART can be enabled on GPIO2
 1 port 10-bit ADC
* Both the CPU and flash clock speeds can be doubled by overclocking on some devices. CPU
can be run at 160 MHz and flash can be sped up from 40 MHz to 80 MHz.

A finales de octubre de 2014, Espressif lanzó un kit de desarrollo de software (SDK) que
permite programar el chip, eliminando la necesidad de un microcontrolador por separado.
Desde entonces, ha habido muchos lanzamientos oficiales de SDK; Espressif mantiene dos
versiones del SDK – una basada en RTOS y la otra basada en callbacks.

Una alternativa al SDK oficial de Espressif es el open source esp-open-sdk que se basa en la
cadena de herramientas (toolchain) GCC. ESP8266 utiliza el microcontrolador Cadence
Tensilica LX106 y la cadena de herramientas GCC que es de código abierto y mantenida por
Max Filippov. Otra alternativa es “Unofficial Development Kit” de Mikhail Grigorev.

Otros SDK de código abierto para el ESP8266:

 NodeMCU: un firmware basado en Lua.

 Arduino: un firmware basado en C ++. Este núcleo permite que la CPU ESP8266 y sus
componentes Wi-Fi sean programados como cualquier otro dispositivo Arduino. El
Arduino Core ESP8266 está disponible a través de
GitHub: https://github.com/esp8266/Arduino y cuyo reference
es https://github.com/esp8266/Arduino/blob/master/doc/reference.md
 MicroPython: una implementación de Python para dispositivos embebidos a la
plataforma ESP8266.
 ESP8266 BASIC: Un intérprete básico de código abierto específicamente diseñado
para el Internet de las cosas.
 Mongoose Firmware: Un firmware de código abierto con servicio gratuito en la
nube: https://github.com/cesanta/mongoose-iot

Github del foro ESP8266: https://github.com/esp8266

El módulo WIFI ESP8266, que es algo muy parecido a los módulos Bluetooth y que al igual
que ellos incluye toda la electrónica necesaria para la comunicación Radio Frecuencia en la
banda WFI, así como la pila TCP/IP y que se comunica con nosotros a través de un puerto
serie. De hecho, exactamente igual que los modos HC-06 y HC-05 se gobierna mediante
comandos AT (comandos hayes https://es.wikipedia.org/wiki/Conjunto_de_comandos_Hayes)
y todo por un precio similar al de los Bluetooth.

Dentro de la gran cantidad de usos para este módulo caben destacar los siguientes:

 Electrodomésticos conectados.
 Automatización del hogar.
 Automatización de la industria.
 Cámaras IP.
 Redes de sensores.
 Wereables.
 IoT (Internet of Things o Internet de las Cosas)
 IIoT (Industrial Internet of Things o Internet de las Cosas para el sector Industrial)

Más información:

 https://en.wikipedia.org/wiki/ESP8266
 SDK: http://hackaday.com/2014/10/25/an-sdk-for-the-esp8266-wifi-chip/
  esp-open-sdk: https://github.com/pfalcon/esp-open-sdk
 http://www.esp8266.com/
 https://github.com/esp8266/esp8266-wiki/wiki

Características

Datos de ESP8266 de datasheet:

 802.11 b/g/n
 Integrated low power 32-bit MCU
 Integrated 10-bit ADC • Integrated TCP/IP protocol stack
 Integrated TR switch, balun, LNA, power amplifier and matching network
 Integrated PLL, regulators, and power management units
 Supports antenna diversity
 WiFi 2.4 GHz, support WPA/WPA2
 Support STA/AP/STA+AP operation modes
 Support Smart Link Function for both Android and iOS devices
 SDIO 2.0, (H) SPI, UART, I2C, I2S, IR Remote Control, PWM, GPIO
 STBC, 1×1 MIMO, 2×1 MIMO
 A-MPDU & A-MSDU aggregation & 0.4s guard interval
 Deep sleep power <10uA, Power down leakage current < 5uA
 Wake up and transmit packets in < 2ms
 Standby power consumption of < 1.0mW (DTIM3) • +20 dBm output power in 802.11b
mode
 Operating temperature range -40C ~ 125C
 FCC, CE, TELEC, WiFi Alliance, and SRRC certified

EL ESP8266 no tiene ROM y usa una ROM externa SPI y soporta hasta 16MB.

Web Oficial del producto: https://espressif.com/en/products/hardware/esp8266ex/overview

Recursos: https://espressif.com/en/products/hardware/esp8266ex/resources

Datasheet: https://espressif.com/sites/default/files/documentation/0a-
esp8266ex_datasheet_en.pdf

Tabla de consumo del módulo ESP8266:

Si queremos alimentar el módulo ESP8266 con Arduino debemos ver las limitaciones de
Arduino: pin power limitations: http://playground.arduino.cc/Main/ArduinoPinCurrentLimitations,
a 5V la limitación es de 1A del regulador de tensión. Como va alimentado a 3.3V la limitación
es de 150mA limitado por el regulador de tensión.
Regulador http://www.ti.com/lit/ds/symlink/lp2985-33.pdf, por lo tanto alimentar el ESP8266
desde el pin de 3.3V puede dar problemas y es recomendable usar otra fuente de
alimentación.

Pinout ESP8266:
Pinout placas: http://www.pighixxx.com/test/portfolio-items/esp8266/?portfolioID=360

Diagrama de bloques
Los módulos ESP8266 los podemos encontrar en diferentes encapsulados y placas:

Interesante artículo sobre que módulo wifi ESP8266 elegir: http://polaridad.es/esp8266-

modulo-wifi-elegir-caracteristicas/

ESP WROOM otro encapsulado ya trae una memoria Flash SPI de 2MB y con certificación
FCC y CE:

 http://www.espressif.com/en/products/hardware/esp-wroom-02/overview
 https://espressif.com/en/products/hardware/esp-wroom-02/overview
 http://www.cnx-software.com/2015/05/05/espressif-vroom-wifi-esp8266-modules-are-
fcc-and-ce-certified/
 Datasheet: http://www.espressif.com/sites/default/files/documentation/esp-wroom-
s2_datasheet_en.pdf

Características de los módulos:

 Active dimensions

Name pins Pitch Form factor LEDs Antenna Shielded? (mm) Notes

ESP-

01 6 0.1″ 2×4 DIL Yes PCB trace No 14.3 × 24.8

ESP- 2×4 U-FL

02 6 0.1″ castellated No connector No 14.2 × 14.2

ESP- 2×7

03 10 2 mm castellated No Ceramic No 17.3 × 12.1

ESP- 2×4

04 10 2 mm castellated No None No 14.7 × 12.1

ESP- U-FL

05 3 0.1″ 1×5 SIL No connector No 14.2 × 14.2

ESP-

06 11 misc 4×3 dice No None Yes 14.2 × 14.7 Not FCC approved

ESP- Ceramic + U-

07 14 2 mm 2×8 pinhole Yes FL connector Yes 20.0 × 16.0 Not FCC approved

ESP- 2×7

08 10 2 mm castellated No None Yes 17.0 × 16.0 Not FCC approved

ESP-

09 10 misc 4×3 dice No None No 10.0 × 10.0

ESP- 2 1×5

10 3 mm? castellated No None No 14.2 × 10.0

ESP-

11 6 0.05″ 1×8 pinhole No Ceramic No 17.3 × 12.1

ESP- 2×8

12 14 2 mm castellated Yes PCB trace Yes 24.0 × 16.0 FCC and CE approved[14]

ESP- 2×8

12E 20 2 mm castellated Yes PCB trace Yes 24.0 × 16.0 4 MB Flash

ESP- 2×8 FCC and CE approved. Improved

12F 20 2 mm castellated Yes PCB trace Yes 24.0 × 16.0 antenna performance. 4 MB Flash

Marked as ″FCC″. Shielded

ESP- 1.5 2×9 W18.0 x module is placed sideways, as

13 16 mm castellated No PCB trace Yes L20.0 compared to the ESP-12 modules.

2×8

ESP- castellated

14 22 2 mm +6 No PCB trace Yes 24.3 x 16.2

En nuestro caso vamos a usar el ESP-01:

Esquemático:
Wiki: https://nurdspace.nl/ESP8266

Módulo usado:

 https://www.seeedstudio.com/WiFi-Serial-Transceiver-Module-w%26-ESP8266-1MB-
Flash-p-2485.html
 https://www.sparkfun.com/products/13678

También tenemos placas basadas en ESP8266 e incluso con puerto USB integrado:

 http://tienda.bricogeek.com/wifi/807-sparkfun-esp8266-thing-dev.html
 https://www.sparkfun.com/products/13231
 https://www.sparkfun.com/products/13711
 ESP con formato Arduino: http://www.banggood.com/WeMos-D1-R2-WiFi-ESP8266-
Development-Board-Compatible-Arduino-UNO-Program-By-Arduino-IDE-p-
1011870.html
  https://www.adafruit.com/products/2471 y tutorial https://learn.adafruit.com/adafruit-
huzzah-esp8266-breakout/overview
 Más placas: https://www.losant.com/blog/top-6-esp8266-modules

Y un Shield ESP8266 para Arduino: https://www.sparkfun.com/products/13287

Más información:

 http://programarfacil.com/podcast/esp8266-wifi-coste-arduino/
 http://makezine.com/2015/04/01/esp8266-5-microcontroller-wi-fi-now-arduino-
compatible/

El sucesor del ESP8266 puede que sea el

ESP32 https://espressif.com/en/products/hardware/esp32/overview con wifi + bluetooth y más
potente.

Datasheet
ESP32: https://espressif.com/sites/default/files/documentation/esp32_datasheet_en.pdf

Primeras impresiones sobre el ESP32: https://www.sparkfun.com/news/2017

Características ESP32:

 CPU: Xtensa Dual-Core 32-bit LX6 microprocessor, operating at 160 or 240 MHz and
performing at up to 600 DMIPS
 Memory: 520 KiB SRAM
 Wireless connectivity:
 Wi-Fi: 802.11b/g/n/e/i
 Bluetooth: v4.2 BR/EDR and BLE
 Peripheral interfaces:
 12-bit SAR ADC up to 18 channels
 2 × 8-bit DACs
 10 × touch sensors
 Temperature sensor
 4 × SPI
 2 × I²S
 2 × I²C
 3 × UART
 1 SD/SDIO/MMC host
 1 slave (SDIO/SPI)
 Ethernet MAC interface with dedicated DMA and IEEE 1588 support
 CAN bus 2.0
 IR (TX/RX)
 Motor PWM
 LED PWM up to 16 channels
 Hall effect sensor
 Ultra low power analog pre-amplifier
 Security:
 IEEE 802.11 standard security features all supported, including WFA, WPA/WPA2 and
WAPI
 Secure boot
 Flash encryption
  1024-bit OTP, up to 768-bit for customers
 Cryptographic hardware acceleration: AES, SHA-2, RSA, ECC, Random Number
Generator (RNG)

Uso ESP8266 con Arduino (Puerto Serie)

El ESP8266 se puede usar con un microcontrolador como Arduino conectado por puerto serie
y manejarlo con comandos hayes o programarlo como si de un microcontrolador se tratara con
el IDE de Arduino usando el SDK https://github.com/esp8266/Arduino y usar el lenguaje de
programación de Arduino (el core de Arduino).

Pines:

 TX (goes to the 3.3V Rx of the UART USB adapter to the PC)

 CH_PD (enable/power down, must be pulled to 3.3v directly or via resistor)
 RESET
 VCC (3.3v power supply)
 GND (connect to power ground)
 GPIO 2
 GPIO 0 (leave open or pull up for normal, pull down to upload new firmware)
 RX (goes to the 3.3V Tx of the UART USB adapter to the PC)

Para usar el ESP8266 con Arduino vamos a conectarnos por el puerto serie y mandar
comandos AT (hayes) para manejarlo. Este es el esquema.
IMPORTANTE:

 El ESP8266 va alimentado a 3,3V, ¡no alimentarlo con 5 voltios!

 El ESP8266 necesita comunicarse vía serie a 3.3V y no tiene entradas tolerantes 5V,
por lo que necesita la conversión de nivel para comunicarse con un microcontrolador
5V como la mayoría de los Arduinos

Sin embargo, esta segunda advertencia puede ser ignorada y conectar el puerto serie
directamente a Arduino, pero existe el peligro de dañar el módulo.

Con un programador FTDI que tenga salida a 3.3V podemos hacer lo mismo que con un
Arduino pero sin ningún peligro.
ESP8266 quick start
guide: http://rancidbacon.com/files/kiwicon8/ESP8266_WiFi_Module_Quick_Start_Guide_v_1.
0.4.pdf

Guia sparkfun del ESP8266: https://learn.sparkfun.com/tutorials/esp8266-thing-hookup-guide

Ejemplo de level shifter para usar con Arduino:

 https://www.adafruit.com/products/757
 https://www.adafruit.com/products/395 (8 canales)
 http://www.electan.com/voltagelevel-translator-txb0104-breakout-p-4014.html
 http://www.electan.com/pca9306-level-translator-breakout-p-3494.html
 https://www.sparkfun.com/products/12009
 https://learn.sparkfun.com/tutorials/bi-directional-logic-level-converter-hookup-guide
 https://www.pololu.com/product/2595
 Datasheet: https://cdn-shop.adafruit.com/datasheets/sn74lvc245a.pdf

Cheatsheet: https://cdn.sparkfun.com/datasheets/Wireless/WiFi/ESP8266ModuleV1.pdf
Por lo tanto la primera forma de usar el módulo ESP8266 es comunicarse con él a través del
puerto serie y manejarlo mediante los comandos AT (hayes) que tiene en su firmware.

El conjunto de comandos Hayes es un lenguaje desarrollado por la compañía Hayes

Communications que prácticamente se convirtió en estándar abierto de comandos para
configurar y parametrizar módems. Los caracteres «AT», que preceden a todos los comandos,
significan «Atención», e hicieron que se conociera también a este conjunto de comandos
como comandos AT. Midiendo la longitud de los bits se puede determinar en detalle la
velocidad de transmisión.

Comandos hayes:

 https://es.wikipedia.org/wiki/Conjunto_de_comandos_Hayes
 https://en.wikipedia.org/wiki/Hayes_command_set

Comandos Hayes para ESP8266:

 Command set oficial http://www.espressif.com/sites/default/files/4a-

esp8266_at_instruction_set_en_v1.5.4_0.pdf
 Command set for ESP8266 (cheatsheet): http://www.pridopia.co.uk/pi-
doc/ESP8266ATCommandsSet.pdf
 ESP8266 command reference https://room-15.github.io/blog/2015/03/26/esp8266-at-
command-reference/
 Básico https://github.com/esp8266/at-command-set
Proyectos con ESP8266:

 Estación meteorologica con esp8266 + arduino +

thingspeak https://create.arduino.cc/projecthub/Blue_jack/personal-weather-station-
arduino-esp8266-thingspeak-8d5cba

Más información:

 https://nurdspace.nl/ESP8266
 http://www.electrodragon.com/w/Category:ESP8266
 https://www.itead.cc/wiki/ESP8266_Serial_WIFI_Module

Videos:

 https://www.youtube.com/playlist?list=PLmfT_cdP5PYDRYIvGIQ4YQYnEprshtxO8
  https://www.youtube.com/watch?v=qU76yWHeQuw

Uso ESP8266 con IDE Arduino

Hemos visto como realizar las conexiones y vimos los comandos AT que nos permiten
configurar las acciones del WIFI. El ESP8266 dispone internamente de un pequeño
procesador, prácticamente es capaz de replicar casi cualquier cosa los Arduinos puedan
hacer. Así que los proyectos con sensores más Arduinos que envían los datos a la WIFI
mediante un ESP8266, es muy probable que podamos ahorrarnos el Arduino en el proceso.

Gracias a un firmware basado en C ++, permite que la CPU ESP8266 y sus componentes Wi-
Fi sean programados como cualquier otro dispositivo Arduino.

 Puedes desarrollar con el mismo IDE que ya conoces

 Han hecho un Cross compiler, de forma que prácticamente utilizas los mismos
comandos que utilizas con Arduino, con lo que te ahorras aprender nada nuevo
 Dependiendo del modelo de ESP8266 que tengas, dispones de más o menos pines
disponibles con PWM y otras cosas más como I2C y SPI, pero para el modelo
ESP8266-01 solo tienes dos pines disponibles GPIO0 y GPIO2
 Puedes programar el procesador de tu ESP8266 exactamente como si fuera un
Arduino con los mismos comandos, y en lo que se refiere a la WIFI, puedes olvidarte
de los comandos AT, porque incluye una serie de librerías, que imitan la librería WIFI
de Arduino con lo que se pueden reutilizar muchos programas.

El Arduino Core ESP8266 está disponible a través de

GitHub: https://github.com/esp8266/Arduino

Reference de Arduino core a

ESP8266: https://github.com/esp8266/Arduino/blob/master/doc/reference.md

Toda la documentación del soporte de Arduino core a

ESP8266: https://github.com/esp8266/Arduino/tree/master/doc

Documentación de la librería
esp8266wifi: https://github.com/esp8266/Arduino/tree/master/doc/esp8266wifi que usa los
mismos métodos que https://www.arduino.cc/en/Reference/WiFi

Podemos descargar un IDE ya configura para ESP8266

de https://github.com/esp8266/Arduino/releases/

O podemos instalar el soporte a terceros en nuestro IDE simplemente añadiendo el texto

“http://arduino.esp8266.com/stable/package_esp8266com_index.json” en propiedades:
Y luego desde el gestor de tarjetas dar a instalar al soporte para ESP8266.
ESP8266 Community: http://arduino.esp8266.com/stable/package_esp8266com_index.json

 Generic ESP8266 modules

 Olimex MOD-WIFI-ESP8266
 NodeMCU 0.9 (ESP-12)
 NodeMCU 1.0 (ESP-12E)
 Adafruit HUZZAH ESP8266 (ESP-12)
 SparkFun Thing
 SweetPea ESP-210
 WeMos D1
 WeMos D1 mini

Para instalar el Arduino Core ESP8266 en nuestro IDE de Arduino seguir las
instrucciones: http://www.instructables.com/id/Setting-Up-the-Arduino-IDE-to-Program-
ESP8266/?ALLSTEPS

IMPORTANTE: Cuando cargas un sketch en el ESP8266 con el IDE Arduino estamos

cargando en la flash de ESP8266 un nuevo firmware borrando el que viene por defecto visto
anteriormente para manejar el módulo con comando hayes.

Otras características de este soporte:

 Actualización OTA
  Soporta muchas de las librerías de Arduino y otras librerías hechas por terceros está
ya adaptadas para usar con el ESP8266.

Más información:

 Wiki: https://github.com/esp8266/esp8266-wiki/wiki
 https://learn.adafruit.com/adafruit-huzzah-esp8266-breakout/using-arduino-ide
 https://learn.sparkfun.com/tutorials/esp8266-thing-hookup-guide/installing-the-
esp8266-arduino-addon
 http://www.prometec.net/esp8266-pluggin-arduino-ide/
 http://www.prometec.net/esp8266-con-arduino-ide/
 http://hackaday.com/2015/03/18/how-to-directly-program-an-inexpensive-esp8266-wifi-
module/

Firmware ESP8266

Como hemos hablado el módulo ESP8266 es un microcontrolador como los que hemos visto
con Arduino y podemos cargarle un firmware con un programa que hayamos hecho y
compilado con el IDE de Arduino o usar un firmware como el que viene por defecto que es el
de comandos hayes.

Además de los firmwares anteriores tenemos otros firmware disponibles como el oficial
basado en un RTOS.

 Firmware nodeMCU (basado en LUA): https://github.com/nodemcu/nodemcu-firmware

 ESP8266 RTOS SDK
 Firmware para usar micropython: https://github.com/micropython/micropython/

Para descargar las herramientas y últimas versiones del firmware usar la

web: https://espressif.com/en/products/hardware/esp8266ex/resources

Más información de como actualizar firmware (version actualizada en la parte de ejercicios):

 http://randomnerdtutorials.com/flashing-nodemcu-firmware-on-the-esp8266-using-
windows/
 http://www.electrodragon.com/w/Category:ESP8266_Firmware_and_SDK
 http://www.instructables.com/id/Intro-Esp-8266-firmware-update/?ALLSTEPS
 http://www.xess.com/blog/esp8266-reflash/
 http://www.esp8266.com/wiki/doku.php?id=loading_firmware
 http://www.prometec.net/firmware-esp8266
 Troubleshooting guide: http://randomnerdtutorials.com/esp8266-troubleshooting-guide/

Ejercicios ESP8266

Conexión a Arduino

Lo primero es decir que este es módulo muy sencillo y diseñado desde el principio con la
Internet of Things en mente (IOT), y por eso incluye todo lo necesario para conectarse a un
punto de acceso WIFI mediante comandos de texto AT, vía un puerto serie, que puede ser
configurada a diferentes velocidades.
Una vez que lo configuramos para que se conecte a nuestra WIFI, el módulo es capaz de
enviar información que le remitimos vía la puerta serie a una dirección IP y puerto que
deseemos.

Cuando se trata de recibir, limpia todo el empaquetado TCP/IP y nos reenvía por la puerta
serie la información de datos limpia, con lo que tiene la enorme virtud de permitirnos
olvidarnos de la gestión del TCP/IP y de las demandas de procesador y memoria que
suponen. A cambio no es exactamente una conexión WIFI, porque no tenemos acceso al
stack o al socket IP pero para el Arduino esto es casi una ventaja.

La fuente interna de 3.3V del Arduino da un máximo de 150 mA, cuando el consumo del
módulo suele ser en el arranque bastante superior a esto, lo que le llevará a unos arranques
poco fiables, y aunque se acaba consiguiendo, deben repetirse una y otra vez. En nuestro
caso usaremos una fuente externa de alimentación de 3.3V para alimentar este módulo
ESP8266.

ESP8266 programado por puerto serie

Conexión con programador FTDI:

Conexión con Arduino:

Conectar un terminal serie a 115200-8-N y mandar el comando AT, si nos responde OK es
que ya estamos conectados con el módulo.

Manual oficial de comandos: http://www.espressif.com/sites/default/files/4a-

esp8266_at_instruction_set_en_v1.5.4_0.pdf
Ejecutar los siguientes comandos y ver lo que devuelve:

 AT+RST: reinicia el módulo

 AT+GMR: versión de firmware
 AT+CWMODE=3: activa modo AP, comprobar redes wifi
 AT+CWLAP: para ver las redes wifi
 AT+CWJAP=”SSID”,”password”: Conectarse a una red wifi
(AT+CWJAP=”AndroidAP4628″,”esp8266wifi”)
 AT+CIFSR: comprobar la IP asignada

Actuar como un cliente TCP:

 AT+CIPMUX=1: Habilitar múltiples conexiones

 AT+CIPSTART=4,”TCP”,”google.com”,80: Especifica el canal de conexión que desea
conectar (0 – 4), el tipo de protocolo (TCP / UDP), la dirección IP (o el dominio si tiene
acceso a DNS) y el número de puerto
 A continuación, debe especificar la cantidad de datos que desea enviar (después de
especificar qué canal). Vamos a enviar “GET / HTTP / 1.0 \r \n \r \n” que es 18 bytes:
AT+CIPSEND=4,18
 Y recibiremos la respuesta del servidor:

+IPD,4,559:HTTP/1.0 301 Moved Permanently

Location: http://www.google.com/
Content-Type: text/html; charset=UTF-8
Date: Sat, 12 Nov 2016 16:37:23 GMT
Expires: Mon, 12 Dec 2016 16:37:23 GMT
Cache-Control: public, max-age=2592000
Server: gws
Content-Length: 219
X-XSS-Protection: 1; mode=block
X-Frame-Options: SAMEORIGIN
Connection: close
<HTML><HEAD><meta http-equiv=”content-type” content=”text/html;charset=utf-8″>
<TITLE>301 Moved</TITLE></HEAD><BODY>
<H1>301 Moved</H1>
The document has moved
<A HREF=”http://www.google.com/”>here</A&gt;.
</BODY></HTML>
4,CLOSED

Actuar como servidor:

 Comprobar que IP tenemos con AT+CIFSR

 AT+CIPSERVER=1,1336: para poner a escuchar en un puerto, en este caso el 1336
 Desde otro dispositivo en la red: telnet 192.168.1.2 1336
 En el puerto serie veré todo lo que se escriba por telnet
 Para responder desde el ESP8266 debo usar AT+CIPSEND=0,8 seguido del texto. En
este caso es el canal 0 y mando 8 caracteres.

Hacer lo mismo pero usando Arduino, para ello conectarlo según el esquema superior y cargar
el programa:
1
#include <SoftwareSerial.h>
2
SoftwareSerial BT1(3, 2); // RX | TX
3
void setup()
4
{ Serial.begin(9600);
5
BT1.begin(115200);
6
}
7 void loop()
8 {

9 if (BT1.available())

10 { char c = BT1.read();

Serial.print(c);
11
}
12
if (Serial.available())
13
{ char c = Serial.read();
14
BT1.print(c);
15
}
16 }
17

Configurar el baud rate de ESP8266 a 9600 para que funcione mejor con el comando
“AT+UART_DEF=9600,8,1,0,0”, puesto que a 115200 da problemas con el puerto serie
software.

Para hacer una reseteo de la configuración de fábrica usar el comando: “AT+RESTORE”

Hacer un programa con Arduino que se conecte automáticamente a una red y nos puestre la
IP asignada:

 AT+CWMODE_DEF=1
 AT+CWJAP=”SSID”,”paswword”)
 AT+CIFSR: comprobar la IP asignada

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

Arduino/tree/master/Ejercicio61-ESP8266

Más información:

 http://rancidbacon.com/files/kiwicon8/ESP8266_WiFi_Module_Quick_Start_Guide_v_1.
0.4.pdf
  http://www.prometec.net/arduino-wifi/
 http://www.prometec.net/esp8266/
 http://www.prometec.net/servidor-web-esp8266/
 https://www.sistemasorp.es/2014/10/07/probando-el-modulo-wifi-esp8266/
 http://www.leantec.es/blog/26_Como-conectar-Arduino-a-una-red-WIFi-con-el-m.html
 Vídeo: https://www.hackster.io/Blue_jack/esp8266-atcommands-connect-to-internet-
5185fe

Configuración como punto de acceso

Podemos poner el ESP8266 en modo punto de acceso para que se conecten otros
dispositivos wifi, recordad que es un modo soft AP.

Escribir la siguiente secuencia de comandos:

 AT+CWSAP=”NoWorriESSID”,”password”,3,0
 AT+CWMODE=3
 AT+CWLIF: IP de los dispositivos conectados

Para saber el significado de cada parámetro y sus opciones

ver https://espressif.com/sites/default/files/documentation/4a-
esp8266_at_instruction_set_en.pdf

Más información:

 http://rancidbacon.com/files/kiwicon8/ESP8266_WiFi_Module_Quick_Start_Guide_v_1.
0.4.pdf
 https://learn.sparkfun.com/tutorials/esp8266-thing-hookup-guide/example-sketch-ap-
web-server
 https://www.hackster.io/rayburne/esp8266-access-point-using-arduino-ide-19f632
 http://dominicm.com/esp8266-configure-access-point/
 http://www.jopapa.me/esp8266APyTCP.html
 http://www.instructables.com/id/ESP8266-based-web-configurable-wifi-general-purpos-
1/

ESP8266 programado con IDE Arduino

Conectar al programador FTDI como hemos visto anteriormente. Pero para programar el
módulo (Y para actualizar el firmware) necesitáis colocar el módulo en estado de
programación y eso se consigue poniendo a GND la patilla GPIO0.
Vamos a programar el blink de Arduino en la patilla GPIO2, que es la que nos queda libre:

1
void setup()
2 { pinMode(2, OUTPUT); }
3

4 void loop()
5 { digitalWrite(2, HIGH);

6 delay(1000);

7 digitalWrite(2, LOW);

delay(1000);
8
}
9

Para probarlo.
IMPORTANTE: Al cargar un programa pierdo el firmware original.

Más información:

 http://www.prometec.net/esp8266-pluggin-arduino-ide/
 http://www.prometec.net/esp8266-con-arduino-ide/

Veamos los ejemplos de ESP8266 que vienen en el soporte para el IDE de Arduino, usando la
librería ESP8266WiFi.h:

 Blink
 ESP8266Wifi/Wifiscan: Scan networks
 ESP8266Wifi/WifiClient Conectar a wifi
 ESP8266WebSerber/HelloServer: Servidor web wifi

El reference para programar:

 https://github.com/esp8266/Arduino/tree/master/doc
  El reference de wifi es similar a https://www.arduino.cc/en/Reference/WiFi

Firmware Update

Para actualizar el firmware necesitamos descargar la herramienta “flash download tools” para
el ESP8266 y el firmware con los comandos hayes, además aprovechamos para actualizar a
la última versión del firmware.

Para programar recordar y actualizar firmware recordar que el pin GPIO0 debe estar a masa y
que hay que un reset del módulo para comenzar la carga del nuevo firmware.

Descarga: https://espressif.com/en/products/hardware/esp8266ex/resources

Descargar la última versión de:

 Tools/Flash Download Tools V3.4.2 (ESP8266 & ESP32)

 SDK & demos/ESP8266 NONOS SDK V2.0.0 20160810

Abrir la aplicación Flash download tool y elegir ESP8266. Luego configurar de la siguiente
forma:
Configurando los ficheros para BOOT MODE Flash size 8Mbit: 512KB+512KB:

 boot_v1.2+.bin 0x00000
 user1.1024.new.2.bin 0x01000
 esp_init_data_default.bin 0xfc000 (optional)
 blank.bin 0x7e000
 blank.bin 0xfe000

Que se encuentran en el directorio bin del fichero de SDK que nos hemos descargado.
Para comprobar la frecuencia de cristal del módulo y la flash, simplemente dando a start sin
seleccionar los ficheros y reseteando el módulo obtendremos la información.

Más información sobre el Firmware update (como referencia no están actualizados):

 http://www.instructables.com/id/Cargar-firmware-al-ESP8266-con-Arduino/
 http://www.prometec.net/firmware-esp8266/
 http://remotexy.com/en/help/esp8266-firmware-update/

IMPORTANTE: no descargar nada de fuentes no fiables

NODEMCU

NodeMCU es una plataforma IoT de código abierto. Incluye firmware que se ejecuta en el
ESP8266 Wi-Fi SoC de Espressif Systems y el hardware que se basa es el módulo ESP-12.

El término “NodeMCU” por defecto se refiere al firmware en lugar de los kits de desarrollo de
ESP8266. El firmware utiliza el lenguaje de secuencias de comandos Lua. Se basa en el
proyecto eLua, y está basado en el SDK Espressif Non-OS SDK for ESP8266.

Un grupo de desarrolladores chinos de plataformas abiertas de hardware, quienes se basaron

en el ESP8266 para lanzar un kit llamado NodeMCU para el desarrollo de prototipos
compatible con Arduino, que se programa en lenguaje Lua, con conectividad USB y Wi-Fi, y a
un precio sorprendentemente bajo.
Pinout:
Web oficial: http://www.nodemcu.com/index_en.html

Github: https://github.com/nodemcu

Documentación: http://nodemcu.readthedocs.io/en/master/

Lua: https://en.wikipedia.org/wiki/Lua_(programming_language)

Firmware: https://github.com/nodemcu/nodemcu-firmware

Node mcu flasher: https://github.com/nodemcu/nodemcu-flasher

Más información:

 https://en.wikipedia.org/wiki/NodeMCU
 https://www.fayerwayer.com/2015/05/nodemcu-el-sucesor-de-arduino-integra-wi-fi-y-
cuesta-menos-de-ocho-dolares/
Tutorial de uso: http://blog.nyl.io/esp8266-meets-nodemcu/

Proyectos con nodemcu:

 http://www.instructables.com/id/Flowmeter-NodeMcu-Counting-Litres/?ALLSTEPS
 https://www.hackster.io/nodemcu/products/nodemcu-firmware
 Getting started: http://www.instructables.com/id/Get-Started-with-ESP8266-Using-AT-
Commands-NodeMCU/?ALLSTEPS
 Acceso led placa via web: http://www.instructables.com/id/NodeMCU-Onboard-LED-
Access-Via-Web-Server/?ALLSTEPS
 Blink with nodemcu and Visuino: http://www.instructables.com/id/Blink-With-ESP8266-
and-Visuino/
 Ejemplo muy bueno con dos nodeMCU y control de temepratura y humedad con
visuino: http://www.instructables.com/id/Remote-Wi-Fi-DHT11-Temperature-an-
Humidity-I2C-2-X/

Arduino UNO Wifi

Se trata de una nueva placa de arduino.org que es el clásico Arduino UNO al que le añade en
la misma placa y con el formato del Arduino UNO un chip ESP8266, obteniendo al final un
Arduino UNO con conectividad wifi. Es el módulo perfecto para comenzar un proyectos de IoT.

Datasheets:

 ATmega328P: http://www.atmel.com/images/Atmel-8271-8-bit-AVR-Microcontroller-
ATmega48A-48PA-88A-88PA-168A-168PA-328-328P_datasheet_Complete.pdf
 ESP8266: http://download.arduino.org/products/UNOWIFI/0A-ESP8266-Datasheet-EN-
v4.3.pdf

A nivel de entradas y salidas y otras características físicas es exactamente igual a un Arduino

UNO, pero se le ha añadido un módulo wifi ESP8266 que es un SoC con la pila de protocolos
TCP/IP integrada que puede dar acceso a la red wifi o el puede actuar como un punto de
acceso.

Una de las características más interesantes de el Arduino UNO wifi es que soporta
programación OTA (over-the-air), tanto para transferir sketches como para actualizar el
firmware wifi.

Información de producto http://www.arduino.org/products/boards/arduino-uno-wifi

En el Arduino UNO wifi, hay un chip SC16IS750IBS con una UART y un interfaz I2C/SPI que
permite la comunicación entre el AtMega16u2, AtMega328p y el ESP8266EX. Este chip tiene
un interfaz I2C/SPI esclavo que hace de interfaz a una UART, así como 8 pines I/O
programables, ofreciendo una conversión de I2C/SPI a serie (RS232/RS485) bidireccional.

http://www.arduino.org/images/products/details/ArduinoUNOWIFI_drawing2.jpg

Datasheet
SC16IS750IBS: http://www.nxp.com/documents/data_sheet/SC16IS740_750_760.pdf
Arduino UNO wifi permite comunicar vía wifi con los sensores o actuadores montados en la
placa. Es posible usarlo como cliente de una red wifi, como servidor para conectar otros
clientes o crear una conexión wifi ad-hoc.

Arduino UNO wifi tiene precargado un sketch con un servidor REST (RestServer) que permite
manejar el arduino desde un navegador simplemente conectando a la SSID del Arduino
(Arduino-Uno-WiFi-xxxxxx) y entrando a la IP 192.168.240.1 para gestionarlo y usar los
siguientes comandos para manejar los pines:

 “/arduino/digital/13” -> digitalRead(13)

 “/arduino/digital/13/1” -> digitalWrite(13, HIGH)
 “/arduino/analog/2/123” -> analogWrite(2, 123)
 “/arduino/analog/2” -> analogRead(2)
 “/arduino/mode/13/input” -> pinMode(13, INPUT)
 “/arduino/mode/13/output” -> pinMode(13, OUTPUT)

Esquemático: http://download.arduino.org/products/UNOWIFI/Arduino-UNO-WiFi-V4_AF1.pdf

http://www.arduino.org/images/products/details/ArduinoUNOWIFI_drawing1.jpg

Programación

El Arduino UNO wifi puede programarse como un Arduino normal por el puerto serie o por wifi
de la misma forma que el Arduino Yun

Para usar este Arduino tendremos que utilizar el IDE

de arduino.org: http://www.arduino.org/downloads

Si al conectar el Arduino UNO wifi no lo reconoce Windows, instalar los drivers que hay en la
carpeta drivers del IDE de Arduino.org

Después de alimentar Arduino UNO wifi, conectarse a la red Arduino-Uno-WiFi-xxxxxx y abrir

el enlace http://192.168.240.1/

http://labs.arduino.org/dl1542?display&scale=0.7

Y desde la web podemos conectar Arduino UNO wifi a cualquier red wifi donde queramos
integrarlo.

Más información en: http://www.arduino.org/learning/getting-started/getting-started-with-

arduino-uno-wifi

NOTA: para programar por wifi, es necesario que el ordenador y el Arduino estén conectados
a la misma red wifi y la placa está en modo STA.

Tutoriales Arduino UNO wifi:

 http://www.arduino.org/learning/tutorials/boards-tutorials/readmacaddress
 http://www.arduino.org/learning/tutorials/boards-tutorials/restserver-and-restclient
 http://www.arduino.org/learning/tutorials/boards-tutorials/webserver
 http://www.arduino.org/learning/tutorials/boards-tutorials/webserverblink
La diferencia entre el Arduino UNO wifi y el wifi shield es que el wifi shield usa el SPI y este
Arduino usa el I2C para conectarse al puerto serie del ESP8266 para mandar los comandos y
transmitir por wifi.

La librería usada es la arduinowifi.h que aún no está documentada oficialmente, pero

indagando en la librería “ArduinoWiFi.h” vemos que hace “extern ArduinoWifiClass Wifi; “, es
decir crea el objeto Wifi de la clase ArduinoWifiClass y por eso podemos llamarlo desde el
programa sin tener que instanciarlo previamente.

Código de la librería arduinowifi.h https://github.com/arduino-org/arduino-library-arduino-wifi

Es una librería para configuración y manejo del ESP8266 por el bus I2C.

El reference para la librería wifi es http://www.arduino.org/learning/reference/WiFi pero aunque

es para el wifi shield, han diseñado la librería de Arduino Uno Wifi para que comparta nombre
de las funciones y uso similar.

Al arrancar el Arduino UNO Wifi se inicia en modo AP y podemos conectarnos vía wifi para
configurarlo y que luego se conecte a una red wifi.

Como cambiar el firmware: http://www.arduino.org/learning/tutorials/advanced-guides/how-to-

change-the-firmware-on-an-arduino-uno-wifi

En el Arduino UNO wifi ciao está integrado y puede usarse la

librería http://www.arduino.org/learning/reference/ciao-library.

Más información sobre CIAO: http://www.arduino.org/learning/tutorials/advanced-

guides/content/ciao

Ejemplo con CIAO:

 Con Thingspeak http://www.arduino.org/learning/tutorials/boards-

tutorials/ciaorestclient-thingspeak-2
 Ejemplo con ciao y rest http://www.arduino.org/learning/tutorials/boards-
tutorials/restserver-and-restclient

Ejercicio con Arduino UNO Wifi: basado en el ejercicio 27 del botón

mejorado: https://github.com/jecrespo/Aprendiendo-Arduino/tree/master/Ejercicio27-
Boton_Mejorado_UNO_WIFI

Comparar el código de:

 https://github.com/jecrespo/Aprendiendo-Arduino/tree/master/Ejercicio27-
Boton_Mejorado_UNO_WIFI
 https://github.com/jecrespo/Aprendiendo-Arduino/tree/master/Ejercicio27-
Boton_Mejorado_DHCP

Wifi Shield

El WiFi Shield de Arduino conecta Arduino a Internet de forma inalámbrica.

http://arduino.cc/en/uploads/Main/A000058_front_450.jpg

Toda la información sobre este Shield en :

 http://arduino.cc/en/Main/ArduinoWiFiShield
 http://arduino.cc/en/Guide/ArduinoWiFiShield
 http://arduino.cc/en/uploads/Main/arduino-wifi-shield-schematic.pdf

Y los datasheet de los integrados:

 http://datasheet.octopart.com/HDG104-DN-3-H%26D-Wireless-datasheet-
11793609.pdf
 http://www.digikey.com/product-highlights/us/en/atmel-at32uc3-series-
microcontrollers/277

Para conectarte al 32UC3: http://arduino.cc/en/Hacking/WiFiShield32USerial

Y la librería para manejar el shield en: http://arduino.cc/en/Reference/WiFi

Actualizar su firmware: http://arduino.cc/en/Hacking/WiFiShieldFirmwareUpgrading

http://arduino.cc/en/uploads/Main/ArduinoWiFiShieldPinUseDescribed_2.jpg

Wifi library:

 http://arduino.cc/en/Reference/WiFi
 https://github.com/arduino/wifishield

Un proyecto hecho con Ethernet pasarlo a wifi con el wifi shield, simplemente se trata de
cambiar las líneas de código de la parte de red de la librería ethernet a las equivalentes de la
librería wifi.

Ejercicio 27. Botón mejorado Wifi.

Partiendo del ejercicio 27 del botón mejorado que enciende y apaga un led desde una web
embebida en arduino con un ethernet shield, modificarlo para que funcione con un Arduino con
el shield wifi.

Ejercicio con Ethernet: https://github.com/jecrespo/Aprendiendo-

Arduino/tree/master/Ejercicio27-Boton_Mejorado

Solución: https://github.com/jecrespo/Aprendiendo-Arduino/tree/master/Ejercicio27-
Boton_Mejorado_WIFI

WiFi Shield 101

Arduino WiFi Shield 101 es un shield potente para aplicaciones IoT con autenticación
criptográfica, desarrollado con ATMEL, que conecta la placa Arduino a Internet de forma
inalámbrica. La conexión a una red WiFi es simple, no se necesita ninguna configuración
adicional además del SSID y la contraseña. El WiFi Shield 101 viene con una biblioteca fácil
de usar que permite conectar la placa Arduino a Internet con pocas instrucciones. Como
siempre, cada elemento de la plataforma – hardware, software y documentación está
libremente disponible y de código abierto. Se basa en el módulo Atmel SmartConnect-
WINC1500, compatible con la norma IEEE 802.11 b/g/n

Características:

 Operating voltage both 3.3V and 5V (supplied from the host board)
 Connection via: IEEE 802.11 b/g/n for up to 72 Mbps networks
 Encryption types: WEP and WPA2 Personal
 Support TLS 1.1 (SHA256)
 Connection with Arduino or Genuino on SPI port
 Onboard CryptoAuthentication by ATMEL

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

La de Adafruit https://www.adafruit.com/products/2891
El módulo wifi WINC1500 integrado es un controlador de red capaz de protocolos TCP y UDP.
El Wifi Shield 101 también cuenta con un hardware de seguridad de cifrado / descifrado
proporcionado por el chip ATCC508A CryptoAuthentication que es un método ultra seguro
para proporcionar un acuerdo clave para el cifrado/descifrado, diseñado específicamente para
el mercado de IoT.

Datasheet módulo wifi: http://www.atmel.com/devices/atwinc1500.aspx

El pin digital 7 se utiliza como un pin de handshake entre el shield WiFi 101 y Arduino, y no se
debe utilizar. El pin digital 5 se utiliza como pin RESET entre el shield WiFi 101 yArduino, y no
debe utilizarse.

Tener en cuenta que Uno + WiFi Shield 101 no es compatible con la biblioteca Serial de
software. El WiFi Shield 101 usa una biblioteca que es muy compleja y ocupa más del 60% de
la memoria disponible, dejando poco espacio para los sketches. Tener en cuenta que para un
uso básico es compatible con el Uno, pero para proyectos complejos se recomienda usar el
shield WiFi 101 con un Arduino / Genuino Zero, 101 o Mega 2560.

El Wifi Shield 101 se usa con la librería Wifi101 https://www.arduino.cc/en/Reference/WiFi101

Ejemplo sencillo por con el wifi shield

101: https://www.arduino.cc/en/Tutorial/Wifi101SimpleWebServerWiFi

Más información:

 https://blog.arduino.cc/2015/09/30/arduino-wifi-shield-101-available-in-the-store/
 https://www.arduino.cc/en/Main/ArduinoWiFiShield101

MKR1000

Es un nuevo Arduino con un microcontrolador que lleva integrado wifi y mucho más. El
Arduino MKR1000 ha sido diseñado para ofrecer una solución práctica y económica buscando
conectividad WiFi para gente con mínima experiencia en redes.
Este Arduino está basado en la MCU ATSAMW25 especialmente diseñado para proyectos
IoT. Este SoC está compuesto de tres bloques principales:

 SAMD21 Cortex-M0+ 32bit low power ARM MCU

 WINC1500 low power 2.4GHz IEEE® 802.11 b/g/n Wi-Fi
 ECC508 CryptoAuthentication

Microcontrolado ATSAMW25 http://www.atmel.com/devices/ATSAMW25.aspx

Este Arduino también incluye un circuito para cargar baterías Li-Po y utilizar el MKR1000
alimentándose con este tipo de baterías.

IMPORTANTE: Arduino MKR1000 funciona a 3.3V, el máximo voltaje que pueden tolerar los
pines es de 3.3V y aplicar voltajes mayores podría dañar la placa. Mientras que una salida de
5V digital es posible, para una comunicación bidireccional de 5V es necesario level shifting.

Datasheet MCU: http://www.atmel.com/devices/ATSAMW25.aspx

Esquemático: https://www.arduino.cc/en/uploads/Main/MKR1000-schematic.pdf

Pinout:
Web del producto https://www.arduino.cc/en/Main/ArduinoMKR1000

MKR1000 usa la librería wifi101: https://www.arduino.cc/en/Reference/WiFi101

Empezar con MKR1000

Getting Started https://www.arduino.cc/en/Guide/MKR1000

Para programar el MKR1000 es necesario añadir al IDE de Arduino soporte para esta placa,
ya que el microcontrolador no es un AVR sino un ARM Cortex-M0 de 32 bits. SAMD Core.

En este enlace explica como añadir soporte (Arduino Cores) para nuevas
placas: https://www.arduino.cc/en/Guide/Cores

El MKR1000 y Arduino Zero tienen unas librerías específicas por su microcontrolador:

 Control del RTC interno https://www.arduino.cc/en/Reference/RTC

 Audio gracias al DAC (conversor digital analógico) que
dispone: https://www.arduino.cc/en/Reference/AudioZero
  Muestrear una entrada analógica para obtener la
frecuencia: https://www.arduino.cc/en/Reference/AudioFrequencyMeter
 Programador para ejecutar varias funciones simultaneamente
(multitarea): https://www.arduino.cc/en/Reference/Scheduler

Tutoriales MKR1000:

 Paso a paso con MKR1000: http://programarfacil.com/blog/arduino-blog/configurar-la-

wifi-arduino-mkr1000/
 Client https + internal
rtc: https://www.arduino.cc/en/Tutorial/ScheduledWiFiSSLWebClient
 NTP con MKR1000: https://www.arduino.cc/en/Tutorial/WiFiRTC
 Battery Life: https://www.arduino.cc/en/Tutorial/MKR1000BatteryLife
 Ejemplos en project hub con
MKR1000: https://create.arduino.cc/projecthub/products/arduino-mkr1000-genuino-
mkr1000
 https://www.hackster.io/nekhbet/hello-world-with-arduino-genuino-mkr1000-relay-
board-and-ap-81fb63
 Paso a paso con MKR1000: http://programarfacil.com/blog/arduino-blog/configurar-la-
wifi-arduino-mkr1000/

Proyectos interesantes:

 https://create.arduino.cc/projecthub/Arduino_Genuino/smart-thermostat-e1f400
 https://create.arduino.cc/projecthub/Arduino_Genuino/one-button-to-rule-them-all-
915bbe
 https://create.arduino.cc/projecthub/benbrandt22/wifi-controlled-precision-camera-
slider-b6062f
 https://create.arduino.cc/projecthub/iot-design-shop/fizviz-large-scale-physical-
visualizations-for-your-stats-03249d

MKR1000 como access point https://www.arduino.cc/en/Reference/WiFi101BeginAP (AP soft)

Ejercicio 39 NTP con MKR1000: https://github.com/jecrespo/Aprendiendo-

Arduino/tree/master/Ejercicio39-NTP_MKR1000

Arduino Yun

Otra forma de añadir la funcionalidad de Wifi a Arduino es usar Arduino Yun que tiene wifi
integrado y la librería bridge para conectar el microcontrolador con el microprocesador que
tiene wifi integrado.
Arduino Yun: http://www.arduino.org/products/boards/4-arduino-boards/arduino-yun con MCU
Atmel AVR de 8 bits ATmega32U4 y procesador MIPS Qualcomm Atheros AR9331 a 400 MHz
con wifi integrado y SO linux Linino basado en OpenWRT y ethernet. Su principal
característica es la capacidad de comunicar la MCU con el SO linux mediante un puerto serie
interno. Esta placa no es 100% hardware libre, al no hacerse público la parte donde se
encuentra el procesador Atheros AR9331. También hay disponible una version Yun mini para
protoboards: http://www.arduino.org/products/boards/4-arduino-boards/arduino-yun-mini
Web del producto https://www.arduino.cc/en/Main/ArduinoBoardYun

Librería Bridge:

 Bridge Library – Your reference to the Bridge Library

 Bridge – Simple REST style calls to access analog and digital pins

Recientemente ha aparecido el Arduino Yun Shield que es una placa para añadir las
funcionalidades del Arduino Yun a cualquier Arduino.

Web del producto https://www.arduino.cc/en/Main/ArduinoYunShield

Ejemplo de uso con Arduino Yun: https://github.com/jecrespo/Coche_AprendiendoArduino

Para comenzar una vez actualizado:

 Getting started con Arduino Yun: https://www.arduino.cc/en/Guide/ArduinoYun

 Getting started con Arduino Yun
Shield: https://www.arduino.cc/en/Guide/ArduinoYunShield

CC3000

Otro integrado wifi muy usado con arduino es el CC3000, pero que se ha quedado un poco
obsoleto.

Chip CC3000:
  http://www.ti.com/product/cc3000
 http://www.ti.com/lit/ds/symlink/cc3000.pdf
 http://processors.wiki.ti.com/index.php/CC3000_Overview

Y la librería: https://github.com/sparkfun/SFE_CC3000_Library

Y un buen paso a paso para usar esta shield:

 https://learn.adafruit.com/adafruit-cc3000-wifi/overview

Y un ejemplo de uso práctico para hacer domótica en casa:

 http://www.openhomeautomation.net/wireless-relay-arduino-wifi/

Otros Módulos Wifi

ESP32 el sucesor de ESP8266:

 Web oficial: http://www.espressif.com/en/products/hardware/esp32/overview

 Datasheet: http://www.espressif.com/sites/default/files/documentation/esp32_datashee
t_en_0.pdf
 http://esp32.com/
 http://makezine.com/2015/12/09/meet-esp32-new-big-brother-to-iot-board-esp8266/
 pinout: http://www.pighixxx.com/test/2015/12/esp32-pinout/
 https://hackaday.com/tag/esp32/

Soporte para el IDE de Arduino:

 http://www.esp32.com/viewtopic.php?t=121
 Version beta https://github.com/me-no-dev/ESP31B

Primeras impresiones: https://www.sparkfun.com/news/2017

Tutorial http://www.instructables.com/id/Beginners-ESP32-Guide-to-Assembly-Testing/

Tabla comparativa: http://www.cnx-software.com/2016/03/25/esp8266-and-esp32-differences-

in-one-single-table/

WiFi3 Click

Otro módulo derivado de esp8266:

 http://www.mikroe.com/click/wifi3/
 http://microcontrollershop.com/product_info.php?products_id=7131
 http://download.mikroe.com/manuals/click/wifi-3/wifi_3_click_manual.pdf
 http://es.rs-online.com/web/p/kits-de-desarrollo-de-procesador-y-
microcontrolador/8856615/
NL6621 como alternativa al ESP8266

The NL6621 WiFi SOC is powered by a 160 MHz ARM Cortex-M3 with 448 KB of RAM, and
everything else is integrated in the SOC. The module has 32 GPIOs, SPI, I2C, I2S digital
audio, and most of the peripherals that you’d expect.

 http://hackaday.com/2016/01/30/esp8266-killer/
 http://www.nufront.com/index.php/project/index/id/30.html
Anuncios
REPORT THIS AD

REPORT THIS AD

Compártelo:

 Twitter
 Facebook3
 Google

Relacionado
WiFiEn "Arduino"
Wifi en ArduinoEn "Arduino"
Arduino en IoTEn "Arduino"
Esta entrada se publicó en Arduino, Comunicación, ESP8266, Wifi y está etiquetada
con Arduino, Arduino Yun, Comandos Hayes, Comunicación Inalámbrica, ESP32, esp82, FTDI, Genuino
MKR1000, IoT, NodeMCU, Wifi en 12 noviembre, 2016.

Enviar emails con Arduino

Deja un comentario

El Simple Mail Transfer Protocol (SMTP) (Protocolo para la transferencia simple de correo electrónico),
es un protocolo de red utilizado para el intercambio de mensajes de correo electrónico entre ordenadores
u otros dispositivos (Arduino, teléfonos móviles, etc.). Fue definido en el RFC 2821 y es un estándar
oficial de Internet.

El funcionamiento de este protocolo se da en línea, de manera que opera en los servicios de correo
electrónico. Sin embargo, este protocolo posee algunas limitaciones en cuanto a la recepción de
mensajes en el servidor de destino (cola de mensajes recibidos). Como alternativa a esta limitación se
asocia normalmente a este protocolo con otros, como el POP o IMAP, otorgando a SMTP la tarea
específica de enviar correo, y recibirlos empleando los otros protocolos antes mencionados (POP O
IMAP).
Más información
en: http://es.wikipedia.org/wiki/Simple_Mail_Transfer_Protocol y http://es.kioskea.net/contents/279-
protocolos-de-mensajeria-smtp-pop3-e-imap4

Éste es un protocolo que funciona en línea, encapsulado en una trama TCP/IP. El correo se envía
directamente al servidor de correo del destinatario. El protocolo SMTP funciona con comandos de textos
enviados al servidor SMTP (al puerto 25 de manera predeterminada). A cada comando enviado por el
cliente (validado por la cadena de caracteres ASCII CR/LF, que equivale a presionar la tecla Enter) le
sigue una respuesta del servidor SMTP compuesta por un número y un mensaje descriptivo.

Esta es la secuencia de envío de un correo:

 Al abrir la sesión SMTP, el primer comando que se envía es el comando HELO seguido por un
espacio (escrito <SP>) y el nombre de dominio de su equipo (para decir “hola, soy este
equipo”), y después validado por Enter (escrito <CRLF>). Desde abril de 2001, las
especificaciones para el protocolo SMTP, definidas en RFC 2821, indican que el comando HELO
sea remplazado por el comando EHLO.
 El segundo comando es “MAIL FROM:” seguido de la dirección de correo electrónico del
remitente. Si se acepta el comando, el servidor responde con un mensaje “250 OK”.
 El siguiente comando es “RCPT TO:” seguido de la dirección de correo electrónico del
destinatario. Si se acepta el comando, el servidor responde con un mensaje “250 OK”.
 El comando DATA es la tercera etapa para enviar un correo electrónico. Anuncia el comienzo
del cuerpo del mensaje. Si se acepta el comando, el servidor responde con un mensaje
intermediario numerado 354 que indica que puede iniciarse el envío del cuerpo del mensaje.
 Si se acepta el comando, el servidor responde con un mensaje “250 OK”.
Las especificaciones básicas del protocolo SMTP indican que todos los caracteres enviados están
codificados mediante el código ASCII de 7 bits y que el 8º bit sea explícitamente cero. Por lo tanto, para
enviar caracteres acentuados es necesario recurrir a algoritmos que se encuentren dentro de las
especificaciones MIME.

Ejemplo de Conversación SMTP mediante telnet:

  http://www.anta.net/misc/telnet-troubleshooting/smtp.shtml
 http://www.earthinfo.org/example-smtp-conversation/
 https://www.ndchost.com/wiki/mail/test-smtp-auth-telnet

RFC 2821:

 https://www.ietf.org/rfc/rfc2821.txt

Para enviar correos electrónicos desde arduino, es como si lo hiciéramos utilizando telnet. Esto se hacía
mucho antiguamente cuando los servidores de correo no solían estar protegidos contra el reenvío de
emails y cualquiera podía conectarse al puerto 25 de un servidor de correo y enviar un correo con un
remitente falso.

Un ejemplo de como mandar correo electrónico con Arduino directamente:

 Para mandar un correo como un cliente/servidor

SMTP: http://playground.arduino.cc/Code/Email
 Y para leer correos desde nuestro Arduino con
POP3: http://playground.arduino.cc/Code/EmailPOP3
 http://itmanageratschool.blogspot.com.es/2012/06/control-de-temperatura-v2-sin-
necesidad.html
 http://playground.arduino.cc/Code/WiFiEmailClient
 http://wiki.mcselec.com/How_to_send_an_Email_with_Arduino_and_Ethernet_Shield_(W510
0)

Obviamente para poder enviar un correo de la forma anteriormente vista necesitamos un servidor SMTP
no protegido. La gran mayoría de los servidores de correo requieren que nos autentiquemos por lo que se
complica un poco el proceso de enviar correo a través de telnet pero esto no significa que no podamos
hacerlo.

Podemos montar una raspberry pi que haga de servidor SMTP que reciba los correos de nuestro arduino
y usar la raspberry pi para que reenvíe los correos a través de gmail u otro servicio de correo.

Por supuesto disponemos de librerías que implementan un cliente SMTP en arduino:

 SMTP client: https://github.com/gregington/SMTPClient

Ejercicio31-MandaCorreo: Mandar un correo desde Arduino

Solución: https://github.com/jecrespo/Aprendiendo-Arduino/tree/master/Ejercicio31-MandaCorreo

Otra estrategia para mandar correos desde Arduino es dejarlo en manos de un servidor, es decir, con
Arduino mando un POST HTTP que recoge el servidor y este mediante PHP, python u otro lenguaje se
encarga de mandar el correo con las librería que tiene disponibles.
Anuncios
REPORT THIS AD

REPORT THIS AD

Compártelo:
  Twitter
 Facebook
 Google

Relacionado
Tema 6 - Comunicaciones con Arduino (3)En "Arduino"
Conceptos básicos de comunicacionesEn "Arduino"
Protocolos IoT Capa AplicaciónEn "CoAP"
Esta entrada se publicó en Arduino, Comunicación, email, SMTP y está etiquetada
con Arduino, Comunicación Inalámbrica, email, SMTP en 13 noviembre, 2016.

Bluetooth en Arduino
8 respuestas

Bluetooth es una especificación industrial para Redes Inalámbricas de Área Personal (WPAN)
que posibilita la transmisión de voz y datos entre diferentes dispositivos mediante un enlace
por radiofrecuencia en la banda ISM de los 2.4 GHz. Los principales objetivos que se
pretenden conseguir con esta norma son:

 Facilitar las comunicaciones entre equipos móviles.

 Eliminar los cables y conectores entre estos.
 Ofrecer la posibilidad de crear pequeñas redes inalámbricas y facilitar la sincronización
de datos entre equipos personales.

Se denomina Bluetooth al protocolo de comunicaciones diseñado especialmente para

dispositivos de bajo consumo, que requieren corto alcance de emisión y basados en
transceptores de bajo costo.

Los dispositivos que incorporan este protocolo pueden comunicarse entre sí cuando se
encuentran dentro de su alcance. Las comunicaciones se realizan por radiofrecuencia de
forma que los dispositivos no tienen que estar alineados y pueden incluso estar en
habitaciones separadas si la potencia de transmisión es suficiente. Estos dispositivos se
clasifican como “Clase 1”, “Clase 2” o “Clase 3” en referencia a su potencia de transmisión.

Los dispositivos con Bluetooth también pueden clasificarse según su capacidad de canal:
Versión Ancho de banda

Versión 1.2 1 Mbit/s

Versión 2.0 + EDR 3 Mbit/s

Versión 3.0 + HS 24 Mbit/s

Versión 4.0 32 Mbit/s

La especificación de Bluetooth define un canal de comunicación a un máximo 720 kbit/s (1

Mbit/s de capacidad bruta) con rango óptimo de 10 m (opcionalmente 100 m con repetidores).
Opera en la frecuencia de radio de 2,4 a 2,48 GHz con amplio espectro y saltos de frecuencia
con posibilidad de transmitir en Full Duplex con un máximo de 1600 saltos por segundo. Los
saltos de frecuencia se dan entre un total de 79 frecuencias con intervalos de 1 MHz; esto
permite dar seguridad y robustez.

Tanto Bluetooth clásico como Bluetooth de baja energía aplican la característica de salto de
frecuencia adaptativa (AFH – Adaptive Frequency Hopping) que detecta interferencias de. Por
ejemplo, un dispositivo WLAN 802.11 b, g, n que transmite cercano, si se detecta tal
interferencia, el canal se coloca automáticamente en la lista negra. Con el fin de manejar la
interferencia temporal, un esquema implementado vuelve a intentar los canales de la lista
negra y si la interferencia ha cesado el canal se puede utilizar. AFH impide que Bluetooth
interfiera con otras tecnologías inalámbricas cercanas.

El hardware que compone el dispositivo Bluetooth está compuesto por dos partes:

 un dispositivo de radio, encargado de modular y transmitir la señal.

 un controlador digital, compuesto por una CPU, un procesador de señales digitales
(DSP – Digital Signal Processor) llamado Link Controller (o controlador de Enlace) y de
las interfaces con el dispositivo anfitrión.

El LC o Link Controller se encarga del procesamiento de la banda base y del manejo de los
protocolos ARQ y FEC de la capa física; además, se encarga de las funciones de
transferencia tanto asíncrona como síncrona, la codificación de audio y el cifrado de datos.

Bluetooth de baja energía, también denominada como Bluetooth LE, Bluetooth ULP (Ultra Low
Power) y Bluetooth Smart, es una nueva tecnología digital de radio (inalámbrica) interoperable
para pequeños dispositivos desarrollada por Bluetooth.

Los dispositivos BlueTooth pueden actuar como Masters o como Slaves. La diferencia es que
un BlueTooth Slave solo puede conectarse a un master y a nadie más, en cambio un master
BlueTooth, puede conectarse a varios Slaves o permitir que ellos se conecten y recibir y
solicitar información de todos ellos, arbitrando las transferencias de información (Hasta un
máximo de 7 Slaves).

Cada uno de los dispositivos que se identifican vía BlueTooth presentan una dirección única
de 48 bits y además un nombre de dispositivo que nos sirva para identificarlo cómodamente a
los humanos. Por eso cuando configuras tu móvil puedes especificar un nombre propio que
será el que mostrarás a los demás cuando busquen tu teléfono en la inmediaciones.

La dirección propia también se puede identificar pero lógicamente, es un poco menos cómoda
y tiene menos utilidad. Tampoco es raro establecer un protocolo IP sobre transporte
BlueTooth, con lo que además de su identificación interna BlueTooth (Equivalente al MAC
Ethernet) dispondrá de una dirección IP para conectarse a Internet. Por eso puedes conectarte
vía Bluetooth a tu PC, por ejemplo, y a través de él conectarte a internet.

Así pues un nodo BlueTooth puede ser Master o Slave y dispone de una dirección única, así
como de un nombre para identificarse y muy habitualmente también incluye un PIN de
conexión o número de identificación que debe teclearse para ganar acceso al mismo.

Como el BlueTooth lo desarrolló Nokia para conectar teléfonos móviles, a otros dispositivos
como auriculares, micrófonos o conexiones al audio del coche, existe un procedimiento
definido que se llama Pairing (o emparejamiento) que vincula a dos dispositivos Bluetooth.

Cuando vinculas dos dispositivos BT, se inicia un proceso en el que ellos se identifican por
nombre y dirección interna y se solicitan la clave PIN para autorizar la conexión.

Si el emparejamiento se realiza con éxito, ambos nodos suelen guardar la identificación del
otro y cuando se encuentran cerca se vuelven a vincular sin necesidad de intervención
manual. (Aunque para que tu BlueTooth pueda enviar o recibir música, debe aceptar otra
norma posterior llamada Advanced Audio Distribution Profile (A2DP) y que en caso de ser
algún sistema antiguo te impedirá la reproducción.)

Para manejar los módulos Bluetooth usamos comandos Hayes o

AT: https://es.wikipedia.org/wiki/Conjunto_de_comandos_Hayes

Comandos AT básicos

 AT+VERSION, versión del Firmware

 AT+NAMEXXX, Programa el nombre que queremos presentar cuando alguien nos
busque
 AT+BAUDX, Fija la velocidad de comunicación entre el modulo y la consola según a la
siguiente tabla:
 1 configura 1200bps
 2 configura 2400bps
 3 configura 4800bps
 4 configura 9600bps (Default)
 5 configura 19200bps
 6 configura 38400bps
 7 configura 57600bps
 8 configura 115200bps
 AT+PINXXXX, configura el número de identificación personal, que se requerirá para
establecer la vinculación
 AT+ROLE Nos informa de si está configurado como Maestro 1, o como esclavo 0.
 AT+ROLE1 Configura el modulo como Master.
 AT+ROLE0 Configura el modulo como Slave.

Protocolo base de Bluetooth 802.15: https://es.wikipedia.org/wiki/IEEE_802.15

Los módulos HC-05 y HC-06 son Bluetooth V2. Pero con el tiempo han ido apareciendo
módulos como los que conocemos que soportan el protocolo Bluetooth V4.0 o Low Energy al
alcance de todos los bolsillos y los fabricantes chinos han empezado a suministrarlos de forma
accesible, tales como los modelos HC-08 y HC-10.
El nuevo Bluetooth 4.0 es un nuevo protocolo diseñado pensando en disminuir todo lo posible
las necesidades de energía de los dispositivos que lo usan, y de sobre todo de la propia
comunicación que tradicionalmente ha sido de consumo insaciable.

Se le suele llamar también BLE por Bluetooth Low Energy, o simplemente Bluetooth LE.
Mejora bastante el consumo previo, pero la distancia también disminuye.

BLE: http://www.atmel.com/products/wireless/bluetooth/default.aspx

Un poco de teoría de bluetooth:

 https://www.bluetooth.com/
 https://es.wikipedia.org/wiki/Bluetooth
 https://en.wikipedia.org/wiki/Bluetooth

Más información:

 http://www.bluezona.com/index.php?option=com_content&task=view&id=25&Itemid=5
0/
 https://es.wikipedia.org/wiki/Bluetooth_de_baja_energ%C3%ADa
 https://es.wikipedia.org/wiki/Bluetooth_(especificaci%C3%B3n)
 Tecnologías inalámbricas para aplicaciones
industriales: http://www.digikey.com/en/articles/techzone/2012/jan/wireless-
technologies-for-industrial-applications
 http://www.prometec.net/bluetooth-le/

Bluetooth con Arduino

Para dotar de comunicación bluetooth con Arduino podemos hacerlo de varia formas:

 Modulo bluetooth externo https://www.adafruit.com/products/1535

 Módulo HC-05 o HC-06
 Módulo Bluetooth 4.0 HC-08 y HC-09
 Módulo sparkfun: https://www.sparkfun.com/products/12577
 Módulo integrado en placa como el arduino
bt https://www.arduino.cc/en/Main/ArduinoBoardBT?from=Main.ArduinoBoardBluetooth
o BQ Zum Core https://www.bq.com/es/placa-zum-core que permiten su programacion
mediante OTA
 Microcontrolador con Bluetooth integrado como el Arduino
101: https://www.arduino.cc/en/Main/ArduinoBoard101
 Shield Bluetooth: http://wiki.seeedstudio.com/wiki/Bluetooth_Shield
 Arduino wireless programmer: https://www.itead.cc/arduino-wireless-programmer.html

Los módulo más frecuentes en el mercado son los módulos HC-06 y HC-05 que son muy
económicos y están disponibles independientes o en modo SHIELD y para zocalo XBEE.
Manual del módulo: https://core-electronics.com.au/attachments/guides/Product-User-Guide-
JY-MCU-Bluetooth-UART-R1-0.pdf

Como el módulo BlueTooth es básicamente un nodo BT conectado a un interface serie,

podríamos en principio conectar los pines RX y Tx a los equivalentes de Arduino en los pines
0 y 1 digitales, sin más que cruzarlos (BT Tx a Arduino Rx y BT Rx a Aduano Tx) y de hecho
muchos ejemplos en Internet utilizan este esquema y se comunican con el BT mediante las
familiares instrucciones de Serial.print ().

Sin embargo, puesto que los pines 0 y 1 se utilizan en la comunicación serie de Arduino con el
PC a través del USB y por tanto, si los usamos para comunicar con el modulo BT,
perderíamos la conexión con el PC, es mejor usar otros pines.

Para ello tenemos que importar una librería que habilite la comunicación serie con otros pines
como es la librería SoftwareSerial.

NOTA el módulo HC-06, a diferencia del HC-05, no espera un terminador de línea como \n, si
no que salta por tiempo y debemos tenerlo en cuenta a la hora de hacer el programa de
conexión con Arduino.

Un ejemplo de cómo convertir un coche RC en bluetooth:

 https://www.hackster.io/jegatheesan/easy-hack-rc-to-rc-and-bt-car-using-linkit-one-
aab56b
  Y la
app: https://play.google.com/store/apps/details?id=braulio.calle.bluetoothRCcontroller&
hl=en

Ejercicios Bluetooth

El módulo que vamos a usar para las prácticas es el HC-05 que tiene 6 patillas.
El módulo HC-05, que puede configurarse tanto como Master que como Slave, y que además
dispone de bastante más parámetros de configuración y capacidades de interrogación.

Mientras que el HC-06 entra en modo de programación en cuanto lo enciendes y mientras no

haya nadie conectado por Bluetooth, el HC-05 es ligeramente más complicado de colocar en
modo comandos y requiere una cierta manera de arrancado, concretamente requiere que el
pin KEY, (que no estaba conectado el caso del HC-06) esté en HIGH cuando encendemos el
módulo.

Conexión a Arduino
Como el modulo HC-05 funciona a 3,3 V hay bastante controversia en internet respecto a si
debemos o no, poner divisores de tensión para acceder a los pines del módulo con Arduino.
Pero por las pruebas hechas y los tutoriales en principio no es necesario usar un divisor de
tensión y los pines son tolerantes a 5V, pero hacerlo bajo vuestra responsabilidad.

Fijaros que al hacer esta conexión, el LED del módulo HC-05, parpadea continuamente. Esto
indica que no está pareado o vinculado. Cuando conectes algo al módulo, esta luz se quedará
fija y es la forma de saber si hay conexión o no.

También usaremos un terminal bluetooth en nuestro móvil como:

 Arduino Bluetooth
terminal: https://play.google.com/store/apps/details?id=appinventor.ai_el_profe_garcia.
Arduino_Bluetooth_Terminal
  Bluetooth
Terminal: https://play.google.com/store/apps/details?id=Qwerty.BluetoothTerminal
 Bluetooth spp tools
pro: https://play.google.com/store/apps/details?id=mobi.dzs.android.BLE_SPP_PRO

Para esta práctica usaremos esta configuración:

En primer lugar, para que el HC-05 entre en modo comandos AT, requiere que cuando se
enciende el módulo, el pin KEY este HIGH. Por eso hemos conectado la tensión Vcc del
módulo BlueTooth al pin 8 de nuestro Arduino.
NOTA: El módulo que vamos a usar tiene un botón, este botón es el que debemos pulsar
para poner el módulo en modo configuración (comandos AT). También para usar algunos de
los comandos importantes como AT+NAME, es necesario pulsar el botón al ejecutar el
comando y que guarde los cambio.

El consumo del módulo es mínimo y nuestro Arduino es capaz de alimentarlo sin problemas,
por eso el módulo se encenderá cuando pongamos HIGH en el pin 8. Esto nos permitirá poner
en HIGH el pin digital 9, al iniciar nuestro programa y después levantar el pin 9, de este modo
cuando arranque entrará sin más en el modo de comandos AT.

El resto de los pines se conectan de forma que Txd y Rxd se deben conectar cruzados con los
pines de comunicación de Arduino, que usaremos mediante la librería software Serial. El pin
State refleja, la situación en la que se encuentra el módulo y por ahora no vamos a utilizarlo.

Con este procedimiento garantizamos que el modulo HC-05 entra solo en modo AT
comandos, y que nuestra consola nos va a servir para programarlo.

Para mandar comandos AT usaremos este sketch:

1 #include <SoftwareSerial.h>

SoftwareSerial BT1(10, 11); // RX | TX

2
void setup()
3
{ pinMode(8, OUTPUT); // Al poner en HIGH forzaremos el modo AT
4
pinMode(9, OUTPUT); // cuando se alimente de aqui
5
digitalWrite(9, HIGH);
6
delay (500) ; // Espera antes de encender el modulo
7 Serial.begin(9600);
8 Serial.println("Levantando el modulo HC-06");

9 digitalWrite (8, HIGH); //Enciende el modulo

10 Serial.println("Esperando comandos AT:");

BT1.begin(38400);
11
}
12

13
void loop()
14
{ if (BT1.available())
15
Serial.write(BT1.read());
16
if (Serial.available())
17 BT1.write(Serial.read());
18 }
19

20

También podemos usar directamente el FTDI con el siguiente pineado:

Si todo está bien conectado veremos en consola:

Lista de comandos AT:

AT COMMAND LISTING

COMMAND FUNCTION

AT Test UART Connection

AT+RESET Reset Device

AT+VERSION Query firmware version

AT+ORGL Restore settings to Factory Defaults

AT+ADDR Query Device Bluetooth Address

AT+NAME Query/Set Device Name

AT+RNAME Query Remote Bluetooth Device’s

AT+ROLE Query/Set Device Role

AT+CLASS Query/Set Class of Device CoD

AT+IAC Query/Set Inquire Access Code

AT+INQM Query/Set Inquire Access Mode

AT+PSWDAT+PIN Query/Set Pairing Passkey

AT+UART Query/Set UART parameter

AT+CMODE Query/Set Connection Mode

AT+BIND Query/Set Binding Bluetooth Address

AT+POLAR Query/Set LED Output Polarity

AT+PIO Set/Reset a User I/O pin

Referencia de los comandos AT:

 http://www.instructables.com/files/orig/FKY/Z0UT/HX7OYY7I/FKYZ0UTHX7OYY7I.pdf
 http://www.martyncurrey.com/?wpdmdl=2248
 https://arduino-info.wikispaces.com/BlueToothCommandUtility

Es importante comprender, que en cuanto conectemos algún dispositivo a nuestro modulo

Bluettotth HC-05, la luz roja dejará de parpadear y automáticamente saldremos del modo de
comandos AT para entrar en el de transporte de información, es decir, cualquier cosa que le
enviemos, incluyendo comandos AT, se consideraran texto plano que se reenviará al otro
extremos de la conexión Bluetooth.

NOTA para nuestro módulo el parpadeo de las luces es de la siguiente forma:

 Modo AT (configuración): parpadeo lento

 Modo normal sin nada conectado: parpadeo rápido
 Modo normal conectado: parpadeo lento con doble parpadeo

Los valores por defecto del módulo usado son:

 Name = HC-05
 Password = 1234
 Baud rate in communication mode = 9600
 Baud rate in AT/Command mode = 38400

Probar a mandar comandos AT y luego salir de modo AT con AT+RESET y comunicar entre el
móvil y Arduino usando la aplicación “Bluetooth spp tools pro”.

Basic Bluetooth

Hacer el ejercicio basic_bluetooth donde encenderemos el led 13 mandando un 1 y lo

apagaremos mandando un 0 desde el móvil con la aplicación: Bluetooth spp tools pro.
Enlace: https://play.google.com/store/apps/details?id=mobi.dzs.android.BLE_SPP_PRO

Ejercicio41 – Bluetooth: https://github.com/jecrespo/Aprendiendo-

Arduino/tree/master/Ejercicio41-Bluetooth/basic_bluetooth

Interacción Móvil-Arduino

Usar ardudroid para controlar los pines de Arduino desde el móvil:

  App: https://play.google.com/store/apps/details?id=com.techbitar.android.Andruino&hl=
es_419
 Manual de uso: http://www.techbitar.com/ardudroid-simple-bluetooth-control-for-
arduino-and-android.html
 Código en Arduino: https://github.com/jecrespo/Aprendiendo-
Arduino/tree/master/Ejercicio41-Bluetooth/ardudroid

Mandar a Arduino los datos de los sensores del móvil con sensoduino

 App: https://play.google.com/store/apps/details?id=com.techbitar.android.sensoduino
 Manual de uso: http://www.techbitar.com/sensoduino.html

Para saber todo sobre el módulo bluetooth y hacer más ejercicios:

 http://www.martyncurrey.com/arduino-with-hc-05-bluetooth-module-at-mode/
 http://www.martyncurrey.com/hc-05-fc-114-and-hc-06-fc-114-first-look/
 http://www.martyncurrey.com/hc-05-fc-114-and-hc-06-fc-114-part-2-basic-at-
commands/
 http://www.martyncurrey.com/hc-05-fc-114-and-hc-06-fc-114-part-3-master-mode-and-
auto-connect/
 http://www.martyncurrey.com/arduino-with-hc-05-bluetooth-module-in-slave-mode/

Más información:

 http://www.prometec.net/bt-hc06/
 http://www.prometec.net/bt-hc05/
 Instrucciones de usuario del
módulo: https://www.rcscomponents.kiev.ua/datasheets/hc_hc-05-user-instructions-
bluetooth.pdf
 Controlar Arduino con Android: http://www.prometec.net/android-bt/
 Arduino a PC con bluetooth: http://www.prometec.net/pc-bt/
 http://www.prometec.net/bluetooth-le/
 http://www.martyncurrey.com/hc-05-fc-114-and-hc-06-fc-114-part-2-basic-at-
commands/
 http://www.techbitar.com/modify-the-hc-05-bluetooth-module-defaults-using-at-
commands.html
 http://wiki.bernardino.org/index.php/Using_the_HC-05_Bluetooth
 Tutorial de configuración: http://www.geekfactory.mx/tutoriales/bluetooth-hc-05-y-hc-
06-tutorial-de-configuracion/
 Tutorial muy completo: http://diymakers.es/arduino-bluetooth/
 Un buen tutorial del modulo de adafruit: https://learn.adafruit.com/introducing-bluefruit-
ez-link/overview
 Tutorial: http://saber.patagoniatec.com/hc-05-bluetooth-conectar-esclavo-hc05-
maestro-master-save-wireless-tutorial-iot-celular-smartphone-arduino-argentina-ptec/
 Tutorial: http://www.naylampmechatronics.com/blog/24_Configuraci%C3%B3n–del-
m%C3%B3dulo-bluetooth-HC-05-usa.html
 Tutorial muy bueno: http://www.martyncurrey.com/arduino-with-hc-05-bluetooth-
module-at-mode/
 Muy buen tutorial del HC05: https://arduino-info.wikispaces.com/BlueTooth-HC05-
HC06-Modules-How-To
Anuncios
REPORT THIS AD
 REPORT THIS AD

Compártelo:

 Twitter
 Facebook10
 Google

Relacionado
Conectividad IoTEn "Bluetooth"
Wifi en ArduinoEn "Arduino"
WiFiEn "Arduino"
Esta entrada se publicó en Arduino, Bluetooth, Comunicación y está etiquetada
con Arduino, BLE, Bluetooth, Comandos Hayes, Comunicación Inalámbrica, HC-05 en 13 noviembre, 2016.

Interrupciones
12 respuestas

Si queremos detectar un cambio de estado en esta entrada, el método que hemos usado
hasta ahora es emplear las entradas digitales para consultar repetidamente el valor de la
entrada, con un intervalo de tiempo (delay) entre consultas.

Este mecanismo se denomina “poll”, y tiene 3 claras desventajas.

 Suponer un continuo consumo de procesador y de energía, al tener que preguntar

continuamente por el estado de la entrada.
 Si la acción necesita ser atendida inmediatamente, por ejemplo en una alerta de
colisión, esperar hasta el punto de programa donde se realiza la consulta puede ser
inaceptable.
 Si el pulso es muy corto, o si el procesador está ocupado haciendo otra tarea mientras
se produce, es posible que nos saltemos el disparo y nunca lleguemos a verlo.

Para resolver este tipo de problemas, los microprocesadores incorporan el concepto

de interrupción, que es un mecanismo que permite asociar una función a la ocurrencia de un
determinado evento. Esta función de callback asociada se denomina ISR (Interruption Service
Rutine).

En programación, una interrupción es una señal recibida por el procesador o MCU, para
indicarle que debe «interrumpir» el curso de ejecución actual y pasar a ejecutar código
específico para tratar esta situación.

Una interrupción es una suspensión temporal de la ejecución de un proceso, para pasar a

ejecutar una subrutina de servicio de interrupción, la cual, por lo general, no forma parte del
programa. Una vez finalizada dicha subrutina, se reanuda la ejecución del programa. Las
interrupciones HW son generadas por los dispositivos periféricos habilitando una señal del
CPU (llamada IRQ del inglés “interrupt request”) para solicitar atención del mismo.
Todos los dispositivos que deseen comunicarse con el procesador por medio de
interrupciones deben tener asignada una línea única capaz de avisar al CPU cuando le
requiere para realizar una operación. Esta línea se denomina IRQ.

Las IRQ son líneas que llegan al controlador de interrupciones, un componente de

hardware dedicado a la gestión de las interrupciones, y que está integrado en la MCU.

El controlador de interrupciones debe ser capaz de habilitar o inhibir las líneas de

interrupción y establecer prioridades entre las mismas. Cuando varias líneas de petición de
interrupción se activan a la vez, el controlador de interrupciones utilizará estas prioridades
para escoger la interrupción sobre la que informará al procesador principal. También puede
darse el caso de que una rutina de tratamiento de interrupción sea interrumpida para realizar
otra rutina de tratamiento de una interrupción de mayor prioridad a la que se estaba
ejecutando.

Procesamiento de una Interrupción:

1. Terminar la ejecución de la instrucción máquina en curso.

2. Salvar el estado del procesador (valores de registros y flags) y el valor del contador de
programa en la pila, de manera que en la CPU, al terminar el proceso de interrupción,
pueda seguir ejecutando el programa a partir de la última instrucción.
3. La CPU salta a la dirección donde está almacenada la rutina de servicio de
interrupción (Interrupt Service Routine, o abreviado ISR) y ejecuta esa rutina que tiene
como objetivo atender al dispositivo que generó la interrupción.
4. Una vez que la rutina de la interrupción termina, el procesador restaura el estado que
había guardado en la pila en el paso 2 y retorna al programa que se estaba usando
anteriormente.

Tipos de Interrupciones:

 Interrupciones HW o externas: Estas son asíncronas a la ejecución del procesador, es

decir, se pueden producir en cualquier momento independientemente de lo que esté
haciendo el CPU en ese momento. Las causas que las producen son externas al
 procesador y a menudo suelen estar ligadas con los distintos dispositivos de entrada o
salida.
 Interrupciones SW: Las interrupciones por software son aquellas generadas por un
programa en ejecución. Para generarlas, existen distintas instrucciones en el código
máquina que permiten al programador producir una interrupción. Arduino no soporta
las interrupciones por software
 Un evento programado o Timer. Son las interrupciones asociadas a los timers y
gracias a ellas funciona millis().
 Excepciones: Son aquellas que se producen de forma síncrona a la ejecución del
procesador típicamente causada por una condición de error en un programa.
Normalmente son causadas al realizarse operaciones no permitidas tales como la
división entre 0, el desbordamiento, el acceso a una posición de memoria no permitida,
etc.

Definiciones genéricas de Interrupciones:

 https://es.wikipedia.org/wiki/Interrupci%C3%B3n
 http://programarfacil.com/blog/arduino-blog/interrupciones-con-arduino-ejemplo-
practico/
 https://en.wikipedia.org/wiki/Interrupt

Interrupciones en Arduino

Internamente, Arduino (mejor dicho el microcontrolador AtMega) tiene ciertas interrupciones

configuradas que lanza según la situación. Para la transmisión de datos a través del puerto
serie, para resetear la placa antes de cargar un programa, comunicación I2C, etc…

El uso de interrupciones es casi obligatorio en un programa avanzado de un microcontrolador.

Básicamente cuando un evento ocurre se levanta una bandera y la ejecución se traslada a
una rama de código diferente. De esta forma no es necesario esperar un loop a comprobar
que un evento ha ocurrido para ejecutar una acción.

Las interrupciones pueden ocurrir por un cambio en un puerto (solo en aquellos que soporten
interrupciones HW), overflow en un timer, comunicación serie (USART), etc…

Normalmente no se ve, pero las interrupciones ocurren constantemente durante la operación

normal de Arduino. Por ejemplo las interrupciones ayudan a las funciones delay() y millis() así
como a la función Serial.read().
El procesador dentro de cualquier Arduino tiene dos tipos de interrupciones: “externas” y
“cambio de pin”.

Más información:

 http://www.prometec.net/interrupciones/
 http://programarfacil.com/blog/arduino-blog/interrupciones-con-arduino-ejemplo-
practico/
 http://www.sites.upiicsa.ipn.mx/polilibros/portal/Polilibros/P_terminados/PolilibroFC/Uni
dad_V/Unidad%20V_2.htm
 http://playground.arduino.cc/Code/Interrupts

Las interrupciones son muy útiles para hacer que las cosas ocurran automáticamente en los
programas del microcontrolador y pueden resolver problemas de temporización.

Las tareas más usuales en las que usar interrupciones son en la monitorización de entradas
de usuario o entradas externas críticas en el tiempo, así como en lectura de periféricos con
requisitos de temporización muy específicos donde queramos capturar un evento que tiene
una duración muy corta inferior al tiempo de loop de nuestro programa.

Para definir una interrupción necesitamos tres cosas:

 Un pin de Arduino que recibirá la señal de disparo

 Una condición de disparo
 Una función que se ejecutará, cuando se dispara la interrupción (Llamada call back
function).

En cuanto a la condición de disparo puede ser:

 LOW, La interrupción se dispara cuando el pin es LOW.

 CHANGE, Se dispara cuando pase de HIGH a LOW o viceversa.
 RISING, Dispara en el flanco de subida (Cuando pasa de LOW a HIGH).
  FALLING, Dispara en el flanco de bajada (Cuando pasa de HIGH a LOW).
 Y una solo para el DUE: HIGH se dispara cuando el pin esta HIGH.

Para saber todo sobre las interrupciones en el ATmega328p, debemos consultar su

información en la página 32 y 82 de http://www.atmel.com/Images/Atmel-42735-8-bit-AVR-
Microcontroller-ATmega328-328P_datasheet.pdf

Los vectores de interrupción es una tabla en memoria que contiene la dirección de memoria
de la primera instrucción de interrupción. ATmega328p Interrupt vectors, además esta tabla
establece la prioridad de las interrupciones:

Y así funciona el ISR vector table:

Las librería de avr-libc que se usa para manejar las interrupciones es <avr/interrupt.h>:

 http://www.nongnu.org/avr-libc/user-manual/group__avr__interrupts.html
 http://www.atmel.com/webdoc/AVRLibcReferenceManual/group__avr__interrupts.html

Más información:

 http://courses.cs.washington.edu/courses/csep567/10wi/lectures/Lecture7.pdf
 http://ee-classes.usc.edu/ee459/library/documents/avr_intr_vectors/
 http://www.luisllamas.es/2016/04/que-son-y-como-usar-interrupciones-en-arduino/
 http://avrmicrotutor.blogspot.com.es/2011/08/basic-understanding-of-
microcontroller.html
 https://felixmaocho.wordpress.com/2013/08/05/arduino-manejo-de-interrupciones/

Interrupciones Externas en Arduino

Estas interrupciones hardware, se diseñaron por la necesidad de reaccionar a suficiente

velocidad en tiempos inimaginablemente cortos a los que la electrónica trabaja habitualmente
y a los que ni siquiera el software era capaz de reaccionar.

Para las interrupciones externas o hardware, solo hay dos pines que las soportan en los
ATmega 328 (p.e. Arduino UNO), son las INT0 y INT1 que están mapeadas a los pines 2 y 3.
Estas interrupciones se pueden configurar con disparadores en RISING o FALLING para
flancos o en nivel LOW. Los disparadores son interpretados por hardware y la interrupción es
muy rápida.

El Arduino mega tiene más pines disponibles para interrupciones externas. Pines de External
Interrupts para Mega: 2 (interrupt 0), 3 (interrupt 1), 18 (interrupt 5), 19 (interrupt 4), 20
(interrupt 3), and 21 (interrupt 2). Estos pines pueden ser configurados para disparar una
interrupción al detectar un nivel bajo, un flanco ascendente, un flanco descendente o un
cambio de nivel.

En el pin de reset también hay otra interrupción que sólo se dispara cuando detecta voltaje
LOW y provoca el reset del microcontrolador.
Para configurar una interrupción en Arduino se usa la función attachInterrupt(). El primer
parámetro a configurar es el número de interrupción, normalmente se usa el nº de pin para
traducir al nº de interrupción.

Tabla de pines que soportan interrupción HW en Arduino:

Board Digital Pins Usable For Interrupts

Uno, Nano, Mini, other 328-based 2, 3

Mega, Mega2560, MegaADK 2, 3, 18, 19, 20, 21

Micro, Leonardo, other 32u4-based 0, 1, 2, 3, 7

Zero all digital pins, except 4

MKR1000 Rev.1 0, 1, 4, 5, 6, 7, 8, 9, A1, A2

Due all digital pins

Esto quiere decir que el Arduino UNO puede definir dos interrupciones hardware llamadas 0 y
1, conectadas a los pines 2 y 3

Para saber qué número de interrupción estás asociada a un pin, debemos usar la
función digitalPinToInterrupt(pin). El número de interrupción su mapeo en los pines
dependerá del MCI. El uso de número de interrupción puede provocar problemas de
compatibilidad cuando el sketch funciona en diferentes placas.

Tabla de interrupciones y número de pin asociado:

Board int.0 int.1 int.2 int.3 int.4 int.5

Uno, Ethernet 2 3

Mega2560 2 3 21 20 19 18
32u4 based (e.g Leonardo, Micro) 3 2 0 1 7

Arduino Due tiene grandes capacidades a nivel de interrupciones que permiten asociar una
interrupción a cada uno de los pines disponibles. Arduino Zero permite asociar una
interrupción a todos los pines excepto para el pin 4.

Aspectos importantes a tener en cuenta con el uso de interrupciones:

 Dentro de la función llamada desde la interrupción, la función delay() no funciona y el

valor devuelto por millis() no aumenta. La razón es que estas funciones hacen uso de
interrupciones que no se disparan mientras está disparada una interrupción externa.
 Los datos recibidos por el puerto serie se pueden perder mientras se está en la función
llamada por la interrupción.
 Se deben declarar como “volatile” cualquier variable que sea modificada dentro de la
función llamada por una interrupción: https://www.arduino.cc/en/Reference/Volatile

Tutorial de Interrupciones externas en MCUs AVR de 8 bits: http://www.avr-

tutorials.com/interrupts/The-AVR-8-Bits-Microcontrollers-External-Interrupts

Programación de interrupciones externas en C: http://www.avr-tutorials.com/interrupts/avr-

external-interrupt-c-programming

Las interrupciones de hardware, también conocidas como INT0 e INT1, llaman a una rutina de
servicio de interrupción cuando algo sucede con uno de los pines asociados. La ventaja es
que Arduino tiene una simple rutina de configuración para conectar la rutina de servicio de
interrupción al evento: attachInterrupt (). La desventaja es que sólo funciona con dos pines
específicos: pin digital 2 y 3 en la placa Arduino.

El Atmega328p solo tiene dos interrupciones de hardware INT0 e INT1, sin embargo los
microcontroladores AVR pueden tener una interrupción ante un cambio en cualquier pin, es lo
que denomina pin change interrupt. http://playground.arduino.cc/Code/Interrupts. Estas
interrupciones no son soportadas directamente por Arduino y necesitan ser accedidas a través
de una librería adicional.

Las interrupciones de cambio de pin pueden habilitarse en más pines. Para los ATmega
328, pueden habilitarse en cualquiera de los pines de señal disponibles. Estas son disparadas
igual en flancos RISING o FALLING, pero depende del código de la interrupción configurar el
pin que recibe la interrupción y determinar qué ha pasado. Las interrupciones de cambio de
pin están agrupadas en 3 puertos de la MCU, por lo tanto hay 3 vectores de interrupciones
para todo el conjunto de pines. Esto hace el trabajo de resolver la acción en una interrupción
más complicada.
Si necesita más pines para interrupciones, hay un mecanismo para generar una interrupción
cuando se cambia cualquier pin en uno de los puertos de 8 bits. No sabes pin, sino sólo en
qué puerto. Si se genera una interrupción cuando se cambia uno de los pines ADC0 a ADC5
(utilizado como entrada digital). En ese caso, se llama a la rutina de servicio de interrupción
ISR (PCINT1_vect). En la rutina se puede averiguar cuál de los pines específicos dentro de
ese puerto ha sido el que ha cambiado.

En primer lugar, los indicadores de habilitación de interrupción de cambio de pin deben

ajustarse en el registro PCICR. Estos son los bits PCIE0, PCIE1 y PCIE2 para los grupos de
pines PCINT7..0, PCINT14..8 y PCINT23..16 respectivamente. Los pines individuales se
pueden activar o deshabilitar en los registros PCMSK0, PCMSK1 y PCMSK2. En el circuito
Arduino, en combinación con la hoja de datos Atmel Atmega328, se puede ver que el pin
PCINT0 corresponde al pin 0 en el puerto B (llamado PB0). Este es el pin 8 en el Arduino Uno.
Otro ejemplo es el pin A0 de la tarjeta Arduino, que puede utilizarse como una entrada digital:

 Pin Change Interrupt Request 0 (pins D8 to D13) (PCINT0_vect)

 Pin Change Interrupt Request 1 (pins A0 to A5) (PCINT1_vect)
 Pin Change Interrupt Request 2 (pins D0 to D7) (PCINT2_vect)

“The Pin Change Interrupt Request 2 (PCI2) will trigger if any enabled PCINT[23:16] pin
toggles. The Pin Change Interrupt Request 1 (PCI1) will trigger if any enabled PCINT[14:8] pin
toggles. The Pin Change Interrupt Request 0 (PCI0) will trigger if any enabled PCINT[7:0] pin
toggles.”

PCINT son unos pines determinados que se puede ver en la página 19 a que corresponden
de http://www.atmel.com/Images/Atmel-42735-8-bit-AVR-Microcontroller-ATmega328-
328P_datasheet.pdf
Los pines de interrupción deben estar configurados como INPUT, las resistencias pullup
pueden habilitarse para poder detectar interruptores simples.

Es cierto que solo se puede configurar una rutina de interrupción para cada grupo de pines en
un puerto, pero hay muchos casos donde es suficiente.

Más información:

 https://thewanderingengineer.com/2014/08/11/arduino-pin-change-interrupts/
 http://www.geertlangereis.nl/Electronics/Pin_Change_Interrupts/PinChange_en.html
 http://playground.arduino.cc/Main/PinChangeInterrupt
 http://www.ermicro.com/blog/?p=2292
 http://gammon.com.au/interrupts
 http://playground.arduino.cc//Main/PinChangeIntExample
 http://www.avr-tutorials.com/interrupts/about-avr-8-bit-microcontrollers-interrupts

También disponemos de la PinChangeInt Library. PinChangeInt implementa interrupciones de

cambio de pin para el entorno Arduino. Esta biblioteca fue diseñada para el Arduino Uno /
Duemilanove, y funciona bien en el Nano. El soporte MEGA está incluido pero no de una
forma completa.

 http://playground.arduino.cc/Main/PinChangeInt
 https://github.com/GreyGnome/PinChangeInty
 nueva versión EnableInterrupt https://github.com/GreyGnome/EnableInterrupt
 wiki https://github.com/GreyGnome/EnableInterrupt/wiki

Registros para las interrupciones externas y pin change son:

 External Interrupt Control Register A: The External Interrupt Control Register A

contains control bits for interrupt sense control.
Name: EICRA
 External Interrupt Mask Register: When addressing I/O Registers as data space using
LD and ST instructions, the provided offset must be used. When using the I/O specific
commands IN and OUT, the offset is reduced by 0x20, resulting in an I/O address
offset within 0x00 – 0x3F.
Name: EIMSK
 External Interrupt Flag Register: When addressing I/O Registers as data space using
LD and ST instructions, the provided offset must be used. When using the I/O specific
commands IN and OUT, the offset is reduced by 0x20, resulting in an I/O address
offset within 0x00 – 0x3F.
Name: EIFR
 Pin Change Interrupt Control Register
Name: PCICR
 Pin Change Interrupt Flag Register: When addressing I/O Registers as data space
using LD and ST instructions, the provided offset must be used. When using the I/O
specific commands IN and OUT, the offset is reduced by 0x20, resulting in an I/O
address offset within 0x00 – 0x3F.
Name: PCIFR
 Pin Change Mask Register 2
Name: PCMSK2
 Pin Change Mask Register 1
Name: PCMSK1
 Pin Change Mask Register 0
Name: PCMSK0

Cada interrupción está asociada con dos bits, un bit de indicador de interrupción (flag) y un bit
habilitado de interrupción (enabled). Estos bits se encuentran en los registros de E/S
asociados con la interrupción específica:

 El bit de indicador de interrupción se establece siempre que se produce el evento de

interrupción, independientemente de que la interrupción esté o no habilitada.
Registro EIFR
 El bit activado por interrupción se utiliza para activar o desactivar una interrupción
específica. Básicamente se le dice al microcontrolador si debe o no responder a la
interrupción si se dispara. Registro EIMSK

En resumen, básicamente, tanto la Interrupt Flag como la Interrupt Enabled son necesarias
para que se genere una solicitud de interrupción como se muestra en la figura siguiente.
Aparte de los bits habilitados para las interrupciones específicas, el bit de enable de
interrupción global DEBE ser habilitado para que las interrupciones se activen en el
microcontrolador.

Para el microcontrolador AVR de 8 bits, este bit se encuentra en el registro de estado de E/S
(SREG). La interrupción global habilitada es bit 7, en el SREG.

Interrupciones Internas en Arduino

Las interrupciones internas en Arduino son aquellas interrupciones relacionadas con los timers
y que también son denominadas interrupciones de eventos programados.

Arduino tiene tres timers. Son el timer cero, timer uno, timer dos.Timer cero y dos son de 8 bits
y el temporizador uno es de 16 bits.

Crearemos una interrupción interna utilizando la interrupción de un temporizador. Para ello

necesitaremos una librería adecuada para el temporizador que usemos. Podemos crear tres
tipos de interrupción interna, son interrupción de desbordamiento de temporizador (timer
overflow), interrupción de comparación de salida (Output Compare Match Interrupt),
interrupción de captura de entrada (Timer Input Capture Interrupt).

Ya vimos que las interrupciones de los timers se usan para PWM y también con la librería
MSTimer2: http://www.pjrc.com/teensy/td_libs_MsTimer2.html

En el apartado de timers trataremos más a fondo los temporizadores de Arduino y sus

interrupciones asociadas.
Problemas y soluciones con las interrupciones en
Arduino: http://rcarduino.blogspot.com.es/2013/04/the-problem-and-solutions-with-arduino.html

ISR (Interrupt Service Routines)

La función de callback asociada a una interrupción se denomina ISR (Interruption Service

Rutine). ISR es una función especial que tiene algunas limitaciones, una ISR no puede tener
ningún parámetro en la llamada y no pueden devolver ninguna función.

Dos ISR no pueden ejecutarse de forma simultánea. En caso de dispararse otra interrupción
mientras se ejecuta una ISR, la función ISR se ejecuta una a continuación de otra.

Una ISR debe ser tan corta y rápida como sea posible, puesto que durante su ejecución se
paraliza el curso normal del programa y las interrupciones se deshabilitan.

Se se usan varias ISR en el sketch, solo una se puede ejecutar y otras interrupciones serán
ejecutadas después de que la ISR actual finalice, en un orden que depende las prioridad de
las interrupciones y que depender de interrupt handler.

La función millis() no funciona dentro del ISR puesto que usa interrupciones para su uso. La
función micros() funciona dentro de ISR pero después de 1-2 ms se empieza a comportar de
forma extraña. delayMicroseconds() no usa ningún contador y funcionará correctamente
dentro del ISR. Por lo tanto si la ISR dura mucho tiempo provocará retrasos en el reloj interno,
puesto que millis() no avanza mientras se ejecuta el ISR.

Para pasar datos entre el programa principal y el ISR se usan las variables globales, pero para
que estas variables se actualicen correctamente deben declararse con el modificador
“volatile”: https://www.arduino.cc/en/Reference/Volatile

Volatile es una palabra reservada que se pone delante de la definición de una variable para
modificar la forma en que el compilador y el programa trata esa variable.
Declarar una variable volátil es una directiva para el compilador. Específicamente, dice al
compilador que cargue la variable desde la RAM y no desde un registro de almacenamiento,
que es una ubicación de memoria temporal donde se almacenan y manipulan las variables del
programa. Bajo ciertas condiciones, el valor de una variable almacenada en registros puede
ser inexacto.

Una variable debe ser declarada volátil siempre que su valor pueda ser cambiado por algo
más allá del control de la sección de código en la que aparece, como un subproceso que se
ejecuta simultáneamente. En Arduino, el único lugar en el que es probable que ocurra es en
secciones de código asociadas con interrupciones, las llamadas rutinas de servicio de
interrupción (ISR).

Para poder modificar una variable externa a la ISR dentro de la misma debemos declararla
como “volatile”. El indicador “volatile” indica al compilador que la variable tiene que ser
consultada siempre antes de ser usada, dado que puede haber sido modificada de forma
ajena al flujo normal del programa (lo que, precisamente, hace una interrupción). Al indicar
una variable como Volatile el compilador desactiva ciertas optimizaciones, lo que supone una
pérdida de eficiencia. Por tanto, sólo debemos marcar como volatile las variables que
realmente lo requieran, es decir, las que se usan tanto en el bucle principal como dentro de la
ISR.

Esta es la secuencia cuando se dispara una interrupción:

1. El microcontrolador completa la instrucción que está siendo ejecutada.

2. El programa de Arduino que se está ejecutando, transfiere el control a la Interrupt
Service Routine (ISR). Cada interrupción tiene asociada una ISR que es una función
que le dice al microcontrolador que hacer cuando ocurre una interrupción.
3. Se ejecuta la ISR mediante la carga de la dirección de comienzo de la ISR en el
contador del programa.
4. La ejecución del ISR continua hasta que se encuentra el RETI (return from the
interrupt instruction). Más
información: http://www.atmel.com/webdoc/avrassembler/avrassembler.wb_RETI.html
5. Cuando ha finalizado ISR, el microcontrolador continua la ejecución del programa
donde lo dejó antes de que ocurriera la interrupción.
Más información en: http://gammon.com.au/interrupts

Hay muchos I/O registros en el microcontrolador asociados a las interrupciones externas.

Estos registros almacenan los flag de las interrupciones, los bits de enable, así como
información de control de cada interrupción externa.

Más información de
interrupciones: http://cs4hs.cs.pub.ro/wiki/roboticsisfun/chapter2/ch2_10_interrupts

Funciones de Interrupciones en Arduino

El core de Arduino ofrece una serie de instrucciones para programar las interrupciones
externas, pero no las de pin change ni las de temporizadores:

 interrupts() – https://www.arduino.cc/en/Reference/Interrupts
Habilita las interrupciones (antes han debido ser inhabilitadas con noInterrupts()). Las
interrupciones permiten a ciertas tareas importantes que se ejecuten en segundo plano
y defecto las interrupciones están habilitadas. Algunas funciones no funcionarán si se
deshabilitan las interrupciones y las comunicaciones entrantes serán ignoradas,
también podrán modificar ligeramente la temporización del código. Las interrupciones
se pueden deshabilitar para casos particulares de secciones críticas del código.
 noInterrupts() – https://www.arduino.cc/en/Reference/NoInterrupts
Deshabilita las interrupciones. Las interrupciones pueden ser habilitadas de nuevo con
interrupts().
 attachInterrupt() – https://www.arduino.cc/en/Reference/AttachInterrupt
Me permite configurar una interrupción externa, pero no otro tipo de interrupciones. El
primer parámetro es el número de interrupción que va asociado a un pin, luego la
función ISR y finalmente el modo.
  detachInterrupt() – https://www.arduino.cc/en/Reference/DetachInterrupt
Deshabilita la interrupción. El parámetro que se le pasa es el número de la
interrupción.
 digitalPinToInterrupt(pin) traduce el pin al número de interrupción específica.
 usingInterrupt() – https://www.arduino.cc/en/Reference/SPIusingInterrupt
Deshabilita la interrupción externa pasada como parámetro en la llamada
a SPI.beginTransaction() y se habilita de nuevo en endTransaction() para prevenir
conflictos en las transacciones del bus SPI

En attachInterrupt() los modos disponibles que definen cuando una interrupción externa es
disparada, se hace mediante 4 constantes:

 LOW, La interrupción se dispara cuando el pin es LOW.

 CHANGE, Se dispara cuando pase de HIGH a LOW o viceversa, es decir un cambio
en el estado del pin.
 RISING, Dispara en el flanco de subida (Cuando pasa de LOW a HIGH).
 FALLING, Dispara en el flanco de bajada (Cuando pasa de HIGH a LOW).
 Y solo para el DUE: HIGH se dispara cuando el pin esta HIGH.

Normalmente, las variables globales se utilizan para pasar datos entre un ISR y el programa
principal. Para asegurarse de que las variables compartidas entre un ISR y el programa
principal se actualizan correctamente, declararlas como volátiles.

La función delay() no deshabilita las interrupciones, por lo tanto los datos recibidos por el serial
Rx son guardados, los valores PWM funcionan y las interrupciones externas funcionan. Sin
embargo la función delayMicroseconds() deshabilita las interrupciones mientras está
ejecutándose.

Más información:

 https://www.arduino.cc/en/Reference/AttachInterrupt
 http://www.engblaze.com/we-interrupt-this-program-to-bring-you-a-tutorial-on-arduino-
interrupts/

Para manejar las interrupciones por cambio de pin disponemos de varias librerías:
Ver http://playground.arduino.cc/Main/LibraryList#Interrupts

Multitarea

Utilizar interrupciones nos permitirá olvidarnos de controlar ciertos pines. Esto muy importante
ya que dentro de una aplicación o programa, no vamos a hacer una única cosa. Por ejemplo,
queremos que un LED se encienda o se apague cuando pulsamos un botón. Esto es
relativamente sencillo pero cuando además queremos que otro LED parpadee, la cosa se
complica.

La probabilidad de capturar el evento cuando se pulsa el botón disminuye con el aumento de

tiempo de parpadeo. En estos casos, y en muchos otros, nos interesa liberar el procesador de
Arduino para que solo cuando se pulse el botón, haga una acción determinada. Así no
tendremos que estar constantemente comprobando el pin X si ha pulsado el botón.
Precisamente este es el sentido de las interrupciones, poder hacer otras cosas mientras no
suceda el evento, pero cuando ese evento externo esté presente, que ejecute rápidamente el
código asociado.

Los controladores de interrupciones: administran la ejecución de tareas por interrupciones, lo

cual permite la multitarea.

Todas las tareas que hemos realizado hasta ahora han sido síncronas. Es decir, solicitamos
unos datos (puerto serie, ethernet, etc…), esperamos la respuesta y los mostramos en
pantalla. La contraposición es un proceso asíncrono, nosotros lanzamos la petición y en
cuanto se pueda se realizará y se mostrará el resultado sin esperar.

Si nos encontramos con respuestas lentas, no es buena técnica esperar de forma “síncrona”
porque seguramente obtengamos un error de que se ha excedido el tiempo de espera
“timeout”. Si estamos descargando datos de gran volumen, tampoco es buena técnica que
dejemos la aplicación “congelada” mientras se descargan los datos. Lo ideal es lanzar la
descarga de fondo, es decir, de forma “asíncrona”.

Un proceso síncrono es aquel que se ejecuta y hasta que no finaliza solo se ejecuta ese
proceso (todo en el mismo loop), mientras que uno asíncrono comienza la ejecución y
continúan ejecutándose otras tareas por lo que el proceso total se completa en varios loops.
Son dos formas de atacar un problema. Este nuevo concepto es muy interesante y abre
muchas posibilidades a nuestros programas que requieren conexiones remotas.

Multitask en Arduino, muy recomendable:

 https://learn.adafruit.com/multi-tasking-the-arduino-part-1
 https://learn.adafruit.com/multi-tasking-the-arduino-part-1/using-millis-for-timing
 http://harteware.blogspot.com.es/2010/11/protothread-powerfull-library.html

Ejercicios Interrupciones Arduino

Hacer un ejercicio simple donde asociemos al pin 2 una interrupción que encienda y apague el
pin 13.

Código:

1
const byte ledPin = 13;
2 const byte interruptPin = 2;
3 volatile byte state = LOW;

5 void setup() {

6 pinMode(ledPin, OUTPUT);

pinMode(interruptPin, INPUT_PULLUP);
7
attachInterrupt(digitalPinToInterrupt(interruptPin), blink, CHANGE);
8
9 }

10

11 void loop() {

digitalWrite(ledPin, state);
12
}
13

14
void blink() {
15
state = !state;
16
}
17

En el siguiente código definimos el pin digital 10 como salida, para emular una onda cuadrada
de periodo 300ms (150ms ON y 150ms OFF). Para visualizar el funcionamiento de la
interrupción, en cada flanco activo del pulso simulado, encendemos/apagamos el LED
integrado en la placa, por lo que el LED parpadea a intervalos de 600ms (300ms ON y 300ms
OFF). No estamos encendiendo el LED con una salida digital, si no que es la interrupción que
salta la que enciende y apaga el LED (el pin digital solo emula una señal externa).

1 const int emuPin = 10;

3 const int LEDPin = 13;

4 const int intPin = 2;

volatile int state = LOW;

5

6
void setup() {
7
pinMode(emuPin, OUTPUT);
8
pinMode(LEDPin, OUTPUT);
9
pinMode(intPin, INPUT_PULLUP);
10
attachInterrupt(digitalPinToInterrupt(intPin), blink, RISING);
11 }
12

13 void loop() {

14 //esta parte es para emular la salida

15 digitalWrite(emuPin, HIGH);
16 delay(150);

17 digitalWrite(emuPin, LOW);

delay(150);
18
}
19

20
void blink() {
21
state = !state;
22
digitalWrite(LEDPin, state);
23 }
24

25

El siguiente código empleamos el mismo pin digital para emular una onda cuadrada, esta vez
de intervalo 2s (1s ON y 1s OFF). En cada interrupción actualizamos el valor de un contador.
Posteriormente, en el bucle principal, comprobamos el valor del contador, y si ha sido
modificado mostramos el nuevo valor. Al ejecutar el código, veremos que en el monitor serie
se imprimen números consecutivos a intervalos de dos segundos.

const int emuPin = 10;

1

2
const int intPin = 2;
3
volatile int ISRCounter = 0;
4 int counter = 0;
5

7 void setup()

8 {

9 pinMode(emuPin, OUTPUT);

10
pinMode(intPin, INPUT_PULLUP);
11
Serial.begin(9600);
12
attachInterrupt(digitalPinToInterrupt(intPin), interruptCount, LOW);
13
}
14
15 void loop()

16 {

//esta parte es para emular la salida

17
digitalWrite(emuPin, HIGH);
18
delay(1000);
19
digitalWrite(emuPin, LOW);
20
delay(1000);
21

22

23 if (counter != ISRCounter)
24 {

25 counter = ISRCounter;

26 Serial.println(counter);

27 }

}
28

29
void interruptCount()
30
{
31
ISRCounter++;
32
timeCounter = millis();
33 }
34

35

36

37
Anuncios
REPORT THIS AD

REPORT THIS AD

Compártelo:

 Twitter
 Facebook5
 Google

Relacionado
Arduino.cc y Arduino.org. Los dos ArduinosEn "Arduino"
Alimentación ArduinoEn "Arduino"
Novedades en Arduino. Arduino.cc y Arduino.orgEn "Arduino"
Esta entrada se publicó en Arduino, Interrupciones y está etiquetada
con Arduino, Interrupciones, ISR, Multitarea, timer en 13 noviembre, 2016.

Arduino Watchdog
6 respuestas

En electrónica, un perro guardián (en inglés watchdog) es un mecanismo de seguridad que

provoca un reset del sistema en caso de que éste se haya bloqueado.

Consiste en un temporizador que irá continuamente decrementando un contador, inicialmente

con un valor relativamente alto. Cuando este contador llegue a cero, se reiniciará el sistema,
así que se debe diseñar una subrutina en el programa de manera que refresque o reinicie al
perro guardián antes de que provoque el reset. Si el programa falla o se bloquea, al no
actualizar el contador del perro guardián a su valor de inicio, éste llegará a decrementarse
hasta cero y se reiniciará el sistema mediante una interrupción.

El watchdog es un timer que va dentro de la arquitectura del microcontrolador y es

independiente del resto de timers. Ver diagrama de bloques:
La interrupción del watchdog como vimos anteriormente es la más prioritaria en la tabla de los
vectores de interrupción.
El Watchdog Timer en el microprocesador del Arduino solo tiene una fuente de reloj que es su
propio oscilador interno de 128kHz (a diferencia de los temporizadores internos de 8/16bit, que
pueden usar el reloj del sistema de 16Mhz o un reloj externo). Es este oscilador separado
permite que el WDT funcione en el modo de potencia más baja: SLEEP_MODE_PWR_DOWN
.

Toda la información del wathcdog en el ATmega328p está en la página 75

de http://www.atmel.com/Images/Atmel-42735-8-bit-AVR-Microcontroller-ATmega328-
328P_datasheet.pdf

Los registros que maneja el watchdog son:

 MCU Status Register – To make use of the Reset Flags to identify a reset condition,
the user should read and then Reset the MCUSR as early as possible in the program.
If the register is cleared before another reset occurs, the source of the reset can be
found by examining the Reset Flags.
Name: MCUSR
  WDTCSR – Watchdog Timer Control Register
Name: WDTCSR

Configuración del watchdog timer:

(1) WDTON es un fuse que habilita o deshabilita el watchdog.

Los tres modos de funcionamiento son:

 Interrupt Mode – La rutina del vector de interrupción WDT_vect se llamará cuando el

WDT expire. Puede utilizarse para despertar al microcontrolador desde los modos de
sleep, incluido el modo de suspensión de menor potencia
(SLEEP_MODE_PWR_DOWN), en el que no están disponibles otros temporizadores.
 System reset Mode: cuando se produce un timeout del tiempo de espera del
watchdog, se reiniciará el microcontrolador. Para usar en el manejo de bloqueos o
culegues del código.
 Interrupt and System Reset Mode – Primero se llamará a la ISR de la interrupción
WDT_vect, cuando se complete se va al System Reset Mode.

La selección del prescale se hace mediante estos bits y son los únicos tiempos permitidos al
watchdog:
Para gestionar el watchdog con Arduino debe utilizarse la librería de wdt.h y sólo tres
funciones:

 wdt_disable() para desactivar el watchdog, necesario llamarlo antes de configurar un

nuevo watchdog
 wdt_enable(tiempo) que configura y activa el watchdog al tiempo que se indica como
parámetro (tiempo)
 wdt_reset() que renueva el intervalo que cuenta el perro guardián.

La documentación de la librería <avr/wdt.h>: Watchdog timer handling

 http://www.nongnu.org/avr-libc/user-manual/group__avr__watchdog.html
 http://www.atmel.com/webdoc/AVRLibcReferenceManual/group__avr__watchdog.html
 Macro
wdt_enable: http://www.atmel.com/webdoc/AVRLibcReferenceManual/group__avr__w
atchdog_1gaf6cfea2a1b61e2530ea0c4ef8fc572b3.html
 Macro
wdt_disable: http://www.atmel.com/webdoc/AVRLibcReferenceManual/group__avr__w
atchdog_1gab3784e1b871d61ed338da5658184b725.html

La librería wdt.h se encuentra en la ruta: C:\Program Files

(x86)\Arduino\hardware\tools\avr\avr\include\avr
También disponemos de una librería para manejar el
wdt: https://github.com/WickedDevice/SoftReset

NOTA: los bootloader antiguos de Arduino no tienen soporte para watchdog y en ese caso hay
que actualizar el bootloader o poner el optiboot: https://github.com/Optiboot/optiboot. Optiboot
está instalado por defecto en el Arduino y puede usarse para actualizar los Arduino antiguos.

Más información:

 https://en.wikipedia.org/wiki/Watchdog_timer
 http://black-electronics.com/blog/how-to-use-watchdog-timer-with-arduino/
 http://donalmorrissey.blogspot.com.es/2010/04/sleeping-arduino-part-5-wake-up-
via.html
 https://ariverpad.wordpress.com/2012/02/26/resetting-the-arduino-through-software-
for-fun-and-profit/
 http://www.megunolink.com/articles/how-to-detect-lockups-using-the-arduino-
watchdog/
 Interesante artículo de watchdog en Arduino y Raspberry
PI: http://www.instructables.com/id/Raspberry-Pi-and-Arduino-Building-Reliable-
Systems/?ALLSTEPS
 Interesante artículo de watchdog en Arduino y Raspberry
PI: http://www.instructables.com/id/Raspberry-Pi-and-Arduino-Building-Reliable-
Systems/?ALLSTEPS

Resetear Arduino

Al pulsar el botón de reinicio, se resetea el AVR. Además, el IDE de Arduino envía una señal
especial que hace que la tarjeta Arduino se resete.

Cómo deshabilitar el autoreset on serial

connnection: http://playground.arduino.cc/Main/DisablingAutoResetOnSerialConnection

Después de encender o reiniciar el AVR, inmediatamente comienza a ejecutar el bootloader.

El bootloader de Arduino observa durante unos segundos para ver si se está descargando un
nuevo sketch desde el IDE de Arduino. Si es así, borra todo lo que estaba en flash y quema en
el nuevo sketch. A continuación, el gestor de arranque comienza a ejecutar cualquier sketch
que se encuentre en el flash.

Si queremos saber cuántas veces se ha reiniciado un Arduino, podemos guardarlo en la

EEPROM, e incluso saber la razón del reinicio mirando el registro MCUSR.

Otras formas de resetear Arduino:

 WDT, es la forma más fiable de resetear el AVR el mismo

 Conectar un cable al pin de reset desde alguna fuente externa o desde un pin del
mismo Arduino con una resistenca de 1K.
 Ejecutar la dirección 0 (jmp 000) que vuelve a la dirección 0 pero no resetea
completamente Arduino y no todas las configuraciones por defecto son restauradas,
como por ejemplo el estado de los pines.

Código:
void software_Reset()
// Restarts program from beginning but
// does not reset the peripherals and registers
{
asm volatile (” jmp 0″);
}

void(* resetFunc) (void) = 0; //declare reset function at address 0

Para más información sobre System Reset ver página 72

de http://www.atmel.com/Images/Atmel-42735-8-bit-AVR-Microcontroller-ATmega328-
328P_datasheet.pdf

Más información:

 http://playground.arduino.cc/Main/ArduinoReset
 http://www.xappsoftware.com/wordpress/2013/06/24/three-ways-to-reset-an-arduino-
board-by-code/
 http://www.instructables.com/id/two-ways-to-reset-arduino-in-software/?ALLSTEPS

Ejercicio Watchdog Arduino

Comprobar el funcionamiento del watchdog con este ejercicio.

Ejercicio52: https://github.com/jecrespo/Aprendiendo-Arduino/tree/master/Ejercicio53-
Watchdog
Anuncios
REPORT THIS AD

REPORT THIS AD

Compártelo:

 Twitter
 Facebook7
 Google

Relacionado
InterrupcionesEn "Arduino"
ICSPEn "Arduino"
Uso de Librerías ArduinoEn "Arduino"
Esta entrada se publicó en Arduino, Watchdog y está etiquetada con Hardware, software
reset, timer, Watchdog en 13 noviembre, 2016.

Bus SPI
6 respuestas

Ya hemos visto la comunicación serie asíncrona el la comunicación serie con la UART, donde
para sincronizar se debe usar la misma frecuencia de reloj en ambos extremos y se añade un
par de bits extra a la comunicación en forma de un bit de Start y otro de Stop. (Para enviar 8
bits de datos tenemos que enviar 10 bits).

El SPI es un protocolo de comunicación síncrona de 4 hilos, entre dispositivos electrónicos

presentado por Motorola, ahora Freescale, http://www.freescale.com/ en 1982, que ha ganado
bastante aceptación en la industria como sistema de comunicación de muy corta distancia,
normalmente dentro la placa de circuito impreso. Es un protocolo de transmisión que permite
alcanzar velocidades muy altas y que se diseñó pensando en comunicar un microcontrolador
con distintos periféricos y que funciona a full dúplex.

SPI utiliza una solución síncrona, porque utiliza unas líneas diferentes para los datos y el
Clock. El Clock es una señal que indica al que escucha exactamente cuándo leer las líneas de
datos, con lo que el problema de pérdida de sincronía se elimina de raíz.

Uno de los motivos por los que SPI es tan popular es que el hardware de recepción puede ser
un sencillo Shift register, lo que es una solución mucho más simple y barata que una UART
(Universal Asíncronous Receiver Transmitter o sistema universal asíncrono de recepción y
transmisión serie) de comunicación serie.

El Bus SPI (del inglés Serial Peripheral Interface) es un estándar de comunicaciones, usado
principalmente para la transferencia de información entre circuitos integrados en equipos
electrónicos. El bus de interfaz de periféricos serie o bus SPI es un estándar para controlar
casi cualquier dispositivo electrónico digital que acepte un flujo de bits serie regulado por un
reloj (comunicación sincrónica).
El bus SPI incluye una línea de reloj, dato entrante, dato saliente y un pin de chip select, que
conecta o desconecta la operación del dispositivo con el que uno desea comunicarse. De esta
forma, este estándar permite multiplexar las líneas de reloj.

Muchos sistemas digitales tienen periféricos que necesitan existir pero no ser rápidos. La
ventajas de un bus serie es que minimiza el número de conductores, pines y el tamaño del
circuito integrado. Esto reduce el coste de fabricar montar y probar la electrónica. Un bus de
periféricos serie es la opción más flexible cuando se tiene tipos diferentes de periféricos serie.
El hardware consiste en señales de reloj, data in, data out y chip select para cada circuito
integrado que tiene que ser controlado. Casi cualquier dispositivo digital puede ser controlado
con esta combinación de señales. Los dispositivos se diferencian en un número predecible de
formas. Unos leen el dato cuando el reloj sube otros cuando el reloj baja. Algunos lo leen en el
flanco de subida del reloj y otros en el flanco de bajada. Escribir es casi siempre en la
dirección opuesta de la dirección de movimiento del reloj.

Más información en:

 http://es.wikipedia.org/wiki/Serial_Peripheral_Interface
 http://en.wikipedia.org/wiki/Serial_Peripheral_Interface_Bus

El bus SPI se define mediante 4 pines:

 SCLK o SCK : Señal de reloj del bus. Esta señal rige la velocidad a la que se
transmite cada bit.
 MISO(Master Input Slave Output): Es la señal de entrada a nuestro dispositivo, por
aquí se reciben los datos desde el otro integrado.
 MOSI(Master Output Slave Input): Transmisión de datos hacia el otro integrado.
 SS o CS: Chip Select o Slave Select, habilita el integrado hacia el que se envían los
datos. Esta señal es opcional y en algunos casos no se usa.

El funcionamiento para un envío de un Master es el siguiente:

 Se habilita el chip al que hay que enviar la información mediante el CS (Opcional).

 Se carga en el buffer de salida el byte a enviar.
 La línea de Clock empieza a generar la señal cuadrada donde normalmente por cada
flanco de bajada se pone un bit en MOSI.
  El receptor normalmente en cada flanco de subida captura el bit de la linea MISO y lo
incorpora en el buffer.

Se repite el proceso 8 veces y se ha transmitido un byte. Si se ha terminado de transmitir se

vuelve a poner la linea CS en reposo. Hay que tener en cuenta que a la vez que el Master está
enviando un dato también lo recibe así que si el Slave ha depositado algún byte en el buffer de
salida, este también será enviado y recibido por el Master, comunicación full-duplex.

La señal de reloj es generada por el master y la línea SS normalmente se mantiene HIGH y se

activa con LOW, lo que despierta al esclavo seleccionado. Cuando se termina la transferencia
la línea se levanta a HIGH y el esclavo se desactiva.
A diferencia de otros buses el SPI no implementa el nivel del enlace entre dispositivos, es
decir no hay un campo para la dirección ni un campo para ACK, etc. El SPI se comporta como
un shift register donde a cada golpe de clock se captura un bit. En parte no es necesaria hacer
un direccionamiento de los chips ya que mediante la señal Chip select, habilitamos al
integrado al que queremos enviar los datos.

Ventajas de SPI sobre I2C.

 I2C No es Full-Duplex por lo que no permite envíos y recepciones al mismo tiempo.

 I2C un poco más complejo que SPI.
 I2C no tiene control de errores, por ejemplo mediante paridad etc. Aunque se puede
realizar por Software.
 Velocidades de comunicación relativamente elevadas. En el caso de Arduino de hasta
8 Mhz.
 Completo control sobre la trama de bits al no exigir direccionamiento ni ACK.
 Se requiere un hardware sencillo (Barato)
 Requiere un menor consumo y menor electrónica de conexión que el I2C
 Como el Clock lo proporciona el master, los esclavos no necesitan osciladores (más
barato)

Desventajas de SPI:

 No hay control del flujo por hardware.

 Las comunicaciones tiene que estar perfectamente establecidas de antemano. No
puedes enviar mensajes de diferentes longitudes cuando convenga.
  No hay confirmación de la recepción como ocurre en I2C con el ACK. Es decir no
sabemos si el mensaje a llegado al destino.
 Usa más pines que otros buses, ya que necesita uno por cada esclavo. Eso implica
que no hay direccionamiento en la propia trama. A menos que se diseñe por software.
 Funcionamiento a distancias cortas
 Master único y casi sin posibilidad de master múltiple

Tanto el bus SPI como el I2C son llamados buses de tarjeta, es decir están pensados para
trabajar a distancias pequeñas del entorno de una tarjeta, en caso de necesitar un bus serie a
larga distancia hay que ir a buses de campo como RS485, CAN, etc…

El canal SPI fue diseñado para aplicaciones de transmisión de datos a velocidades altas (10
Mbps) y distancias cortas, del orden de 10 a 20 cms, ó bien dentro de un mismo PCB (circuito
impreso), entre 2 circuitos integrados como podrían ser un microcontrolador y otro dispositivo,
por ejemplo, un circuito integrado con la función RFID. Las señales de transmisión de datos y
control del canal SPI, usan niveles de voltaje TTL ó bien 3.3 volts, dependiendo de la
tecnología de fabricación del dispositivo.

Más información en:

 http://www.electroensaimada.com/spi.html
 http://www.prometec.net/bus-spi/
 https://learn.sparkfun.com/tutorials/serial-peripheral-interface-spi

La mayoría de los microcontroladores modernos tienen soporte HW para SPI, así como las
placas BeagleBoard y Raspberry Pi.

El estándar SPI es un estándar de facto, es decir, no ha sido consensuado ni legitimado por

un organismo de estandarización al efecto. Por el contrario, se trata de una norma
generalmente aceptada y ampliamente utilizada por iniciativa propia de un gran número de
interesados. Por lo tanto cada fabricante puede implementar de forma diferente el SPI y
debemos prestar atención al datasheet del dispositivo.

Estandar SPI: http://www.st.com/st-web-

ui/static/active/en/resource/technical/document/technical_note/DM00054618.pdf

SPI block Guide: http://www.nxp.com/files/microcontrollers/doc/ref_manual/S12SPIV4.pdf

Cuando el número de esclavos crece suele ser más frecuente conectarlos en cascada, con el
MISO de uno (Salida), conectado al MOSI (Entrada) del siguiente. En este caso solo usamos
una única línea SS, que se comparte entre todos los esclavos.

Esta configuración es típica de una situación en la que le master envía datos pero no recibe
nada de vuelta, como en el caso de una cadena de múltiples display LEDs (Matrices de 8×8),
en los que se envía información para ser mostrada pero, no hay datos de vuelta. En este caso
incluso podemos desconectar la línea MISO.

Una vez que todos los datos son enviados la línea SS es activada y todos los chips son
activados simultáneamente.
SPI en daisy-chaining: http://www.maximintegrated.com/en/app-notes/index.mvp/id/3947

SPI en Arduino

Arduino soporta de serie el bus SPI, con una librería estándar se llama SPI que está incluida
en el IDE de Arduino y que gestiona todas las complicaciones y el arbitraje del protocolo.

Para usar el bus SPI en Arduino, se usa la librería: http://arduino.cc/en/Reference/SPI

En un primer paso importamos la librería del SPI con #include <SPI.h>. En el setup hay que
iniciar y configurar el SPI con SPI.begin() y además hay que definir el pin SS como salida.

Finalmente mediante la función SPI.transfer enviamos el byte que queremos.

Métodos SPI:

 begin() — Inicializa el bus SPI

 end() — Deshabilita el bus SPI.
 setBitOrder() — Configura el orden de los bits enviados como el menos significativo
primero o el más significativo primero.
 setClockDivider() — Configura del divisor de reloj en el bus SPI. ES decir configura la
velocidad del bus.
 setDataMode() — Configura el modo de dato del bus SPI, es decir, polaridad y fase del
reloj.
 transfer() — Transfiere un byte sobre el bus SPI, tanto de envío como de recepción.
 SPI settings: https://www.arduino.cc/en/Reference/SPISettings
Para controlar el bus SPI es necesario usar esos unos pines inexcusablemente, aunque
podemos elegir entre dos juegos de ellos, entre ciertos pines digitales, según el modelo y la
tabla que especificamos abajo, y usando los equivalentes en el bus ICSP. La siguiente tabla
muestra que pines corresponden a los líneas SPI en cada Arduino:

Arduino / Genuino Board MOSI MISO SCK SS (slave) SS (master) Level

Uno or Duemilanove 11 or ICSP-4 12 or ICSP-1 13 or ICSP-3 10 – 5V

Mega1280 or Mega2560 51 or ICSP-4 50 or ICSP-1 52 or ICSP-3 53 – 5V

Leonardo ICSP-4 ICSP-1 ICSP-3 – – 5V

Due ICSP-4 ICSP-1 ICSP-3 – 4, 10, 52 3,3V

Zero ICSP-4 ICSP-1 ICSP-3 – – 3,3V

101 11 or ICSP-4 12 or ICSP-1 13 or ICSP-3 10 10 3,3V

MKR1000 8 10 9 – – 3,3V

Los pines ICSP son los pines del conector ICSP de Arduino que tienen la siguiente
disposición:

Todas las placas con microcontroladores AVR tienen un pin SS que se usa cuando actúa
como esclavo. Dado que esta librería solo soporta el estado maestro, este pin debe
ponerse siempre como output, sino el interfaz SPI podría ponerse como esclavo. Sin embargo,
es posible usar el pin SS para dispositivos, por ejemplo el pin 4 y 10 son usados para controlar
las conexiones de la Ethernet Shield.

En el Arduino Due, el interfaz SPI funciona diferente al resto de Arduinos. Este tiene 3 pines
para dispositivos SS. Uso extendido de la librería SPI en
Due: http://arduino.cc/en/Reference/DueExtendedSPI

Para microcontroladores “Microchip PIC” y “ARM-based” podemos tener varios modos de

funcionamiento:

Clock Polarity Clock Edge

SPI Mode

(CPOL/CKP) (CKE/NCPHA)

0 0 1

1 0 0

2 1 0

3 1 1

Uso del bus SPI: https://www.pjrc.com/teensy/td_libs_SPI.html

Un magnífico ejemplo de como usar el bus SPI en los microcontroladores AVR y uso con
registros de desplazamiento: http://www.ermicro.com/blog/?p=1050

Más información:

 https://www.arduino.cc/en/Reference/SPI

Registros Arduino para SPI

Internamente el microcontrolador ATmega328p tiene un bus SPI que puede trabajar como
master o slave. Para manejar internamente este bus, se hace uso de una serie de registros.

En la página 215 de http://www.atmel.com/Images/Atmel-42735-8-bit-AVR-Microcontroller-

ATmega328-328P_datasheet.pdf puede verse el funcionamiento del bus SPI en el
microcontrolador.

Características del bus SPI en Arduino:

 Full-duplex, Three-wire Synchronous Data Transfer

 Master or Slave Operation
 LSB First or MSB First Data Transfer
 Seven Programmable Bit Rates
 End of Transmission Interrupt Flag
 Write Collision Flag Protection
 Wake-up from Idle Mode
 Double Speed (CK/2) Master SPI Mode

Diagrama de bloques:
Los microcontroladores AVR tienen los siguientes tres registros para manejar SPI:

 SPCR – SPI Control Register – This register is basically the master register i.e. it
contains the bits to initialize SPI and control it.

 SPSR – SPI Status Register – This is the status register. This register is used to read
the status of the bus lines.
  SPDR – SPI Data Register – The SPI Data Register is the read/write register where the
actual data transfer takes place.

Los 4 modos disponibles de funcionamiento de SPI son:

Velocidad del bus SPI:

De una forma más detallada, el funcionamiento es de la siguiente forma: el SPI Master
(servidor) inicializa el ciclo de comunicación cuando se coloca en bajo el Selector de Esclavo
(SS-Selector Slave)(cliente). Master y Slave(servidor y cliente) preparan los datos a ser
enviados en sus respectivos registros de desplazamiento y el Master genera el pulso del reloj
en el pin SCK para el intercambio de datos. Los datos son siempre intercambiados desde el
Maestro al Esclavo en MasterOut-SlaveIn, MOSI, y desde Esclavo al Maestro en MasterIn-
SlaveOut, MISO. Después de cada paquete de datos el Maestro debe sincronizar el esclavo
llevando a ‘alto’ el selector de Esclavo, SS.

Cuando se configure como Maestro, la interfaz SPI no tendrá un control automático de la línea
SS. Este debe ser manejado por software antes de que la comunicación pueda empezar,
cuando esto es realizado, escribiendo un byte en el registro de la SPI comienza el reloj de la
SPI, y el hardware cambia los 8 bits dentro del Esclavo. Después de cambiar un Byte, el reloj
del SPI para, habilitando el fin de la transmisión (SPIF). Si la interrupción del SPI está
habilitado (SPIE) en el registro SPCR, una interrupción es requerida. El Master podría
continuar al cambio del siguiente byte escribiendo dentro del SPDR, o señalizar el fin del
paquete colocando en alto el Esclavo seleccionado, línea SS. El último byte llegado se
mantendrá en el registro Buffer para luego usarse.

Cuando lo configuramos como un Esclavo, la interfaz SPI permanecerá durmiendo con MISO
en tres-estados siempre y cuando el pin SS esté deshabilitado. En este estado, por el software
se podría actualizar el contenido del registro SPDR, pero los datos no serán desplazados por
la llegada del pulso de reloj en el pin SCK hasta que el pin SS no sea habilitado( ‘0’ ). Será
visto como un byte completamente desplazado en el fin de la transmisión cuando SPIF se
habilite. Si la interrupción SPI, SPIE en SPCR, está habilitada, una interrupción es solicitada.
El Esclavo podría continuar para colocar nuevos datos para ser enviados dentro del SPDR
antes de seguir leyendo la data que va llegando. El último byte que entra permanecerá en el
buffer para luego usarse.

Más información:

 http://avrhelp.mcselec.com/index.html?using_the_spi_protocol.htm
 http://www.ermicro.com/blog/?p=1050
 http://maxembedded.com/2013/11/the-spi-of-the-avr/

Dispositivos SPI

Los dispositivos SPI se comunican entre sí utilizando un bus de 4 señales (MOSI, MISO, SCK,
SS) y un esquema maestro/esclavo, en el cual el maestro inicia el protocolo de trasmisión de
los datos. En ocasiones, las interfaces SPI son circuitos que están ya disponibles como parte
del hardware en los microcontroladores como por ejemplo el 18F2550 (Microchip) ó Atmega8
(Atmel-AVR) ó bien en dispositivos como módulos lectores RFID, tarjetas de memoria,
convertidores A/D, etc.

Diferentes tipos de periféricos con SPI: http://www.mct.net/faq/spi.html

Aplicaciones SPI : http://en.wikipedia.org/wiki/Serial_Peripheral_Interface_Bus#Applications

Varios dispositivos con interfaz SPI: https://www.sparkfun.com/search/results?term=spi

Veamos varios ejemplo de dispositivos SPI:

 EEPROM: https://www.arduino.cc/en/Tutorial/SPIEEPROM
 RAM: https://www.digikey.com/es/product-highlight/m/microchip-technology/spi-serial-
sram-nvsram-devices
 Ethernet usado en el Ethernet Shiel W5100: http://www.ermicro.com/blog/?p=1773
Adaptadores

También disponemos de adaptadores o bridges de SPI a otros puertos.Por ejemplo de USB a

SPI: http://en.wikipedia.org/wiki/Serial_Peripheral_Interface_Bus#Host_adapters

Conversor de USB a SPI: http://www.maximintegrated.com/en/products/interface/controllers-

expanders/MAX3421E.html
Otro conversor SPI a USB: https://www.sparkfun.com/products/9235

SPI to serial (UART):

 https://www.sparkfun.com/products/retired/9981
 https://www.maximintegrated.com/en/products/interface/controllers-
expanders/MAX3107.html
 http://www.nxp.com/products/interface-and-connectivity/interface-and-system-
management/bridges/i2c-spi-slave-to-uart-irda-gpio-bridges:MC_51852
 http://www.nxp.com/products/interface-and-connectivity/interface-and-system-
management/bridges/spi-slave-to-i2c-master-gpio-bridges:MC_53345

SPI to I2C:

 http://www.nxp.com/products/interface-and-connectivity/interface-and-system-
management/bridges/spi-slave-to-i2c-master-gpio-bridges/spi-to-ic-bus-
interface:SC18IS601IPW

ISP (In Sytem Programming)

Recordar que el conector ICSP se usa para hacer la programación del microcontrolador y que
comparte los pines. In system programming:

 http://es.wikipedia.org/wiki/Programaci%C3%B3n_en_el_sistema
 http://en.wikipedia.org/wiki/In-system_programming
 http://www.atmel.com/Images/doc0943.pdf → Atmel in system programming, explica
como conecto al MCU directamente para programarlo con ISP.
Por ejemplo un ISP: http://www.pololu.com/product/1300. Lleva este
PIC http://ww1.microchip.com/downloads/en/DeviceDoc/41350E.pdf con un firmware para
realizar esta función.
Y podemos programar un microcontrolador por el conector ICSP:
Ejercicios SPI Arduino

Ejemplos de uso de SPI:

 Sensor de presión https://www.arduino.cc/en/Tutorial/BarometricPressureSensor

 Potenciometro digital: https://www.arduino.cc/en/Tutorial/DigitalPotControl

Ejercicio34-SPI: Comunicar dos arduinos por SPI.

Cómo hacerlo:

 http://www.electroensaimada.com/spi.html
 http://www.gammon.com.au/forum/?id=10892

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

REPORT THIS AD

Compártelo:

 Twitter
 Facebook2
 Google

Relacionado
Tema 6 - Comunicaciones con Arduino (4)En "Arduino"
I2CEn "Arduino"
Bus I2C/TWIEn "Arduino"
Esta entrada se publicó en Arduino, Bus SPI y está etiquetada con Arduino, Bus
SPI, MISO, MOSI, Programado ISP en 13 noviembre, 2016.

Bus I2C/TWI
Deja un comentario

Al comenzar a usar Arduino puede resultar algo complejo entender las diferencias entre los
diferentes tipos de interfaces de comunicación (y protocolos asociados).

Dentro la comunicación serie integrada en los microcontroladores de Arduino tenemos:

 UART (recepción-transmisión asíncrona universal) es uno de los protocolos serie más

utilizados. La mayoría de los microcontroladores disponen de hardware UART. Usa
una línea de datos simple para transmitir y otra para recibir datos. Comúnmente, 8 bits
de datos son transmitidos de la siguiente forma: un bit de inicio, a nivel bajo, 8 bits de
datos y un bit de parada a nivel alto. UART se diferencia de SPI y I2C en que es
asíncrono y los otros están sincronizados con señal de reloj. La velocidad de datos
UART está limitado a 2Mbps
  SPI es otro protocolo serie muy simple. Un maestro envía la señal de reloj, y tras cada
pulso de reloj envía un bit al esclavo y recibe un bit de éste. Los nombres de las
señales son por tanto SCK para el reloj, MOSI para el Maestro Out Esclavo In, y MISO
para Maestro In Esclavo Out. Para controlar más de un esclavo es preciso utilizar SS
(selección de esclavo).
 I2C es un protocolo síncrono. I2C usa solo 2 cables, uno para el reloj (SCL) y otro para
el dato (SDA). Esto significa que el maestro y el esclavo envían datos por el mismo
cable, el cual es controlado por el maestro, que crea la señal de reloj. I2C no utiliza
selección de esclavo, sino direccionamiento.

Más información en:

 http://electronics.stackexchange.com/questions/37814/usart-uart-rs232-usb-spi-i2c-ttl-
etc-what-are-all-of-these-and-how-do-th
 http://geekenformacion.blogspot.com.es/2013/01/interfaces-de-comunicacion-spi-i2c-
uart.html

I2C es un bus de comunicaciones en serie. Su nombre viene de Inter-Integrated Circuit (Inter-

Circuitos Integrados). La versión 1.0 data del año 1992 y la versión 2.1 del año 2000, su
diseñador es Philips. La velocidad es de 100 kbit/s en el modo estándar, aunque también
permite velocidades de 3.4 Mbit/s. Es un bus muy usado en la industria, principalmente para
comunicar microcontroladores y sus periféricos en sistemas integrados (Embedded Systems)
y generalizando más para comunicar circuitos integrados entre si que normalmente residen en
un mismo circuito impreso.

La principal característica de I²C es que utiliza dos líneas para transmitir la información: una
para los datos y otra para la señal de reloj. También es necesaria una tercera línea, pero esta
sólo es la referencia (masa). Como suelen comunicarse circuitos en una misma placa que
comparten una misma masa esta tercera línea no suele ser necesaria.

Las líneas se llaman:

 SDA: datos
 SCL: reloj
 GND: tierra

Las dos primeras líneas son drenador abierto, por lo que necesitan resistencias de pull-
up. Dos o más señales a través del mismo cable pueden causar conflicto, y ocurrirían
problemas si un dispositivo envía un 1 lógico al mismo tiempo que otro envía un 0. Por tanto el
bus es “cableado” con dos resistencia para poner el bus a nivel alto, y los dispositivos envían
niveles bajos. Si quieren enviar un nivel alto simplemente lo comunican al bus.
Más información:

 http://www.prometec.net/bus-i2c/
 http://www.electroensaimada.com/i2c.html
 http://www.luisllamas.es/2016/05/arduino-i2c/
 http://www.slideshare.net/FabioSierra1/bus-i2-c-de-arduino
 https://learn.sparkfun.com/tutorials/i2c
 http://www.ehu.eus/micros-virtual/unidad21/
 http://robots-argentina.com.ar/Comunicacion_busI2C.htm
 http://www.i2c-bus.org/
 http://es.wikipedia.org/wiki/I%C2%B2C
 Y mucha más información en: http://en.wikipedia.org/wiki/I%C2%B2C donde se explica
la capa física más profundamente.

Los dispositivos conectados al bus I2C tienen una dirección única para cada uno. También
pueden ser maestros o esclavos. El dispositivo maestro inicia la transferencia de datos y
además genera la señal de reloj, pero no es necesario que el maestro sea siempre el mismo
dispositivo, esta característica se la pueden ir pasando los dispositivos que tengan esa
capacidad. Esta característica hace que al bus I2C se le denomine bus multimaestro.

Las líneas SDA y SCL son del tipo drenaje abierto, es decir, un estado similar al de colector
abierto, pero asociadas a un transistor de efecto de campo (o FET). Se deben polarizar en
estado alto (conectando a la alimentación por medio de resistores “pull-up”) lo que define una
estructura de bus que permite conectar en paralelo múltiples entradas y salidas.
Fijaros también que hay unas resistencias de Pullup conectadas a SDA y SCL. Son
imperativas, ya que el bus es activo bajo (Esto es, la señal activa es un 0, no un 1). Cuando
vayas a conectar algo al bus I2C, es imprescindible que leas el manual para saber si los
pullups los tienes que poner tú, o vienen puestos en el componente.

Puede haber más de un master. La norma propone un sistema de arbitraje, para transferir el
control de uno a otro, pero en un instante dado, sólo uno puede ser el master.

El proceso de comunicación en el bus I2C es:

 El maestro comienza la comunicación enviando un patrón llamado “start condition”.

Esto alerta a los dispositivos esclavos, poniéndolos a la espera de una transacción.
 El maestro se dirige al dispositivo con el que quiere hablar, enviando un byte que
contiene los siete bits (A7-A1) que componen la dirección del dispositivo esclavo con
el que se quiere comunicar, y el octavo bit (A0) de menor peso se corresponde con la
operación deseada (L/E), lectura=1 (recibir del esclavo) y escritura=0 (enviar al
esclavo).
 La dirección enviada es comparada por cada esclavo del bus con su propia dirección,
si ambas coinciden, el esclavo se considera direccionado como esclavo-transmisor o
esclavo-receptor dependiendo del bit R/W.
 Cada byte leído/escrito por el maestro debe ser obligatoriamente reconocido por un bit
de ACK por el dispositivo maestro/esclavo.
 Cuando la comunicación finaliza, el maestro transmite una “stop condition” para dejar
libre el bus.
Las transacciones en el bus I2C tienen este formato:

| start | A7 A6 A5 A4 A3 A2 A1 R/W | ACK | … DATA … | ACK | stop | idle |

Cuando los datos son enviados por SDA, los pulsos de reloj son enviados por SCL para
mantener el maestro y el esclavo sincronizados. Puesto que los datos son enviados como un
bit en cada pulso de reloj, la transferencia de datos es un octavo la frecuencia de reloj. La
frecuencia del reloj estándar originalmente se puso a 100 KHz y la mayoría de los integrados y
microcontroladores soportan esta velocidad. En posteriores actualizaciones, se introdujo una
fast speed de 400 KHz y una high speed de 1.7 a 3.4 MHz. Arduino puede soportar la
velocidad estándar y fast speed, BeagleBoard tiene tres buses I2C cada uno a una
velocidad distinta y tanto BeagleBoard como Raspberry Pi soportan velocidad estándar y fast
speed. Fast speed corresponde a una velocidad de transferencia de 50Kbytes/sec lo que
puede ser una velocidad muy baja para algunas aplicaciones de control. Una opción en ese
caso es usar SPI en lugar de I2C.

The speed grades:

 standard mode: 100 kbit/s

 full speed: 400 kbit/s
 fast mode: 1 mbit/s
 high speed: 3,2 Mbit/s

I2C también se conoce como TWI (Two Wire Interface) y no dispone de un conector
estandarizado. Únicamente por motivos de licencia se le denomina TWI, no obstante, la
patente caducó en 2006, por lo que actualmente no hay restricción sobre el uso del término
I2C.

I2C bus specification: http://i2c.info/i2c-bus-specification

Especificación y manual de usuario de
I2C: http://www.nxp.com/documents/user_manual/UM10204.pdf

I2C bus y como usarlo: http://www.i2c-bus.org/fileadmin/ftp/i2c_bus_specification_1995.pdf

Presentación de I2C por

Philips: http://www.nxp.com/documents/application_note/AN10216.pdf

I2C no tiene limitaciones de velocidad, el maestro genera la velocidad de reloj y I2C provee de
un mecanismo que si el esclavo es más lento es capaz de ponerse el maestro en modo de
espera.

SMBus (Bus de Administración del Sistema) es un subconjunto del protocolo I2C definido por
Intel en 1995. Todas las placas bases modernas tienen un bus SMBus al que se conectan la
mayor parte de los chips de monitorización del sistema. Estos chips sirven para medir
temperaturas de componentes, velocidad de ventiladores, voltajes, etc. Toda clase de
información sobre hardware.

Direccionamiento I2C

En principio, el número de dispositivos que se puede conectar al bus no tiene límites, aunque
hay que observar que la capacidad máxima sumada de todos los dispositivos no supere los
400 pF. El valor de los resistores de polarización no es muy crítico, y puede ir desde 1K8
(1.800 ohms) a 47K (47.000 ohms). Un valor menor de resistencia incrementa el consumo de
los integrados pero disminuye la sensibilidad al ruido y mejora el tiempo de los flancos de
subida y bajada de las señales. Los valores más comunes en uso son entre 1K8 y 10K.

Lo más común en los dispositivos para el bus I2C es que utilicen direcciones de 7 bits, aunque
existen dispositivos de 10 bits. Este último caso es raro. Una dirección de 7 bits implica que se
pueden poner hasta 128 dispositivos sobre un bus I2C, ya que un número de 7 bits puede ir
desde 0 a 127. Cuando se envían las direcciones de 7 bit, de cualquier modo la transmisión es
de 8 bits. El bit extra se utiliza para informarle al dispositivo esclavo si el dispositivo maestro
va a escribir o va a leer datos desde él. Si el bit de lectura/escritura (R/W) es cero, el
dispositivo maestro está escribiendo en el esclavo. Si el bit es 1 el maestro está leyendo
desde el esclavo. La dirección de 7 bit se coloca en los 7 bits más significativos del byte y el
bit de lectura/escritura es el bit menos significativo.

Direcciones de esclavos con 7,8 y 10

bits: http://www.totalphase.com/support/articles/200349176
Cada fabricante usa su propio direcionamiento para los esclavos, por ejemplo
Philips: http://www.diolan.com/downloads/i2c-address-allocation-table.pdf

I2C en Arduino

Arduino dispone de soporte I2C por hardware vinculado físicamente a ciertos pines. También
es posible emplear cualquier otro grupo de pines como bus I2C a través de software, pero en
ese caso la velocidad será mucho menor.

Los pines a los que está asociado varían de un modelo a otro. La siguiente tabla muestra la
disposición en alguno de los principales modelos. Para otros modelos, consultar el esquema
de patillaje correspondiente.

MODELO SDA SCK

Uno A4 A5

Nano A4 A5

Mini Pro A4 A5

Mega 20 21
Para usar el bus I2C en Arduino, el IDE Standard proporciona la librería “Wire.h”, que contiene
las funciones necesarias para controlar el hardware integrado.

Existen otras librerías más avanzadas que Wire.h para manejar el bus I2C, como por
ejemplo I2Cdevlib o I2C library.

Para saber más de i2c en el Atmega328p ver página 260

de http://www.atmel.com/Images/Atmel-42735-8-bit-AVR-Microcontroller-ATmega328-
328P_datasheet.pdf

Características de I2C en ATmega328p:

 Simple, yet Powerful and Flexible Communication Interface, only two Bus Lines
Needed
 Both Master and Slave Operation Supported
 Device can Operate as Transmitter or Receiver
 7-bit Address Space Allows up to 128 Different Slave Addresses
 Multi-master Arbitration Support
 Up to 400kHz Data Transfer Speed
 Slew-rate Limited Output Drivers
 Noise Suppression Circuitry Rejects Spikes on Bus Lines
 Fully Programmable Slave Address with General Call Support
 Address Recognition Causes Wake-up When AVR is in Sleep Mode
 Compatible with Philips I2C protocol

Módulo TWI en ATmega328p:

El I2C en el microcontrolador ATmega328p usa los registros:

Register Name Function

TWCR Two Wire Control Register Controls the actions of the TWI module

TWSR Two Wire Status Register Reports the status of the TWI actions

TWDR Two Wire Data/Address Register Contains the data you want to transmit or have received
TWBR Two Wire Bit Rate Register Controls the frequency of the clock (SCL)

La librería para manejar el bus I2C en Arduino es Wire: http://arduino.cc/en/reference/wire

Esta librería permite comunicar con I2C/TWI Arduino con otros dispositivos. En las placas
Arduino con el diseño R3 (1.0 pinout), la SDA (línea de datos) y SCL (línea de reloj) están en
los pines cerca del pin AREF.

El Arduino Due tiene dos interfaces I2C / TWI SDA1 y SCL1 que están cerca del pin AREF y
los adicionales en los pines 20 y 21.

Funciones:

 begin() – Inicia la librería Wire y especifica si es master o slave

 requestFrom() – Usado por el maestro para solicitar datos del esclavo
 beginTransmission() – Comenzar transmisión con esclavo.
 endTransmission() – Finaliza la transmisión que comenzó con un esclavo y transmite
los bytes en cola.
 write() – Escribe datos desde un esclavo como respuesta a una petición del maestro o
pone en cola la transmisión de un maestro.
  available() – Devuelve el número de bytes para leer
 read() – Lee un byte transmitido desde un esclavo a un maestro o viceversa
 onReceive() – Llama a una función cuando un esclavo recibe una transmisión de un
maestro. Registra una función de callback.
 onRequest() – Llama a una función cuando un maestro solicita datos de un maestro.
Registra una función de callback.

Y para profundizar más en el I2C en Arduino:

 https://www.arduino.cc/en/Reference/Wire
 http://playground.arduino.cc/Main/WireLibraryDetailedReference
 http://playground.arduino.cc/Code/ATMELTWI

Aplicaciones I2C

Podríamos usar el bus I2C para comunicar Raspberry Pi con Arduino y otros dispositivos:

Como conectar via I2C Arduino y Raspberry Pi.

Tutorial de I2C en Raspberry: http://www.instructables.com/id/Raspberry-Pi-I2C-Python/all

Librería python para usar I2C en Raspberry Pi

https://github.com/quick2wire/quick2wire-python-api

Usar I2C en Linux:

 http://elinux.org/Interfacing_with_I2C_Devices
 http://www.acmesystems.it/i2c

También disponemos de controladores I2C en caso de no tener disponibles puertos I2C en el

microcontrolador: http://www.nxp.com/documents/application_note/AN10148.pdf que reciben
datos en formato pararlelo, lo pasana serie y lo mandan a un bus I2C y en sentido contrario.

Otro ejemplo de aplicación I2C es este shield que maneja 8 relés usando dos pines I2C e
incluso se pueden apilar para manejar, 16 o 24 relés en el mismo bus I2C:

 http://www.freetronics.com.au/products/relay8-8-channel-relay-driver-
shield#.WBi_di3hDcs
 Esquemático: https://github.com/freetronics/RelayDriverShield8/blob/master/RelayDriv
erShield8.pdf?raw=true
 Quickstart guide: http://www.freetronics.com.au/pages/relay8-8-channel-relay-driver-
shield-quickstart-guide#.WBjAfC3hDcs
Como ejemplo curioso de I2C el Wii Remote (conocido como Wiimote) es el dispositivo de
entrada principal de Wii. Es un dispositivo inalámbrico que utiliza la tecnología Bluetooth
estándar para comunicarse con la Wii. Está construido alrededor de un Broadcom BCM2042
bluetooth System-on-a-chip, y contiene múltiples periféricos que le proporcionan datos, así
como un puerto de expansión para complementos externos.

El mando Wii incluye un puerto de expansión de 6 pines que permite conectar periféricos
externos. Las comunicaciones son I2C síncronas bidireccionales y los dispositivos
proporcionan un bloque de registro virtual de longitud 0x100 que está mapeado en 0xa40000
en el espacio de direcciones del Wii Remote (La dirección I2C de 7 bits es 0x52).

Webs del proyecto:

 http://wiibrew.org/wiki/Wiimote
 http://wiibrew.org/wiki/Wiimote/Extension_Controllers

Ejercicios I2C Arduino

Escaner I2C

Cada componente que conectamos al bus I2C tiene una dirección única, y cada mensaje y
orden que transmitimos al bus, lleva anexa esta dirección, indicando cuál de los muchos
posibles, es el receptor del mensaje.

Esto implica que sabemos la dirección del componente. Lo normal es comprobar la

información técnica del fabricante del componente, y ahí suele decirnos cuál es la dirección
por defecto. Pero es posible que tengamos un dispositivo sin documentación, para ello hay un
programa para Arduino, que nos informa, de lo que hay en nuestro bus y con qué dirección.

Este programa, no tiene ni idea de quien responde y lo que hace, pero bastante es que nos
informe de que hay alguien en la dirección xx. Si no sabemos en qué dirección está un
componente dado, basta con colocarlo solo en el bus, y ver qué dirección nos reporta el I2C
scanner.
En algunas ocasiones, sobre todo al comprar en vendedores chinos, el fabricante no nos
facilita la dirección del dispositivo o incluso lo proporciona de forma incorrecta. Esta es una
circunstancia común y nada preocupante. Para eso disponemos de un sketch llamado
“Scanner I2C” que realiza un barrido por todas las posibles direcciones del bus, y muestra el
resultado en caso de encontrar un dispositivo en la dirección.El sketch scanner I2C está
disponible en este enlace, o podéis usar la siguiente versión reducida y traducida.

Ver http://playground.arduino.cc/Main/I2cScanner

#include "Wire.h"
1
extern "C" {
2
#include "utility/twi.h"
3
}
4 void scanI2CBus(byte from_addr, byte to_addr, void(*callback)(byte address, byte res
5 {

6 byte rc;

7 byte data = 0;

for( byte addr = from_addr; addr <= to_addr; addr++ ) {

8
rc = twi_writeTo(addr, &data, 0, 1, 0);
9
callback( addr, rc );
10
}
11
}
12
void scanFunc( byte addr, byte result ) {
13 Serial.print("addr: ");
14 Serial.print(addr,DEC);

15 Serial.print( (result==0) ? " Encontrado!":" ");

16 Serial.print( (addr%4) ? "\t":"\n");

}
17

18

19
const byte start_address = 8;
20
const byte end_address = 119;
21

22
void setup()
23
{
24 Wire.begin();

25 Serial.begin(9600);

Serial.print("Escaneando bus I2C...");

26
scanI2CBus( start_address, end_address, scanFunc );
27
Serial.println("\nTerminado");
28
}
29

30
void loop()
31 {
32 delay(1000);
33 }

34

35

36

37
Comunicar Arduinos por I2C

Ejercicio33-I2C: comunicar por I2C tres arduinos

Ejemplo de uso con dos Arduinos:

 http://arduino.cc/en/Tutorial/MasterWriter
 http://arduino.cc/en/Tutorial/MasterReader
 http://arduino.cc/en/Tutorial/DigitalPotentiometer
 http://www.electroensaimada.com/i2c.html
 http://programarfacil.com/blog/conectar-dos-arduinos-i2c/
Solución: https://github.com/jecrespo/Aprendiendo-Arduino/tree/master/Ejercicio33-I2C

Dispositivos I2C

En el mercado hay multitud de sensores y dispositivos I2C para utilizar con Arduino, veamos
alguno de los más importantes.

Para escribir en el dispositivo I2C las tramas serían las indicadas en el gráfico siguiente.
Tras la condición de Start iniciada por el microcontrolador se envía el primer byte conteniendo
la dirección del dispositivo I2C con el que se quiere comunicar y en el último bit aparece el 0
indicando que se va a escribir, la información pasa del microcontrolador al dispositivo I2C.

Le sigue a esta trama el bit de acknowledgement generado por el esclavo para confirmar la
correcta recepción de byte anterior. El byte siguiente se refiere a la dirección o registro del
dispositivo I2C donde se quiere escribir o enviar el dato desde el microcontrolador.

A partir del tercer byte, se envían los datos de forma sucesiva, y es el dispositivo I2C el que va
autoincrementando la dirección de memoria donde se guarda el dato recibido.Se finaliza la
comunicación con el bit de parada.

Para leer datos del dispositivo I2C, la secuencia es la siguiente.

Inicia el dispositivo master la comunicación a través del bit de Start. Después viene la
dirección del esclavo al que se dirige, indicando que va realizar la lectura del mismo (bit
R/W=1). En este caso, el dispositivo I2C también va realizando un autoincremento del registro
a leer.

Aplicaciones I2C: http://en.wikipedia.org/wiki/I%C2%B2C#Applications

Listado de productos I2C: http://www.nxp.com/products/interface_and_connectivity/i2c/

En el mercado podemos encontrar muchos dispositivos I2C. Ejemplos de dispositivos I2C:

 http://www.seeedstudio.com/depot/s/i2c.html?search_in_description=0
 https://www.sparkfun.com/search/results?term=i2c
  http://www.electan.com/advanced_search_result.php?keywords=i2c&osCsid=4l26edd9
i9lisn84sk51l0doq2

Cabe destacar: módulos GPS, RTC (Real Time Clock), IMU (Inertial Measurement Unit),
Display gráfico, EEPROM, Sensores de temperatura y humedad, sensor de presión, distancia,
driver motor, etc…

I2C al tratarse de una comunicación serie también puede convertirse a otros protocolos serie.

Doble UART con I2C/SPI

interface: http://www.nxp.com/documents/data_sheet/SC16IS752_SC16IS762.pdf, este chip
ofrece conversion de protocolo bidireccional de I2C/SPI a RS-232/RS-485

Conversor de USB a I2C:

 http://www.ftdichip.com/Products/ICs/FT201X.html
 http://www.acroname.com/products/R286-USB-I2C.html

Este circuito utiliza el integrado convertidor de USB a Serie de la casa FTDI por lo que hay
disponibles controladores tanto para Windows como para Apple y Linux. Una vez instalado el
driver el circuito aparece en el ordenador como un puerto serie más, por lo que todo lo que
hace falta para poder controlar dispositivos I2C es mandar las órdenes directamente al puerto
serie y el circuito se encarga de traspasarlas directamente al bus I2C.

Más información en:

 http://www.superrobotica.com/s310425.htm
 http://www.robot-electronics.co.uk/htm/usb_i2c_tech.htm

Ejemplo de pantalla LCD por I2C de http://www.prometec.net/bus-i2c/

De usb a I2C con software: http://www.telos.de/conniimm20/

Interfaz I2C de módulo EEPROM: http://www.miniinthebox.com/es/at24c02-i2c-interfaz-de-

modulo-de-memoria-eeprom-blue_p643036.html

Y el código para usarlo: http://playground.arduino.cc/Code/I2CEEPROM

Colección de librerías para usar dispositivos I2C con Arduino: http://www.i2cdevlib.com/ y los
dispositivos: http://www.i2cdevlib.com/devices

Si queremos saber los dispositivos que hay conectados en un bus I2C con las direcciones de
cada uno de ellos y mostrarlo por consola disponemos de este código: I2C
scanner http://playground.arduino.cc/Main/I2cScanner

IMU (Inertial Measurement Unit)

Una IMU es un dispositivo capaz de medir la fuerza (aceleración) y la velocidad.

Generalmente consta de un Acelerómetro y un Giroscopio. Por lo tanto una IMU no mide
ángulos, por lo menos no directamente, requiere algunos cálculos.

Un dispositivo I2C muy interesante es el MPU-6050 que nos sirve para probar e introducirnos
en el mundo de los giroscopios y acelerómetros.

 https://www.invensense.com/products/motion-tracking/6-axis/mpu-6050/
 datasheet: https://www.cdiweb.com/datasheets/invensense/MPU-
6050_DataSheet_V3%204.pdf

Definiciones:

 https://en.wikipedia.org/wiki/Inertial_measurement_unit
 https://es.wikipedia.org/wiki/Unidad_de_medici%C3%B3n_inercial

El MPU-6050 es una IMU de 6DOF (se lee “6 Degrees Of Freedom“ o 6 grados de libertad).
Esto significa que lleva un acelerómetro y un giroscopio, ambos de 3 ejes (3+3 = 6DOF). Hay
IMUs de 9DOF, en ese caso también llevan un magnetómetro. Otras pueden tener 5DOF, en
cuyo caso el giroscopio sólo mide dos ejes, etc.

El MPU-6050 opera con 3.3 voltios, aunque algunas versiones llevan un regulador que permite
conectarla a 5V. El MPU-6050 utiliza el protocolo de comunicación I2C.
El acelerómetro mide la aceleración. La aceleración puede expresarse en 3 ejes: X, Y y Z, las
tres dimensiones del espacio. Por ejemplo, si mueves la IMU hacia arriba, el eje Z marcará un
cierto valor. Si es hacia delante, marcará el eje X, etc. La gravedad de la Tierra tiene una
aceleración de aprox. 9.8 m/s², perpendicular al suelo como es lógico. Así pues, la IMU
también detecta la aceleración de la gravedad terrestre. Gracias a la gravedad terrestre se
pueden usar las lecturas del acelerómetro para saber cuál es el ángulo de inclinación respecto
al eje X o eje Y.

Supongamos que la IMU esté perfectamente alineada con el suelo. Entonces, como puedes
ver en la imagen, el eje Z marcará 9.8, y los otros dos ejes marcarán 0. Ahora supongamos
que giramos la IMU 90 grados. Ahora es el eje X el que está perpendicular al suelo, por lo
tanto marcará la aceleración de la gravedad.

Si sabemos que la gravedad es 9.8 m/s², y sabemos qué medida dan los tres ejes del
acelerómetro, por trigonometría es posible calcular el ángulo de inclinación de la IMU. Una
buena fórmula para calcular el ángulo es:

Dado que el ángulo se calcula a partir de la gravedad, no es posible calcular el ángulo Z (giro
sobre si mismo) con esta fórmula ni con ninguna otra. Para hacerlo se necesita otro
componente: el magnetómetro, que es un tipo de brújula digital. El MPU-6050 no lleva, y por
tanto nunca podrá calcular con precisión el ángulo Z. Sin embargo, para la gran mayoría de
aplicaciones sólo se necesitan los ejes X e Y.

El giroscopio mide la velocidad angular, es decir, el número de grados que se gira en un

segundo.En un principio, los giroscopios eléctricos eran unos voluminosos artefactos muy
caros usados en aviones y para dirigir cohetes. Actualmente la miniaturización de circuitos y
gracias a la tecnología MEMS, es posible tener un giroscopio en un chip a un precio muy
asequible.

La media de velocidad angular en vez de medirse en grados por segundo, se mide en otra
unidad que son radianes por segundo (1rad/s = 180/PI grados/s). Si sabemos el ángulo inicial
de la IMU, podemos sumarle el valor que marca el giroscopio para saber el nuevo ángulo a
cada momento. Supongamos que iniciamos la IMU a 0º. Si el giroscopio realiza una medida
cada segundo, y marca 3 en el eje X, tendremos el ángulo con esta sencilla fórmula:
Dónde Δt es el tiempo que transcurre cada vez que se calcula esta fórmula, AnguloYAnterior
es el ángulo calculado la última vez que se llamó esta fórmula y GiroscopioY es la lectura del
ángulo Y del giroscopio.

Y lo mismo pasa con los ejes X, Z. Sólo que se suele ignorar el eje Z, puesto que al no poder
calcular un ángulo Z con el Acelerómetro, no se puede aplicar un Filtro Complementario para
el eje Z.

Podemos ver los datos del acelerómetro y giroscopio de nuestro smartphone

con https://play.google.com/store/apps/details?id=com.mtorres.phonetester&hl=es

Error en las medidas. Las IMUs son unos artefactos mágicos que con un poco de
trigonometría pueden dar un ángulo con total exactitud. Pero hay dos problemas muy
importantes: el ruido y los errores. El ruido son todas aquellas interferencias que afectan a los
dispositivos electrónicos. El acelerómetro es capaz de medir cualquier ángulo, sin embargo
sus lecturas son ruidosas y tienen un cierto margen de error. Si se dibuja un gráfico de las
medidas de un acelerómetro en función del tiempo, se verá algo de este estilo:
El ángulo real (ideal) está marcado en azul, y las medidas reales están en rojo. Por si esto
fuera poco, el acelerómetro también detecta cualquier aceleración que no sea la de la
gravedad. Por tanto, si mueves la IMU sin girarla, al aplicar una aceleración en otro eje, la IMU
lo detectará como un cambio de rotación.

Por otra parte tenemos el giroscopio. A diferencia del acelerómetro, da las medidas con
mucha precisión. Pero al realizar los cálculos del ángulo es inevitable que se produzca un
pequeño error, que con el tiempo va acomulándose hasta que cualquier similitud con la
realidad es pura coincidencia. Esto en inglés se llama drift (deriva). Hay varias formas de
combinar los datos del acelerómetro y el giroscopio para así obtener medidas exactas. Para
ello son necesarios los filtros.

Hay que conseguir eliminar el ruido, el drift y conseguir que el acelerómetro no cambie de
ángulo al detectar otra fuerza que no sea la gravedad. Hay distintos algoritmos, llamados
filtros, que hacen esta tarea. Uno de los mejores es el Filtro de Kálman, se utiliza en los
aviones, cohetes y satélites geoestacionarios.

El filtro de Kálman es sorprendente. Capaz de calcular el error de cada medida a partir de las
medidas anteriores, eliminarlo y dar el valor real del ángulo. En cierto modo es un algoritmo
que aprende en cada iteración.

Sin embargo tiene dos problemas: Tiene un coste de procesamiento algo elevado y es muy
complicado de entender. Ver https://es.wikipedia.org/wiki/Filtro_de_Kalman

Existen otros filtros a nuestra disposición. El que vamos a utilizar es conocido como Filtro
Complementario o Complementary Filter en inglés. Es ideal para implementar con Arduino:
fácil de utilizar, bajo coste de procesamiento y con una precisión muy buena.

¿En qué consiste exactamente? El Filtro Complementario es en realidad una unión de dos
filtros diferentes: un High-pass Filter para el giroscopio y un Low-pass Filter para el
Acelerómetro. El primero deja pasar únicamente los valores por encima de un cierto límite, al
contrario que el Low-pass filter, que sólo permite a los que están por debajo.

La fórmula resultante de combinar (complementar, de aquí el nombre) los dos filtros es:

Dónde AnguloGyro es el ángulo del Giroscopio que hemos calculado previamente, y

AnguloAccel el ángulo del Acelerómetro calculado con la fórmula de la tangente. Δt es el
tiempo que ha pasado (en segundos) desde la última vez que se ha calculado el filtro. Esta
fórmula es la misma para el eje X, Y.

Es posible probar a cambiar el valor de 0.98 y 0.02 por un valor personalizado. Eso sí, ambos
tienen que sumar 1.

Más información para uso de MPU-6050:

 http://robologs.net/2014/10/15/tutorial-de-arduino-y-mpu-6050/
 http://www.prometec.net/usando-el-mpu6050
 Tutorial del Arduino playground: http://playground.arduino.cc/Main/MPU-6050
 Una librería más más avanzada para uso de
: http://www.i2cdevlib.com/devices/mpu6050#source
 Documentación de la
librería: http://www.i2cdevlib.com/docs/html/class_m_p_u6050.html
 La web del sensor: http://www.invensense.com/products/motion-tracking/6-axis/mpu-
6050/
 Otros sensores del mismo fabricante: http://www.invensense.com/products/motion-
tracking/6-axis/mpu-6050/
 Data Sheet, especificaciones: https://www.cdiweb.com/datasheets/invensense/MPU-
6050_DataSheet_V3%204.pdf

DMP: El MPU6050 IMU contiene un DMP (Digital Motion Processor) que fusiona los datos del
acelerómetro y del giroscopio para minimizar los efectos de los errores inherentes a cada
sensor. El DMP calcula los resultados en términos de cuaterniones, y puede convertir los
resultados en ángulos de Euler y realizar otros cálculos con los datos. Invensense no revelará
el algoritmo que utilizan para combinar los datos.

Mientras que la información del giroscopio (velocidad angular) o acelerómetro (aceleración

lineal) para cada eje (X, Y y Z) se puede leer de forma directa, el acceso a los registros del
DMP es algo más compleja, debido a que el fabricante no ha abierto toda la información al
respecto.

Más información de DMP:

 Acceso a los registros DMP con

librería: https://minibots.wordpress.com/2014/12/16/libreria-para-lectura-de-angulos-
de-inclinacion-de-un-mpu-6050-con-dmp/
 Y la libreria simplificada: https://github.com/RafaGS/SimpleDmp
 Documentación oficial del dmp: http://www.i2cdevlib.com/forums/topic/153-official-dmp-
documentation-is-released-by-invensense/

MEMS – sistemas micro-electro-mecánicos. Los IMUs son sistemas MEMS, los avances en
el campo de los semiconductores están dando lugar a circuitos integrados con características
tridimensionales e incluso con piezas móviles. Estos dispositivos, llamados Sistemas Micro
electromecánicos (MEMS), pueden resolver muchos problemas que un microprocesador más
el software o configuración no ASIC (Chip integrados de aplicación específica) no pueden. La
tecnología MEMS puede aplicarse utilizando un sin número de diferentes materiales y técnicas
de fabricación; la elección dependerá del tipo de dispositivo que se está creando y el sector
comercial en el que tiene que operar.

Los acelerómetros actuales son simples dispositivos MEMS consistentes en una micro
estructura suspendida con una masa determinada de referencia conocida como masa sísmica
dentro de una cámara de gas sellada. Bajo la influencia de aceleraciones externas la masa
cambia de su posición neutral y ese cambio es convertido en una señal eléctrica mediante
piezoresistencias con cambio de la capacitancia.

ABC del acelerometro (MUY BUENO): http://5hertz.com/tutoriales/?p=228

Los giroscopios basados en sistemas MEMs usan el mismo sistema que el péndulo de
Foucault y usa un elemento vibrante (giroscopios de estructura vibrante). El principio físico
subyacente es que un objeto vibrante tiende a continuar vibrando en el mismo plano que gira
su apoyo. En la literatura de ingeniería, este tipo de dispositivos se conocen como “giroscopio
de vibración de Coriolis”, debido a que a medida que el plano de oscilación gira, la respuesta
detectada por el transductor resulta del término de Coriolis presente en sus ecuaciones de
movimiento. Los giroscopios de estructura vibrante son más simples y económicos, que los
giroscopios de rotación convencionales. Los dispositivos de estado sólido que usan este
principio son un tipo económico de indicadores de posición.
Como funciona internamente un
girocopio: http://www5.epsondevice.com/en/information/technical_info/gyro/

Diferentes tipos de giroscopios:

Más información:

 https://en.wikipedia.org/wiki/Microelectromechanical_systems
 https://es.wikipedia.org/wiki/Sistemas_microelectromec%C3%A1nicos
 Acelerometro: https://en.wikipedia.org/wiki/Accelerometer
 Giroscopio: https://en.wikipedia.org/wiki/Gyroscope
  Giroscopios de estructura
vibrante: https://en.wikipedia.org/wiki/Vibrating_structure_gyroscope#MEMS_gyroscop
es y https://es.wikipedia.org/wiki/Gir%C3%B3scopo_de_estructura_vibrante

Guia de compras de IMU de sparkfun: https://www.sparkfun.com/pages/accel_gyro_guide

Un IMU de 9 grados de libertad incorpora un magnetómetro (brújula digital) al conjunto de

acelerómetro y giroscopio. El MPU-9150 que es un MPU-6050 + brujula
(magnetometro): http://playground.arduino.cc/Main/MPU-9150

Otro ejemplo de IMU de 9 grados de libertad: https://www.sparkfun.com/products/10724 que

tiene un magnetometro. Tutorial de este IMU: https://github.com/ptrbrtz/razor-9dof-
ahrs/wiki/Tutorial

Otra IMU con 9DOF es el GY-85. Al contrario que el MPU-6050 tiene en el mismo chip el
acelerómetro y el giroscopio, el GY-85 integra tres sensores: Acelerómetro de 3 ejes,
Giroscopio de 3 ejes y sensor de campo magnético de 3 ejes.

Comprar: http://www.dx.com/es/p/gy-85-6dof-9dof-imu-sensor-module-for-arduino-
148436#.VzRp0oSLTcs

Las referencias de los integrados son:

 ADXL345 (Acelerómetro de 3 ejes)

 HMC5883L (Sensor de campo magnético de 3 ejes)
 ITG3205 (Giroscopio de 3 ejes)

Esquemático:
Ejercicio IMU MPU6050

El MPU6050 que vamos a utilizar es un chip de 6 dof o grados de libertad porque incluye un
acelerómetro de 3 ejes y un giróscopo de 3 ejes.
Aunque lo que miden los sensores internos son aceleraciones lineales y angulares el
procesador interno del IMU es capaz de realizar cálculos sobre la marcha para darnos
informaciones más útiles como los ángulos de inclinación con respecto a los 3 ejes principales.
Conseguir los datos en bruto del MPU6050 es la parte fácil, procesarlos y reaccionar es otra
historia que se puede complicar un poco más.

Para estas sesión vamos a utilizar una Breakout board bastante típica llamada GY-521, que
incluye un MPU650 y un regulador de tensión, con lo que podemos alimentar a tanto 3.3V
como a 5V

El siguiente diagrama muestra la orientación de los ejes de sensibilidad y la polaridad de

rotación.
Esquema de conexión
Probar el I2C scanner http://playground.arduino.cc/Main/I2cScanner con el MPU conectado
normal y luego con AD0 a masa y comprobar que cambia su dirección.

Ver los ejercicios 62 de https://github.com/jecrespo/Aprendiendo-

Arduino/tree/master/Ejercicio62-MPU6050

 raw_data
 advanced_values

Este programa es de lo más sencillo, y lo que hace es leer e imprimir los valores en bruto que
los acelerómetros y giroscopios que le envían a Arduino, es decir sin procesar en absoluto,
algo que sirve de muy poco. Son las medidas reales que producen los acelerómetros y los
giróscopos, pero así no valen de mucho.

Hay 6 valores. Los tres primeros corresponden a los acelerómetros y los tres últimos a los
giróscopos. Si vas girando el IMU en direcciones perpendiculares verás con rapidez cual es
cada uno de los ejes, porque aunque el chip esté en movimiento inercial aun detectará la
aceleración de la gravedad, claramente en una de las direcciones.

Vamos a instalar las librerías correspondientes y a probar con uno de los programas de
ejemplo que tanto las conexiones como el MPU6050 están en condiciones operativas.

 Información del playground: http://playground.arduino.cc/Main/MPU-6050

 Para un uso serio de MPU-6050 tenemos la librería
mpu6050: http://www.i2cdevlib.com/devices/mpu6050#source
 Código: https://github.com/jrowberg/i2cdevlib/tree/master/Arduino/MPU6050
 Para más información del MPU-6050
ver: https://www.invensense.com/products/motion-tracking/6-axis/mpu-6050/
 También podemos usar una librería alternativa de I2C llamada
I2Cdev: http://www.i2cdevlib.com/
 Código: https://github.com/jrowberg/i2cdevlib

Para medir los ángulos, vamos a usar estas librerías. Cargar el ejemplo MPU6050_DMP6.

El texto que aparece al principio de cada línea “ypr” corresponde a las iniciales en ingles de
los tres ángulos de referencia Yaw, Pitch y Roll. Y los valores que van cambiando son poco
más o menos el valor instantáneo de cada uno de esos ángulos.
Si el IMU dispone además de un magnetómetro de 3 ejes, ya está en condiciones de apuntar
al Norte además y puede fijar con precisión el segundo eje, y el tercero cae por su propio
peso, pero no es el caso del MPU6050 que estamos usando.

Ahora conectar un servo para moverlo girando la IMU:

Ver ejercicio MPU6050_DMP6_SERVO: https://github.com/jecrespo/Aprendiendo-
Arduino/tree/master/Ejercicio62-MPU6050

RTC (Real Time Clock)

Ya conocemos la librería Time para Arduino. Empezamos utilizando el reloj interno, pero tiene
varios problemas evidentes, como el hecho de que el reloj interno se reinicia cada 50 días
aproximadamente, y además si cortamos la corriente a nuestro Arduino, pone el reloj a 00 y
vuelve a empezar desde el 1 de enero de 1970. Una solución, que nos permita usar un reloj
fiable que se mantenga incluso cuando apagamos Arduino es usar un RTC

Uno RTC muy extendido para reloj digital es el DS1307 de Maxim. Por muy poco dinero
realiza todas las funciones para llevar un reloj con calendario y solo hay que añadirle una
batería externa para que no pierda la hora al perder la corriente.

Un RTC es un reloj:

 https://es.wikipedia.org/wiki/Reloj_en_tiempo_real
 https://en.wikipedia.org/wiki/Real-time_clock

Generalmente los RTC son dispositivos I2C y los más comunes son el DS1307 y el DS3231.

Para usar un RTC con Arduino es necesaria la librería time que ofrece la funcionalidad de
mantener la fecha y hora en Arduino y se usa el RTC como fuente de sincronización de la
hora.

La librería time añade funcionalidades de tiempo a Arduino, ya sea con o sin HW externo. Nos
permite obtener la fecha y hora como año, mes, dia, hora, minuto, segundo, día de la semana,
etc… También da la hora con el tipo de dato estándar de C time_t de la librería
<time.h>: http://www.cplusplus.com/reference/ctime/

 Arduino Time Library: http://playground.arduino.cc/Code/time

 github: https://github.com/PaulStoffregen/Time
 Time Library: http://www.pjrc.com/teensy/td_libs_Time.html
 Time Alarms Library: http://www.pjrc.com/teensy/td_libs_Time.html
 DS1307RTC Library: http://www.pjrc.com/teensy/td_libs_DS1307RTC.html
 Código de la librería Time: https://github.com/PaulStoffregen/Time

Sabe que la librería estandard de C time.h (http://www.cplusplus.com/reference/ctime/) no

existe para los microcontroladores AVR, pero si para los ARM y gracias a esta librería es
posible añadir esta funcionalidad a Arduino.

La versión anterior de la librería Time es la

DateTime: http://playground.arduino.cc/Code/DateTime

Las características de un RTC a la hora de comprar son:

 Dirección I2C configurable

 Compensación de año bisiesto (leap year)
 Fecha máxima

Generalmente encontramos RTCs con bus I2C,pero también se pueden encontrar con puerto
serie o bus SPI o 1-Wire.

RTCs de TI: http://www.ti.com/lsds/ti/clock-and-timing/real-time-clocks-products.page

RTCs de ST: http://www.st.com/web/en/catalog/sense_power/FM151/CL1410?sc=rtc

RTCs de MI: https://www.maximintegrated.com/en/products/digital/real-time-clocks.html

Más información:

 http://www.prometec.net/relojes-rtc/

El DS1307 de Maxim/Dallas es un circuito integrado capaz de almacenar y llevar la cuenta de

la fecha y hora, además disponemos de unos cuantos bytes de datos de usuario en su
memoria RAM no volátil (NVRAM). Arduino posee una CPU potente, sin embargo aún así es
incapaz de mantener la hora correctamente a largo plazo, debido a los microsegundos que se
atrasan al no dividir la frecuencia del reloj principal para dar con el segundo exacto.

Características DS1307:

 RTC: Real Time Clock, o reloj de tiempo real. Que lleva la cuenta de segundos
minutos y horas además de día mes y año automáticamente, válido hasta el año 2100.
 56 byte de memoria RAM respaldada por una batería exterior, que mantiene la fecha y
hora cuando no hay corriente.
 Detección automática de corte de corriente y cambio a modo batería.
 Muy bajo consumo, lo que ayuda a que la batería dure entre 5 y 10 años.
 I2C integrado en el mismo chip.

El DS1307 requiere un cristal de 32.768 Khz, este valor viene dado por el hecho de que 2^15
= 32,768. Esto quiere decir que la frecuencia es divisible binariamente para generar un
segundo exacto. El cristal ya se incluye si compramos algún módulo con el DS1307.

El DS1307 requiere dos fuentes de alimentación: Por una parte, requiere alimentación de 5
volts que opera mientras el circuito está encendido y funcionando y otra fuente que proviene
de una batería de litio (tipo reloj) que mantiene funcionando el reloj/calendario mientras la
alimentación principal NO está disponible. El cambio entre ambas fuentes de alimentación es
gestionado por el DS1307 de manera automática.

Disponemos de un pin de salida que puede ser configurado para que el RTC entregue una
onda cuadrada con una frecuencia configurable, las frecuencias disponibles se muestran en la
siguiente tabla y se configuran mediante los bits RS1, RS0 y SQWE de registro de control, si
se usa este pin hay que agregar una resistencia pull-up, ya que es del tipo “Open drain” (solo
puede “drenar” corriente no es fuente de corriente)
Los registros del DS1307 almacenan la fecha y la hora en formato BCD. La dirección de cada
registro y la información almacenada en cada uno se muestra en la siguiente tabla:
El funcionamiento del chip se controla mediante el bit 7 del registro del segundero (0x00) y el
registro de control (0x07): El bit CH del segundero detiene el reloj cuando está en alto (así se
entregan los módulos de fábrica) y en este modo NO se lleva el conteo de tiempo porque el
oscilador está detenido. ES MUY IMPORTANTE PONER A 0 ESTE BIT PARA QUE EL RTC
FUNCIONE. El registro de control maneja la funcionalidad del pin de salida de onda cuadrada.
A partir de la dirección 0x08 disponemos de memoria RAM no volátil (NVRAM) cuyo contenido
no se borra con la pérdida de energía, este segmento de memoria funciona de manera similar
a una memoria EEPROM.

El el DS1307 es uno de los RTC más usados y mejor documentados para Arduino.
Características:

 Placa: https://www.sparkfun.com/products/12708
 Placa: https://www.adafruit.com/products/264
 Chip: https://www.maximintegrated.com/en/products/digital/real-time-
clocks/DS1307.html
 Datasheet: http://datasheets.maximintegrated.com/en/ds/DS1307.pdf
 Tutoriales:
 http://bildr.org/2011/03/ds1307-arduino/
 http://combustory.com/wiki/index.php/RTC1307_-_Real_Time_Clock
  Tutorial Adafruit: https://learn.adafruit.com/ds1307-real-time-clock-breakout-board-
kit/overview
 http://www.prometec.net/relojes-rtc/
 Muy buena explicación: http://www.geekfactory.mx/tutoriales/tutoriales-
arduino/ds1307-en-tinyrtc-con-arduino/
 Proyecto con un RTC: https://www.sparkfun.com/products/11734
 Configurar hora en DS1307 con puerto serie: http://www.instructables.com/id/Setting-
the-DS1307-Real-Time-Clock-using-the-Seria/

El DS1307 devuelve los valores de la hora via I2C en formato decimal codificado en binario
(BCD – https://es.wikipedia.org/wiki/Decimal_codificado_en_binario). Para evitar hacer los
cálculos y olvidarnos del protocolo I2C disponemos de varias librerías:

 Librería recomendada DS1307RTC (Disponible para instalar desde el Gestor de

Librerías): http://www.pjrc.com/teensy/td_libs_DS1307RTC.html y
código https://github.com/PaulStoffregen/DS1307RTC
 Librería adafruit RTClib: https://github.com/adafruit/RTClib
 Librería geekfactory RTClib: https://github.com/geekfactory/RTCLib

Uso del DS1307 con Raspberry Pi: http://www.instructables.com/id/DIY-RTC-DS1307-Module-

and-use-with-Raspberry-Pi/?ALLSTEPS

Conexión de DS1307 con Arduino:

Otros RTCs:
  DS3231M extremamente exacto com
MEMs: https://www.maximintegrated.com/en/products/digital/real-time-
clocks/DS3231M.html
 Articulo con DS3231M: https://blog.adafruit.com/2011/03/18/part-finder-friday-ds3231-
high-precision-real-time-clock-with-built-in-oscillator/
 Placa DS3231M: https://www.adafruit.com/product/255
 Librería DS3131: http://polaridad.es/libreria-arduino-fecha-hora-temperatura-rtc-
ds3231-i2c/ y https://github.com/JChristensen/DS3232RTC
 DS1306: http://datasheets.maximintegrated.com/en/ds/DS1306.pdf
 DS1302: http://playground.arduino.cc/Main/DS1302
 DS3234 con bus SPI: https://www.sparkfun.com/products/10160

Ver los ejemplos de la librería time. Dirección I2C: 0x68

 Leer qué hora está dando el reloj con el ejemplo ReadTest de la librería
DS1307RTC: https://github.com/PaulStoffregen/DS1307RTC/blob/master/examples/Re
adTest/ReadTest.ino
 Configurar el reloj con el ejemplo SetTime de la librería
DS1307RTC: https://github.com/PaulStoffregen/DS1307RTC/blob/master/examples/Se
tTime/SetTime.ino

__DATE__ Y __TIME__ son macros estándar predefinidas en C++ y están disponibles en

todos lo compiladores que implementan el estándar. Podemos aprovechar esto para poner en
hora el reloj interno corriendo un programa que convierta estos valores a formato fecha time_t
y asignarlo al valor del reloj interno, como hace SetTime.

La macro __DATE__ expande a un string que describe la fecha en la que el

preprocesador/compilador está corriendo. El string contiene 11 caracteres en el formato “mmm
dd yyyy”

La macro __TIME__ expande a un string que describe la hora del preprocesador/compilador.

El string contiene 8 caracteres en el formato: “hh:mm:ss”

Ejercicio43-RTC1: Actualizar hora de RTC manualmente por puerto serie.

Modulo que usado para practica: https://www.sparkfun.com/products/12708

Solución: https://github.com/jecrespo/Aprendiendo-Arduino/tree/master/Ejercicio43-
RTC/actualiza_hora_manual

Ejercicio43-RTC2: Mostrar en una pantalla LCD la fecha y hora obtenida del RTC.

Display puerto serie usado: https://www.sparkfun.com/products/9395

Quick Start: https://www.sparkfun.com/tutorials/246

Uso: http://playground.arduino.cc/Learning/SparkFunSerLCD

Solución: https://github.com/jecrespo/Aprendiendo-Arduino/blob/master/Ejercicio43-
RTC/Display_Hora/Display_Hora.ino

GPS

Los módulos GPS generalmente también vienen con interfaz I2C

Ejemplo: http://arduinoguruji.blogspot.com.es/p/gps-interfacing-with.html

Datasheet: https://www.u-blox.com/sites/default/files/products/documents/NEO-
6_DataSheet_(GPS.G6-HW-09005).pdf

Librerías:

 http://arduiniana.org/libraries/tinygps/
  https://www.pjrc.com/teensy/td_libs_TinyGPS.html
 Código fuente: https://github.com/mikalhart/TinyGPS/
 Librería mejorada: http://arduiniana.org/libraries/tinygpsplus/
 Código fuente: https://github.com/mikalhart/TinyGPSPlus
Anuncios
REPORT THIS AD

REPORT THIS AD

Compártelo:

 Twitter
 Facebook1
 Google

Relacionado
I2CEn "Arduino"
Tema 6 - Comunicaciones con Arduino (4)En "Arduino"
Bus SPIEn "Arduino"
Esta entrada se publicó en Arduino, I2C y está etiquetada con Arduino, I2C, IMU, RTC, TWI en 14
noviembre, 2016.

Funciones definidas por usuario

Deja un comentario

Una función es un bloque de código que tiene un nombre y un conjunto de instrucciones que
son ejecutadas cuando se llama a la función. Son funciones setup() y loop() de las que ya se
ha hablado.

Las funciones de usuario pueden ser escritas para realizar tareas repetitivas y para reducir el
tamaño de un programa. Segmentar el código en funciones permite crear piezas de código
que hacen una determinada tarea y volver al área del código desde la que han sido llamadas.

Las funciones se declaran asociadas a un tipo de valor. Este valor será el que devolverá la
función, por ejemplo ‘int’ se utilizará cuando la función devuelva un dato numérico de tipo
entero. Si la función no devuelve ningún valor entonces se colocará delante la palabra “void”,
que significa “función vacía”
Sintaxis:

tipo nombreFunción (parámetros) {

instrucciones;

Para llamar a una función, simplemente:

nombreFunción(parámetros);

En una función que devuelve un valor siempre debe tener la instrucción Return, este termina
una función y devuelve un valor a quien ha llamado a la
función: http://arduino.cc/en/Reference/Return

Ventajas del uso de funciones:

 Ayuda a tener organizado el código.

 Una función codifica una tarea en un lugar de nuestro sketch, así que la función solo
debe ser pensada una sola vez.
 Reduce la probabilidad de errores al modificar el código.
 Hacen que el tamaño del sketch sea menor porque el código de la función es
reutilizado.
 Facilita la lectura del código.
 Hace más sencillo reutilizar código en otros sketches.

Más información: http://arduino.cc/en/Reference/FunctionDeclaration

Nombres de funciones
Generalmente los nombres de las funciones deben ser en minúscula, con las palabras
separadas por un guión bajo, aplicándose éstos tanto como sea necesario para mejorar la
legibilidad.

“mixedCase” (primera palabra en minúscula) es aceptado únicamente en contextos en donde

éste es el estilo predominante con el objetivo de mantener la compatibilidad con versiones
anteriores.

En el caso de las clases, los nombres deben utilizar la convención “CapWords” (palabras que
comienzan con mayúsculas).

Las funciones en Arduino pueden estar dentro del mismo fichero .ino o en otro fichero con
extensión .ino dentro del directorio del sketch.

Paso por Valor y Paso por Referencia

Hasta ahora siempre hemos declarado los parámetros de nuestras funciones del mismo modo.
Sin embargo, éste no es el único modo que existe para pasar parámetros.

La forma en que hemos declarado y pasado los parámetros de las funciones hasta ahora es la
que normalmente se conoce como “por valor”. Esto quiere decir que cuando el control pasa a
la función, los valores de los parámetros en la llamada se copian a “objetos” locales de la
función, estos “objetos” son de hecho los propios parámetros.

1
int funcion(int n, int m) {
2
n = n + 2;
3 m = m - 5;
4 return n+m;

5 }

7 int a = 10;

int b = 20;
8
Serial.println(funcion(a,b));
9
Serial.println(funcion(10,20));
10

Empezamos haciendo a = 10 y b = 20, después llamamos a la función “funcion” con las

objetos a y b como parámetros. Dentro de “funcion” esos parámetros se llaman n y m, y sus
valores son modificados. Sin embargo al retornar al programa que lo llama, a y b conservan
sus valores originales. Lo que pasamos no son los objetos a y b, sino que copiamos sus
valores a los objetos n y m. Es lo mismo que hacer funcion(10,20), cuando llamamos a la
función con parámetros constantes. Si los parámetros por valor no funcionasen así, no sería
posible llamar a una función con valores constantes o literales.
Las referencias sirven para definir “alias” o nombres alternativos para un mismo objeto. Para
ello se usa el operador de referencia (&).

Por ejemplo:

1 int a;
2 int &r = a;

3 a = 10;

4 Serial.println(r);

En este ejemplo los identificadores a y r se refieren al mismo objeto, cualquier cambio en una
de ellos se produce en el otro, ya que son, de hecho, el mismo objeto. El compilador mantiene
una tabla en la que se hace corresponder una dirección de memoria para cada identificador de
objeto. A cada nuevo objeto declarado se le reserva un espacio de memoria y se almacena su
dirección. En el caso de las referencias, se omite ese paso, y se asigna la dirección de otro
objeto que ya existía previamente. De ese modo, podemos tener varios identificadores que
hacen referencia al mismo objeto, pero sin usar punteros.

Si queremos que los cambios realizados en los parámetros dentro de la función se conserven
al retornar de la llamada, deberemos pasarlos por referencia. Esto se hace declarando los
parámetros de la función como referencias a objetos. Por ejemplo:

1
int funcion(int &n, int &m) {
2
n = n + 2;
3
m = m - 5;
4 return n+m;
5 }

7 int a = 10;

8 int b = 20;

9
Serial.println(funcion(a,b));
10
Serial.println("a = " + String(a) + " b = " + String(b));
11
//es ilegal pasar constantes como parámetros cuando estos son referencias
12
Serial.println(funcion(10,20));
13

En este caso, los objetos “a” y “b” tendrán valores distintos después de llamar a la función.
Cualquier cambio de valor que realicemos en los parámetros dentro de la función, se hará
también en los objetos referenciadas. Esto quiere decir que no podremos llamar a la función
con parámetros constantes, ya que aunque es posible definir referencias a constantes, en este
ejemplo, la función tiene como parámetros referencias a objetos variables. Y si bien es posible
hacer un casting implícito de un objeto variable a uno constante, no es posible hacerlo en el
sentido inverso. Un objeto constante no puede tratarse como objeto variable.

Una const reference es una referencia a que no permite cambiar la variable a través de esa
referencia. Por ejemplo const int &r = a; en r tengo el valor de a pero no puedo cambiar el
valor de a usando r.

No confundir este concepto con el modificador de variable static, que es utilizado para crear
variables que solo son visibles dentro de una función, sin embargo, al contrario que las
variables locales que se crean y destruyen cada vez que se llama a la función, las variables
estáticas mantienen sus valores entre las llamadas a las funciones.

Más información:

 http://c.conclase.net/curso/?cap=015#inicio
 https://aprendiendoarduino.wordpress.com/2016/06/29/variables-2/
 Paso de argumentos por valor: http://www.learncpp.com/cpp-tutorial/72-passing-
arguments-by-value/
 Paso de argumentos de referencia http://www.learncpp.com/cpp-tutorial/73-passing-
arguments-by-reference/
 Paso de argumentos por dirección: http://www.learncpp.com/cpp-tutorial/74-passing-
arguments-by-address/
 Devolución de valores por valor, referencia y dirección: http://www.learncpp.com/cpp-
tutorial/74a-returning-values-by-value-reference-and-address/

Sobrecarga de Funciones

Hay operadores que tienen varios usos, como por ejemplo *, &, << o >>. Esto es lo que se
conoce en C++ como sobrecarga de operadores. Con las funciones existe un mecanismo
análogo, de hecho, en C++, los operadores no son sino un tipo especial de funciones, aunque
eso sí, algo peculiares.

Así que en C++ podemos definir varias funciones con el mismo nombre, con la única condición
de que el número y/o el tipo de los argumentos sean distintos. El compilador decide cuál de
las versiones de la función usará después de analizar el número y el tipo de los parámetros. Si
ninguna de las funciones se adapta a los parámetros indicados, se aplicarán las reglas
implícitas de conversión de tipos.

Las ventajas son más evidentes cuando debemos hacer las mismas operaciones con objetos
de diferentes tipos o con distinto número de objetos. También pueden usarse macros para
esto, pero no siempre es posible usarlas, y además las macros tienen la desventaja de que se
expanden siempre, y son difíciles de diseñar para funciones complejas. Sin embargo las
funciones serán ejecutadas mediante llamadas, y por lo tanto sólo habrá una copia de cada
una.

Ejemplo:

1 int mayor(int a, int b);

2 char mayor(char a, char b);

3 float mayor(float a, float b);

int mayor(int a, int b, int c, int d);

4

5
int mayor(int a, int b) {
6
if(a > b) return a; else return b;
7
}
8

9
char mayor(char a, char b) {
10 if(a > b) return a; else return b;
11 }

12

13 float mayor(float a, float b) {

14 if(a > b) return a; else return b;

15 }

16
int mayor(int a, int b, int c, int d) {
17
return mayor(mayor(a, b), mayor(c, d));
18
}
19

20

Las llamadas a funciones sobrecargadas se resuelven en la fase de compilación. Es el

compilador el que decide qué versión de la función debe ser invocada, después de analizar, y
en ciertos casos, tratar los argumentos pasados en la llamadas. A este proceso se le llama
resolución de sobrecarga.

Tener en cuenta que el tipo de retorno de la función no se considera en la sobrecarga de

funciones. Consideremos el caso en el que desea escribir una función que devuelve un
número aleatorio, pero se necesita una versión que devolverá un entero, y otra versión que
devolverá un doble.

int getRandomValue();
double getRandomValue();

Pero el compilador toma esto como un error. Estas dos funciones tienen los mismos
parámetros (ninguno) y en consecuencia, la segunda getRandomValue () serán tratada como
una redeclaración errónea de la primera. En consecuencia, tendrán que ser dado diferentes
nombres a estas funciones.

Más información:

 http://c.conclase.net/curso/?cap=021
 http://www.learncpp.com/cpp-tutorial/76-function-overloading/
 http://codigomaldito.blogspot.com.es/2005/11/sobrecarga-de-funciones.html
 http://c.conclase.net/curso/?cap=034

Sobrecarga de operadores:

 http://www.learncpp.com/cpp-tutorial/91-introduction-to-operator-overloading/
 https://es.wikibooks.org/wiki/Programaci%C3%B3n_en_C%2B%2B/Sobrecarga_de_O
peradores
 http://www.worldbestlearningcenter.com/index_files/cpp-operator-overloading.htm
 http://stackoverflow.com/questions/17108721/c-operator-overloading-and-templates-
with-arduino

Ámbito de las variables

Una variable puede ser declarada al inicio del programa antes de la parte de configuración
setup(), a nivel local dentro de las funciones, y, a veces, dentro de un bloque, como para los
bucles del tipo if.. for.., etc. En función del lugar de declaración de la variable así se
determinará el ámbito de aplicación, o la capacidad de ciertas partes de un programa para
hacer uso de ella.

Una variable global es aquella que puede ser vista y utilizada por cualquier función y
estamento de un programa. Esta variable se declara al comienzo del programa, antes de
setup().

Recordad que al declarar una variable global, está un espacio en memoria permanente en la
zona de static data y el abuso de variables globales supone un uso ineficiente de la memoria.

Una variable local es aquella que se define dentro de una función o como parte de un bucle.
Sólo es visible y sólo puede utilizarse dentro de la función en la que se declaró. Por lo tanto,
es posible tener dos o más variables del mismo nombre en diferentes partes del mismo
programa que pueden contener valores diferentes, pero no es una práctica aconsejable
porque complica la lectura de código.

En el reference de Arduino hay una muy buena explicación del ámbito de las
variables:http://arduino.cc/en/Reference/Scope

La variables estáticas solo se crean e inicializan la primera vez que la función es llamada. Ver
ejemplo en: http://arduino.cc/en/Reference/Static

Más información:

 http://www.prometec.net/ambito-variables/
 https://aprendiendoarduino.wordpress.com/2016/06/29/variables-2/
Inline

Cuando usamos el nombre de una función, indicando valores para sus argumentos, dentro de
un programa, decimos que llamamos o invocamos a esa función. Esto quiere decir que el
procesador guarda la dirección actual, “salta” a la dirección donde comienza el código de la
función, la ejecuta, recupera la dirección guardada previamente, y retorna al punto desde el
que fue llamada.

Esto es cierto para las funciones que hemos usado hasta ahora, pero hay un tipo especial de
funciones que trabajan de otro modo. En lugar de existir una única copia de la función dentro
del código, si se declara una función como inline, lo que se hace es insertar el código de la
función, en el lugar (y cada vez) que sea llamada. Esta indica al compilador que cada llamada
a la función inline deberá ser reemplazado por el cuerpo de esta función. En la práctica la
función inline es utilizado sólo cuando las funciones son pequeñas para evitar generar un
ejecutable de tamaño considerable.

La palabra reservada inline tiene la ventaja de acelerar un programa si éste invoca

regularmente a la función inline. Permite reducir considerablemente el código, en particular
para los accesadores de una clase. Un accesador de clase es típicamente una función de una
línea.

Ejemplo:

1 inline int mayor(int a, int b) {

2 if(a > b) return a;

3 return b;

4 }

Más información de inline:

 http://es.kioskea.net/faq/2823-la-funcion-inline-en-c
 http://c.conclase.net/curso/?cap=020c
 http://www.cprogramming.com/tutorial/lesson13.html
 http://www.cplusplus.com/articles/2LywvCM9/

Prototipos de Funciones

Primero recordar que en el lenguaje de Arduino al contrario que en estandar C, no es

necesario declarar los prototipos de las funciones, puesto que de eso se encarga el de incluirlo
el arduino builder, al igual que de añadir el main..

En C++ es obligatorio usar prototipos. Un prototipo es una declaración de una función.

Consiste en una presentación de la función, exactamente con la misma estructura que la
definición, pero sin cuerpo y terminada con un “;”.

En general, el prototipo de una función se compone de las siguientes secciones:

  Opcionalmente, una palabra que especifique el tipo de almacenamiento, puede ser
extern o static. Si no se especifica ninguna, por defecto será extern.
 El tipo del valor de retorno, que puede ser void, si no necesitamos valor de retorno.
 Modificadores opcionales.
 El identificador de la función. Es costumbre, muy útil y muy recomendable, poner
nombres que indiquen, lo más claramente posible, qué es lo que hace la función, y que
permitan interpretar qué hace el programa con sólo leerlos.
 Una lista de declaraciones de parámetros entre paréntesis. Los parámetros de una
función son los valores de entrada (y en ocasiones también de salida).

Un prototipo sirve para indicar al compilador los tipos de retorno y los de los parámetros de
una función, de modo que compruebe si son del tipo correcto cada vez que se use esta
función dentro del programa, o para hacer las conversiones de tipo cuando sea necesario.

Normalmente, los prototipos de las funciones se declaran dentro del fichero del programa, o
bien se incluyen desde un fichero externo, llamado fichero de cabecera, (para esto se usa la
directiva #include).

Ya lo hemos dicho más arriba, pero las funciones son extern por defecto. Esto quiere decir
que son accesibles desde cualquier punto del programa, aunque se encuentren en otros
ficheros fuente del mismo programa. En contraposición las funciones declaradas static sólo
son accesibles dentro del fichero fuente donde se definen.

Más información:

 http://c.conclase.net/curso/?cap=003
 arduino builder https://github.com/arduino/arduino-builder
 https://www.programacion.com.py/escritorio/c/los-prototipos-en-c

Bibliotecas/Librerías en C++

Junto con los compiladores de C y C++, se incluyen ciertos archivos llamados bibliotecas más
comúnmente librerías. Las bibliotecas contienen el código objeto de muchos programas que
permiten hacer cosas comunes, como leer el teclado, escribir en la pantalla, manejar números,
realizar funciones matemáticas, etc.

Las bibliotecas están clasificadas por el tipo de trabajos que hacen, hay bibliotecas de entrada
y salida, matemáticas, de manejo de memoria, de manejo de textos y como imaginarás existen
muchísimas librerías disponibles y todas con una función específica.

La declaración de librerías, tanto en C como en C++, se debe hacer al principio de todo

nuestro código, antes de la declaración de cualquier función o línea de código, debemos
indicarle al compilador que librerías usar, para el saber qué términos están correctos en la
escritura de nuestro código y cuáles no. La sintaxis es la siguiente: #include <nombre de la
librería> o alternativamente #include “nombre de la librería”. En tu código puedes declarar
todas las librerías que quieras aunque en realidad no tienen sentido declarar una librería que
no vas a usar en tu programa, sin embargo no existe límite para esto.

La directiva de preprocesador #include se usa en los lenguajes C y C++ para “incluir” las
declaraciones de otro fichero en la compilación. Esta directiva no tiene más misterio para
proyectos pequeños. En cambio, puede ayudar aprovechar bien esta directiva en proyectos
con un gran número de subdirectorios.

Ejemplo:

#include “iostream”
#include “string”
#include <math.h>
using namespace std;

Lo único adicional, es la línea que dice using namespace std; esta línea nos ayuda a declarar
un espacio de nombre que evita tener que usarlo cada que accedemos a alguna función
específica de una librería. Teniendo este namespace declarado podemos llamar por ejemplo
el comando cout >>, que pertenece a la librería iostream, sin embargo sin este namespace
sería std::cout >>, imagina tener que hacer esto cada vez que uses algún comando o función
de las librerías, sería bastante tedioso.

A continuación pondré algunas de las librerías de uso más común de C++ y que forman parte
de las librerías estándar de este lenguaje.

 fstream: Flujos hacia/desde ficheros. Permite la manipulación de archivos desde el

programar, tanto leer como escribir en ellos.
 iosfwd: Contiene declaraciones adelantadas de todas las plantillas de flujos y sus
typedefs estándar. Por ejemplo ostream.
 iostream: Parte del a STL que contiene los algoritmos estándar, es quizá la más usada
e importante (aunque no indispensable).
 math: Contiene los prototipos de las funciones y otras definiciones para el uso y
manipulación de funciones matemáticas.
 memory: Utilidades relativas a la gestión de memoria, incluyendo asignadores y
punteros inteligentes (auto_ptr). “auto_ptr” es una clase que conforma la librería
memory y permite un fácil manejo de punteros y su destrucción automáticamente.
 ostream: Algoritmos estándar para los flujos de salida.
 Librería stdio: Contiene los prototipos de las funciones, macros, y tipos para manipular
datos de entrada y salida.
 Librería stdlib: Contiene los prototipos de las funciones, macros, y tipos para utilidades
de uso general.
 string: Parte de la STL relativa a contenedores tipo string; una generalización de las
cadenas alfanuméricas para albergar cadenas de objetos.
 vector: Parte de la STL relativa a los contenedores tipo vector; una generalización de
las matrices unidimensionales C/C++
 list: Permite implementar listas doblemente enlazadas (listas enlazadas dobles)
fácilmente.
 iterator: Proporciona un conjunto de clases para iterar elementos.
 regex: Proporciona fácil acceso al uso de expresiones regulares para la comparación
de patrones.
 thread: Útil para trabajar programación multihilos y crear múltiples hilos en nuestra
aplicación.

Más información:

 https://www.programarya.com/Cursos/C++/Bibliotecas-O-Librerias
  Biblioteca estandar de
C++: https://es.wikipedia.org/wiki/Biblioteca_est%C3%A1ndar_de_C%2B%2B
 https://trucosinformaticos.wordpress.com/2012/10/14/como-usar-include-en-c-y-c/

Ejercicios Funciones

Ver ejemplo sencillo de uso de funciones: https://github.com/jecrespo/Aprendiendo-

Arduino/tree/master/Ejercicio02-Funciones

Comparar las funciones con librerías: https://github.com/jecrespo/Aprendiendo-

Arduino/tree/master/Ejercicio03-Librerias

Ejercicio: Menú interactivo con Arduino. Con todo lo visto de Strings, operadores, estructuras
de control y funciones, hacer un ejemplo de un menú interactivo donde se dan varias opciones
y pulsando cada una de ellas se ejecuta una acción concreta. Si el valor pulsado no es
ninguna de las opciones avisar y volver a mostrar el menú hasta que se pulse una opción
correcta.

Solución: https://github.com/jecrespo/Aprendiendo-Arduino/tree/master/Ejercicio46-
Estructuras_de_Control

Librerías vs Funciones en Arduino

Como se ha visto anteriormente, las librerías son trozos de código hechas por terceros que
usamos en nuestro sketch. Esto nos facilita mucho la programación y hace que nuestro
programa sea más sencillo de hacer y luego de entender. Más adelante veremos cómo hacer
una librería.

Las librerías en Arduino incluyen los siguientes archivos comprimidos en un archivo ZIP o
dentro de un directorio. Estas siempre contienen:

 Un archivo .cpp (código de C++)

 Un archivo .h o encabezado de C, que contiene las propiedades y métodos o
funciones de la librería.
 Un archivo Keywords.txt, que contiene las palabras clave que se resaltan en el IDE
(opcional).
 Muy posiblemente la librería incluye un archivo readme con información adicional de lo
que hace y con instrucciones de como usarla.
 Directorio denominado examples con varios sketchs de ejemplo que nos ayudará a
entender cómo usar la librería (opcional).

Más información: https://aprendiendoarduino.wordpress.com/2016/06/27/librerias-3/

Una librería a diferencia de las funciones debe estar al menos en un fichero diferente con
extensión .h y opcionalmente en otro .cpp y además debe ser llamada con #include desde el
sketch de arduino y estar en una ruta accesible desde el IDE de Arduino, ya sea el mismo
directorio del sketch o en algunas de las rutas configuradas para librerías.

La ventaja de usar librerías frente a las funciones es que no es necesario incluir el código cada
vez que se va a reutilizar sino que con tener la librería instalada en el IDE y llamarla mediante
#include ya la puedo usar en mi código.
Al llamar a una librería desde un sketch, la librería completa es cargada a la placa de Arduino
incrementando el tamaño del espacio usado en el microcontrolador, tanto en la memoria flash
como en la RAM.

NOTA: Como instalar una librería de github: http://scidle.com/install-github-libraries-on-

arduino-ide/ habla de quitar caracteres no ASCII, pero comprueba también que no funcione
porque haya subdirectorios.

Las librerías que usamos para los sketches tienen una versión, que se suelen actualizar con
frecuencia. También tenemos un control de versiones en el nuevo IDE a partir de 1.6.4 que
nos facilita la gestión de la versión de las librerías usadas. Este aspecto es importante porque
un sketch que funciona con una versión de una librería es posible que al compilarlo con otra
versión en otro IDE no funcione. Por ello es importante documentar con que versión de librería
está hecho o distribuir el sketch con la librería con la que se ha creado. Generalmente las
librerías tienen compatibilidad hacia atrás, pero puede que no ocurra o que el comportamiento
de la librería sea diferente.

Al cambiar el IDE también nos podemos encontrar que nuestro sketch no es compatible con la
versión de la librería que estemos usando, que es diferente con la que se diseñó originalmente
el sketch.

Listado de librerías: http://playground.arduino.cc/Main/LibraryList

Ejercicio Librerías vs Funciones

Ya hemos visto lo que son las librerías y las funciones definidas por usuario, el uso de unas u
otras dependerá de varios factores como la posibilidad de reutilización del código o la
experiencia del programador con el uso de librerías.

Ejemplos simples de librerías:

 https://github.com/jecrespo/Aprendiendo-Arduino/tree/master/Ejercicio03-Librerias
 https://github.com/jecrespo/Aprendiendo-Arduino/tree/master/Ejercicio44-Test_Library
Anuncios
REPORT THIS AD

REPORT THIS AD

Compártelo:

 Twitter
 Facebook1
 Google

Relacionado
Funciones Definidas por UsuarioEn "Arduino"
Funciones definidas por usuarioEn "Arduino"
Funciones Definidas por UsuarioEn "Arduino"
Esta entrada se publicó en Arduino, C++, Funciones, Librerías, Programación y está etiquetada
con Arduino, C++, Funciones, Librerías Arduino, Programación en 16 noviembre, 2016.
Librerías Arduino
2 respuestas

Manejar Librerías Arduino

Las librerías son trozos de código hechas por terceros que usamos en nuestro sketch. Esto
nos facilita mucho la programación y permite la abstracción haciendo que nuestro programa
sea más sencillo de hacer y de entender. En este apartado también veremos cómo escribir o
modificar librerías.

Disponemos de infinidad de librerías a nuestra disposición para facilitarnos el trabajo, todas

ellas son open source y disponemos de su código.

Las librerías normalmente incluyen los siguientes archivos comprimidos en un archivo ZIP o
dentro de un directorio. Estas siempre contienen:

 Un archivo .cpp (código de C++)

 Un archivo .h o encabezado de C, que contiene las propiedades y métodos o
funciones de la librería.
 Un archivo Keywords.txt, que contiene las palabras clave que se resaltan en el IDE
(opcional).
 Muy posiblemente la librería incluye un archivo readme con información adicional de lo
que hace y con instrucciones de como usarla.
 Directorio denominado examples con varios sketchs de ejemplo que nos ayudará a
entender cómo usar la librería (opcional).

La distintas formas de instalar librerías se puede ver

en https://aprendiendoarduino.wordpress.com/2016/06/27/librerias-3/

Para usar una librería que acabamos de instalar, lo que hay que hacer es leer la
documentación de esa librería si es que está disponible y luego leer y probar los ejemplos que
dispone la librerías.

Pero ahora que ya sabemos manejar clases y objetos, si queremos entrar a fondo en una
librería para saber usarla, podemos abrir el fichero del encabezado (.h) y ver las propiedades y
métodos, ver si hereda de otra librería, etc… y luego incluso ver cómo funciona la propia
librería leyendo el código en el fichero .cpp e incluso si nos atrevemos añadir nuevos métodos
o modificar un método que nos interese.

Problemas comunes con las librerías: https://learn.adafruit.com/adafruit-all-about-arduino-

libraries-install-use/common-library-problems

Con el nuevo gestor de librerías es mucho más fácil gestionar las librerías instaladas así como
su versión y actualización, algo que antes había que hacer manualmente

El listado de librerías se actualiza de internet y se guarda en:

 C:\Users\usuario\AppData\Local\Arduino15\library_index.json

Las placas se actualiza de internet (del gestor de tarjetas) y se guarda en:

  C:\Users\usuario\AppData\Local\Arduino15\package_index.json

El fichero library_index.json se actualiza al abrir el IDE y en caso de tener problemas, se

puede borrar y se genera de nuevo al abrir el IDE.

Es importante darse de alta en github puesto que nos permite estar al día de las novedades en
las librerías y recibir notificaciones cada vez que haya una modificación en las mismas.
Además podemos fácilmente actualizar nuestro repositorio de librerías con el comando PULL
de git y poner una u otra versión en nuestro repositorio con el comando checkout.

Librería Time y Timezone

Como ejemplo para aprender a usar una librería, veamos las librerías Time y Timezone.

 Librería Time: https://github.com/PaulStoffregen/Time

 Librería Timezone: https://github.com/JChristensen/Timezone

Para aprender a manejarlas, simplemente leer el fichero readme que viene en el repositorio de
github y luego los ejemplos.

Algunas funciones librería Time:

 hour(); // the hour now (0-23)

 minute(); // the minute now (0-59)
 second(); // the second now (0-59)
 day(); // the day now (1-31)
 weekday(); // day of the week, Sunday is day 0
 month(); // the month now (1-12)
 year(); // the full four digit year: (2009, 2010 etc)
 hourFormat12(); // the hour now in 12 hour format
 isAM(); // returns true if time now is AM
 isPM(); // returns true if time now is PM
 now(); // returns the current time as seconds since Jan 1 1970
 setSyncProvider(getTimeFunction); // set the external time provider
 setSyncInterval(interval); // set the number of seconds between re-sync

Algunas funciones librería Timezone:

 time_t toLocal(time_t utc); Converts the given UTC time to local time, standard or
daylight as appropriate.
 TimeChangeRule myRule = {abbrev, week, dow, month, hour, offset};
 abbrev is a character string abbreviation for the time zone; it must be no longer than
five characters.
 week is the week of the month that the rule starts.
 dow is the day of the week that the rule starts.
 hour is the hour in local time that the rule starts (0-23).
 offset is the UTC offset in minutes for the time zone being defined.

Ejemplos:

 TimeChangeRule usEDT = {“EDT”, Second, Sun, Mar, 2, -240}; //UTC – 4 hours

  TimeChangeRule usEST = {“EST”, First, Sun, Nov, 2, -300}; //UTC – 5 hours

Una vez visto el manual de la librería, veamos cómo está escrita la librería Time de Arduino
que nos ofrece funcionalidades para mantener la fecha y hora con un hardware externo o sin
él. Nos permite obtener la fecha y hora como: segundo, minuto, hora, día, mes y año. También
da el tiempo con el tipo de dato del estándar C time_t, siendo sencillo el cálculo del tiempo
transcurrido.

Existe una nueva versión de la librería Time cuyo código está derivado librería DateTime del
Arduino Playground pero está actualizada para ofrecer una API que es más flexible y fácil de
usar.

 Nueva librería Time: http://www.pjrc.com/teensy/td_libs_Time.html

 Código librería Time: https://github.com/PaulStoffregen/Time
 Arduino Time Library: http://playground.arduino.cc/Code/Time

Más información de la librería time: http://www.prometec.net/time-arduino/

La librería Time no requiere de ningún HW especial. Internamente depende de la función

millis() de Arduino para llevar un registro del tiempo transcurrido. El tiempo se puede
sincronizar con varios tipos de HW como GPS, NTP, RTC, etc…

Veamos cómo está escrita la librería. El código lo encontramos

en https://github.com/PaulStoffregen/Time. En el readme.txt explica con detalle el uso de la
librería. Explica las funciones disponibles, los ejemplos dentro del directorio examples y el
funcionamiento interno de la librería. también hay un fichero keywords.txt con las palabras
clave que se van a resaltar en el IDE.

También pueden verse los ficheros:

 library.json – Información de la librería

 library.properties – datos de la librería y clasificación que sale en el Gestor de Librerías

Los ficheros que componen la librería son:

 Time.h — Simplemente incluye a TimeLib.h, se hace por temas de compatibilidad

 TimeLib.h — Fichero de cabecera de la libreria Time.
 Time.cpp — código de la librería time
 DateStrings.cpp — contiene los strings de las fecha en inglés, pero se podría hacer
una versión modificada para español.

Fichero TimeLib.h:

 #ifdef __cplusplus permite a la sección del programa que está dentro ser compilado
solo si la macro especificada como parámetro de ha definido. en este caso
__cplusplus es una macro definida cuando el compilador de c++ está en uso. Esto se
usa para comprobar si una cabecera está compilada bajo C o C++
 #include <inttypes.h> incluye la cabecera de inttypes.h que está en C:\Program Files
(x86)\Arduino\hardware\tools\avr\avr\include, cuyo propósito es proveer un conjunto de
tipos de enteros cuyas definiciones sean consistentes en todas las máquinas e
independientes de sistemas operativos. Define una serie de macros para usar con
 printf y scanf, así como funciones para trabajar con el tipo de dato intmax_t que es un
entero con el máximo de anchura soportado.
Ver http://www.cplusplus.com/reference/cstdint/
 Se define el tipo de dato http://www.cplusplus.com/reference/ctime/time_t/ del estandar
C++ que no dispone el avr libc y se “simula” la librería time.h de C++ que no tiene
implementada AVR.
 Se definen una serie de variables enumeradas con typedef enum y typedef struct
 Se definen unas macros para convertir los años de tmYear a un valor de 4 dígitos
 El valor de domingo es 1 como se puede ver en:
typedef enum {dowInvalid, dowSunday, dowMonday, dowTuesday, dowWednesday,
dowThursday, dowFriday, dowSaturday} timeDayOfWeek_t; y como lo define en la
macro #define dayOfWeek(_time_)
 Se definen luego las funciones y se puede ver que hay sobrecarga en las funciones.
Por ejemplo en la función setTime que puede ajustar el tiempo pasando un time_t o los
datos de hora, minuto, segundo, día, mes y año.

Ficheros Time.cpp y DateStrings.cpp:

 La función más importante es now() que calcula el numero de segundo transcurridos

desde la última llamada a now()
 En la función now() es donde comprueba si toca sincronizar de nuevo la hora con
(nextSyncTime <= sysTime)
 En la variable sysTime se guarda la hora, es una variable privada.
 Se definen primero las funciones públicas en Time.cpp y luego las funciones de bajo
nivel.
 Para sincronizar la hora externamente se definen las funciones:
 setSyncProvider(getTimeFunction); // set the external time provider
 setSyncInterval(interval); // set the number of seconds between re-sync
 En DateStrings.cpp está la definición de los strings de fechas. Los strings los guarda
en la memoria flash para no ocupar memoria RAM. Para ello usa PROGMEM y si no
es para AVR, define el PROGMEM y las funciones de progmem de AVR.
 Se modifican las funciones que devuelven el string del día y del mes pasando el entero
con el número de día o mes.

Adicionalmente tenemos otras librería:

 Time Alarms Library que ejecuta funciones a horas específicas usando junto con la
librería Time: http://www.pjrc.com/teensy/td_libs_TimeAlarms.html y
código https://github.com/PaulStoffregen/TimeAlarms
 DS1307RTC que permite acceder al RTC con chip compatible con el DS1307 usado
con la librería Time http://www.pjrc.com/teensy/td_libs_DS1307RTC.html. Y también
está la alternativa https://github.com/adafruit/RTClib y ejemplo de
uso https://learn.adafruit.com/ds1307-real-time-clock-breakout-board-kit/overview

La librería Time no dispone de ajuste de hora por zona horaria (time zone o TZ) ni ajuste de
DST (Daylight Saving Time): https://en.wikipedia.org/wiki/Daylight_saving_time. Se podría
añadir estas funcionalidades a la librería Time o se puede crear una nueva librería que
implemente estas funcionalidades y haga uso de la librería Time.

Para solucionar esta carencia disponemos de la librería Time

zone https://github.com/JChristensen/Timezone. Esta librería no es accesible desde el gestor
de librerías, por lo que habrá que hacer una instalación manual de la misma.
La librería Timezone está diseñada para trabajar en conjunto con la librería Time y debe ser
referenciada en el sketch que se use con timezone. Esta librería convierte el Universal
Coordinated Time (UTC) a la hora local correcta incluso si hay Daylight Saving Time (DST). La
hora puede obtenerse de un GPS, NTP server o un RTC.

La librería Timezone implementa dos objetos para facilitar la conversión de zona:

 Un objeto TimeChangeRule que describe cuando la hora local cambia de hora

estándar a hora de verano y viceversa.
 Un objeto Timezone que usa TimeChangeRule para hacer las conversiones y las
funciones relacionadas. También puede escribir y leer de la EEPROM el
TimeChangeRule. Es posible implementar varias zonas horarias definiendo varios
objetos Timezone.

Para establecer la TimeChangeRule se hace mediante dos reglas por zona, una para definir
cuando comienza el horario de verano y otra cuando comienza el horario estándar. En España
el cambio de horario se produce el último domingo de octubre a las 3.00 y el último domingo
de marzo a las 2.00 (https://es.wikipedia.org/wiki/Horario_de_verano_en_el_mundo)

Definir un Timezone:

 TimeChangeRule SDT = {“SDT”, Last, Sun, Mar, 2, 60}; //Spain Daylight Time UTC +
0 hours
TimeChangeRule SST = {“SST”, Last, Sun, Oct, 3, 180}; //Spain Standard Time UTC
+ 1 hours
 Timezone spainTZ(SDT,SST)

Métodos asociados:

 toLocal(time_t utc) — Convierte la hora obtenida en UTC a hora local

Ficheros librería:

 Timezone.h
 Implementa compatibilidad con IDEs Arduino anteriores a version 1.x comprobando la
versión de ARDUINO
 Incluye la librería Time
 Define las constantes de los nombres con enum y el número de inicio. Define como día
1 el Domingo en lugar del Lunes
 TimeChangeRule es un struct con el nombre (abbrev), 4 bytes para: semana, día de la
semana, mes y hora y un entero para el offset de la zona horaria
 Clase Timezone con dos constructores, 7 métodos públicos, 2 métodos privados y 6
variables privadas.
 Timezone.cpp
 __AVR__ es una macro que indica si el compilador puede usar procesadores AVR y
en ese caso uso la librería EEPROM
 Puedo construir un objeto Timezone con el par de reglas DST o si la tengo guarda en
la EEPROM, pasando la dirección donde la tengo guardada.
 calcTimeChanges() calcula el nuevo dst start y std start al llamarlo.
 Al usar toLocal() ya autocalculo las fechas de dst start y std start. Ver
ejemplo https://github.com/JChristensen/Timezone/blob/master/examples/Clock/Clock.
pde
Más información del uso de la librería Timezone en:

 https://github.com/JChristensen/Timezone
 Hilo de http://forum.arduino.cc/index.php?topic=96891.0
 http://forum.arduino.cc/index.php?topic=224917.0
 http://forum.arduino.cc/index.php?topic=197637.0

NOTA: la librería timezone no soporta

leapsecond https://es.wikipedia.org/wiki/Segundo_intercalar pero podría implementarse en la
librería. Ver http://stackoverflow.com/questions/9168970/arduino-leap-second-clock

Crear Librerias Arduino

Las librerías son trozos de código hechos por terceros que usamos en nuestro sketch. Esto
nos facilita mucho la programación y permite la abstracción haciendo que nuestro programa
sea más sencillo de hacer y de entender. En este apartado veremos cómo escribir o modificar
librerías.

Librerías Arduino: https://www.arduino.cc/en/Main/Libraries

El IDE de Arduino incluye una serie de librerías ya

instaladas: https://www.arduino.cc/en/Reference/Libraries

Listado de librerías del playground de Arduino: http://playground.arduino.cc/Main/LibraryList,

pero existen otras muchas librerías creadas por usuarios o por los fabricantes de HW para
facilitar el uso de esos dispositivos con Arduino.

Este tutorial explica como crear una

librería: http://arduino.cc/en/Hacking/LibraryTutorial.Explica cómo convertir la función morse en
en una librería.

Ejemplo morse.ino

int pin = 13;

void setup()
{
pinMode(pin, OUTPUT);
}

void loop()
{
dot(); dot(); dot();
dash(); dash(); dash();
dot(); dot(); dot();
delay(3000);
}

void dot()
{
digitalWrite(pin, HIGH);
delay(250);
 digitalWrite(pin, LOW);
delay(250);
}

void dash()
{
digitalWrite(pin, HIGH);
delay(1000);
digitalWrite(pin, LOW);
delay(250);
}

Para convertir en una librería de código morse, vemos que hay dos funciones dot() y dash()
para iluminar un led durante 250 ms y 1 segundo y una variable que es ledPin que determina
que pin usar. Este es un estilo de programación clásico usando funciones en lugar de objetos.

Para una librería se necesitan al menos dos ficheros:

 Un fichero de cabecera con la extensión .h. Este fichero tiene las definiciones de la
librería, básicamente un listado de todo lo que hay dentro de la librería
 Un fichero fuente con la extensión .cpp. Este fichero el que contiene el código

En este caso la librería se va a llamar morse y generamos un fichero de cabecera llamado

morse.h.

Veamos el código de morse.h donde se define la clase Morse donde tiene una línea por cada
función o método y también una línea por cada variable o propiedad de la clase.

class Morse
{
public:
Morse(int pin); //constructor
void dot();
void dash();
private:
int _pin;
};

Una clase es una colección de funciones (métodos) y variables (propiedades) que se guardan
todas juntas en un solo lugar. Las funciones pueden ser públicas (public), es decir, pueden
llamarse por quien usa la librería o privadas (private), es decir, que solo pueden llamarse
desde dentro de la propia clase. Todas las clases tienen una función llamada constructor, que
es usada para crear una instancia de la clase. El constructor tiene el mismo nombre que la
clase y no tiene tipo de variable de devolución.

En el fichero de cabecera de una librería es necesario la declaración #include que de acceso a

los tipos y constantes estándar del lenguaje de Arduino (esto se añade automáticamente en
los sketches pero no a las librerías). Esta declaración debe ponerse antes de la definición de
la clase. La declaración debe ser:

 Versión IDE 1.x: #include “Arduino.h”

 Versión IDE 0.x: #include “WProgram.h”
También es común poner todo el fichero de cabecera entre estas instrucciones:

#ifndef Morse_h
#define Morse_h
// the #include statment and code go here…
#endif

Esto evita problemas si alguien accidentalmente incluye dos veces la librería, lo que
provocaría un error de compilación. A esto se llama guardián de inclusión múltiple o include
guard

// Guardián de inclusión múltiple

#ifndef FICHERO_YA_INCLUIDO
#define FICHERO_YA_INCLUIDO

Así se evita que un compilador poco sofisticado abra otra vez el mismo conjunto de ficheros
cuando se incluye un fichero de cabecera dos o más veces. Puede darse el caso de no poner
las inclusiones en el inicio de un fichero.

La directiva #include existe en dos versiones. En una se pone el nombre de fichero entre
comillas, en la otra entre paréntesis angulares (el signo menor y mayor como “comillas”).

#include “fichero_con_comillas.h”
#include <fichero_entre_menor_y_mayor.h>

La versión con los paréntesis angulares busca los ficheros en todos los directorios que se han
especificado en la llamada al compilador – normalmente con la opción “-I”. Estos directorios se
suelen rastrear por el fichero incluido en el orden en que aparecen en la línea de comando.

Cuando se incluye un fichero entre comillas, entonces el compilador busca este fichero
primero en el mismo directorio que el fichero actualmente compilado y después en los demás
directorios. Es decir, la versión con comillas se diferencia de la versión con paréntesis
angulares únicamente por buscar primero en el directorio del fichero compilado. Tras no
encontrarlo ahí actaa igual.

Cuando se crea una librería se debe documentar poniendo un comentario al comienzo de la

librerías con el nombre, breve descripción, quien la ha escrito, fecha, licencia, etc…

El fichero de cabecera queda:

/*
Morse.h - Library for flashing Morse code.
Created by David A. Mellis, November 2, 2007.
Released into the public domain.
*/
#ifndef Morse_h
#define Morse_h

#include "Arduino.h"

class Morse
{
 public:
Morse(int pin);
void dot();
void dash();
private:
int _pin;
};

#endif

Una vez hecho el fichero de cabecera hay que codificar el fichero fuente Morse.cpp

Primero deben ponerse las declaraciones, esto da al resto de código acceso a las funciones
estándar de Arduino y a las definiciones del fichero de cabecera:

#include “Arduino.h”
#include “Morse.h”

Lo siguiente es poner el constructor de la clase. Esto define que ocurre cuando se crea una
instancia de la clase. En este caso el usuario debe especificar cual es el pin que se va a usar.
Configuramos el pin como salida y los guardamos en una variable privada para usarlo desde
otras funciones.

Morse::Morse(int pin)
{
pinMode(pin, OUTPUT);
_pin = pin;
}

El código “Morse::” antes del nombre de la función indica que la función es parte de la clase
Morse. Esto se ve en todas las funciones de la clase. La variable llamada “_pin” es una
variable privada tal y como se ha definido en el fichero de cabecera y se pone el simbolo “_”
delante por convención para indicar que es privada y para diferenciarlo del argumento de la
función, pero puede llamarse de cualquier forma mientras coincida con la definición en el
fichero de cabecera.

Después de definir el constructor, se deben definir las funciones o métodos de la clase. Son
las funciones que se habían definido anteriormente en el sketch:

void Morse::dot()
{
digitalWrite(_pin, HIGH);
delay(250);
digitalWrite(_pin, LOW);
delay(250);
}

void Morse::dash()
{
digitalWrite(_pin, HIGH);
delay(1000);
digitalWrite(_pin, LOW);
delay(250);
}

También es habitual añadir el comentario del fichero al principio del fichero. El fichero
Morse.cpp queda de la siguiente forma:

/*
Morse.cpp - Library for flashing Morse code.
Created by David A. Mellis, November 2, 2007.
Released into the public domain.
*/

#include "Arduino.h"
#include "Morse.h"

Morse::Morse(int pin)
{
pinMode(pin, OUTPUT);
_pin = pin;
}

void Morse::dot()
{
digitalWrite(_pin, HIGH);
delay(250);
digitalWrite(_pin, LOW);
delay(250);
}

void Morse::dash()
{
digitalWrite(_pin, HIGH);
delay(1000);
digitalWrite(_pin, LOW);
delay(250);
}

De esta forma ya tenemos una librería completa. Ahora para incluirla en nuestro IDE debemos
crear un directorio Morse dentro del subdirectorio “libraries” del directorio de nuestro entorno
de trabajo definido en las propiedades del IDE. Copiar Morse.h y Morse.cpp dentro del
directorio Morse y abrir o reiniciar el IDE de Arduino. A partir de este momento veremos
nuestra librería disponible en el IDE y podremos incluirla en los sketches con la declaración
#include <Morse.h>. La librería será compilada por los sketches que la usen.

El anterior sketch quedaría ahora sustituido por:

#include <Morse.h>

Morse morse(13);

void setup()
{
}
void loop()
{
morse.dot(); morse.dot(); morse.dot();
morse.dash(); morse.dash(); morse.dash();
morse.dot(); morse.dot(); morse.dot();
delay(3000);
}

Podemos ver que primero se llama a la declaración de la librería Morse. Esto hace que la
librería esté disponible en el sketch y lo incluye en el código enviado a la placa Arduino, lo que
hace que si la librería es muy pesada, ocupe mucha más memoria nuestro sketch y si no voy a
usar una librería es mejor no incluirla para ahorrar espacio.

También observamos que creamos una instancia de la clase Morse llamada “morse”. Al
ejecutar esta línea el constructor de la clase es llamado pasando un argumento, creando así el
objeto “morse” en nuestro sketch. Luego podemos llamar a los métodos dot() y dash()
precedidos del prefijo morse del nombre del objeto.

Es posible tener múltiples instancias de la clase Morse, cada una un pin diferente guardado en
la variable privada “_pin”.

Si creamos una librería es conveniente crear el fichero keywords.txt dentro del directorio
Morse. De esta forma conseguiremos resaltar las palabras clave que definamos en el fichero
keywords. En cada línea del fichero keywords.txt se indica el nombre de la palabra clave y
seguido por un tabulador, el tipo de keyword.

 Las clases deben ser del tipo KEYWORD1 que se resaltan en naranja.
 Las funciones deben ser del tipo KEYWORD2 que se resaltan en marrón

Para que el fichero keywords.txt se aplique al IDE es necesario reiniciar el IDE.

El fichero keywords.txt quedaría:

Morse KEYWORD1
dash KEYWORD2
dot KEYWORD2

También es aconsejable ofrecer ejemplos de uso de la librería para que los posibles usuarios
sepan usarla. Esto se hace creando un directorio “examples” dentro del directorio Morse y
añadir en el subdirectorio los sketches de ejemplos que serán visibles desde el IDE.

La librerías morse con los ejemplos y el fichero keywords.txt se puede descargar

en: http://www.arduino.cc/en/uploads/Hacking/Morse.zip

Para más información sobre la creación de librerías con un buen “estilo Arduino”, ver la Guía
de Estilo de API. Guia de estilo para escribir
librerías: http://arduino.cc/en/Reference/APIStyleGuide

Ver ejemplos simples de librerías:

 https://github.com/jecrespo/Aprendiendo-Arduino/tree/master/Ejercicio03-Librerias
  https://github.com/jecrespo/Aprendiendo-Arduino/tree/master/Ejercicio44-Test_Library
 https://github.com/jecrespo/Aprendiendo-Arduino/tree/master/Ejercicio56-
Libreria_Morse

Más información:

 https://www.arduino.cc/en/Hacking/LibraryTutorial
 https://www.arduino.cc/en/Reference/APIStyleGuide

Guía de estilo para escribir una librería de Arduino

Para facilitar el entendimiento de las librerías o APIs de Arduino y hacer que el entorno de
Arduino sea más homogéneo, desde arduino.cc dan unas pautas para escribir librerías al
“estilo Arduino”. Algunas de estas prácticas van en contra de la programación programación
profesional, pero esto hace posible a los principiantes comenzar a trabajar de forma sencilla
con Arduino.

 Se amable con el usuario. Tener una modelo claro del concepto que va tratar la librería
y las funciones que se van a implementar.
 Organizar las funciones pública alrededor de los datos y funcionalidades que el
usuario quiere. Frecuentemente el conjunto de comandos para un módulo electrónico
son demasiado complicado, pero podemos reorganizar las funciones desde un punto
de vista de uso a alto nivel. Pensar en lo que hace la mayoría de las personas y
organizar la API en función de ese uso. Un ejemplo es la
librería https://github.com/adafruit/Adafruit-BMP085-Library. La función readPressure()
hace todos los pasos para obtener la presión final, siendo transparente para el usuario
todos los complejos pasos intermedios. Esto abstrae al usuario no solo de los
comandos I2C necesarios, sino de de los cálculos intermedios.
 Usar palabras claras para escribir la librerías. Usar nombres de funciones y variables
claros que expresen claramente lo que son o hacen y no usar términos técnicos.
 Evitar palabras que tengan diferente significado para el público en general.
 Documentar todo. Al escribir ejemplos usar esta
guía: http://www.arduino.cc/en/Reference/StyleGuide
 Usar las librerías del core de Arduino y su estilo:
 Usar read() para leer entradas y write() para escribir salidas
 Usar las librerías Stream.h y print.h cuando se estén manejando byte streams. Si no
es posible al menos intentar usar su modelo de API.
 Para aplicaciones de redes, usar las librerías de Client y Server como base.
 Usar begin() para inicializar unas instancia de una librería, normalmente con unos
parámetros de configuración. Usar end() para finalizarla.
 Usar funciones camel case, no con guión bajo. Por ejemplo analogRead en lugar de
analog_read. Esto es una adopción de processing por motivos de facilidad la lectura.
 No usar nombre de constantes largos que son difíciles de leer.
 Evitar usar argumentos booleanos. En su lugar es preferible ofrecer dos funciones
diferentes con nombres que describan la diferencia entre ellas.
 No asumir conocimiento de punteros. Los principiantes en C suelen encontrar
dificultades con el uso de & y *, en la medida de lo posible tratar de evitar el uso de
punteros.
 Al usar la comunicación serie de cualquier tipo, permitir al usuario especificar el objeto
de stream en lugar de solo “Serial”, esto hará la librería compatible con los los puertos
del Arduino Mega y Due y también poder usar interfaces alternativos como el
SoftwareSerial. ver el uso de begin(Stream &serial) en las
 librerías https://github.com/firmata/arduino y https://github.com/andrewrapp/xbee-
arduino
 Cuando se escriba una librería que ofrezca comunicación byte-stream heredada de la
la clase Stream de Arduino, de forma que la librería pueda ser usada por otras librerías
que acepte objetos Stream: si es posible, el método read() inmediatamente accede a
los datos del buffer sin esperar a que lleguen más datos y si es posible el método
write() debe guardar los datos al buffer de transmisión, pero debe esperar si el buffer
no tiene suficiente espacio para guardar inmediatamente todo los datos salientes. La
función yield() debe llamarse mientras se espera. De esta forma mantenemos
compatibilidad con el restos de librerías Stream.

Unos ejemplos de librerías que definen realmente bien las funciones de alto nivel son:

 https://github.com/adafruit/Adafruit-BMP085-Library
 https://github.com/adafruit/DHT-sensor-library

Viendo los métodos públicos que definen es muy fácil entender que es lo que hacen.

Otro buen ejemplo de abstracción de la librerías wire (I2C) se puede ver

en: https://github.com/adafruit/RTClib donde con una serie de métodos obtengo los datos del
RTC siendo totalmente transparente para el usuario el uso de la librería wire.

Es frecuente que nos encontremos que algunas librerías se quedan cortas para algunas
funcionalidades avanzadas, puesto que como se ha visto en la guía de estilo se tiende a
simplificar. Un ejemplo de esto es la librería ethernet donde muchas de las funcionalidades del
Wiznet 5100 no están implementadas en la librería, pero esto no impide que nosotros
podamos añadirlas.

Más información: https://www.arduino.cc/en/Reference/APIStyleGuide

Modificar librerías

Es habitual que al usar una librería necesitemos una propiedad o un método que no esté
implementado o queramos modificar el comportamiento, para ello podemos modificar
localmente la librería que tengamos instalada en nuestro IDE.

En el caso que queramos colaborar en una librería hecha, podemos hacer un fork de esa
librería en nuestra cuenta de github y añadir una nueva funcionalidad o corregir ese fallo e
incluso podemos hacer un pull request para que se añada en la librería original nuestra
modificación. También podemos tener nuestra propia librería como un fork de la librería
original.

Un pull request es una petición que el propietario de un fork de un repositorio hace al

propietario del repositorio original para que este último incorpore los commits que están en el
fork. Explicación de pull request: http://aprendegit.com/que-es-un-pull-request/

Para modificar la librería time y añadir una funcionalidad, lo primero es hacer un fork del
código https://github.com/PaulStoffregen/Time en tu repositorio, en mi caso
en https://github.com/jecrespo/Time y luego clonarlo en el ordenador para modificarlo.

Ejercicios Librerías
Modificar Librería Ethernet

Ver como averiguar la IP de quien se ha conectado y modificar librería ethernet para

implementar un método que de devuelva la IP de origen.

Librería ethernet modificada en https://github.com/jecrespo/Aprendiendo-

Arduino/tree/master/Otros/Ethernet%20Modificada

Crear una librería para NTP

Ejercicio: A partir del ejemplo de Arduino para obtener la hora de un servidor

NTP https://www.arduino.cc/en/Tutorial/UdpNtpClient, crear una librería para obtener de forma
sencilla la hora con una llamada a la función readNTP().

Ver Ejercicio39-NTP para obtener fecha y hora en Arduino sin necesidad de un RTC usando
NTP: https://github.com/jecrespo/Aprendiendo-Arduino/tree/master/Ejercicio39-NTP

Basado en:

 https://github.com/PaulStoffregen/Time TimeNTP example

 https://www.arduino.cc/en/Tutorial/UdpNtpClient
 http://playground.arduino.cc/Code/NTPclient

Protocolo:

 https://es.wikipedia.org/wiki/Network_Time_Protocol
 https://en.wikipedia.org/wiki/Network_Time_Protocol
 epoch converter: http://www.epochconverter.com/

Las firmas de tiempo que se usan en NTP, son de 32 bits indicando la parte entera en
segundos desde el 1 de Enero de 1900, y una parte fraccionaria también de 32 bits. Por ello
la resolución teórica de NTP sería de 232 segundos =136 años, y una resolución teórica de
2E-32 segundos, o sea 0,233 nanosegundos.

Nota: Ojo al llamar al constructor de algo p.e. ethernet sin hacer el begin ethernet antes.

Solución: https://github.com/jecrespo/simpleNTP
Anuncios
Compártelo:

 Twitter
 Facebook1
 Google

Relacionado
LibreríasEn "Arduino"
Librerías ArduinoEn "Arduino"
Librerías ArduinoEn "Arduino"
Esta entrada se publicó en Arduino, Librerías, Programación y está etiquetada con Arduino, Librerías
Arduino, Programación, time, timezone en 16 noviembre, 2016.

ZigBee/XBee
10 respuestas

ZigBee

IEEE 802.15.4 es un estándar que define el nivel físico y el control de acceso al medio de
redes inalámbricas de área personal con tasas bajas de transmisión de datos (low-rate
wireless personal area network, LR-WPAN). El grupo de trabajo IEEE 802.15 es el
responsable de su desarrollo. También es la base sobre la que se define la especificación
de ZigBee, cuyo propósito es ofrecer una solución completa para este tipo de redes
construyendo los niveles superiores de la pila de protocolos que el estándar no cubre.

IEEE802.15.4:

 https://es.wikipedia.org/wiki/IEEE_802.15.4
 https://en.wikipedia.org/wiki/IEEE_802.15.4
 http://www.ieee802.org/15/pub/TG4.html
 https://es.wikipedia.org/wiki/IEEE_802.15

El estandar 802.15.4
simplificado: http://catarina.udlap.mx/u_dl_a/tales/documentos/lem/archundia_p_fm/capitulo4.p
df

Bluetooth y RFID se encuentran en el grupo de trabajo 802.15.

ZigBee es el nombre de la especificación de un conjunto de protocolos de alto nivel de

comunicación inalámbrica para su utilización con radiodifusión digital de bajo consumo,
basada en el estándar IEEE 802.15.4 de redes inalámbricas de área personal (wireless
personal area network, WPAN). Su objetivo son las aplicaciones que requieren
comunicaciones seguras con baja tasa de envío de datos y maximización de la vida útil de sus
baterías.

En principio, el ámbito donde se prevé que esta tecnología cobre más fuerza es en domótica,
como puede verse en los documentos de la ZigBee Alliance. La razón de ello son diversas
características que lo diferencian de otras tecnologías:

 Su bajo consumo.
 Su topología de red en malla.
 Su fácil integración (se pueden fabricar nodos con muy poca electrónica).
ZigBee utiliza la banda ISM para usos industriales, científicos y médicos; en concreto, 868
MHz en Europa, 915 en Estados Unidos y 2,4 GHz en todo el mundo. Sin embargo, a la hora
de diseñar dispositivos, las empresas optarán prácticamente siempre por la banda de 2,4
GHz, por ser libre en todo el mundo. El desarrollo de la tecnología se centra en la sencillez y el
bajo costo más que otras redes inalámbricas semejantes de la familia WPAN, como por
ejemplo Bluetooth.

Zigbee:

 https://es.wikipedia.org/wiki/ZigBee
 https://en.wikipedia.org/wiki/ZigBee
 Zigbee Alliance: http://www.zigbee.org/

Tabla comparativa de módulos

802.1.4 https://en.wikipedia.org/wiki/Comparison_of_802.15.4_radio_modules

El estándar Zigbee se utiliza primordialmente para aplicaciones domóticas donde es mínima la

capacidad de transferencia de información y el costo y consumo tienen un papel fundamental.
ZigBee se utiliza para controlar la calefacción, iluminación, sistema de seguridad, etc. de
cualquier edificio inteligente. Se espera que ZigBee se aplique para industrias, juguetes,
periféricos de PC, componentes electrónicos, sistemas de control automático, medicina, etc.
pero en este momento su principal aplicación es en los sistemas de domótica y de
automatización.
Zigbee Soporta tres tipos de topologías de red:

 Star o Estrella: presenta larga vida útil como consecuencia del bajo consumo que
requiere.
 Mesh o Malla: en la cual existen múltiples rutas para alcanzar un destino,
obteniéndose alta confiabilidad.
 Cluster Tree o Racimo de Árbol: es una topología del tipo Mesh-Star que encierra los
beneficios de ambas.

Las comunicaciones Zigbee se realizan en la banda libre de 2.4GHz. A diferencia de bluetooth

no utiliza FHSS (Frequency hooping), sino que realiza las comunicaciones a través de una
única frecuencia, es decir, de un canal. Normalmente puede escogerse un canal de entre 16
posibles. El alcance depende de la potencia de emisión del dispositivo así como el tipo de
antenas utilizadas (cerámicas, dipolos, …) El alcance normal con antena dipolo en visión
directa suele ser aproximadamente (tomando como ejemplo el caso de MaxStream, en la
versión de 1mW de potencia) de 100m y en interiores de unos 30m. La velocidad de
transmisión de datos de una red Zigbee es de hasta 256kbps. Por último decir que una red
Zigbee la pueden formar, teóricamente, hasta 65535 equipos, es decir, el protocolo está
preparado para poder controlar en la misma red esta cantidad enorme de dispositivos. La
realidad es menor, siendo, de todas formas, de miles de equipos.

El estándar Zigbee permite la interoperabilidad entre diferentes dispositivos de de diferentes

fabricantes. Por ejemplo, nos permitiría controlar luces, sistemas de climatización, riego
automático, etc.. de diferentes marcas usando un mismo protocolo con productos certificados
Zigbee.

Para lograr esta interoperabilidad entre dispositivos, el protocolo Zigbee está organizado en
capas que separan los componentes y las funciones en módulos independientes.
Las capas PHY y MAC son las especificadas por el estándar IEEE 802.15.4 y las capa NWK
está especificada por el estándar Zigbee que maneja la estructura de red, enrutamiento y
seguridad.

La capa de aplicación es la que habilita la interoperabilidad y está compuesta por:

 APS: ofrece un interfaz entre la red y la capa de aplicación, define los mensajes
estandarizados que permite la comunicación entre dispositivos de diferentes
fabricantes.
 Application Framework: es el entorno donde se almacenan las aplicaciones en los
dispositivos ZigBee.
 ZDO (ZigBee Device Object): ofrece funcionalidades de descubrimiento de dispositivos
y gestión avanzada de red.

Más información: http://www.electrocomponentes.com/articulos/diciembre06/zigbee.html

XBee

XBee es el nombre comercial del Digi de una familia de módulos de comunicación por radio y
están basados en el estándar zigbee, pero digi tiene muchos Xbee y algunos son zigbee
estándar y otros son propietarios o modificaciones del estándar. Existen muchos módulos
Xbee basados en el estándar IEEE 802.15.4

Los módulos Xbee han sido diseñados para aplicaciones que requieren de un alto tráfico de
datos, baja latencia y una sincronización de comunicación predecible. Por lo que básicamente
XBee es propiedad de Digi basado en el protocolo Zigbee. En términos simples, los XBee son
módulos inalámbricos fáciles de usar.

Xbee es el nombre comercial de la familia de módulos de radio con un factor de forma

compatible de Digi International

Los módulos de radio XBee pueden ser usados con un número mínimo de conexiones: Power
(3.3V), GND y TX/RX de la UART, junto con otras conexiones recomendables como reset y
sleep. La mayoría de los módulos XBee tienen otras conexiones omo flow
control, input/output (I/O), analog-to-digital converter (A/D) and indicator

Los módulos XBee funcionan a 3.3V y los pines no son tolerantes a 5V. Desde Arduino
podemos alimentar un módulo XBee, pero la comunicación serie en Arduino es a 5V y en el
módulo XBee es a 3.3V.

Se puede usar un divisor de tensión como este:

Es posible usar un módulo adaptador de 5V a 3.3V como
este https://www.parallax.com/sites/default/files/downloads/32401-XBee-5V-3.3V-Adapter-
v1.2.pdf

XBee:

 https://en.wikipedia.org/wiki/XBee
 http://www.digi.com/lp/xbee
 http://examples.digi.com/

La familia de módulos de radio XBee es:

 XBee 802.15.4 — The initial point-to-point topology or star topology module running
the IEEE 802.15.4 protocol
 XBee-PRO 802.15.4 — A higher power, longer range version of the XBee 802.15.4
 XBee DigiMesh 2.4 — A 2.4 GHz XBee module that uses DigiMesh, a sleeping mesh
networking protocol developed by Digi International
 XBee-PRO DigiMesh 2.4 — A higher power, longer range version of the XBee
DigiMesh 2.4
 XBee ZB — An XBee module that incorporates the ZigBee PRO mesh networking
protocol
 XBee-PRO ZB — A higher power, longer range version of the XBee ZB
 XBee ZB SMT — A surface mount XBee running the ZigBee protocol
 XBee-PRO ZB SMT — A higher power, longer range version of the XBee ZB SMT
 XBee SE — An XBee ZB module that incorporates the security cluster for the ZigBee
Smart Energy public profile
 XBee-PRO SE — A higher power, longer range version of the XBee SE
 XBee-PRO 900HP — A 900 MHz XBee-PRO module with up to 28 mile range with
high-gain antenna that supports DigiMesh networking protocol
 XBee-PRO 900 (Legacy) — A 900 MHz proprietary point-to-point and star topology
module, not recommended for new design
 XBee-PRO XSC (S3B) — A 900 MHz module compatible over the air with the Digi
9XStream radios
 XBee-PRO DigiMesh 900 (Legacy) — A 900 MHz module that uses DigiMesh, not
recommended for new design (see XBee-PRO 900HP for new designs)
 XBee-PRO 868 — An 868 MHz 500 mW long-range module that supports proprietary
point-to-point and star, for use in Europe
 XBee 865/868LP — An 868 MHz XBee module that uses DigiMesh, available in
Surface Mount form-factor (also configurable to 865 MHz for use in India)
 XBee ZigBee (S2C) — Incorporates an upgrade to the transceiver chip, replacing
the Silicon Labs EM250 with the Silicon Labs EM357, effectively adding more RAM,
more flash, faster clock speed and lowering the current draw.[11]
 XBee-PRO ZigBee (S2C) — A higher power, longer range version of the XBee ZigBee
(S2C)

Nuevos módulos de XBEE SMD para Europa: http://www.digi.com/pdf/ds_xbee868lp.pdf. Son

los 868LP operan en la frecuencia 863-870 MHz utilizando 20 canales para ofrecer más
referencia e inmunidad en 868 MHz.

Kits de aprendizaje de XBee de Digi:

  XBee Arduino compatible Coding
Platform: https://docs.digi.com/display/XBeeArduinoCodingPlatform/XBee+Arduino+Co
mpatible+Coding+Platform
 Comprarlo: http://www.digikey.es/product-detail/en/digi-international/XKB2-AT-
WWG/602-1550-ND/5271212
 Wireless Connectivity
Kit: http://www.digi.com/resources/documentation/Digidocs/90001456-13/Default.htm
 Comprarlo: http://www.digikey.es/product-detail/en/digi-international/XKB2-AT-
WWC/602-1551-ND/5305247

Los módulos más sencillos de Xbee son los serie 1 (también llamada 802.15.4) que no
soportan mesh e implementan el estándar 802.15.4. Son los más fáciles de usar y los más
recomendados para empezar a trabajar. Más
información: http://www.digi.com/pdf/ds_xbeemultipointmodules.pdf y ejemplo de
uso: http://examples.digi.com/get-started/basic-xbee-802-15-4-chat/

Para usar un módulo XBee con Arduino es necesario un Shield o un adaptador para conectar
el puerto serie de XBee con el de Arduino.
Para usar o configurar un módulo XBee con Ordenador es necesario un adaptador que
generalmente tiene un chip FTDI que hace de pasarela entre el puerto serie y el USB.

XBee explorer:

 http://tienda.bricogeek.com/modulos-radiofrecuencia/156-xbee-explorer-usb.html
 http://www.electan.com/xbee-explorer-usb-p-3121.html
 Dongle https://www.sparkfun.com/products/11697
 Versión económica http://es.aliexpress.com/item/FT232RL-USB-to-Serial-Port-Bee-
Adapter-Board-Foca-Compatible-with-XBee-USB-Adapter/1959031547.html
 Otra versión económica http://www.dx.com/p/arduino-ft232rl-xbee-usb-to-serial-
adapter-v1-2-board-module-blue-140960#.V5-vxfmLTcs
 Hazlo tu mismo http://www.kobakant.at/DIY/?p=204
Guía de uso de XBee Shield: https://learn.sparkfun.com/tutorials/xbee-shield-hookup-guide

Buena página para saber más de XBee: http://xbee.cl/

Guía de compra de XBee

Digi dispone de una amplia variedad de módulos con diferentes características para diferentes
funciones/aplicaciones. A la hora de elegir, esta tabla de comparación puede ser
útil: http://www.digi.com/pdf/chart_xbee_rf_features.pdf

Y en este enlace también explica perfectamente como elegir nuestro módulo

XBee: http://docs.digi.com/display/XBeeArduinoCodingPlatform/XBee+buying+guide
Los parámetros que afectan a la hora de elegir un módulo en función de la aplicación son:

 El país de uso, las frecuencias están reguladas en cada país y debe tenerse en
cuenta.
 Alcance de la señal. Para un mayor rango será necesario seleccionar una antena o
usar un módulo XBee-PRO
 Consumo del módulo
 Topología de la red de nuestra aplicación.

Guia de compra de módulos XBee de sparkfun: https://www.sparkfun.com/pages/xbee_guide

Resellers de Digi para compras on-line:

 Adafruit
 Fry’s
 Maker Shed
 Microcenter
 Parallax
 RobotShop
 Seeed Studio
 Solarbotics
 Sparkfun
 TrossenRobotics

Para cualquier duda o ayuda, se puede recurrir al foro de digi

en http://www.digi.com/support/forum/

Arquitectura Básica de una Red XBee

Una red XBee la forman básicamente 3 tipos de elementos. Un único dispositivo Coordinador,
dispositivos Routers y dispositivos finales (end points). Los módulos XBee son versátiles a la
hora de establecer diversas topologías de red, dependiendo la serie de XBee que escojamos
pueden crearse redes

El Coordinador: Es el nodo de la red que tiene la única función de formar una red. Es el
responsable de establecer el canal de comunicaciones (como hablábamos antes) y del PAN
ID (identificador de red) para toda la red. Una vez establecidos estos parámetros, el
Coordinador puede formar una red, permitiendo unirse a él a dispositivos Routers y End
Points. Una vez formada la red, el Coordinador hace las funciones de Router, esto es,
participar en el enrutado de paquetes y ser origen y/o destinatario de información.

Los Routers: Es un nodo que crea y mantiene información sobre la red para determinar la
mejor ruta para enrutar un paquete de información. Lógicamente un router debe unirse a una
red Zigbee antes de poder actuar como Router retransmitiendo paquetes de otros routers o de
End points.

End Device: Los dispositivos finales no tienen capacidad de enrutar paquetes. Deben
interactuar siempre a través de su nodo padre, ya sea este un Coordinador o un Router, es
decir, no puede enviar información directamente a otro end device. Normalmente estos
equipos van alimentados a baterías. El consumo es menor al no tener que realizar funciones
de enrutamiento.
Los módulos XBee son versátiles a la hora de establecer diversas topologías de red,
dependiendo la serie de XBee que escojas puedes crear redes:

 Punto a punto
 Estrella
 Malla
 Árbol
 Mixtas

Módulos XBee

Los módulos XBee de digi son pequeños módulos RF (radio frecuencia) que transmiten y
reciben datos sobre el aire usando señales de radio. La capacidad inalámbrica es esencial
cuando se quieren instalar sensores en lugares donde no hay cables.

Los módulos XBee son altamente configurables y soportan múltiples protocolos para permitir
usarlo tanto en un enlace punto a punto como en un diseño complejo con muchos dispositivos
en una red mesh.

Algunos ejemplos de uso de los módulos XBee:

 Controlar un robot remotamente

 Añadir inteligencia a una casa edificio sin tener que realizar cableados
 Para aplicaciones industriales, por ejemplo para monitorizar temperatura, presión o
máquinas complejas.

Más información en: http://www.digi.com/resources/documentation/Digidocs/90001456-

13/Default.htm#concepts/c_introduction_to_xbee_modules.htm%3FTocPath%3D_____3

Las series

XBee Series 1 (también llamados XBee 802.15.4) – Son la serie más fácil para trabajar, no
necesitan ser configurados, pero incluso así se pueden obtener beneficios de estos módulos.
Debido a que son fáciles para trabajar, son los más recomendables especialmente si se está
empezando. Para comunicaciones Punto-a-Punto, estos módulos trabajan tan bien como los
de la Serie 2, pero sin todo el trabajo de pre configuración previo. El hardware de las Series 1
y las Series 2/2.5/ZB NO SON COMPATIBLES. No trates de mezclarlos, no funcionará.

Guia de usuario serie 1:

http://www.hmangas.com/Electronica/Datasheets/Shield%20XBee%20Arduino/XBee-
Guia_Usuario.pdf

XBee Znet 2.5 (Formalmente Series 2) Retirado – Los módulos Serie 2 deben ser
configurados antes de ser usados. Pueden funcionar en modo Transparente o por medio de
comandos API, pero todo esto depende de que firmware se configure en los módulos.
También pueden funcionar en una red mesh. Son más difíciles que usar que los de la Serie 1.
No existe una forma en que estos módulos sean compatibles con los de la Serie 1. Los
módulos Znet 2.5 ya no se venden, pero han sido reemplazados con módulos ZB más
compatibles. Datasheet

https://www.sparkfun.com/datasheets/Wireless/Zigbee/XBee-2.5-Manual.pdf

XBee ZB (el actual módulo Series2) – Básicamente es el módulo Znet 2.5, pero con un
nuevo firmware. Esto significa que también funcionan en modo transparente o por medio de
comandos API. También funcionan en redes mesh. Estos a menudo son llamados módulos de
Serie 2, por lo que si escuchas a alguien hablar sobre esta serie, probablemente estén
hablando de estos módulos. Puede que no sea el término correcto, pero se hace distinción de
estos con los módulos de la Serie 1, los cuales son los más populares.

XBee 2B (el imás actual módulo Series2) – Son nuevos módulos que poseen mejoras en el
hardware respecto de los de la Serie 2, básicamente son los mismo que los anteriores pero
con un firmware más nuevo, mejorando por ejemplo el uso de la potencia. Funcionan con el
Firmware del módulo ZB, pero debido al cambio de hardware, ya no pueden funcionar con el
firmware del módulo Znet 2.5. Por lo que ten cuidado si agregas uno de estos módulos a una
red ya existente que utilice módulos Znet 2.5. Actualmente algunas tarjetas son 2B y otras son
ZB.

Básicamente el problema es mezclarlos.

900 MHz vs 2.4GHz – La mayoría de los módulos XBee operan a 2.4 GHz , pero hay unos
pocos que operan a 900 MHz. Básicamente los de 900 MHz pueden llegar muy lejos con una
antena de alta ganancia (hasta casi 24 Km). Además a menor frecuencia, la señal posee
mayor penetración. Otro punto importante es que los módulos de 900 MHz no están
permitidos en algunos países, Digi tiene versiones de 868 MHz que sí está permitido en la
mayoría de los países.

Documentación módulos XBee:

 Módulos: http://www.digi.com/products/xbee-rf-solutions/modules
 Series 1 (XBee 802.15.4): http://www.digi.com/products/xbee-rf-
solutions/modules/xbee-series1-module
 XBee ZB (Series 2): http://www.digi.com/products/xbee-rf-solutions/rf-modules/xbee-
zigbee
 XBee digimesh: http://www.digi.com/products/xbee-rf-solutions/modules/xbee-
digimesh-2-4
 Diferencias entre serie 1 y serie
2: http://knowledge.digi.com/articles/Knowledge_Base_Article/The-Major-Differences-
in-the-XBee-Series-1-vs-the-XBee-Series-2

Más información http://xbee.cl/tutorial-xbee/

Regulaciones en paises: http://www.digi.com/resources/certifications

Toda la documentación de
digi: http://www.digi.com/resources/documentation/digihelp/default.htm

XCTU

Para configurar y usar los módulos XBee es necesario descargar e instalar XBee
Configuration and Test Utility (XCTU) que es un software multiplataforma que permite
interactuar con los módulos mediante un interfaz gráfico. Esta aplicación incluye herramientas
que hacen muy sencillo configurar y probar los módulos XBee.

XCTU nos sirve para configurar, inicializar, actualizar firmware y testear los módulos XBee,
comunicándose por puerto serie a los módulos. Una ventaja de este software es que puedes
ver rápidamente un resumen de todos los parámetros del módulo y una descripción de ellos.

Más información y descarga de XCTU: http://www.digi.com/products/xbee-rf-solutions/xctu-

software/xctu

XCTU User Guide: http://www.digi.com/resources/documentation/digidocs/90001458-

13/default.htm

Drivers para los módulos: http://www.digi.com/support/productdetail?pid=3257&type=drivers

Para empezar a usarlo es tan simple como instalar el software XCTU, conectar el módulo RF a
la placa de desarrollo, que tiene un módulo FTDI que saca un interfaz USB y luego enchufar el
USB a nuestro PC. Para usarlo con USB es necesario poner el jumper en la posición UART en
lugar de la de loopback.

Más información de la placa de desarrollo de

XBee: https://docs.digi.com/display/XBeeHardware/XBee+Grove+Development+Board

Tutorial XCTU: http://docs.digi.com/display/XBeeArduinoCodingPlatform/XCTU+walkthrough

Cómo configurar los módulos: http://docs.digi.com/display/XCTU/Configure+your+modules

Primera Aplicación. Chat Básico

El primer ejemplo es un chat básico para transmitir en tiempo real mensajes por el aire con los
módulos XBee.
Ejercicio completo: http://www.digi.com/resources/documentation/Digidocs/90001456-
13/Default.htm#containers/cont_basic_chat.htm%3FTocPath%3DBasic%2520chat%7C_____0

Para configurar un módulo XBee con el XCTU, lo primero es poner el modo configuración y
descubrir los módulos, seleccionando el puerto COM del USB al que he conectado la placa de
desarrollo.

Para poder ver el módulo remoto es necesario configurar los parámetros DH y DL de la MAC
del módulo remoto.

NOTA: Si se conectan los módulos en las placas de desarrollo y se alimenta mediante batería,
los módulos trabajan de forma autónoma, por ejemplo recogiendo datos de un sensor y
mandandolo al nodo central

Cómo se comunican los dispositivos XBee

Los dispositivos XBee se comunican entre ellos a través del aire enviando y recibiendo
mensajes. Estos dispositivos no pueden gestionar los datos enviados o recibidos, sin embargo
pueden comunicarse con otros dispositivos a través del interfaz serie.

Los dispositivos XBee transmiten al aire los datos que llegan del puerto y transmiten al puerto
serie cualquier dato que llega por el aire. Los microcontroladores o los PCs pueden controlar
que envían los dispositivos XBee y gestionan los mensajes inalámbricos entrantes.

Por lo tanto tenemos dos tipos de comunicación en los dispositivos XBee:

 Comunicación inalámbrica: es la comunicación entre los módulos XBee, estos

módulos deben ser parte de la misma red y usar la misma frecuencia de radio.
 Comunicación serie: es la comunicación entre el módulo XBee y el microcontrolador o
el PC a través de un puerto serie.

En la comunicación inalámbrica los módulos transmiten y reciben información a través de la

modulación de las ondas electromagnéticas. Para que se realice la transmisión ambos
módulos deben estar en la misma frecuencia y en la misma red. Esto se determina por dos
parámetros:

 Channel (CH) es la frecuencia usada para comunicar, es decir, el canal dentro de la

red.
 Personal Area Network Identifier (ID) es un identificador único que establece que
los módulos están en la misma red.

Un módulo XBee solo recibirá y transmitirá datos a otros XBee dentro de las misma red
(mismo ID) y usando el mismo canal (mismo CH).
Direccionamiento

Los módulos de XBee tienen varias direcciones diferentes, cada una con un propósito.

Type Example Unique

64-bit 0013A20012345678 Always

16-bit 1234 Yes, but only within a network

Node identifier Bob’s module Uniqueness not guaranteed

Cada módulo de XBee tiene una dirección única de 64 bits, esta dirección se llama MAC y es
análogo a la MAC de las tarjetas de red o wifi. El valor de 64 bits está compuesto por los
parámetros Serial Number High (SH) y Serial Number Low (SL), que aparecen impresos en la
parte trasera del módulo. El valor SH es generalmente el mismo para todos los módulos XBee
(0013A200) e identifica los módulos de Digi. La dirección 000000000000FFFF está reservada
para mandar un mensaje de broadcast.

Una dirección de 16 bit puede ser asignada a cada módulo XBee y no es única. Este valor
puede leerse o escribirse a través del parámetro MY. Si el valor es FFFF se deshabilita la
recepción de paquetes con direcciones de 16 bit.

El identificador de nodo es un string corto que permite identificar fácilmente un módulo con un
nombre. Para leer o escribir el node identifier se hace a través del parámetro NI.

Comunicación serie

Un módulo XBee puede funcionar como un módulo independiente o conectado a un

microcontrolador o PC. Cuando opera como módulo independiente simplemente manda datos
al nodo central de los sensores o dispositivos conectados a los puertos del módulo. Cuando
está conectado a un microcontrolador o un PC, el módulo XBee usa la comunicación serie. En
el caso de Arduino, este manda a través del puerto serie datos al módulo XBee para que sean
transmitidos por el aire.

El módulo XBee hace de interface con el microcontrolador a través de la UART (puerto serie
asíncrono). Para más información ver las guías de usuario:

 XBee/XBee-PRO S1 802.15.4 http://ftp1.digi.com/support/documentation/90000982.pdf

 XBee/XBee-PRO S2C
802.15.4 http://ftp1.digi.com/support/documentation/90001500.pdf

Un arduino o el dispositivo externo conectado a uno módulo XBee mediante puerto serie
puede tener varios modos de operación en función de cómo se comunican por el puerto serie.
Los módulos XBee soportan dos modos de operación:
  Modo Transparente (Aplicación transparente). La radio pasa la información tal cual la
recibe por el puerto serie. Este modo tiene funcionalidades limitadas pero es la forma
más sencilla de comenzar.
 Modo API (Aplicación de programación). En este caso un protocolo determina la forma
en que los datos son intercambiados. Este modo permite hacer una red de
comunicaciones más grande.

Ventajas y desventajas de un modo u

otro: http://www.digi.com/resources/documentation/Digidocs/90001456-
13/Default.htm#concepts/c_xbee_comparing_at_api_modes.htm%3FTocPath%3DHow%2520
XBee%2520devices%2520work%7CWireless%2520communication%7CSerial%2520communi
cation%7C_____2

Más información en: http://www.digi.com/resources/documentation/Digidocs/90001456-

13/Default.htm#containers/cont_how_xbees_work.htm%3FTocPath%3DHow%2520XBee%25
20devices%2520work%7C_____0

Modo Transparente

En modo transparente el módulo XBee funciona de forma que todo lo recibido por el puerto
serie es enviado inmediatamente al aire y todo lo recibido por la radio es se manda tal cual al
puerto serie.

En modo transparente para comunicar dos módulos, es necesario configurar la dirección del
destino en el módulo que envía datos. Esta dirección se programa en los
parámetros: Destination Address High (DH) y Destination Address Low (DL).

El modo transparente tiene muchas limitaciones, por ejemplo al trabajar con varios módulos es
necesario configurar la dirección de destino antes de mandar un mensaje. Sin embargo, el
modo transparente es perfecto cuando hay comunicación punto a punto entre solo dos
elementos.

En modo transparente podemos usar el modo comando que es un estado en que los
caracteres enviados al módulo XBee son interpretados como comandos en lugar de
transmitirlos vía radio. Para cambiar a modo comando hay que mandar el string “+++”, cuando
el módulo recibe un segundo de silencio seguido del string “+++” (sin /n o /r) y otro segundo de
silencio, deja de mandar datos por radio y comienza a aceptar comandos locales. Al entrar en
modo comando si transcurren 10 segundo sin recibir datos automáticamente sale de modo
comando y vuelve a modo transparente. Para salir del modo configuración usar ATCN.

El propósito del modo comando es leer o escribir la configuración local del módulo XBee. Para
ello se usando los comandos AT (https://es.wikipedia.org/wiki/Conjunto_de_comandos_Hayes)
. Un comando AT comienza con las letras “AT” seguida de dos caracteres que identifican el
comando a ejecutar y algunos otros parámetros opcionales.

Por lo tanto desde un Arduino sería muy sencillo configurar un módulo XBee en lugar de usar
el interfaz gráfico XCTU.

Más información en: http://www.digi.com/resources/documentation/Digidocs/90001456-

13/Default.htm#containers/cont_xbee_transparent_mode.htm%3FTocPath%3DXBee%2520tra
nsparent%2520mode%7C_____0
Modo API

El modo API ofrece un interfaz estructurado donde los datos son comunicados a través del
interfaz serie en paquetes organizados y en un determinado orden. Esto permite establecer
una comunicación compleja entre módulos sin tener que definir un protocolo propio.

Por defectos los módulos XBee trabajan en modo transparente, pero esto tiene unas
limitaciones:

 Si un módulo necesita transmitir mensajes a módulos diferentes debe cambiar la

configuración para establecer el nuevo destino.
 Para leer y escribir la configuración del módulo hay que entrar primero en modo
comando.
 En modo transparente un módulo XBee no puede distinguir el origen de la
comuinicación que recibe.

Para resolver estas limitaciones XBee da la alternativa del modo API (Application
Programming Interface).

Ventajas del modo API:

 Configurar módulos locales y remotos en la red y sin necesidad de entrar en modo

comando.
 Comunicar con uno o varios destinatarios
 Identificar el módulo que ha mandado la comunicación
 Recibir el estado de la transmisión de los paquetes
 Obtener la fuerza de la señal de los paquetes recibidos
 Hacer gestión y diagnóstico de la red.
 Hacer funciones avanzadas domo actualización de firmware remota.

Estructura de la Trama

En modo API los datos enviados están estructurados en una trama. Se envían a través de
interfaz serie de XBee y contiene el mensaje inalámbrico e información adicional como la
calidad de la señal.

La estructura de la trama es:

 Frame data

Start Frame
Length Data Checksum

delimiter type

1 2 3 4 5 6 7 8 9 … n n+1

API

Single
frame
0x7F MSB LSB Frame-type-specific data

type byte

API frame type determina el tipo de trama e indica cómo está organizada la información de los
datos enviados. Los tipos de tramas soportadas dependen del tipo de módulo de Xbee que
usemos. Más información para lo módulos usados en página 85
de http://ftp1.digi.com/support/documentation/90000982.pdf

Checksum ayuda a comprobar la integridad de los datos mandados. Las tramas enviadas por
puerto serie con checksum incorrecto nunca serán procesadas por el módulos y serán
ignoradas.

Para configurar el modo AP, se modifica el parámetro AP. Permite seleccionar entre los dos
modos API soportados y el modo por defecto que es el transparente.

Mode AP value Description

Transparent 0 API modes are disabled and the module operates in transparent mode

API 1 1 API mode without escaped characters

API 2 2 API mode with escaped characters

La diferencia ente API 1 y API 2 es que las tramas usan caracteres de escape. Puesto que la
transmisión por el aire solo es del payload, dos módulos con diferente configuración API 1 y
API 2 pueden comunicarse sin problemas.

El modo AP non-escaped (API 1) se basa únicamente en el delimitador de inicio y la longitud

de los bytes para diferenciar las tramas, si los bytes en un paquete se pierden, la cuenta de
bytes será incorrecta y el siguiente paquete (trama) también se perderá. API escaped (API 2)
implica secuencias de caracteres de escape en una trama para mejorar la fiabilidad
especialmente en entornos ruidosos.

La estructura de la trama es básicamente la misma en ambos modos API pero en API 2, todos
los bytes excepto el delimitador de inicio deben estar escapados si es necesario. Los
siguientes bytes de datos deben ser escapados en modpo API 2:

 0x7E: Start delimiter

 0x7D: Escape character
 0x11: XON
 0x13: XOFF

El modo API 2 garantiza que todos los bytes 0x7E recibidos son delimitadores de inicio, este
carácter no puede ser parte de cualquier otro campo de la trama (longitud, datos o checksum),
puesto que debe estar escapado. Para escapar un carácter, insertar 0x7D (carácter de
escape) y añadirlo con el byte a ser escapado (XOR con 0x20). En modo API 2 la longitud no
incluye los caracteres de escape y el checksum es calculado con los datos no escapados.

Configurar un módulo local XBee en modo API

Para consultar o modificar un valor de configuración de un módulo local (módulo conectado

directamente al puerto serie), es necesario usar los comandos AT. Son los mismos comandos
usados en modo transparente pero incluyendolo en una trama de tipo comando AT (0x08 o
0x09) y la respuesta vuelve en una trama de tipo respuesta AT (0x88).

Ejemplo: Configurar un módulo local en modo

API. http://www.digi.com/resources/documentation/Digidocs/90001456-
13/Default.htm#containers/cont_sending_frames.htm

Cuando un módulo está en modo API, al usarlo con el SW XCTU y entrar en la consola, la
vista es diferente a si está en modo transparente. Además desde consola hay una utilidad
para generar una trama con el frame generator.
Configuración Remota de un módulo XBee

Trabajar en modo API nos permite configurar un módulo remoto al que estamos conectados.
Cualquier comando AT usado en local se puede usar en un módulo remoto. Para ello se
manda una Remote AT Command Request (0x17) al módulo remoto.

La respuesta del módulo remoto al comando AT es Remote AT Command Response (0x97)

con el resultado del comando procesado por el módulo remoto. Si el frame ID del Remote AT
Command es0, esta respuesta no es enviada.
Transmitir y recibir datos inalámbricamente en modo API

Esta imagen resume el intercambio de información en los puestos serie de los módulos.

1. Se manda por el puerto serie una Petición de transmisión (0x10) o un Explicit

Addressing Command Frame (0x11) al módulo XBee A.
2. El módulo XBee A transmite por el aire los datos de la trama al módulo configurado
como destino, en este caso el módulo XBee B
3. El módulo remoto B recibe los datos por el aire y manda por su puerto serie una trama
de paquete recibido (0x90) o Explicit Rx Indicator (0x91), dependiendo del valor de API
Options (AO). Esta trama contiene los datos recibidos por el aire y la dirección de
origen del módulo que la ha transmitido, en este caso XBee A.
4. El módulo remoto B transmite un paquete de wireless acknowledge con el estado al
XBee A
5. El módulo XBee A manda un paquete Transmit Status (0x8B) a través de su puerto
serie con el estado de las transmisión.

Ejemplo: Transmitir y recibir datos en modo

API http://www.digi.com/resources/documentation/Digidocs/90001456-
13/Default.htm#containers/cont_transmit_and_receive_data_with_xctu.htm (El tipo de trama es
un Tx Request 0x00 del protocolo 802.15.4 y no como pone en la práctica un Transmit
Request 0x10 del protocolo ZigBee)

Más información en http://www.digi.com/resources/documentation/Digidocs/90001456-

13/Default.htm#containers/cont_api_mode.htm

Librerías Xbee

Para poder manejar el modo API disponemos de librerías que nos ayudan a generar la trama
a enviar y a interpretar la trama recibida. Estas librerías nos ayudan a interpretar las tramas de
API.

 XBee mbed Library para dispositvos ARM mbed https://www.mbed.com/en/. Más

detalles en: https://developer.mbed.org/teams/Digi-International-Inc/code/XBeeLib/.
  Digi XBee Ansi C Library es una librería en ANSI C para comunicar con módulos
XBee en modo API. Más detalles
en: https://github.com/digidotcom/xbee_ansic_library/.
 XBee-arduino es una librería de Arduino para comunicar con módulos XBee en modo
API. Más información en: https://github.com/andrewrapp/xbee-arduino
 XBee Java Library librería desarrollada en Java que permite interactuar como
módulos XBee en modo API. Más información en: XBee Java Library documentation.

Seguridad y cifrado

Los módulos XBee pueden ser configurados para comunicación segura mediante claves de
cifrado.

Los datos son cifrados antes de ser enviados y luego en el receptor son descifrados para
poder usarlos. Activar la seguridad en una red XBee puede producir un ligero incremento en
latencia y tamaño de los paquetes enviados.

Para habilitar la comunicación segura se deben configurar los siguientes parámetros con el
mismo valor en todos los dispositivos de la red:

 EE = 1: AES Encryption Enable

 KY: AES Encryption key que debe ser un string de 32 caracteres hexadecimales. Una
vez configurado este valor es imposible recuperarlo.

El cifrado es de 128 bits AES.

Ahorro de energía

Los módulos XBee tienen capacidades de ahorro de energía. los módulos se pueden poner en
estado sleep y apenas consumir energía, pudiendo llegar a una duración de batería de varios
años.

El protocolo 802.15.4 contiene cuatro conductas básicas para el modo sleep que se puede
dividor en dos categorías: pin-controlled sleep mode y cyclic sleep mode. Por defectos el
modo sleep está siempre deshabilitado.

Los parámetros básicos para configurar en modo sleep son:

 SM (Sleep Mode)
 ST (Time before sleep)
 SP (Cyclic sleep period)

Modo pin-controlled sleep: este modo es controlado por el Sleep_RQ (pin 9) de forma que
cuando es puesto a HiGH (3.3 V) entra en modo sleep. (SM = 1)

Modo Cyclic Sleep mode: el módulo se despierta y vuelve a modo sleep en con una
programación fija basada en el tiempo. Con SM = 4 se activa el modo y con SM = 5 además
de activar el modo cíclico, permite activar a través del pin 9, siendo una mezcla de ambos
modos. En estos dos modos se debe configurar los parámetros ST y SP.
Para comunicación bidireccional en modos sleep, los protocolos ZigBee o DigiMesh pueden
dar funcionalidades más apropiadas.

Los pines de los módulos relacionados con el modo sleep son el pin 9 que pone el módulo en
modo sleep cuando está a HIGH (3.3V) y el pin 13 es una salida que se pone a HIGH cuando
está despierto o a LOW cuando está como sleep, este pin se puede conectar a un led o a una
entrada del microcontrolador.

Para más información ver guía de usuario del correspondiente

módulo: http://ftp1.digi.com/support/documentation/90000982.pdf

Más información en: http://www.digi.com/resources/documentation/Digidocs/90001456-

13/Default.htm#containers/cont_explore_low_power.htm

Ejercicio: http://www.digi.com/resources/documentation/Digidocs/90001456-
13/Default.htm#tasks/t_ex_enable_sleep.htm

Comandos AT

Para entrar en modo comando a un XBee hay que poner la cadena “+++” y esperar a que nos
devuelva un “OK” el módulo. El propósito es leer o cambiar la configuración del módulo XBee.

Cuando se quiere leer o escribir una configuración, se debe enviar un comando AT con la
siguiente estructura:

Comandos AT:

 AT: comprueba la conexión con el módulo

 ATCN: se sale del módulo de comandos.
  ATWR: Escribe la configuración actual a la memoria no volátil y persiste después de
iniciar de nuevo el módulo.

Todos los comandos para la serie 1 pueden verse en la guia de

usuario: http://ftp1.digi.com/support/documentation/90000982.pdf

Más información en: http://www.digi.com/resources/documentation/Digidocs/90001456-

13/Default.htm#concepts/c_at_commands.htm%3FTocPath%3DXBee%2520transparent%252
0mode%7CCommand%2520mode%7C_____1

Pin Pairing

Todos los módulos XBee tienen un conjunto de pines que pueden usarse como entradas y
salidas sin necesidad de conectar un microcontrolador externo.

Pin pairing se refiere a la comunicación directa de los pines entre dos módulos XBee. Esto
enlaza virtualmente uno de los pines del XBee directamente con a los pines de otro XBee, por
ejemplo para un timbre inalámbrico.
Los módulos de la serie 1 tienen 9 pines de I(O, seis de los cuales pueden leer valores
analógicos.

Ejercicio completo en: http://www.digi.com/resources/documentation/Digidocs/90001456-

13/Default.htm#reference/r_pin_pairing.htm%3FTocPath%3DXBee%2520transparent%2520m
ode%7CPin%2520pairing%7C_____0

Aclaraciones:

 Al poner el parámetro MY a FFFF habilita la recepción de paquetes de direcciones 64

bits deshabilitando la recepción de paquetes de direcciones de 16 bit.
 Señalar que el parámetro I/O Input Address (IA) enlaza una salida de XBee a una
dirección de 64 bit específica. Esto significa que las salidas digitales de un XBee
configuradas con el parámetro IA sólo aceptarán cambios de las peticiones que
lleguen de la dirección configurada. De ahí la necesidad de configurar este parámetro
en el XBee_B.
 En el ejercicio no explica bien porque poner el parámetro IC a 10. La explicación
completa está en: http://www.digi.com/resources/documentation/Digidocs/90001456-
13/tasks/t_obtain_data_from_sensor.htm

NOTA IC = 0x10 = B10000

DIO12 DIO11 DIO10 DIO9 DIO8 DIO7 DIO6 DIO5 DIO4 DIO3 DIO2 DIO1 DIO0

0 0 0 0 0 0 0 0 1 0 0 0 0

Ejercicio: cómo obtener datos de un sensor conectado a un módulo

XBee: http://www.digi.com/resources/documentation/Digidocs/90001456-
13/tasks/t_obtain_data_from_sensor.htm

Ejemplo Pin Pairing para manejar un joystick

Para manejar un joystick y controlar remotamente un elemento inalámbricamente podemos

usar el pin pairing de forma sencilla.
La configuración de los módulos XBee usando direcciones de 16 bits para simplificar quedaría:

Param Joystick Follower Effect

CH C C Define la frecuencia a usar. Debe ser la misma en ambos módulos.

ID 2015 2015 Define la red a la que se conecta la radio. Debe ser la misma en ambos módulos.

DH 0 —
DH y DL forma la dirección de destino. Es donde las notificaciones son mandadas cuando

DL 5678 — cambia el valor del pin. Se configura como dirección corta de 16 bits.

MY 1234 5678 Define la dirección corta de 16 bits.

DO Low Configura el pin DIO1/AD1 en el joystick como entrada y en el follower como salida. Lo que

D1 DI [3] [4] ocurre en el joystick como entrada se transmite al follower como salida.

DO Low

D2 DI [3] [4] Configura el pin DIO2/AD2 en el joystick como entrada y en el follower como salida.
 DO Low

D3 DI [3] [4] Configura el pin DIO3/AD3 en el joystick como entrada y en el follower como salida.

DO Low

D4 DI [3] [4] Configura el pin DIO4/AD4 en el joystick como entrada y en el follower como salida.

Configura en el joystick que pines monitorizar para mandar la señal al detectar un cambio.

IC 1E — 00011110 (binario) = 1E (hexadecimal)

IA — 1234 Defines the address of the transmitting module (leader) to pair for I/O.

Los pines I/O de Xbee son: http://www.digi.com/resources/documentation/Digidocs/90001456-

13/Default.htm#reference/r_xbee_s3b_io_pins.htm

Con esta simple configuración ya puedo manejar remotamente con un joystick unas luces o
incluso un coche con las conexiones adecuadas.

Modelos de Comunicación

Existen dos tipos de comunicación y en ambos casos es bidireccional:

 Punto a punto
 Punto a multipunto

Punto a punto

Para que se establezca la comunicación los módulos deben estar en el mismo canal (CH) y en
la misma Network ID (ID), además para iniciar la comunicación es necesario saber la dirección
MAC de 64-bit del destinatario. La forma en que se comunican dos módulos punto a punto
depende si están en modo API o transparente.

Ejemplo de comunicación punto a punto en modo

API: http://www.digi.com/resources/documentation/Digidocs/90001456-
13/Default.htm#containers/cont_ex_chat.htm

Punto a multipunto

En este modelo un módulo puede comunicarse con un módulo o múltiples módulos que estén
en la misma red. Esta comunicación implica un nodo central coordinador con varios nodos
remotos (end devices) conectándose al nodo central.
En el protocolo 802.15.4 los módulos XBee tienen dos roles:

 Coordinator, es el nodo central de la red. Inicia la red y permite a otros dispositivos

conectarse, puede seleccionar la frecuencia del canal y hace la sincronización de la
red. Para configurar un nodo como coordinador hay que cambiar el parámetro CE
(Coordinator Enable) a 1.
 End device, es un nodo remoto de la red. Puede comunicarse con el coordinador y
con otros end devices de la red. Se puede poner en modo sleep.

Las redes mesh solo son soportadas en protocolo ZigBee o Digimesh.

Es posible hacer broadcast, es decir, mandar el mismo datos a todos los nodos posible de la
red. Para mandar un broadcast, la dircción de destino debe ser 000000000000FFFF.

En el coordinador, cambiado el parámetro A2 es posible asociar end devices sin que conozcan
el canal (CH) y el ID de red (ID) siendo inicializados por el coordinador.

Más información: http://www.digi.com/resources/documentation/Digidocs/90001456-

13/Default.htm#concepts/c_comm_models.htm

I/O en módulos XBee

Todos los módulos XBee tienen un conjunto de pines que pueden usarse para conectar
sensores o actuadores y configurarlos. A diferencia de un Arduino, estos módulos no pueden
ejecutar un programa para interaccionar, sino que es necesario un elemento externo como un
Arduino para programarlos o cambiar su comportamiento.
Con estos pines se puede recoger el dato de un sensor y mandarlo a otro módulo o encender
una luz al estar conectado a un relé cuando recibe la señal sobre un pin configurado como
salida.

Pines I/O para módulos XBee 802.15.4

Pin name Physical pin # Parameter

DIO0, AD0 20 D0

DIO1, AD1 19 D1

DIO2, AD2 18 D2

DIO3, AD3 17 D3

DIO4, AD4 11 D4

DIO5, AD5 15 D5

DIO6 16 D6

DIO7 12 D7

DI8 9 D8

PWM0 6 P0
PWM1 7 P1

(D = digital; I = input; O = output; AD = analog input; PWM = pulse-width modulation)

Leer Sensores

Los módulos XBee se pueden usar leer datos de una red de sensores. Para recibir los datos
es necesario configurar los módulos remotos para escuchar en el pin donde se conecta el
sensor y mandar los datos al módulo principal que estará conectado a una MCU o un
ordenador.

En función del tipo de sensor o actuador que conectemos al pin del módulo deberemos
configurarlo adecuadamente.

Hay dos formas de obtener datos de un sensor:

 Haciendo una consulta para que lea todos los pines habilitados como entradas.
Queried sampling (IS)
 Transmitir automáticamente los datos del sensor de forma periódica o cuando un pin
digital cambia. El parámetro IR configura la frecuencia con que se mandan los datos
leídos de los sensores. El parámetro IC configura que pines monitorizar para detección
de cambio, cuando los pines monitorizados detectan un cambio inmediatamente se
leen los sensores y se mandan los datos.

Para seleccionar qué pines monitorizar, se asigna un valor binario a IC basado en este patrón:

DIO12 DIO11 DIO10 DIO9 DIO8 DIO7 DIO6 DIO5 DIO4 DIO3 DIO2 DIO1 DIO0

0 0 0 0 0 0 0 0 0 0 0 0 0
Ejercicios en:

 http://www.digi.com/resources/documentation/Digidocs/90001456-
13/Default.htm#containers/cont_receive_digital.htm
 http://www.digi.com/resources/documentation/Digidocs/90001456-
13/Default.htm#containers/cont_receive_analog.htm

Controlar Dispositivos

Un módulo XBee es capaz de recibir comandos y poner una salida digital o analógica a un
valor al ocurrir un determinado evento, sin el uso de un microcontrolador externo.

Los módulos XBee 802.15.4 tienen 8 salidas digitales (D0 a D7) y pueden configurarse con
una resistencia de pull up o pull down. Los módulos también tienen salida analógica mediante
PWM, en el caso de los módulos XBee 802.15.4 tienen 2 salidas analógicas (P0 y P1)

Recordar que los módulos XBee van a 3.3 V.

Para mandar una actuación a un módulo hay que mandar un comando AT configurado de la
manera correcta para actuar sobre un pin, una vez se ha configurado anteriormente como
salida.

Ejercicios en:

 http://www.digi.com/resources/documentation/Digidocs/90001456-
13/Default.htm#containers/cont_control_devices.htm
 http://www.digi.com/resources/documentation/Digidocs/90001456-
13/Default.htm#tasks/t_ex_send_analog_actuations.htm

Más información: http://www.digi.com/resources/documentation/Digidocs/90001456-

13/Default.htm#containers/cont_inputs_and_outputs.htm

Señal y Rangos de Frecuencia

La distancia de alcance de la señal de los módulos XBee está afectada por diversos factores:
  Algunos materiales pueden reflejar las ondas de radio provocando interferencias. En
particular materiales metálicos.
 Las ondas de radio pueden ser absorbidas por objetos en su camino
 Las antenas pueden ajustarse para incrementar la distancia.
 La línea de visión puede ayudar a incrementar la fiabilidad de la señal.

RSSI (Received Signal Strength Indicator) es el indicador de la cantidad de energía presente

en una señal de radio. Midiendo la fuerza de la señal en la antena receptora es una forma de
determinar la calidad del enlace de comunicación. Su valor se mide en dBm cuanto mayor sea
el valor negativo la señal es más débil. Por lo tanto -50dBm es mejor que -60 dBm.

El pin 6 de los módulos XBee puede ser configurado como salida PWM con el valor de RSSI,
para ello configurar P0 como RSSI [1]. También en el parámetro DB se guarda el valor de
RSSI del último paquete recibido expresado en valor decimal.

Además del valor de RSSI, es conveniente medir la fiabilidad del enlace en porcentaje de
paquetes perdidos, puesto que en entornos con interferencias el valor de RSSI puede ser alto
pero el enlace será malo.

Antenas

A la de lograr un determinado alcance de un módulo, es importante la antena, para ello los

módulos RF XBee disponen de distintos tipos de antenas:

 PCB antenna: está formada en la propia PCB con trazo conductor.

 Cable de antena integrada: es un pequeño cable de 80mm colocado
perpendicularmente a la PCB y soldado directamente a la PCB

 Whip antenna: una antena sólida pero flexible que sobresale 25mm del módulo. Esta
antena aumenta el rango sobre la antena del chip pero en el exterior.
 U.FL antenna: es un pequeño conector para una antena externa. Es una buena opción
si el módulo está en una caja y queremos poner la antena en el exterior.

 RP-SMA antenna: es un conector mayor para una antena externa.

Prueba de Rango

Una prueba de rango nos sirve para medir la calidad del enlace entre dos módulos XBee.
XCTU permite hacer una prueba de rango que supone enviar paquetes desde un módulo local
a uno remoto esperando el echo, contabilizando el número de paquetes enviados y recibidos y
midiendo el RSSI.

Como hacer una prueba de

rango: http://www.digi.com/resources/documentation/Digidocs/90001456-
13/Default.htm#tasks/t_try_range_test.htm
Más información: http://www.digi.com/resources/documentation/Digidocs/90001456-
13/Default.htm#containers/cont_signal_strength.htm

XBee Gateways

Hemos visto cómo hacer una red inalámbrica con los módulos XBee y como hay un
intercambio de información entre los módulo. Ahora bien, si esos datos los queremos sacar
fuera de esa red inalámbrica necesitaremos un gateway que nos saque esos datos a una red
ethernet (Internet/Intranet) o a un bus de campo standard donde poder almacenar y mostrar
los datos y estados de la red Xbee.
XBee to IP Gateway

Este gateway habilita la conexión remota, configuración y gestión de las redes Xbee con redes
IP. Todos los datos Xbee enviados al gateway están automáticamente disponibles para
aplicaciones on line via Device Cloud. Este gateway puede ejecutar aplicaciones python que
comuniquen y gestionen la red XBee.

Más información: http://www.digi.com/products/xbee-rf-solutions/gateways/xbee-gateway

XBee RF Modems

Los módems XBee RF se usan para comunicar con sistemas que usen RS-232, RS-485 o
interfaz USB.

Más información: http://www.digi.com/products/xbee-rf-solutions/modems/xbee-pro-900hp-rf-

modems

Interacción Software – Xbee

Todo el código está disponible en:

 https://github.com/digidotcom/XBeeArduinoCodingPlatform
 Descarga de la última
versión https://github.com/digidotcom/XBeeArduinoCodingPlatform/releases

Los proyectos propuestos en este tutorial para interacción de XBee con software, en este caso
con processing son:

 Follow the
Leader: http://docs.digi.com/display/XBeeArduinoCodingPlatform/Follow+the+Leader
 Car Race
Game: http://docs.digi.com/display/XBeeArduinoCodingPlatform/Car+Race+Game
 Mechanical Sketching
Toy: http://docs.digi.com/display/XBeeArduinoCodingPlatform/Mechanical+Sketching+
Toy
 Scalable Car Race
Game: http://docs.digi.com/display/XBeeArduinoCodingPlatform/Scalable+Car+Race+
Game
 XBee Game
Controller: http://docs.digi.com/display/XBeeArduinoCodingPlatform/XBee+Game+Con
troller

Librería XBee Java: https://github.com/digidotcom/XBeeJavaLibrary

Instalar la librería XBee

java http://docs.digi.com/display/XBeeArduinoCodingPlatform/Installing+the+xbjlib+Processing
+librarypara que una aplicación de processing pueda comunicarse con un modulo XBee

XBee y Arduino

Instalar librería XBee

Arduino http://docs.digi.com/display/XBeeArduinoCodingPlatform/Installing+the+xbee-
arduino+library

Librería: https://github.com/andrewrapp/xbee-arduino

Trabajando con
Arduino: http://docs.digi.com/display/XBeeArduinoCodingPlatform/Working+with+Arduino
Primer proyecto http://docs.digi.com/display/XBeeArduinoCodingPlatform/Stop-
It%21+LED+Game

Todo el código está disponible en:

 https://github.com/digidotcom/XBeeArduinoCodingPlatform
 Descarga de la última
versión https://github.com/digidotcom/XBeeArduinoCodingPlatform/releases

Los proyectos propuestos en este tutorial para uso de XBee con Arduino son:

 LED Game: http://docs.digi.com/display/XBeeArduinoCodingPlatform/Stop-

It%21+LED+Game
 Piedra, Papel y
Tijera: http://docs.digi.com/display/XBeeArduinoCodingPlatform/Rock+Paper+Scissors
 Quiz Show: http://docs.digi.com/display/XBeeArduinoCodingPlatform/Quiz+Show
 Bomb
Defuser: http://docs.digi.com/display/XBeeArduinoCodingPlatform/Bomb+Defuser
 Treasure Hut: http://docs.digi.com/display/XBeeArduinoCodingPlatform/Treasure+Hunt

HW para Arduino

Los dos kits lleva los módulos Serie 1:

 Data sheet del

kit: http://media.digikey.com/pdf/Data%20Sheets/Digi%20International%20PDFs/XKB2
-AT-WWC.pdf
 Datasheet del módulo XBee S1
802.15.4 http://www.digi.com/pdf/ds_xbeemultipointmodules.pdf
 User Guide del módulo XBee S1
802.15.4: http://ftp1.digi.com/support/documentation/90000982.pdf

XBee Shields:

 https://www.arduino.cc/en/Guide/ArduinoWirelessShield
 https://www.arduino.cc/en/Guide/ArduinoWirelessShieldS2
 https://learn.sparkfun.com/tutorials/xbee-shield-hookup-guide
 http://www.seeedstudio.com/wiki/XBee_Shield_V2.0

El Xbee Explorer:

 https://www.sparkfun.com/products/11812

Poner en marcha un Xbee shield:

 https://www.arduino.cc/en/Guide/ArduinoWirelessShieldS2
 https://www.sparkfun.com/products/12847
 https://learn.sparkfun.com/tutorials/xbee-shield-hookup-guide

XBee en la industria: http://www.digi.com/industries

  Sistema de gestión de alumbramiento
público: http://www.digi.com/customersuccesses/xbee-enables-street-light-
management-system
 Monitorización de depósitos: http://www.digi.com/customersuccesses/wireless-tank-
monitoring-with-1844myfuels
Anuncios
REPORT THIS AD

REPORT THIS AD

Compártelo:

 Twitter
 Facebook4
 Google

Relacionado
Conectividad IoTEn "Bluetooth"
Comunicaciones ArduinoEn "Arduino"
WiFiEn "Arduino"
Esta entrada se publicó en Arduino, Comunicación, Xbee y está etiquetada con Arduino, Comunicación
Inalámbrica, IEEE 802.15.4, Xbee, XCTU, zigbee en 16 noviembre, 2016.

Arduino Sleep Mode

2 respuestas

En muchos proyectos donde no es posible tener alimentación eléctrica o de movilidad

tenemos que alimentar el microcontrolador mediante batería, para conseguir alimentar un
microcontrolador durante mucho tiempo con batería podemos usar el modo sleep donde el
consumo se reduce drásticamente.

Ya vimos en el apartado de alimentación Arduino que no tiene sentido alimentar una placa de
Arduino con una batería, incluso aunque pongamos la MCU en modo sleep, puesto que los
componentes de la placa son altamente ineficientes. Sencillamente porque la eficiencia nunca
entró en las especificaciones de diseño, hasta los nuevos modelos.

Normalmente, hay muchos proyectos en los que hay que realizar acciones periódicas de
tiempo en tiempo, como tomar lecturas de sensores o enviar mensajes a un servidor central,
pero la mayor parte del tiempo nuestro Arduino no está haciendo nada más que un loop
continuo.

Sin embargo no hacer nada para un procesador, sigue suponiendo miles de instrucciones por
segundo que consumen una energía preciosa, cuando funciona a baterías.

Cuando el microcontrolador entra en modo de suspensión (sleep) por su código, la ejecución

del código se detendrá en ese punto. Para reanudar la ejecución de su código, el
microcontrolador debe ser despertado desde el modo de suspensión por uno de sus módulos
internos de hardware, temporizador expirado, interrupción externa, WDT, etc.
La librería estándar de Arduino, por ahora no permite acceso a las funciones que hacen dormir
al MCU (Microcontrolador) y hay que usar la librería AVR directamente o librerías de terceros
que nos ayuden a usar el modo sleep.

Para más información ver la documentación del

ATmega328p http://www.atmel.com/Images/Atmel-42735-8-bit-AVR-Microcontroller-
ATmega328-328P_datasheet.pdf en las página 62

Tenemos en el Atmega328p seis modos de Sleep:

 Idle
 ADC Noise Reduction
 Power-save
 Power-down
 Standby
 Extended Standby
El consumo para cada modo es:

 SLEEP_MODE_IDLE: 15 mA
 SLEEP_MODE_ADC: 6.5 mA
 SLEEP_MODE_PWR_SAVE: 1.62 mA
 SLEEP_MODE_EXT_STANDBY: 1.62 mA
 SLEEP_MODE_STANDBY : 0.84 mA
 SLEEP_MODE_PWR_DOWN : 0.36 mA

Los registros usados para manejar el modo sleep:

 Sleep Mode Control Register The Sleep Mode Control Register contains control bits for
power management. When addressing I/O Registers as data space using LD and ST
instructions, the provided offset must be used. When using the I/O specific commands
IN and OUT, the offset is reduced by 0x20, resulting in an I/O address offset within
0x00 – 0x3F.
Name:  SMCR
 MCU Control Register When addressing I/O Registers as data space using LD and ST
instructions, the provided offset must be used. When using the I/O specific commands
IN and OUT, the offset is reduced by 0x20, resulting in an I/O address offset within
0x00 – 0x3F.
Name:  MCUCR
 Power Reduction Register
Name:  PRR

Sleep mode select del registro SMCR:

En avr-libc la librería que gestiona el modo sleep es <avr/sleep.h>

 http://www.atmel.com/webdoc/AVRLibcReferenceManual/group__avr__sleep.html
 http://www.atmel.com/webdoc/AVRLibcReferenceManual/group__avr__sleep.html
 http://www.nongnu.org/avr-libc/user-manual/group__avr__sleep.html
 http://www.nongnu.org/avr-libc/user-manual/group__avr__power.html
 http://www.atmel.com/webdoc/AVRLibcReferenceManual/group__avr__power.html
 Ejemplo de uso: http://www.engblaze.com/hush-little-microprocessor-avr-and-arduino-
sleep-mode-basics/

Más información:
  http://playground.arduino.cc/Learning/ArduinoSleepCode
 http://www.prometec.net/el-modo-sleep-en-arduino/
 http://www.prometec.net/modo-sleep-interrupciones/
 http://www.engblaze.com/low-power-libraries-for-arduino-control-sleep-with-single-
function-calls/
 http://www.gammon.com.au/forum/?id=11497
 https://www.disk91.com/2014/technology/hardware/arduino-atmega328p-low-power-
consumption/
 http://interface.khm.de/index.php/lab/interfaces-advanced/sleep_watchdog_battery/
 https://www.sparkfun.com/tutorials/309
 Enlace muy interesante de low-power Arduino: http://www.gammon.com.au/power

Librerías Modo Sleep Arduino

La librería más ampliamente usada es la low power:

 https://github.com/rocketscream/Low-Power
 http://www.rocketscream.com/blog/2011/07/04/lightweight-low-power-arduino-library/

También hay otras librerías como Enerlib http://playground.arduino.cc/Code/Enerlib o usar las

funciones de avr-libc http://www.engblaze.com/hush-little-microprocessor-avr-and-arduino-
sleep-mode-basics/

Con la librería lowpower es muy fácil poner en modo sleep a Arduino con una línea como:

LowPower.powerDown(SLEEP_8S, ADC_OFF, BOD_OFF);

Hay tres maneras de despertar un Arduino del modo Sleep:

 Interrupciones hardware
 Timers y WDT que es un timer un tanto peculiar
 UART o puerto serie.

Si por un error de programación dejamos arduino en modo sleep permanente, hay que vaciar
la flash de programa y la forma más sencilla es reinstalar reprogramarlo con el blinking led o
cualquier otro programa que no incluya instrucciones de dormir.

En este caso estamos usando el Watch Dog Timer y es una interrupción periódica que se
dispara, si el contador llega a 0. EL WatchDog Timer acepta diferentes periodos de disparo, de
entre una tabla:

 SLEEP_15MS
 SLEEP_30MS
 SLEEP_60MS
 SLEEP_120MS
 SLEEP_250MS
 SLEEP_500MS
 SLEEP_1S
 SLEEP_2S
 SLEEP_4S
 SLEEP_8S
  SLEEP_FOREVER

Esta sencilla instrucción (powerdown) es la de menor consumo de energía, pero hay otros
modos que pueden mantener encendidos ciertos circuitos del procesador interno del UNO y
del Nano y pueden ser útiles:

 idle
 adcNoiseReduction
 powerDown
 powerSave
 powerStandby
 powerExtStandby
 standby

Lista de lo que hace cada modo:

Le pasamos dos parámetros más además del tiempo de despertar, que son:

 ADC_OFF: Apaga los convertidores Analógico a digital

 BOD_OFF: Apaga el circuito de Brown Out Detection, que es un circuito para detectar
niveles bajos de tensión. Si no fuera por este detector BOD, cuando las pilas se fueran
agotando la tensión podría descender de un cierto nivel y dañar los circuitos. Apagarlo
ayuda a reducir consumo, pero ciertamente corres otros peligros.

Usar el WatchDog Timer (del que ya hemos hablado) para despertar cada 8 segundos es una
solución, sin embargo en un proyecto que requiera tomar lecturas cada media hora, despertar
nuestro MCU cada 8 segundos es excesivo, cuando tenemos que estrujar al máximo la
capacidad de la batería.

Para solucionar esto hay un modo de dormir nuestro procesador especialmente útil, que es el
de duérmete sin fecha de despertar, pero despierta cuando recibas una interrupción, es decir
cuando ocurra algo que estamos esperando.

Para ello usamos el ejemplo:

1
void loop()
2
{ attachInterrupt( 0, ServicioBoton, FALLING);
3 LowPower.powerDown(SLEEP_FOREVER, ADC_OFF, BOD_OFF);
4 detachInterrupt(0);
5

6 if (n != contador)

7 { Serial.println(contador);

8 n = contador ;

Serial.flush();
9
}
10
}
11

La primera línea del loop() engancha una interrupción llamada ServicioBoton que se dispara
cuando usamos el pulsador, y que simplemente incrementa contador, para saber cuántas
veces se ha pulsado.

La segunda línea, pone nuestro Arduino a dormir ay va a seguir así hasta que reciba una
interrupción. Cuando detecte una interrupción hardware en el pin 2, despierta súbitamente,
Incrementa el valor de contador y sigue el ciclo normal del programa, donde se encuentra lo
primero con un detachInterrupt, es decir, deshabilitamos las interrupciones hasta que
hagamos nuestra tarea, que en este caso son simplemente comprobar si contador (Que se
incrementó con la interrupción) es diferente de n (El valor último registrador de contador) y si
es así imprime el valor de contador.

Fijaros que no estamos haciendo un debouncing del pulsador. Sería una muy mala idea
hacerlo aquí con un delay, porque el tiempo que durase el delay, nuestro procesador está
activo y consumiendo y eso es algo que no interesa.

También usamos un flush() al final para asegurarnos de que se vacía la cola.

Ejemplo de reducción de consumo:

 http://www.seta43.netau.net/arduraa.html
  http://www.seta43.netau.net/ardurab.html

Tutorial en 5 partes sobre modo sleep:

 http://donalmorrissey.blogspot.com.es/2010/04/putting-arduino-diecimila-to-sleep-
part.html
 http://donalmorrissey.blogspot.com.es/2010/04/putting-arduino-diecimila-to-sleep.html
 http://donalmorrissey.blogspot.com.es/2010/04/sleeping-arduino-part-3-wake-up-
via.html
 http://donalmorrissey.blogspot.com.es/2011/11/sleeping-arduino-part-4-wake-up-
via.html
 http://donalmorrissey.blogspot.com.es/2010/04/sleeping-arduino-part-5-wake-up-
via.html

También hay otra librería de bajo consumo de JeeLib. Para reducir el consumo al máximo lo
mejor es utilizar un microcontrolador solamente y en el skech incluir la librería de bajo
consumo JeeLib.

JeeLib es una colección de ficheros de cabecera, clases y sketches de muestra para su uso
con el IDE de Arduino. Fue escrito y extendido durante los años para simplificar la
experimentación y la exploración del JeeNode y otros productos de JeeLabs.

La clase sleepy es muy sencilla de usar y muy eficaz para hacer sketchs de bajo consumo y
su uso está documentada en: http://jeelabs.org/pub/docs/jeelib/classSleepy.html

Más información:

 http://jeelabs.org/pub/docs/jeelib/
 https://github.com/jcw/jeelib
 http://jeelabs.net/projects/jeelib/wiki
 https://foro.hacklabalmeria.net/t/arduino-bajo-consumo/4230/13
 Uso librería sleepy http://www.homautomation.org/2014/04/03/best-ways-to-power-a-
arduino-according-to-your-need/
 Desarrollar un sketch de bajo consumo: http://jeelabs.org/2011/12/13/developing-a-
low-power-sketch/

Arduinos Compatibles Bajo Consumo

En el mercado tenemos modelos de Arduino y compatible diseñados para tener bajo consumo
y ser alimentados por batería. Combinando este HW con una programación eficiente podemos
lograr dispositivos alimentados por batería durante años:

 Arduino mini: http://www.rocketscream.com/blog/product/mini-ultra-8-mhz-arduino-

compatible/
 Mini ultra con radio: http://www.rocketscream.com/blog/product/mini-ultra-pro-with-
radio/
 Moteino: https://lowpowerlab.com/shop/index.php?_route_=Moteino/moteino-r4
 Arduino
MKR1000: https://store.arduino.cc/index.php?main_page=product_info&products_code
=GBX00004
 JeeNode: http://www.digitalsmarties.net/products/jeenode-usb
  ulpnode: http://hallard.me/category/ulpnode/

Estas placas están diseñadas para consumir poco y usan elementos eficientes. Como se
puede ver son placas que prescinden de elementos innecesarios simplificando mucho las
placas.

El arduino UNO es altamente ineficiente puesto que el diodo de protección y el regulador de

tensión consumen mucho aunque la MCU esté en modo sleep. Intentar alimentar una placa
Arduino UNO con una pila de 9V no es posible si quieres que dure más de un día.

Moteino es una plataforma de desarrollo compatible con Arduino inalámbrico de bajo coste de
bajo consumo basada en el popular chip ATmega328p utilizado en Arduinos tradicionales, lo
que la hace 100% compatible con el IDE de Arduino. Moteino no incluye un convertidor USB-
Serial (como los Arduinos tradicionales), en su lugar es necesario utilizar un adaptador FTDI
externo para cargar los sketches, las ventajas son un menor costo y menor tamaño. Sin
embargo, hay una variante MoteinoUSB que el convertidor serie integrado. Son dispositivos
compatibles con Arduino que utilice el popular transceptor HopeRF RFM69 o el RFM12B más
antiguo. Moteino también viene con un chip de memoria flash SPI opcional para programación
inalámbrica o registro de datos.
Más información:

 https://lowpowerlab.com/guide/moteino/
 https://github.com/lowpowerlab

Para Arduinos alimentados por batería es interesante usar un dispositivo de medida de voltaje
de la batería y saber su capacidad.Esto puede medirse directamente de la batería usando un
divisor de tensión:

 https://lowpowerlab.com/2013/08/27/mailbox-notifier-project-upgrade/
 http://jeelabs.org/2013/05/16/measuring-the-battery-without-draining-it/
Anuncios
REPORT THIS AD

REPORT THIS AD

Compártelo:

 Twitter
 Facebook8
 Google

Relacionado
Alimentación ArduinoEn "Arduino"
Arduino.cc y Arduino.org. Los dos ArduinosEn "Arduino"
Novedades en Arduino. Arduino.cc y Arduino.orgEn "Arduino"
Esta entrada se publicó en Arduino, Sleep Mode y está etiquetada con Arduino, Librerías
Arduino, moteino, Sleep Mode en 16 noviembre, 2016.

IoT con Arduino

2 respuestas

Internet de las cosas (en inglés Internet of things, abreviado IoT) es un concepto que se refiere a la
interconexión digital de objetos cotidianos con Internet.

Definición de wikipedia: https://es.wikipedia.org/wiki/Internet_de_las_cosas

Arduino es un elemento que nos permite de forma sencilla y económica conectar cualquier cosa a
Internet. Con un Arduino y un sencillo módulo ethernet o wifi podemos conectar a Internet sensores para
informar, controlar motores o bombillas desde cualquier parte del mundo o mandar un SMS o email cada
vez que se abra la puerta de casa.

Como afecta IoT a nuestro dia a dia: http://socialgeek.co/tecnologia/8-formas-que-the-internet-of-things-

impactara-dia-dia

IoT en 5 minutos con Arduino: http://hackaday.com/2016/01/08/internet-of-things-in-five-minutes/

Aplicaciones de IoT: https://temboo.com/iot-applications

Temboo es una plataforma de IoT que nos permite conectar fácilmente mediante una API un Arduino
con Internet, mostrar los datos recogidos e interactuar con ellos desde un navegador web.

 Tembo + Arduino: https://temboo.com/arduino/others/

 Tembo + Arduino Yun: https://blog.arduino.cc/2013/09/11/the-power-of-temboo-connect-
the-yun-to-100-apis/

Una visión del IoT aplicado a la industria es lo denominado como Industria 4.0 o Industria conectada o
IIoT que deriva del concepto de M2M (machine to machine) que se refiere al intercambio de
información o comunicación en formato de datos entre dos máquinas remotas sin necesidad de conexión
a Internet sino que puede ser en una red privada y crear una industria inteligente donde todos los
elementos están interconectados y comparten los datos.

Definiciones de wikipedia:

 https://es.wikipedia.org/wiki/M2M
 https://es.wikipedia.org/wiki/Industria_4.0

Diferencias entre IoT y M2M: https://www.pubnub.com/blog/2015-01-02-iot-vs-m2m-understanding-

difference/

Telefónica y IoT: http://www.thinkingthings.telefonica.com/

El coche autónomo, en el que trabajan grupos como Google, BMW, Volvo o Tesla, es toda una proeza
de la robótica.La conducción autónoma se basa en las comunicaciones máquina a máquina (M2M), por
las que los vehículos pueden intercomunicarse con las señales, los semáforos y los otros automóviles.
Todo esto también tiene mucho que ver con las smart cities.
Elementos que intervienen en el IoT

Explicación gráfica de los elementos necesarios en

IoT: http://www.libelium.com/products/meshlium/wsn/

 Qué quieres medir?

 Cómo lo quieres conectar?
 Qué quieres hacer con los datos?
Elementos en IoT:

 Dispositivos Hardware (por ejemplo Arduino), es el dispositivo con el que vamos a medir
(sensor) o interactuar (actuador, p.e. bombilla).
Sensores: https://www.artik.io/blog/2015/iot-101-sensors
HW IoT low cost con ESP8266: https://en.wikipedia.org/wiki/ESP8266
 Conectividad. Medio de comunicación, como vamos a comunicar el HW, ya sea por red o de
forma inalámbrica. Ethernet, Wifi, GPRS, LPWAN, zigbee, bluetooth, ANT+, etc…
Conectividad: https://www.artik.io/blog/2015/iot-101-connectivity

 Protocolos de comunicación, lenguaje para comunicar el HW y el SW. HTTP, fiware, MQTT, API
REST,…
Redes: https://www.artik.io/blog/2015/iot-101-networks
  Plataformas Software, para tratar los datos recogidos por nuestros sensores y almacenarlos.
Pueden ser plataformas de terceros o plataformas propias desarrolladas por nosotros o
simplemente guardar en BBDD propias. Por ejemplo: Carriots, Thingspeak, Temboo, Thinger,
etc…
Además todas estas plataformas SW que están en la nube, deben estar soportadas por un HW
de servidores, unas BBDD de gran capacidad y una infraestructura segura que los hospede.
 Servicios, son los servicios que ofrecen las plataformas como mostrar los datos recogidos,
mandar avisos cuando se detecte un evento o la interconexión con otras plataformas o
simplemente. Servicios ofrecidos por la plataforma carriots: https://www.carriots.com/que-es-
carriots

A modo de resumen, estos son los elementos en el IoT

Sensor — MCU — Comunicación — Protocolo — Plataforma — Servicios

Uno de los retos del IoT es mandar datos de cualquier sensor a través de cualquier protocolo a cualquier
plataforma de forma inalámbrica y usando la menor energía posible (baterías) y todo esto mediante una
comunicación segura.

IoT con Arduino

Ahora vamos a conectar Arduino a Internet o a cualquier otro tipo de red, es este caso usaremos ethernet
y WiFi.
Webserver con Ajax

Mediante Ajax podemos actualizar los datos de la web embebida en Arduino sin necesidad de cargar
toda la web, sino solo mandando los datos actualizados, economizando los datos mandados a través de la
red.

Ajax:

 https://es.wikipedia.org/wiki/AJAX
 http://www.w3schools.com/ajax/ajax_intro.asp

Ejemplo del webserver anterior que muestra los datos de las entradas analógicas pero con Ajax.

Código: https://github.com/jecrespo/Aprendiendo-Arduino-Proyectos/tree/master/Proyecto_9-
Servidor_Web_%20Embebido/EthernetServer-Ajax

Ejemplo avanzado de regulador de encendido con ajax, ejercicio

42: https://github.com/jecrespo/Aprendiendo-Arduino/tree/master/Ejercicio42-Ajax

Grabar datos de Arduino en un Ordenador (datalogger)

Con Arduino conectado a una red, se pueden recoger los datos (datalogger) y mandarlos a un servidor
(p.e. una Raspberry Pi) y guardarlos en una Base de Datos. Con estos datos almacenados podemos
mostrarlos, analizarlos, etc…

Grabar Datos leídos por Arduino en la entrada analógica A0 y grabarlos en una BBDD dentro de una
Raspberry Pi o de un servidor público.

Arduino llama a un servicio (p.e. en PHP) pasándole las variables que quiero almacenar y ese servicio se
encarga de grabar en la BBDD que puede estar en el mismo servidor.
Métodos POST y GET de HTTP: http://www.w3schools.com/tags/ref_httpmethods.asp

Código: https://github.com/jecrespo/Aprendiendo-Arduino-Proyectos/tree/master/Proyecto_10-
Grabar_Raspberry

BBDD: https://qvm602.aprendiendoarduino.com o IP Raspberry Pi

Mandar mensajes de Arduino y visualizarlos en tiempo real

Arduino solicita un nombre y un mensaje que escribimos en el puerto serie y lo manda a un servidor.
Desde el servidor vemos los mensajes en tiempo real. Por ejemplo serviría para enviar alarmas a un
sistema de monitorización cuando Arduino detecta un evento (pulsar un botón, abrir una puerta, etc…).

Visualizar los mensajes: http://www.aprendiendoarduino.com/servicios/ o IP Raspberry Pi

Código: https://github.com/jecrespo/Aprendiendo-Arduino-Proyectos/tree/master/Proyecto_10-
Grabar_Mensajes

Uso de plataformas de IoT con Arduino

Podemos usar de forma gratuita diversas plataformas para conectar nuestro Arduino con ellas y usarlas
para mostrar datos, responder a ciertos eventos, realizar acciones, etc…

Algunas plataformas existentes son:

 Temboo: https://temboo.com/
 Librería: https://temboo.com/library/
 Usar con Arduino: https://temboo.com/arduino
 Aplicaciones IoT: https://temboo.com/iot-applications
 carriots: https://www.carriots.com/
 Mandar datos a Carriots: https://www.carriots.com/tutorials/arduino_carriots/arduino_library
 Ejemplo de uso: https://www.carriots.com/tutorials/arduino_carriots/alert_system
 API carriots: https://www.carriots.com/documentation/api
 ThingSpeak: https://thingspeak.com/
 Ejemplo ThingSpeak: http://community.thingspeak.com/tutorials/arduino/using-an-arduino-
ethernet-shield-to-update-a-thingspeak-channel/
 Librería ThingSpeak: http://community.thingspeak.com/2015/10/official-thingspeak-library-
for-arduino-and-particle/
 nimbits: http://bsautner.github.io/com.nimbits/ (Para instalar una plataforma en una
Raspberry Pi)
 Plot.ly: https://plot.ly/
 API plot.ly: https://github.com/plotly/arduino-api
 Ejemplo: https://plot.ly/arduino/dht22-temperature-tutorial/
 Ejemplo de uso de plot.ly https://github.com/jecrespo/Aprendiendo-Arduino-
Proyectos/tree/master/Proyecto_5-Grafic_Plotly

Ejercicios IoT

Plataforma Aprendiendoarduino
Disponemos de una plataforma sencilla de IoT en http://www.aprendiendoarduino.com/servicios/

Desde ella podemos:

 Mandar datos desde Arduino o ESP8266 y verlos en tiempo

real: http://www.aprendiendoarduino.com/servicios/datos/index.html
 Visualizar en tiempo real los datos
enviados: http://www.aprendiendoarduino.com/servicios/datos/graficas.html
 Envío de mensajes y
visualización: http://www.aprendiendoarduino.com/servicios/mensajes/index.html
 Envío de SMSs y visualización de los enviados y estado del
envío: http://www.aprendiendoarduino.com/servicios/SMS/index.html

El código de arduino para usar cada uno de ellos es:

 Datalogger temperatura: https://github.com/jecrespo/aprendiendoarduino-

servicios/tree/master/arduino_code/data_logger_temperatura_DHCP
 Grabar mensajes: https://github.com/jecrespo/aprendiendoarduino-
servicios/tree/master/arduino_code/graba_mensaje_DHCP
 Envía SMS: https://github.com/jecrespo/aprendiendoarduino-
servicios/tree/master/arduino_code/envia_SMS_DHCP

Todo el código de la plataforma y Arduino en: https://github.com/jecrespo/aprendiendoarduino-servicios

Conexión para enviar datos de temperatura:

Datasheet sonda temperatura: https://www.arduino.cc/en/uploads/Main/TemperatureSensor.pdf

Thingspeak

Mandar datos de temperatura a una plataforma pública como https://thingspeak.com/

Código: https://github.com/jecrespo/Aprendiendo-Arduino/tree/master/Ejercicio65-Thingspeak_DHCP

ESP8266
Hacer un sketch para ESP8266 que mande un mensaje de alarma o un SMS cuando se ponga a masa el
GPIO2 a masa y mande la recuperación al volver a leer HIGH.

ADVERTISEMENT
Anuncios
REPORT THIS AD

REPORT THIS AD

Compártelo:

 Twitter
 Facebook6
 Google

Relacionado
¿Qué es IoT?En "Arduino"
Arduino y IoTEn "Arduino"
Presentación Curso Soluciones IoT con Herramientas LibresEn "Arduino"
Esta entrada se publicó en Arduino, IoT y está etiquetada
con Arduino, Datalogger, IoT, plataformas, smart city en 16 noviembre, 2016.

Presentación del Curso

Deja un comentario

Objetivos

El objetivo de este curso es iniciarse en el mundo del hardware libre, los microcontroladores,
Internet de las cosas, robótica, el mundo maker y DIY, utilizando la plataforma Arduino.

Al finalizar el curso serás capaz de manejar la plataforma Arduino, conocer su potencial e

implementar proyectos sencillos con Arduino. Aprenderás a usar el entorno de programación
utilizado por Arduino y ejecutar programas sobre Arduino.

Requisitos

Este curso parte desde cero, por lo que no son necesarios unos conocimientos previos, pero
sí son recomendables conocimientos básicos de programación (especialmente C++),
electricidad y electrónica.

Es recomendable un conocimiento medio de Inglés puesto que gran parte de la

documentación está en Inglés.

Metodología

Este curso de iniciación es principalmente práctico pero se verán algunos conceptos teóricos
que establecen las bases necesarias para entender la plataforma Hardware y Software de
Arduino.
La duración es de 6 horas repartidas en dos jornadas de tres horas cada una.

Los recursos utilizados para la realización de este curso son:

 La documentación del curso se publicará en formato web a través la

página: http://www.aprendiendoarduino.com/ur-maker-2016/ y se usará para realizar el
seguimiento del curso.
 Todo el código de las prácticas utilizado en el curso está disponible
en: https://github.com/jecrespo/Aprendiendo-Arduino
 Las publicaciones del curso y otros recursos interesantes que se comentarán a lo largo
del curso se podrán seguir a través de twitter:
 hashtag #aprendiendoarduino
 web: https://twitter.com/hashtag/aprendiendoarduino?f=realtime&src=hash
 cuenta twitter: https://twitter.com/jecrespom

Además están disponibles otros recursos para ampliar información:

 Más cursos, talleres y publicaciones en:

 http://www.aprendiendoarduino.com/
 https://aprendiendoarduino.wordpress.com/
 Más código Arduino: https://github.com/jecrespo
 Lista de
correo: http://list.aprendiendoarduino.com/mailman/listinfo/aprendiendoarduino.com.not
icias

Para interactuar en el curso se puede hacer mediante:

 twitter con el hashtag #aprendiendoarduino

 En el blog poniendo comentarios en los post con la documentación del curso
 correo a aprendiendoarduino@gmail.com

Para realizar las prácticas de este curso es necesario usar un kit de Arduino con al menos un
Arduino, algunos sensores, actuadores y elementos de electrónica como jumpers,
resistencias, leds, etc…

La documentación del curso y código de Arduino está continuamente creciendo y disponible

de forma libre en http://www.aprendiendoarduino.com/ y http://github.com/jecrespo. Todos los
cursos, talleres, jornadas, etc… estarán disponibles en estas webs.

Toda la documentación está liberada con licencia Creative Commons. Reconocimiento –

NoComercial – CompartirIgual (by-nc-sa): No se permite un uso comercial de la obra original
ni de las posibles obras derivadas, la distribución de las cuales se debe hacer con una licencia
igual a la que regula la obra original.

Aprendiendo Arduino by Enrique Crespo is licensed under a Creative Commons

Reconocimiento-NoComercial-CompartirIgual 4.0 Internacional License.
Material

Todo el material entregado es en préstamo y debe cuidarse al máximo, a la hora del montaje
de las prácticas se seguirán las instrucciones para evitar dañar los componentes.

Todos los Kits y Arduino en préstamo tienen un número de serie entre el 1 y 21. A cada
alumno se le asignará uno de ellos y es el que usará durante todo el curso.

Al principio del curso se entregará una hoja de préstamo de material que deberá estar
rellenada con el número de kit entregado y firmada. Al final del curso se entregará otra hoja de
devolución de material comprobando que todo el material está correcto.

Organización del curso

Duración total de 6 horas. El curso se celebra los viernes 16 y 23 de diciembre de 2016 en

horario de 17.00 a 20.00. Se hará un descanso de 5 minutos aproximadamente a mitad de la
sesión.

Contenido del curso día 1:

 Hardware y Software Arduino

 Comunidad Arduino
 Programación Arduino

Contenido del curso día 2:

 Manejar Arduino
 Fabricación con Arduino
 Arduino Conectado a Internet

Documentación del curso: http://www.aprendiendoarduino.com/ur-maker-2016/

Como Empezar con Arduino

Para empezar con Arduino debes preguntarte qué sabes de electrónica y qué sabes de
programación. Si no sabes de electrónica, es difícil entender cómo funcionan los elementos
con los que va a interactuar la placa Arduino y si no sabes de programación no va a ser
posible traducir las órdenes que deseas hacer a la electrónica para que las ejecute Arduino.

La gran ventaja de Arduino es que no es necesario ser un experto en cada una de esas áreas,
nos ofrece una capa de programación fácil de entender y el HW es muy sencillo de manejar
sin saber mucho de electrónica.

 ¿Cuanto sabes de electricidad/electrónica?

 ¿Cuanto sabes de programación?

En este curso no es posible a aprender a programar o electrónica, para ello necesitaríamos

mucho más tiempo, pero sí vamos a aprender la estructura de los programas, manejar el HW
de Arduino y las estructuras de programación del core o API de Arduino.
También pondremos más de énfasis en lo que es un makerspace y un Fab Lab, la fabricación
con Arduino, dado el entorno donde nos encontramos, y en la conexión a Internet de Arduino
pues donde más potencial se puede sacar.

Estamos en un curso de iniciación a Arduino y el objetivo es iniciarse para luego seguir

aprendiendo y hacer proyectos en el propio makerspace o cada uno por su cuenta. Iniciar a
los usuarios o posibles usuarios del makerspace en Arduino, es decir, Arduino como una parte
de un proyecto completo que incluya el diseño y fabricación de una pieza en 3D e incluso
también de una placa pcb.

Artículos de como empezar con Arduino:

 http://www.aprendiendoarduino.com/2016/08/16/como-empezar-con-arduino/
 http://rufianenlared.com/como-empezar-arduino/

Un buen tutorial para los que están empezando lo puedes ver

en https://openwebinars.net/tutorial-de-arduino/

Contacto

Para cualquier consulta durante el curso y en cualquier otro momento mediante

email: aprendiendoarduino@gmail.com

Twitter @jecrespo: https://twitter.com/jecrespom

Y más información sobre el curso y el autor: http://www.aprendiendoarduino.com/acerca-de/

Anuncios
REPORT THIS AD

REPORT THIS AD

Compártelo:

 Twitter
 Facebook
 Google

Relacionado
Presentación Taller Arduino Ingenia’18En "Arduino"
Presentación del cursoEn "Arduino"
Presentación del cursoEn "Arduino"
Esta entrada se publicó en Arduino, Presentacion y está etiquetada con Arduino, Empezar con
Arduino, makerspace, Presentacion en 11 diciembre, 2016.