Manual Arduino
Manual Arduino
Manual Arduino
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.
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…
Metodología
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.
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…
Programación Arduino
1 respuesta
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.
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++:
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
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.
https://en.wikipedia.org/wiki/C_data_types
http://www.cplusplus.com/doc/tutorial/variables/
https://msdn.microsoft.com/en-us/library/cc953fe1.aspx
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/
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/
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.
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
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
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
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:
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
setup() – http://arduino.cc/en/Reference/Setup
loop() – http://arduino.cc/en/Reference/Loop
En arduino para tratar las entradas y salidas digitales usamos las siguientes funciones:
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
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
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
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.
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.
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
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/
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
Electrónicos
Hidráulicos
Neumáticos
Eléctricos
Motores
Bombas
Ejemplos de periféricos:
Pantallas LCD
Teclados
Memorias externas
Cámaras
Micrófonos
Impresoras
Pantalla táctil
Displays numéricos
Zumbadores
Indicadores luminosos, etc…
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
Smoothing: https://aprendiendoarduino.wordpress.com/2016/07/02/smoothing/
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.
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.
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.
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
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/
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
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
Protocolo TCP/IP
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.
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
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/
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.
Ethernet Class
Trabaja con IPs locales y remotas. Facilita el trabajo con direcciones IPs.
Server Class
Crea un servidor que puede mandar y recibir datos de los clientes conectados.
Client Class
Protocolo HTTP
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 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/
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:
/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)
http://blog.micayael.com/2011/02/09/metodos-get-vs-post-del-http/
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.
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 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.
Práctica: Comunicaciones IP
https://github.com/jecrespo/Aprendiendo-Arduino/tree/master/Otros/DHCP_Arduino
https://github.com/jecrespo/Aprendiendo-Arduino/tree/master/Otros/IP_fija_Arduino
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.
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
Componentes:
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
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.
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
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.
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
con lo que tiene (datos) y su algoritmo o programa Es una de sus partes principales, la cual se encarga de
RAM y ROM para su óptimo funcionamiento. Las incluye en un solo circuito integrado.
Velocidad de
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
Para el Microprocesador, el costo es muy alto en la El costo para un sistema basado en Microcontrolador
cableado externo que lo hace más propenso al El alto nivel de integración reduce los niveles de
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)
GPIO:
También intel saca su alternativa a raspberry: http://www.intel.es/content/www/es/es/do-it-
yourself/edison.html
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.
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 los valores que pueden tomar las variables dependen del tamaño de la
palabra: http://es.wikipedia.org/wiki/Palabra_%28inform%C3%A1tica%29
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
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.
http://arduino.cc/en/Tutorial/Memory
https://aprendiendoarduino.wordpress.com/2015/03/29/memoria-flash-sram-y-eeprom/
Placa Arduino Uno a fondo:
Operating Voltage 5V
SRAM 2 KB (ATmega328)
EEPROM 1 KB (ATmega328)
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
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
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.
HoodLoader2: https://github.com/NicoHood/HoodLoader2
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/
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:
Microcontroladores Arduino
Como vimos anteriormente, Arduino es una plataforma para programar de forma sencilla
algunos microcontroladores de la familia AVR de Atmel: http://es.wikipedia.org/wiki/AVR 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.
Puesto que Arduino es una plataforma open source disponemos de toda la documentación de
los microcontroladores usados.
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.
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:
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
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
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.
En el caso del ATmega328p, tiene una arquitectura RISC con 131 instrucciones, la mayoría de
ellas ejecutadas en un solo ciclo de reloj.
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.
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.
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
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
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.
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.
Ejecutar el sketch leer y entender lo que hace y probarlo. Comparar con otros Arduinos y
calibrar.
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
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.
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.
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.
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.
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
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.
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.
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.
Por su parte arduino.org también está trabajando en un rediseño desde cero del clásico IDE
llamado 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”
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.
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
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.
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/
Se trata de una versión de Eclipse paquetizada para usar con Arduino totalmente libre.
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
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.
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):
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)
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.
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);
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:
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
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:
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:
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:
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:
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:
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.
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.
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
Ver ejercicio simple con los registros PORT, PIN y DDR y sacarlos por pantalla.
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.
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.
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.
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.
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.
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.
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.
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
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
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.
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.
Flash 32k bytes (of which 0.5k is used for the bootloader)
SRAM 2k bytes
EEPROM 1k byte
Memoria ESP8266:
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
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.
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.
.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)
PROGMEM
Más información:
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.
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/
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.
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;
}
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.”
Resultado:
https://github.com/jecrespo/Aprendiendo-Arduino/tree/master/Ejercicio05-
Memoria/Memoria1
https://github.com/jecrespo/Aprendiendo-Arduino/tree/master/Ejercicio05-
Memoria/Memoria2
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.
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 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
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.
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
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
Ejercicios EEPROM
Volcado EEPROM
Ejercicio EEPROM
Ejemplo: http://playground.arduino.cc/Code/EEPROMLoadAndSaveSettings
Struct: http://www.cplusplus.com/doc/tutorial/structures/
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.
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.
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.
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:
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
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.
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 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.
Antes de utilizar la tarjeta SD de Arduino debes abrir el archivo sobre el que vayas a trabajar
(verás cómo más adelante). Si por cualquier motivo pierdes la comunicación con dicho archivo
antes de cerrarlo, podrías perder tus datos. Los datos solo se guardan cuando cierras el
archivo o usas la función flush().
Más información:
Ejercicios con SD
http://arduino.cc/en/Tutorial/Datalogger
http://arduino.cc/en/Tutorial/DumpFile
Solución: https://github.com/jecrespo/Aprendiendo-Arduino/tree/master/Ejercicio30-SD
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.
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
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.
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.
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
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.
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
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.
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
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.
Además hay disponible una entrada al bus de 5V para la alimentación directa del cable USB.
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.
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/
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
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.
Control
Design Flexibility Buck Buck, Boost, Buck-Boost
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
https://www.arduino.cc/en/uploads/Main/Arduino_Uno_Rev3-schematic.pdf
http://download.arduino.org/products/UNO/Arduino-UNO-SMD-Rev3e-SCH.pdf
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
Arduino mejorado con selector de voltaje y un regulador más potente entre otras
modificaciones: http://playground.arduino.cc/Main/Luigino328
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.
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.
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.
https://es.wikipedia.org/wiki/MOSFET
https://www.fairchildsemi.com/datasheets/FD/FDN340P.pdf
http://es.rs-online.com/web/p/transistores-mosfet/6710435/
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
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.
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.
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.
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.
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/
https://www.youtube.com/watch?v=WmcMrKELkcs&feature=youtu.be
https://www.youtube.com/watch?v=P_fb6njcaoU
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.
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
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.
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.
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/
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/
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.
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/
http://tienda.bricogeek.com/shields-arduino/520-arduino-solar-charger-shield.html
http://wiki.seeedstudio.com/wiki/Solar_Charger_Shield_V2.2
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:
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.
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.
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 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:
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.
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)
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/
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.
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.
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.
Optiboot: https://github.com/Optiboot/optiboot
Wiki: https://github.com/Optiboot/optiboot/wiki
Optiboot anterior: https://code.google.com/p/optiboot/
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
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.
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
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
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.
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
Ejercicios Bootloader
Usar un Arduino como pasarela para programar otro directamente sin bootloader.
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.
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.
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.
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/
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:
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
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.
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.
1
void setup() {
2 //Initialize serial and wait for port to open:
3 Serial.begin(9600);
4 while (!Serial) {
}
6
}
7
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
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.
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.
http://www.edn.com/electronics-blogs/embedded-basics/4440395/USART-vs-UART–
Know-the-difference
http://www.firmcodes.com/difference-uart-usart/
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:
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.
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.
Principales características del módulo USART, para mayor información ver datasheet del
microcontrolador.
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.
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
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.
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.
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
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
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.
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:
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.
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
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.
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.
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.
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:
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.
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.
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
gcc-avr
binutils-avr
gdb-avr
avr-libc
avrdude
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
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
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/
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
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.
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.
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.
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”
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
También es posible tener varias versiones del IDE instaladas, simplemente usar la instalación
manual con el archivo .zip
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.
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
https://www.arduino.cc/en/Math/H
http://www.nongnu.org/avr-libc/user-manual/group__avr__math.html
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.
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.
Herramientas WinAVR:
avr-gcc (compiler)
avrdude (programmer)
avr-gdb (debugger)
avr-libc (with a good HTML help Documentation)
and more …..
https://sourceforge.net/projects/winavr/
http://winavr.sourceforge.net/
Más información:
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
Proceso de compilación
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.
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:
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/
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
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).
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
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
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
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.
http://savannah.nongnu.org/projects/avrdude
http://www.nongnu.org/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
http://arduinodev.com/arduino-builder-tutorial/
http://arduinodev.com/arduino-uploader/
code: https://github.com/stanleyhuangyc/ArduinoUploader
ejecutable https://sourceforge.net/projects/arduinodev/
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:
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.
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/
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
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.
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
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.
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.
Características:
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.
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
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.
Recursos: https://espressif.com/en/products/hardware/esp8266ex/resources
Datasheet: https://espressif.com/sites/default/files/documentation/0a-
esp8266ex_datasheet_en.pdf
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:
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
Name pins Pitch Form factor LEDs Antenna Shielded? (mm) Notes
ESP-
ESP- 2×7
ESP- 2×4
ESP- U-FL
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
ESP-
ESP-
ESP- 2×8
12 14 2 mm castellated Yes PCB trace Yes 24.0 × 16.0 FCC and CE approved[14]
ESP- 2×8
12F 20 2 mm castellated Yes PCB trace Yes 24.0 × 16.0 antenna performance. 4 MB Flash
2×8
ESP- castellated
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
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/
Datasheet
ESP32: https://espressif.com/sites/default/files/documentation/esp32_datasheet_en.pdf
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)
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:
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:
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
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.
Comandos hayes:
https://es.wikipedia.org/wiki/Conjunto_de_comandos_Hayes
https://en.wikipedia.org/wiki/Hayes_command_set
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
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.
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
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
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.
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.
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.
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
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
Podemos poner el ESP8266 en modo punto de acceso para que se conecten otros
dispositivos wifi, recordad que es un modo soft AP.
AT+CWSAP=”NoWorriESSID”,”password”,3,0
AT+CWMODE=3
AT+CWLIF: IP de los dispositivos conectados
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/
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
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
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.
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/
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.
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
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/
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/
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
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.
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:
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
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
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.
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.
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.
Es una librería para configuración y manejo del ESP8266 por el bus I2C.
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.
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
http://arduino.cc/en/Main/ArduinoWiFiShield
http://arduino.cc/en/Guide/ArduinoWiFiShield
http://arduino.cc/en/uploads/Main/arduino-wifi-shield-schematic.pdf
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
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.
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.
Solución: https://github.com/jecrespo/Aprendiendo-Arduino/tree/master/Ejercicio27-
Boton_Mejorado_WIFI
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
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.
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.
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:
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.
Pinout:
Web del producto https://www.arduino.cc/en/Main/ArduinoMKR1000
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
Tutoriales 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
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 – 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.
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
https://learn.adafruit.com/adafruit-cc3000-wifi/overview
http://www.openhomeautomation.net/wireless-relay-arduino-wifi/
http://www.esp32.com/viewtopic.php?t=121
Version beta https://github.com/me-no-dev/ESP31B
Tutorial http://www.instructables.com/id/Beginners-ESP32-Guide-to-Assembly-Testing/
WiFi3 Click
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.
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.
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.
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.
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.
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:
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
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:
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.)
Comandos AT básicos
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
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/
Para dotar de comunicación bluetooth con Arduino podemos hacerlo de varia formas:
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
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.
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.
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.
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
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.
1 #include <SoftwareSerial.h>
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
COMMAND FUNCTION
http://www.instructables.com/files/orig/FKY/Z0UT/HX7OYY7I/FKYZ0UTHX7OYY7I.pdf
http://www.martyncurrey.com/?wpdmdl=2248
https://arduino-info.wikispaces.com/BlueToothCommandUtility
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
Interacción Móvil-Arduino
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
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.
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.
Tipos 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
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…
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.
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:
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/
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.
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.
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.
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.
“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
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
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:
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.
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.
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
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.
Más información de
interrupciones: http://cs4hs.cs.pub.ro/wiki/roboticsisfun/chapter2/ch2_10_interrupts
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:
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.
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.
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
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).
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() {
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.
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 {
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
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
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:
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
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ódigo:
void software_Reset()
// Restarts program from beginning but
// does not reset the peripherals and registers
{
asm volatile (” jmp 0″);
}
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
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).
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.
http://es.wikipedia.org/wiki/Serial_Peripheral_Interface
http://en.wikipedia.org/wiki/Serial_Peripheral_Interface_Bus
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.
Desventajas de SPI:
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.
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.
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.
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.
Métodos SPI:
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
(CPOL/CKP) (CKE/NCPHA)
0 0 1
1 0 0
2 1 0
3 1 1
Más información:
https://www.arduino.cc/en/Reference/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.
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.
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.
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
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
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
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).
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
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.
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.
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 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.
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.
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.
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
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)
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:
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:
https://github.com/quick2wire/quick2wire-python-api
http://elinux.org/Interfacing_with_I2C_Devices
http://www.acmesystems.it/i2c
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).
http://wiibrew.org/wiki/Wiimote
http://wiibrew.org/wiki/Wiimote/Extension_Controllers
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.
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;
}
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);
30
void loop()
31 {
32 delay(1000);
33 }
34
35
36
37
Comunicar Arduinos por I2C
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.
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.
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.
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.
http://www.superrobotica.com/s310425.htm
http://www.robot-electronics.co.uk/htm/usb_i2c_tech.htm
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
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.
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.
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:
Es posible probar a cambiar el valor de 0.98 y 0.02 por un valor personalizado. Eso sí, ambos
tienen que sumar 1.
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.
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.
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/
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
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
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
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.
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.
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/
Generalmente encontramos RTCs con bus I2C,pero también se pueden encontrar con puerto
serie o bus SPI o 1-Wire.
Más información:
http://www.prometec.net/relojes-rtc/
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:
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
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
Ejercicio43-RTC2: Mostrar en una pantalla LCD la fecha y hora obtenida del RTC.
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
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.
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:
instrucciones;
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
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.
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.
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
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:
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
15 }
16
int mayor(int a, int b, int c, int d) {
17
return mayor(mayor(a, b), mayor(c, d));
18
}
19
20
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
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.
Ejemplo:
3 return b;
4 }
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
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 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.
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
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
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:
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.
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.
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.
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
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.
Las librerías normalmente incluyen los siguientes archivos comprimidos en un archivo ZIP o
dentro de un directorio. Estas siempre contienen:
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.
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
C:\Users\usuario\AppData\Local\Arduino15\library_index.json
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.
Como ejemplo para aprender a usar una librería, veamos las librerías Time y Timezone.
Para aprender a manejarlas, simplemente leer el fichero readme que viene en el repositorio de
github y luego los ejemplos.
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:
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.
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.
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 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:
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
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.
Ejemplo morse.ino
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.
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
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.
#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
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.
/*
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.
#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
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.
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
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
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.
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.
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.
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 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:
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
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/
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.
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.
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.
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.
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.
XBee:
https://en.wikipedia.org/wiki/XBee
http://www.digi.com/lp/xbee
http://examples.digi.com/
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)
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
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
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.
Adafruit
Fry’s
Maker Shed
Microcenter
Parallax
RobotShop
Seeed Studio
Solarbotics
Sparkfun
TrossenRobotics
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.
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á.
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.
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.
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
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.
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
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.
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.
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
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:
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.
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.
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:
Para resolver estas limitaciones XBee da la alternativa del modo API (Application
Programming Interface).
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.
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.
Transparent 0 API modes are disabled and the module operates in transparent mode
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.
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:
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.
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.
Esta imagen resume el intercambio de información en los puestos serie de los módulos.
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.
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:
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.
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.
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:
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.
Aclaraciones:
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
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.
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.
IA — 1234 Defines the address of the transmitting module (leader) to pair for I/O.
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
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.
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:
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.
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.
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
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.
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)
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
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.
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
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.
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.
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.
Los módems XBee RF se usan para comunicar con sistemas que usen RS-232, RS-485 o
interfaz USB.
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
XBee y Arduino
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
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:
HW para Arduino
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
https://www.arduino.cc/en/Guide/ArduinoWirelessShieldS2
https://www.sparkfun.com/products/12847
https://learn.sparkfun.com/tutorials/xbee-shield-hookup-guide
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.
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.
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
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
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
https://github.com/rocketscream/Low-Power
http://www.rocketscream.com/blog/2011/07/04/lightweight-low-power-arduino-library/
Con la librería lowpower es muy fácil poner en modo sleep a Arduino con una línea como:
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
Le pasamos dos parámetros más además del tiempo de despertar, que son:
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.
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.
http://www.seta43.netau.net/arduraa.html
http://www.seta43.netau.net/ardurab.html
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/
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:
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.
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.
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.
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.
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
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
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
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.
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
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
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…).
Código: https://github.com/jecrespo/Aprendiendo-Arduino-Proyectos/tree/master/Proyecto_10-
Grabar_Mensajes
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…
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/
Thingspeak
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.
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.
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.
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.
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…
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.
Manejar Arduino
Fabricación con Arduino
Arduino Conectado a Internet
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.
http://www.aprendiendoarduino.com/2016/08/16/como-empezar-con-arduino/
http://rufianenlared.com/como-empezar-arduino/
Contacto
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.