Archivo de la categoría: Curso Arduino Iniciación

Uso de Librerías Arduino

La instalación, actualización y manejo librerías en Arduino es un aspecto importante a la hora de usar Arduino, veamos unos ejemplos. Para aprender a instalar librerías lo mejor es practicar, veamos unos ejemplos de instalación de algunas librerías muy útiles.

Cuando se va a instalar una librería, la primera tarea es leer la documentación y aprender a usarla, ya sea leyendo el código, viendo los ejemplos o revisando la documentación si está disponible.

Pasos para realizar los ejemplos propuestos:

  • Leer la documentación y entender que hace la librería.
  • Buscar e instalar la librería desde el gestor de librerías, si está disponible.
  • Descargar el .zip del repositorio de github si no está en el gestor de librerías. Botón Download zip
  • Abrir alguno de los ejemplo suministrados por las librerías, leer el código, entender que hace y ejecutarlo en Arduino.

Desinstalar librerías: Para desinstalar una librería simplemente borrar el directorio de la librería situado en la ruta configurada en las preferencias de Arduino y reiniciar el IDE.

Librería MsTimer2

MsTimer2 nos ofrece muchas utilidades de temporización muy útiles en el trabajo diario con Arduino.

Instalar la librería MsTimer2 desde el gestor de librerías. Ejecutar el programa de ejemplo incluido en la librería para hacer blink (FlashLed) en el led integrado sin necesidad de usar la instrucción delay().

Esquema de conexiones:

Documentación de la librería: http://playground.arduino.cc/Main/MsTimer2

Nueva versión de la librería: http://www.pjrc.com/teensy/td_libs_MsTimer2.html

Repositorio: https://github.com/PaulStoffregen/MsTimer2 

Librería Timer

La librería Timer es otra de librería de muy interesante de temporización más flexible pero menos exacta de MsTimer2. Esta librería no está disponible en el gestor de librerías.

Documentación de la librería: http://www.doctormonk.com/2012/01/arduino-timer-library.html

Repositorio: https://github.com/JChristensen/Timer 

Instalar la librería timer y ejecutar los ejemplos blink2 y read_A0_flashLED.

Esquema conexión blink2 (prestar atención al código y poner los leds a los pines correctos):

Esquema conexión read_A0_flashLED (prestar atención al código y poner el led al pin correcto o cambiar el código):

Comparación comportamiento librería msTimer2 y Timer: https://github.com/jecrespo/Aprendiendo-Arduino/tree/master/Otros/compara_timers 

Librería Time

La librería Time que añade funcionalidades de mantenimiento de fecha y hora en Arduino sin necesidad de un hardware externo. También permite obtener fecha y hora como segundo, minuto, hora, día, mes y año.

Librería: http://playground.arduino.cc/Code/Time

Documentación: http://www.pjrc.com/teensy/td_libs_Time.html

Repositorio: https://github.com/PaulStoffregen/Time 

Instalar la librería Time desde el gestor de librerías y ejecutar el ejemplo TimeSerial. Para ver la hora que debemos mandar a Arduino en el ejemplo ver https://www.epochconverter.com/ 

Librería para sonda temperatura/humedad DHT.

Librería para manejar un elemento HW como la sonda de temperatura y humedad DHT22.

Señal de comunicación:

Web del sensor: http://www.seeedstudio.com/depot/grove-temperaturehumidity-sensor-pro-p-838.html 

Documentación: http://www.seeedstudio.com/wiki/Grove_-_Temperature_and_Humidity_Sensor_Pro

Datasheet: https://arduino-info.wikispaces.com/file/view/DHT22.pdf/556588503/DHT22.pdf 

Repositorio: https://github.com/Seeed-Studio/Grove_Temperature_And_Humidity_Sensor

En este caso en el gestor de librerías tenemos dos librerías disponibles:

Pero la tienda donde lo compro me recomienda usar la librería https://github.com/Seeed-Studio/Grove_Temperature_And_Humidity_Sensor

Además de estas tres librerías, existen muchas más. Cualquiera de las librerías para la sonda DHT22 vale para usarla, pero cada una de ellas funciona diferente y cada una de ellas tiene sus ventajas e inconvenientes.

Mi recomendación es la librería DHTstable de Rob Tillaart: https://github.com/RobTillaart/Arduino/tree/master/libraries/DHTstable 

Versión modificada de la librería: https://github.com/jecrespo/DHTlib 

Probar varias librerías y comparar su uso.

Librería Pantalla LCD I2C

Ver este ejemplo: https://aprendiendoarduino.wordpress.com/2018/10/17/pantalla-lcd-i2c-en-arduino/

Instalar la librería LiquidCrystal_I2C del gestor de librerías. Más información https://github.com/marcoschwartz/LiquidCrystal_I2C

En función de la pantalla que compremos TFT, LCD, OLED, etc… hay que buscar que chip disponen y seleccionar la librería adecuada:

Anuncio publicitario

Shields Arduino

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

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

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

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

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

En algunos casos los shields pueden tener el pineado que no permite apilar más.

Ejemplo de 25 shields útiles: https://randomnerdtutorials.com/25-arduino-shields/

Todas las shields de Arduino pueden verse en:

Ethernet Shield V1

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

Esta shield ha sido retirada en sustitución de la Ethernet Shield V2 https://www.arduino.cc/en/Main/ArduinoEthernetShield

Este Shield es el usado en el curso.

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

Ethernet Shield 2

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

Se trata de una versión mejorada del Ethernet Shield V1 con el chip ethernet W5500 en lugar del W5100. Aporta mejoras a la versión 1 y se usa con la librería ethernet2 en lugar de la librería ethernet. https://www.arduino.cc/en/Reference/Ethernet

Chip W5500: http://wizwiki.net/wiki/lib/exe/fetch.php?media=products:w5500:w5500_ds_v106e_141230.pdf

Arduino Wifi Shield

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

Permite conectar un Arduino a Internet mediante Wifi y hace uso de la librería WiFi Library http://arduino.cc/en/Reference/WiFi. También dispone de un slot para una tarjeta micro SD.

Este shield se comunica con Arduino a través del bus SPI mediante los pines ICSP y usa los pines 4 y 10 al igual que la Shield Ethernet. También hace uso del pin 7 que no puedes ser usado.

Debe tenerse en cuenta que dado que la tarjeta SD y la wifi usan el mismo bus SPI, no pueden trabajar simultáneamente, lo que es un punto importante durante la programación si usamos ambos periféricos. Esta tarjeta también dispone de unos interfaces en placa para actualizaciones de firmware y diagnósticos.

Este shield ya está descatalogado y ha sido sustituido por el Arduino WiFi Shield 101

Arduino WiFi Shield 101

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

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

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

Arduino GSM Shield V2

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

Esta placa sustituye a la GSM Shield V1: https://www.arduino.cc/en/Main.ArduinoGSMShieldV1

Conecta Arduino a Internet mediante GPRS, usando una tarjeta SIM. También permite enviar y recibir mensajes y llamadas de voz (SMSs)

Telefónica presentó la nueva versión del proyecto Arduino GSM/GPRS Shield, un dispositivo que incorpora conexión GPRS/GSM a una placa base de hardware libre, dando como resultado un dispositivo de bajo coste conectado gracias a la tecnología machine to machine (M2M) de Telefónica. ¿El fin? Abrir nuevas posibilidades para que el llamado internet de las cosas pueda prosperar de forma sencilla y económica con la colaboración de Arduino.

Como cualquier otro elemento de Arduino, está disponible la documentación de HW y SW y es open source. Usa los pines 2 y 3 (software serial) y el pin 7 (reset), pero hay una serie de condicionantes para su uso con los Arduinos Mega, Yun y Leonardo debido a que los pines que se usan para comunicar deben tener implementada interrupción en el pin 2.

Para su uso es necesaria la librería GSM Library: http://arduino.cc/en/Reference/GSM

En este caso por el consumo de esta shield, se hace necesario alimentar a Arduino mediante una fuente externa y no desde el USB ya que no es capaz de proporcionar suficiente energía. También es posible hacer llamadas de voz haciendo unas pequeñas modificaciones, añadiendo un micrófono y un altavoz.

Arduino Motor Shield

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

Permite manejar dos motores DC, controlando su dirección y velocidad. Está basado en un chip de doble puente H L298:

Como veremos en este curso manejaremos un motor DC con otro integrado de puente H el L293 (http://www.ti.com/lit/ds/symlink/l293.pdf), pero este shield nos facilita mucho su uso.

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

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

Arduino 4 Relay Shield

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

Este shield permite usar 4 relés para manejar cargas mayores de las que soporta Arduino. Soporta cargas de hasta 2A a 30V DC

Nuevas Shields Incorporadas Recientemente

MKR Relay Proto Shield

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

Con este shield se pueden usar 2 relés son cualquier placa de la familia MKR

Arduino Yun Shield

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

Este shield permite ampliar las capacidades del arduino YUN a cualquier Arduino, es decir, añadir un microprocesador para realizar cálculos más potentes y conexión wifi y ethernet.

Getting started: https://www.arduino.cc/en/Guide/ArduinoYunShield

MKR ETH Shield

Web: https://store.arduino.cc/mkr-eth-shield

MKR IMU Shield

Web: https://store.arduino.cc/mkr-imu-shield

MKR ENV Shield

Web: https://store.arduino.cc/mkr-env-shield

MKR Therm Shield

Web: https://store.arduino.cc/mkr-therm-shield

MKR Can Shield

Web: https://store.arduino.cc/arduino-mkr-can-shield

MKR 485 Shield

Web: https://store.arduino.cc/arduino-mkr-485-shield

MKR Mem Shield

Web: https://store.arduino.cc/arduino-mkr-mem-shield

MKR Connector Carrier Shield

Web: https://store.arduino.cc/arduino-mkr-connector-carrier

MKR RGB Shield

Web: https://store.arduino.cc/mkr-rgb-shield

Otras Shields Oficiales

Shields retiradas

Algunas shields han sido retiradas por versiones mejoradas:

Shields no oficiales

Además de las shields oficiales vistas, existen múltiples shields no oficiales de Arduino (no fabricadas por Arduino) que nos permiten ampliar las capacidades de la placa Arduino. Veamos unos ejemplos:

EmonTx Shield

Web: https://shop.openenergymonitor.com/emontx-arduino-shield-smt/

Wiki: https://wiki.openenergymonitor.org/index.php/EmonTx_Arduino_Shield

Github: https://github.com/openenergymonitor/emontx-shield

Un shield para medir corriente eléctrica bajo el proyecto open energy monitor: http://openenergymonitor.org/emon/

Posee 4 entradas para conectar 4 toroidales abiertos y una entrada para conectar el sensor de voltaje mediante un transformador AC-AC, también tiene la posibilidad de montar un transmisor RF.

Grove Shield

Web: https://www.seeedstudio.com/Base-Shield-V2-p-1378.html.

Un Shield para el sistema grove que facilita la conexión de sensores y actuadores.

Relay Shield

Web: https://www.seeedstudio.com/Relay-Shield-v3.0-p-2440.html

Wiki: http://wiki.seeed.cc/Relay_Shield_v3/

Este shield proporciona 4 relés para manejar dispositivos que no pueden controlarse directamente con las I/O de Arduino. Dispone de unos indicadores de uso de los relés.

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

¿Y si necesitamos más de 4 relés?

Shield Relay Driver de 8 canales

Web: http://www.freetronics.com.au/collections/shields/products/relay8-8-channel-relay-driver-shield#.VQxwlo5k6t8.

Este shield permite manejar hasta 8 relés (que no están en el shield) usando solo dos pines de I/O del Arduino. Se comunica con Arduino usando el bus I2C, de forma que apilando varias de estas shields podemos manejar 16, 24 y más relés.

Guía de uso: http://www.freetronics.com.au/pages/relay8-8-channel-relay-driver-shield-quickstart-guide#.VQyBVI5k6t8

GPS Shield

Web: http://www.adafruit.com/products/1272. Con un slot para micro SD donde guardar logs. No es compatible con Arduino Mega ni Due, RTC incluido. Conexión por puerto serie o conexión directa.

Más información en: https://learn.adafruit.com/adafruit-ultimate-gps-logger-shield

Xbee Shield

Webs:

Para comunicación inalámbrica mediante Xbee. Conexión a UART de la MCU o a cualquier otro puerto por software serial. Más información: http://www.seeedstudio.com/wiki/XBee_Shield_V2.0

TFT Shield

Web:  https://www.seeedstudio.com/28-TFT-Touch-Shield-V20-p-1286.html

Wiki: http://wiki.seeed.cc/2.8inch_TFT_Touch_Shield_v2.0/

Pantalla TFT táctil resistiva con un slot para micro SD integrado. Comunicación a Arduino a través de bus SPI.

Bluetooth Shield

Web: https://www.seeedstudio.com/Bluetooth-Shield-V2-p-2416.html

Wiki: http://wiki.seeedstudio.com/wiki/Bluetooth_Shield_V2.0

Comunicación inalámbrica por bluetooth. Conecta con la UART del Arduino o software serial con selector de puerto serie.

Se trata de un shield al que le han incorporado un módulo bluetooth HC-05: http://tienda.bricogeek.com/modulos-bluetooth/800-modulo-bluetooth-hc-05.html

Terminal Shield

Web: http://www.freetronics.com.au/collections/shields/products/terminal-shield-for-arduino#.VQxwn45k6t8.

Shield con borneros y placa de prototipado que nos permite conectar fácilmente cualquier sensor o actuador a un Arduino.

GSM shield

Web: https://www.sparkfun.com/products/13120

Este Shield usa el módulo SM5100B y es similar al shield oficial de Arduino y usa comandos AT a través del puerto serie para manejar la comunicación.

LTE Shield

Web: http://www.gemalto.com/m2m/development/cinterion-connect-shield

Brochure: http://www.gemalto.com/brochures-site/download-site/Documents/m2m-connect-shield.pdf

Tools and documentation: https://developer.gemalto.com/documentation/cinterion%C2%AE-connect-shield-tools-documentation

Uso con raspberry Pi: https://developer.gemalto.com/tutorial/using-connect-shield-raspberry-pi

Otras Shields Interesantes

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

Un listado completo donde encontrar cualquier tipo de shield aunque no actualizado desde hace tiempo: http://shieldlist.org/

Para aprender más sobre los shields: https://learn.sparkfun.com/tutorials/arduino-shields

Breakout Boards

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

Y por supuesto tenemos kits de robótica:

También hay Shields para Raspberry Pi llamadas hats:

GrovePi

Y una librería en C++ para manejar las GPIO de Raspberry Pi para los que están familiarizados con Arduino: http://wiringpi.com/

Shields Wemos D1 Mini

La placa Wemos D1 Mini también usa el modelo de shields apilables, existen bastante modelos de shields disponibles.

Placas de Expansión

También hay disponibles placas de expansión de puertos para diversas placas de forma que podamos acceder más fácilmente a sus pines,

Node MCU:

Arduino Nano:

Placas Arduino

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

Un shield es una placa compatible que se puede colocar en la parte superior de los arduinos y permite extender las capacidades del arduino. De estas hablaremos en profundidad más adelante.

Primer Arduino:

La placas oficiales que hay actualmente en Arduino son: https://store.arduino.cc/arduino-genuino/boards-modules

Kits Arduino: https://store.arduino.cc/arduino-genuino/arduino-genuino-kits

Placas retiradas: https://store.arduino.cc/arduino-genuino/retired

Arduino Uno

Web: https://store.arduino.cc/arduino-uno-rev3

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

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

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

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

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

Arduino Mega

Web: https://store.arduino.cc/arduino-mega-2560-rev3

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

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

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

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

Mega ADK es una placa basada en el Mega2560 pero con un USB host adicional para conectar móviles basados en Android:

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

Getting Started con ADK: https://www.arduino.cc/en/Guide/ArduinoADK

Versiones reducidas del Arduino mega: https://robotdyn.com/catalog/boards/mega_2560_pro_mini_atmega2560_16au/

Arduino Ethernet

Web: https://store.arduino.cc/arduino-ethernet-rev3-without-poe

Incorpora un puerto ethernet, está basado en el Arduino Uno y nos permite conectarnos a una red o a Internet mediante su puerto de red.

Arduino Due

Web: https://store.arduino.cc/arduino-due

Arduino con la mayor capacidad de procesamiento, basado en un microcontrolador de 32 bit y arquitectura ARM: Atmel SAM3X8E ARM Cortex-M3 CPU. Este arduino está alimentado a 3.3V y dado que gran parte de los shields, sensores, actuadores para Arduino y compatible son a 5V lo limita, pero cada vez se ven más elementos donde se puede elegir el voltaje entre 3.3 y 5V.

Importante: 12-bit ADC

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

Arduino Leonardo

Web: https://store.arduino.cc/arduino-leonardo-with-headers

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

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

Los Arduinos basados en el microcontrolador 32u4 permiten aparecer al Arduino conectado al ordenador como un ratón o teclado nativo, simulando un dispositivo de este tipo.

Getting Started: https://www.arduino.cc/en/Guide/ArduinoLeonardoMicro

Librería MouseKeyboard: https://www.arduino.cc/en/Reference/MouseKeyboard

Arduino Leonardo ETH

Web: https://store.arduino.cc/arduino-leonardo-eth  

Es un Arduino Leonardo con ethernet proporcionado por el controlador W5500. Se trata de la versión actualizada del Arduino Ethernet.

Documentación: http://labs.arduino.org/Arduino%20leonardo%20eth

Getting Started: http://labs.arduino.org/Getting+Started+with+Arduino+Leonardo+Eth

Arduino Nano

Una de la placas más populares por su tamaño y precio. Se trata de una placa similar al Arduino UNO pero de un tamaño más compacto.

Web: https://store.arduino.cc/arduino-nano

Arduino Micro

Web: https://store.arduino.cc/arduino-micro

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

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

Arduino Mini (Retirada)

Web: https://store.arduino.cc/arduino-mini-05

Versión miniaturizada de la placa Arduino UNO basado en el ATMega328. Mide tan sólo 30x18mm y permite ahorrar espacio en los proyectos que lo requieran. Las funcionalidades son las misma que Arduino UNO. Necesita un programador para conectarlo al ordenador: http://arduino.cc/en/Main/USBSerial

Arduino Yun

El Arduino Yun es un Arduino que es diferente a lo que son el resto de Arduino porque además de llevar un microcontrolador, incorpora un Microprocesador MIPS con un Sistema Operativo Linux embebido. La ventaja que aporta Arduino Yun y sus derivados es que el microcontrolador y el microprocesador están conectado mediante un puerto serie y además Arduino nos ofrece una serie de herramientas/librerías que facilita la interconexión entre ellos.

Arduno Yun Rev 2: https://store.arduino.cc/arduino-yun-rev-2

Presentación de la placa: https://blog.arduino.cc/2018/03/29/arduino-yun-rev-2-is-here/

Arduino Yun (Modelo Anterior): https://store.arduino.cc/arduino-yun

Guía con Open WRT: https://www.arduino.cc/en/Guide/ArduinoYun

Guía con LininoOS: https://www.arduino.cc/en/Guide/ArduinoYunLin

Arduino Uno Wifi (Rev2)

Nueva placa presentada en 2018: https://blog.arduino.cc/2018/05/17/say-hello-to-the-next-generation-of-arduino-boards/

Web: https://store.arduino.cc/arduino-uno-wiFi-rev2

Basada en el nuevo microcontrolador ATmega4809: http://ww1.microchip.com/downloads/en/DeviceDoc/48-pin-Data-Sheet-megaAVR-0-series-DS40002016B.pdf

Conectividad Wifi y BT gracias al procesador NINA W102 basado en el ESP32: https://www.u-blox.com/sites/default/files/NINA-W10_DataSheet_%28UBX-17065507%29.pdf y cryptochip ECC608.

Familia MKR

La familia de Arduino MKR son una serie de placas con un factor de forma diferente al de Arduino mucho más pequeño y basados todos en el microcontrolador de 32 bits de Atmel SAMD21. Estas placas están pensadas principalmente para IoT.

MKR Family: https://store.arduino.cc/arduino-genuino/arduino-genuino-mkr-family

Arduino MKRZero

Producto: https://store.arduino.cc/arduino-mkrzero

Primero modelo de la familia MKR y heredero del Arduino Zero.

Arduino MKR1000 WIFI

Producto: https://store.arduino.cc/arduino-mkr1000

Versión para IoT con procesador Atmel ARM Cortex M0+ de 32bits ATSAMW25 que es el mismo procesador que Genuino Zero pero con wifi integrado, chip de cifrado y antena integrada.

El ATSAMW25 está compuesto por tres principales bloques:

  • SAMD21 Cortex-M0+ 32bit low power ARM MCU
  • WINC1500 low power 2.4GHz IEEE® 802.11 b/g/n Wi-Fi (mismo que el wifi 101 shield)
  • ECC508 CryptoAuthentication

Arduino MKR WiFi 1010

Producto: https://store.arduino.cc/arduino-mkr-wifi-1010

El MKR WIFI 1010 es una mejora significativa del MKR 1000 WIFI. Está equipado con un módulo ESP32 fabricado por U-BLOX. Esta placa tiene como objetivo acelerar y simplificar la creación de prototipos de aplicaciones de IO basadas en WiFi gracias a la flexibilidad del módulo ESP32 y su bajo consumo de energía.

La placa tienes estos 3 bloques principales:

  • SAMD21 Cortex-M0+ 32bit Low Power ARM MCU;
  • U-BLOX NINA-W10 Series Low Power 2.4GHz IEEE® 802.11 b/g/n Wi-Fi; and Bluetooth
  • ECC508 Crypto Authentication.

Presentación de la placa: https://blog.arduino.cc/2018/05/12/the-mkr-family-gets-bigger-with-two-new-iot-boards/

Arduino MKR FOX 1200

Producto: https://store.arduino.cc/arduino-mkrfox1200

Arduino anunciado en abril de 2017. En una placa de desarrollo pensada para el IoT con conectividad Sigfox. Comparte muchas características con otras placas de la familia MKR como em microcontrolador SAM D21 32-bit Cortex-M0+.

Incluye un módulo ATA8520 con conectividad sigfox de amplia cobertura y bajo consumo capaz de funcionar durante 6 meses con dos pilas AA. También incluye una suscripción por dos años a la red Sigfox: http://www.sigfox.com/en

Web: https://blog.arduino.cc/2017/04/18/introducing-the-arduino-mkrfox1200/

Más información sobre el Arduino MKRFOX1200 en el artículo: https://www.aprendiendoarduino.com/2018/03/05/arduino-mkrfox1200/

Arduino MKR WAN 1300

Producto: https://store.arduino.cc/mkr-wan-1300

Presentado el 25 de septiembre de 2017 en la maker faire de NY: https://blog.arduino.cc/2017/09/25/introducing-the-arduino-mkr-wan-1300-and-mkr-gsm-1400/

Arduino + LoRa:

Arduino MKR GSM 1400

Producto: https://store.arduino.cc/mkr-gsm-1400

Presentado el 25 de septiembre de 2017 en la maker faire de NY: https://blog.arduino.cc/2017/09/25/introducing-the-arduino-mkr-wan-1300-and-mkr-gsm-1400/

Arduino + GSM:

Arduino MKR NB 1500

Producto: https://store.arduino.cc/arduino-mkr-nb-1500

El nuevo estándar Narrow Band IoT, con el ecosistema Arduino fácil de usar. Totalmente compatible con las clases Narrow Band IoT NB y las redes LTE CAT M1.

Presentación de la placa: https://blog.arduino.cc/2018/05/12/the-mkr-family-gets-bigger-with-two-new-iot-boards/

Arduino MKR Vidor 4000

Producto: https://store.arduino.cc/arduino-vidor-4000 :

El MKR VIDOR 4000 es altamente configurable y potente, y puede realizar procesamiento digital de audio y video de alta velocidad.

El MKR VIDOR 4000 puede configurarlo de la manera que desee; esencialmente puede crear su propia tarjeta controladora.

Viene cargado de hardware y potencial:

  • un SRAM de 8 MB
  • un chip Flash QSPI de 2 MB – 1 MB asignado para aplicaciones de usuario
  • un conector Micro HDMI
  • un conector para cámara MIPI
  • Wifi & BLE alimentado por U-BLOX NINA Serie W10.

También incluye la clásica interfaz MKR en la que todos los pines son accionados tanto por SAMD21 como por FPGA.

Además, tiene un conector Mini PCI Express con hasta 25 pines programables por el usuario.

La FPGA contiene 16K Logic Elements, 504 KB de RAM embebida y 56 multiplicadores de 18×18 bit HW para DSP de alta velocidad. Cada pin puede conmutar a más de 150 MHz y puede ser configurado para funciones tales como UARTs, (Q)SPI, PWM de alta resolución/alta frecuencia, codificador de cuadratura, I2C, I2S, Sigma Delta DAC, etc.

La FPGA integrada también se puede utilizar para operaciones DSP de alta velocidad para el procesamiento de audio y vídeo. Esta tarjeta también incluye un Microchip SAMD21. La comunicación entre la FPGA y el SAMD21 es directa.

Accesorios para Arduinos MKR

Y los IoT Bundles:

Nuevos Arduino Nano

En la Maker Faire Bay Area del año 2019, supone un nuevo concepto de placas de pequeño tamaño, económicas y de bajo consumo.

Presentación de las placas: https://blog.arduino.cc/2019/05/17/whats-new-at-maker-faire-bay-area-2019/

Se trata de 4 modelos:

El nuevo microcontrolador ATmega4809 soliciona las limitaciones de las tarjetas antiguas basadas en ATmega328P, puede añadir un segundo puerto serie de hardware, más periféricos y memoria significa que puede abordar proyectos más ambiciosos. Utiliza un chip USB de calidad para que la gente no tenga problemas de conexión o de drivers. El procesador separado que maneja la interfaz USB también permite implementar diferentes clases de USB, como el Dispositivo de Interfaz Humana (HID), en lugar del clásico CDC/UART.

La nueva arquitectura de fuente de alimentación basada en un convertidor DC-DC de alta eficiencia permite alimentar la tarjeta hasta 21V y accionar periféricos de salida hasta 950mA sin sobrecalentamiento.

Otros Arduinos oficiales

Existen aun mas Arduino oficiales, algunos ya retirados:

Todos los productos de Arduino: https://www.arduino.cc/en/Main/Products

Arduinos para Wearables

Arduino Lilypad

Web: https://store.arduino.cc/lilypad-arduino-main-board

Diseñado para dispositivos “wearables” y e-textiles. Para coser con hilo conductor e instalarlo sobre prendas.

Más información para fabricar wearable con arduino en: http://lilypadarduino.org/

Otros:

Retirados

Hay modelos retirados, pero la documentación sigue disponible y es posible aun comprarlas por terceros que las fabrican o fabricarlas uno mismo.

Arduino 101

Web: https://store.arduino.cc/genuino-101

Es el sucesor del Arduino UNO con procesador Intel Curie Quark de 32 bit diseñado para ofrecer el mínimo consumo de energía, 384 KB de memoria flash, 80 KB de SRAM, un sensor DSP integrado, bluetooth de baja energía, acelerómetro y giroscopio de 6 ejes.

Video de 101: https://blog.arduino.cc/2016/01/13/unboxing-and-setup-of-arduino-101/

Código Firmware: https://github.com/01org/corelibs-arduino101 que no hace falta instalarlo porque ya viene integrado en el IDE de arduino.cc y desde el gestor de librerías se instala en: C:\Users\<user>\AppData\Local\Arduino15\packages\Intel\hardware\arc32\1.0.5

Review completa del 101: http://www.kitguru.net/components/cpu/james-morris/intel-genuino-101-review/

Intel ha descontinuado la gama de microcontroladores usados en diversos Arduinos, lo que parece el fin de la asociación entre Intel y Arduino, más aun cuando Arduino ha firmado un acuerdo con ARM.

Placas Compatibles Arduino

La marca Arduino está protegida y solo puede usarse por Arduino, pero debido a que se trata de hardware libre, existen multitud de placas disponibles que bien son clones, placas derivadas (forks) u otras placas totalmente independientes pero que la comunidad ha desarrollado el código para poder programarlas con el lenguaje de programación de Arduino.

Cuando hablamos de placas compatibles con Arduino, son aquellas que se pueden programar con el IDE de Arduino.

Listado no oficial de placas de terceros soportadas por el IDE de Arduino: https://github.com/arduino/Arduino/wiki/Unofficial-list-of-3rd-party-boards-support-urls

Funduino

Web: https://www.funduinoshop.com/epages/78096195.sf/en_GB/?ViewObjectPath=%2FShops%2F78096195

Chipkit

Web: http://chipkit.net/

ESP8266

Web: https://espressif.com/en/products/hardware/esp8266ex/overview

Moteino

Web: https://lowpowerlab.com/guide/moteino/

Resumen

Arduino.cc products: https://www.arduino.cc/en/Main/Products

Como distinguir un arduino oficial de una copia: http://arduino.cc/en/Products/Counterfeit

Guía para comparar Arduino:  https://learn.sparkfun.com/tutorials/arduino-comparison-guide

Ejemplos Arduino con Estructuras de Control

Alarma Umbral

Partiendo del sketch https://www.arduino.cc/en/Tutorial/ifStatementConditional modificarlo para que en lugar de encender un led cuando supere el valor de umbral, simular un envío de un mensaje de alarma mediante Serial.println() cada vez que haya una alarma y se supere el umbral (solo cuando lo sobrepase la primera vez, no de forma continua) y otro mensaje de recuperación cada vez el valor este por debajo del umbral (solo cuando baje la primera vez, no de forma continua).

Esquema de conexión:

Ejecutar el sketch https://www.arduino.cc/en/Tutorial/ifStatementConditional y comprobar su funcionamiento.

El siguiente paso es añadir un texto de alarma y recuperación cuando se supere y cuando esté por debajo. Una vez comprobado que manda continuamente el texto, pensar cómo modificar el sketch para que lo mande solo cuando se supera la primera vez o cuando vuelve al estado normal la primera vez. Esto también sirve para para usar el digitalWrite una vez en lugar de hacerlo continuamente.

Diagrama de flujo:

Solución: https://github.com/jecrespo/aprendiendoarduino-Curso_Arduino_2017/tree/master/Ejercicio07-Detectar_Alarma

Solución Visualino:

Ver en el serial plotter la representación gráfica de lo que está ocurriendo.

  • rojo: umbral
  • verde: estado alarma
  • azul: lectura del potenciómetro

Si comentamos la zona de “print values” veremos que solo se imprime por pantalla “alarma” y “alarma recuperada” cuando se pasa por el umbral, pero no continuamente.

Histéresis

Comprobar el efecto del programa cuando estamos justo en el umbral donde tendremos continuas alarmas y recuperaciones. Para solucionar esto añadir histéresis.

Diagrama de flujo:

Solución: https://github.com/jecrespo/aprendiendoarduino-Curso_Arduino_2017/tree/master/Ejercicio08-Detectar_Alarma_Histeresis

Solución Visualino:

Cambio de comportamiento con un umbral medio de 400 y una histéresis de 50. Ver como cambia el umbral al pasar de estado de alarma a recuperado y viceversa.

Histéresis con Sondas de Temperatura

Hacer este mismo ejemplo con la sonda de temperatura TMP36 https://www.arduino.cc/documents/datasheets/TEMP-TMP35_36_37.pdf con y sin histéresis.

Esquema de conexión:

Hacer este mismo ejemplo con la sonda de temperatura y humedad DHT11

Solución:

Ejemplo de uso con TMP36 con alarma usando un buzzer: https://github.com/jecrespo/aprendiendoarduino-Curso_Programacion_Arduino/blob/master/Ejercicio06-Alarma/Ejercicio06-Alarma.ino

Más prácticas de estructuras de control en el punto 2.9 del curso de programación: https://aprendiendoarduino.wordpress.com/2017/07/05/practica-estructuras-de-control/

Ejemplo con While

Ejemplo con while de calibración de un sensor de iluminación: https://www.arduino.cc/en/Tutorial/WhileStatementConditional

Más ejemplos en: https://www.arduino.cc/en/Tutorial/BuiltInExamples

Estructuras de Control

En programación, las estructuras de control permiten modificar el flujo de ejecución de las instrucciones de un programa.

Con las estructuras de control se puede:

  • De acuerdo con una condición, ejecutar un grupo u otro de sentencias (If-Then-Else)
  • De acuerdo con el valor de una variable, ejecutar un grupo u otro de sentencias (Select-Case)
  • Ejecutar un grupo de sentencias mientras se cumpla una condición (Do-While)
  • Ejecutar un grupo de sentencias hasta que se cumpla una condición (Do-Until)
  • Ejecutar un grupo de sentencias un número determinado de veces (For-Next)

Todos los lenguajes de programación modernos tienen estructuras de control similares. Básicamente lo que varía entre las estructuras de control de los diferentes lenguajes es su sintaxis; cada lenguaje tiene una sintaxis propia para expresar la estructura.

En Visualino las estructuras de control se encuentran en el apartado “control”:

Estructuras de decisión

if:  es un estamento que se utiliza para probar si una determinada condición se ha alcanzado, como por ejemplo averiguar si un valor analógico está por encima de un cierto número, y ejecutar una serie de declaraciones (operaciones) que se escriben dentro de llaves, si es verdad. Si es falso (la condición no se cumple) el programa salta y no ejecuta las operaciones que están dentro de las llaves.

Referencia Arduino: https://www.arduino.cc/reference/en/language/structure/control-structure/if/

if… else:  viene a ser un estructura que se ejecuta en respuesta a la idea “si esto no se cumple haz esto otro”. Por ejemplo, si se desea probar una entrada digital, y hacer una cosa si la entrada fue alto o hacer otra cosa si la entrada es baja.

else: puede ir precedido de otra condición de manera que se pueden establecer varias estructuras condicionales de tipo unas dentro de las otras (anidamiento) de forma que sean mutuamente excluyentes pudiéndose ejecutar a la vez. Es incluso posible tener un número ilimitado de estos condicionales. Recuerde sin embargo que sólo un conjunto de declaraciones se llevará a cabo dependiendo de la condición probada.

Referencia Arduino: https://www.arduino.cc/reference/en/language/structure/control-structure/else/

Tutorial if() – Comparar el valor leido de un potenciometro con un umbral y encender un led si el valor leido es mayor que el umbral https://www.arduino.cc/en/Tutorial/ifStatementConditional

Uso de if con Visualino

Para ampliar más información sobre if…else en Arduino, ver este fantástico artículo de Luis del Valle https://programarfacil.com/blog/arduino-blog/if-else-arduino/

switch..case: Al igual que if, switch..case controla el flujo del programa especificando en el programa que código se debe ejecutar en función de unas variables. En este caso en la instrucción switch se compara el valor de una variable sobre los valores especificados en la instrucción case.

break es la palabra usada para salir del switch. Si no hay break en cada case, se ejecutará la siguiente instrucción case hasta que encuentre un break o alcance el final de la instrucción.

default es la palabra que se usa para ejecutar el bloque en caso que ninguna de las condiciones se cumpla.

Referencia Arduino: https://www.arduino.cc/reference/en/language/structure/control-structure/switchcase/

Uso de switch con Visualino

Tutorial Switch-case – Leer una fotorresistencia y en función de unos valores predefinidos imprimir la cantidad de luz en 4 valores: noche, oscuro, medio, claro https://www.arduino.cc/en/Tutorial/SwitchCase

Estructuras de repetición

for: La declaración for se usa para repetir un bloque de sentencias encerradas entre llaves un número determinado de veces. Cada vez que se ejecutan las instrucciones del bucle se vuelve a testear la condición. La declaración for tiene tres partes separadas por (;). La inicialización de la variable local se produce una sola vez y la condición se testea cada vez que se termina la ejecución de las instrucciones dentro del bucle. Si la condición sigue cumpliéndose, las instrucciones del bucle se vuelven a ejecutar. Cuando la condición no se cumple, el bucle termina.

Cualquiera de los tres elementos de cabecera puede omitirse, aunque el punto y coma es obligatorio. También las declaraciones de inicialización, condición y expresión puede ser cualquier estamento válido en lenguaje C sin relación con las variables declaradas.

Referencia Arduino: https://www.arduino.cc/reference/en/language/structure/control-structure/for/

Tutorial for() – efecto con leds coche fantastico https://www.arduino.cc/en/Tutorial/ForLoopIteration

while: Un bucle del tipo while es un bucle de ejecución continua mientras se cumpla la expresión colocada entre paréntesis en la cabecera del bucle. La variable de prueba tendrá que cambiar para salir del bucle. La situación podrá cambiar a expensas de una expresión dentro el código del bucle o también por el cambio de un valor en una entrada de un sensor.

Referencia Arduino: https://www.arduino.cc/reference/en/language/structure/control-structure/while/

Tutorial while() – calibrar el valor de un sensor analógico https://www.arduino.cc/en/Tutorial/WhileStatementConditional

do..while: El bucle do while funciona de la misma manera que el bucle while, con la salvedad de que la condición se prueba al final del bucle, por lo que el bucle siempre se ejecutará al menos una vez.

Referencia Arduino: https://www.arduino.cc/reference/en/language/structure/control-structure/dowhile/

goto: transfiere el flujo de programa a un punto del programa que está etiquetado.

Referencia Arduino: https://www.arduino.cc/reference/en/language/structure/control-structure/goto/

break: se usa en las instrucciones do, for, while para salir del bucle de una forma diferente a la indicada en el bucle.

Referencia Arduino: https://www.arduino.cc/reference/en/language/structure/control-structure/break/

continue: se usa en las instrucciones do, for, while para saltar el resto de las instrucciones que están entre llaves y se vaya a la siguiente ejecución del bucle comprobando la expresión condicional.

Referencia Arduino: https://www.arduino.cc/reference/en/language/structure/control-structure/continue/

En Visualino están disponibles todas las estructuras de repetición

Y por su puesto ante cualquier duda: https://www.arduino.cc/reference/en/