Archivo de la categoría: Práctica

Ejemplos Ethernet Arduino

IMPORTANTE: Para los ejercicio con conexión Ethernet es imprescindible poner en la MAC del Arduino en los dos últimos dígitos el número del kit. En todos los sketchs hay que sustituir YY por el número de kit.

Para las prácticas la IP de los Arduinos se asignará dinámicamente por DHCP, en este caso ya nos asigna también el servidor DNS y por lo tanto podemos usar nombres de páginas web

Conexión a una Web con Arduino

Crear un cliente ethernet que se conecte varias webs y escriba por consola los datos recogidos. También guarde los datos recibidos en un string. Probar a conectar a varias páginas web y usa el servicio DNS poniendo la url en lugar de la IP.

Webs:

Tutorial: webclient con ejemplo de métodos get y post: http://playground.arduino.cc/Code/WebClient

Solución: https://github.com/jecrespo/aprendiendoarduino-Curso_Arduino_2017/tree/master/Ejercicio35-EthernetClient_DHCP

Web Server

Crear un servidor web sencillo que saque por el puerto serie y también devuelva al navegador que le ha llamado la petición http recibida.

Luego añadir el valor leído en la entrada analógica A0.

Avanzado: Modificar el ejercicio anterior y leer solo la línea de la petición, esto es útil cuando hay que analizar el http request y que Arduino devuelva una cosa u otra en función de la petición que llegue. Quitar comentarios en el bucle que lee los caracteres recibidos y ver lo que ocurre. Fijarse que el tiempo de bucle en este caso es más rápido y esto tiene ventajas.

Tutorial webserver: http://playground.arduino.cc/Code/WebServerST

Solución: https://github.com/jecrespo/aprendiendoarduino-Curso_Arduino_2017/tree/master/Ejercicio39-EthernetServer_DHCP

Anuncios

Funciones Definidas por Usuario

En programación, una función es un grupo de instrucciones con un objetivo particular y que se ejecuta al ser llamada desde otra función o procedimiento. Una función puede llamarse múltiples veces e incluso llamarse a sí misma (función recurrente).

Las funciones pueden recibir datos desde afuera al ser llamadas a través de los parámetros y puede entregar un resultado.

Una función 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 anteriormente.

Las funciones de usuario pueden ser escritas para realizar tareas repetitivas y para reducir el tamaño de un programa. Segmentar el código en funciones permite crear piezas de código que hacen una determinada tarea y volver al área del código desde la que han sido llamadas.

Las funciones se declaran asociadas a un tipo de valor. Este valor será el que devolverá la función, por ejemplo ‘int’ se utilizará cuando la función devuelva un dato numérico de tipo entero. Si la función no devuelve ningún valor entonces se colocará delante la palabra “void”, que significa “función vacía”

Sintaxis:

 
tipo nombreFunción (parámetros) {
   instrucciones;
}

Anatomía de una función en C:

Para llamar a una función, simplemente:

 
nombreFunción(parámetros);

Una función que devuelve un valor siempre debe tener la instrucción Return, esta termina una función y devuelve un valor a quien ha llamado a la función: http://arduino.cc/en/Reference/Return

Si se define una función y no ponemos return el valor devuelto es cero. No da error de compilación.

Ventajas del uso de funciones:

  • Ayuda a tener organizado el código.
  • Una función codifica una tarea en un lugar de nuestro sketch, así que la función solo debe ser pensada una sola vez.
  • Reduce la probabilidad de errores al modificar el código.
  • Hacen que el tamaño del sketch sea menor porque el código de la función es reutilizado.
  • Facilita la lectura del código.
  • Hace más sencillo reutilizar código en otros sketches.

Más información: http://arduino.cc/en/Reference/FunctionDeclaration

Funciones Arduino en playground: http://playground.arduino.cc/Code/Function

En Visualino podemos hacer uso de las funciones en el apartado de “Functions”

En Visualino para multiplicar la lecturas de las entradas analógicas A0 y A1 usando una función multiplicación se puede hacer así:

Solución: https://github.com/jecrespo/aprendiendoarduino-Curso_Arduino_2017/tree/master/Ejercicio42-Visualino_Funciones

Nombres de funciones

Generalmente los nombres de las funciones deben ser en minúscula, con las palabras separadas por un guión bajo, aplicándose éstos tanto como sea necesario para mejorar la legibilidad.

“mixedCase” (primera palabra en minúscula) es aceptado únicamente en contextos en donde éste es el estilo predominante con el objetivo de mantener la compatibilidad con versiones anteriores.

En el caso de las clases, los nombres deben utilizar la convención “CapWords” (palabras que comienzan con mayúsculas).

Las funciones en Arduino pueden estar dentro del mismo fichero .ino o en otro fichero con extensión .ino dentro del directorio del sketch principal.

Funciones vs Librerías

Ejemplo de blink usando funciones:

 
void setup() {
  Serial.begin(9600);
  pinMode(13, OUTPUT);
}

void loop() {
  enciendo();
  delay(1000);  
  apago();
  delay(1000);  
}

void enciendo() {
  Serial.println("Enciendo...");
  digitalWrite(13, HIGH);
}

void apago(){
  Serial.println("Apago...");
  digitalWrite(13, LOW);  
}

Código: https://github.com/jecrespo/aprendiendoarduino-Curso_Arduino_2017/tree/master/Ejercicio43-Blink_Funcion

En Visualino se podría hacer de esta forma:

Solución: https://github.com/jecrespo/aprendiendoarduino-Curso_Arduino_2017/tree/master/Ejercicio43-Visualino_Blink_Funcion

Este ejercicio también se podría hacer dividiendo el código en dos ficheros uno principal que tiene las funciones setup() y loop() y otro con las funciones enciende() y apaga () en el fichero funciones.ino. Los ficheros están en la misma carpeta y al abrirlos en el IDE de Arduino los vemos en pestañas diferentes.

Por lo tanto podemos organizar nuestro código en varios ficheros .ino en la misma carpeta. Todo ellos los veremos en pestañas en el IDE de Arduino.

Código en: https://github.com/jecrespo/aprendiendoarduino-Curso_Arduino_2017/tree/master/Ejercicio44-Funciones

Esto también podría hacerse usando “librerías”  o fichero de C++ con un fichero funciones.h e incluyéndolo en el principal con la instrucción #include “funciones.h”.

En C++ el código se organiza en diferentes ficheros con extensiones .h y .cpp a los que se van llamando con #include para añadirlos al fichero que lo llama para poder usar su contenido.

Código en: https://github.com/jecrespo/aprendiendoarduino-Curso_Arduino_2017/tree/master/Ejercicio45-Librerias

Práctica Final de Funciones

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.

Opciones:

  • 1 – Encender Led pin 13
  • 2 – Apagar Ler pin 13
  • 3 – Contar segundos hasta pulsar tecla y mostrar por pantalla
  • 4 – Fin de programa

Solución: https://github.com/jecrespo/aprendiendoarduino-Curso_Arduino_2017/tree/master/Ejercicio46-Estructuras_de_Control

Uso ESP8266 con Arduino (Puerto Serie)

El ESP8266 se puede usar con un microcontrolador como Arduino conectado por puerto serie y manejarlo con comandos hayes o programarlo como si de un microcontrolador se tratara con el IDE de Arduino usando el SDK https://github.com/esp8266/Arduino y usar el lenguaje de programación de Arduino (el core de Arduino).

En este capítulo vamos a ver como usarlo con el SDK NONOS donde manejamos el ESP8266 mediante comandos AT.

Web de recursos del ESP8266: http://espressif.com/en/products/hardware/esp8266ex/resources

Los SDK oficiales de expressif son:

El SDK RTOS está basado en FreeRTOS:

Guía de programación de ESP8266 RTOS SDK: http://espressif.com/sites/default/files/documentation/20a-esp8266_rtos_sdk_programming_guide_en.pdf

RTOS es un sistema operativo de tiempo real es un sistema operativo que ha sido desarrollado para aplicaciones de tiempo real. Como tal, se le exige corrección en sus respuestas bajo ciertas restricciones de tiempo. Si no las respeta, se dirá que el sistema ha fallado. Para garantizar el comportamiento correcto en el tiempo requerido se necesita que el sistema sea predecible.

Más información: https://es.wikipedia.org/wiki/Sistema_operativo_de_tiempo_real

SDK NONOS ESP8266

Las versiones del SDK NONOS para ESP8266 es la que usa comandos AT para manejarlos. Las verisiones pueden descargarse desde https://github.com/espressif/ESP8266_NONOS_SDK/releases

El firmware puede descargarse de: https://github.com/espressif/ESP8266_NONOS_SDK/tree/master/bin

Github de expressif: https://github.com/espressif

Pinout ESP8266:

Pines:

  • TX (goes to the 3.3V Rx of the UART USB adapter to the PC)
  • CH_PD (enable/power down, must be pulled to 3.3v directly or via resistor)
  • RESET
  • VCC (3.3v power supply)
  • GND (connect to power ground)
  • GPIO 2
  • GPIO 0 (leave open or pull up for normal, pull down to upload new firmware)
  • RX (goes to the 3.3V Tx of the UART USB adapter to the PC)

Para usar el ESP8266 con Arduino vamos a conectarnos por el puerto serie y mandar comandos AT (hayes) para manejarlo. Este es el esquema.

IMPORTANTE:

  • El ESP8266 va alimentado a 3,3V, ¡no alimentarlo con 5 voltios!
  • El ESP8266 necesita comunicarse vía serie a 3.3V y no tiene entradas tolerantes 5V, por lo que necesita la conversión de nivel para comunicarse con un microcontrolador 5V como la mayoría de los Arduinos

Sin embargo, esta segunda advertencia puede ser ignorada y conectar el puerto serie directamente a Arduino, pero existe el peligro de dañar el módulo.

Con un programador FTDI que tenga salida a 3.3V podemos hacer lo mismo que con un Arduino pero sin ningún peligro.

ESP8266 quick start guide: http://rancidbacon.com/files/kiwicon8/ESP8266_WiFi_Module_Quick_Start_Guide_v_1.0.4.pdf

Guia sparkfun del ESP8266: https://learn.sparkfun.com/tutorials/esp8266-thing-hookup-guide

Level Shifter

Los pines Rx y Tx del ESP8266 no son tolerantes a 5V, por lo tanto para trabajar seguro es conveniente usar un bi-directional level shifter: http://www.adafruit.com/datasheets/txb0108.pdf

Este tipos de dispositivos es necesario para comunicar Arduino con otras MCUs que van a 3.3V, con el ESP8266 y con Raspberry Pi entre otros.

Ejemplo de level shifter para usar con Arduino:

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

El conjunto de comandos Hayes es un lenguaje desarrollado por la compañía Hayes Communications que prácticamente se convirtió en estándar abierto de comandos para configurar y parametrizar módems. Los caracteres «AT», que preceden a todos los comandos, significan «Atención», e hicieron que se conociera también a este conjunto de comandos como comandos AT. Midiendo la longitud de los bits se puede determinar en detalle la velocidad de transmisión.

Cheatsheet ESP8266: https://cdn.sparkfun.com/datasheets/Wireless/WiFi/ESP8266ModuleV1.pdf

Comandos hayes:

Comandos Hayes para ESP8266:

Proyectos con ESP8266:

Más información:

Videos:

Ejemplo de uso de comandos AT: http://www.seeed.cc/project_detail.html?id=1809

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.

Para descargar las herramientas y últimas versiones del firmware usar la web: https://espressif.com/en/products/hardware/esp8266ex/resources

Más información de como actualizar firmware (version actualizada en la parte de ejercicios):

Firmware Update

Para actualizar el firmware necesitamos descargar la herramienta “flash download tools” para el ESP8266 y el firmware con los comandos hayes, además aprovechamos para actualizar a la última versión del firmware.

Para programar recordar y actualizar firmware recordar que el pin GPIO0 debe estar a masa y que hay que un reset del módulo para comenzar la carga del nuevo firmware.

Descarga: https://espressif.com/en/products/hardware/esp8266ex/resources

Descargar la última versión de:

  • Tools / Flash Download Tools (ESP8266 & ESP32)
  • SDK & demos / ESP8266 NONOS SDK

Descargar la herramienta para cargar el firmware: Flash Download Tools (ESP8266 & ESP32) – V3.4.9.2 – 2017.07.17

El firmware para AT es: ESP8266 NONOS SDK V2.1.0 20170505 – V2.1.0 – 2017.05.05

Enlace al firmware: https://github.com/espressif/ESP8266_NONOS_SDK/tree/master/bin

Ficheros: https://github.com/espressif/ESP8266_NONOS_SDK/tree/v2.1.0/bin

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.

Para cargar el firmware necesitamos un adaptador de USB a serial a 3.3V. Para ello tenemos dos opciones: usar un adaptador o usar un Arduino donde tenga cargado cualquier programa que no haga uso del puerto serie, por ejemplo el blink.

Esquema de conexión con adaptador:

Esquema de conexión con Arduino:

Más información sobre el Firmware update (como referencia no están actualizados):

IMPORTANTE: no descargar nada de fuentes no fiables

Práctica: ESP8266 programado por puerto serie

Conexión con programador FTDI:

Conexión con Arduino:

Conectar un terminal serie a 115200-8-N y mandar el comando AT, si nos responde OK es que ya estamos conectados con el módulo.

Manual oficial de comandos: http://www.espressif.com/sites/default/files/4a-esp8266_at_instruction_set_en_v1.5.4_0.pdf

Ejecutar los siguientes comandos y ver lo que devuelve:

  • AT+RST: reinicia el módulo
  • AT+GMR: versión de firmware
  • AT+CWMODE=3: activa modo AP, comprobar redes wifi
  • AT+CWLAP: para ver las redes wifi
  • AT+CWJAP=”SSID”,”password”: Conectarse a una red wifi (AT+CWJAP=”AndroidAP4628″,”esp8266wifi”)
  • AT+CIFSR: comprobar la IP asignada

Actuar como un cliente TCP:

  • AT+CIPMUX=1: Habilitar múltiples conexiones
  • AT+CIPSTART=4,”TCP”,”google.com”,80: Especifica el canal de conexión que desea conectar (0 – 4), el tipo de protocolo (TCP / UDP), la dirección IP (o el dominio si tiene acceso a DNS) y el número de puerto
  • A continuación, debe especificar la cantidad de datos que desea enviar (después de especificar qué canal). Vamos a enviar “GET / HTTP / 1.0 \ r \ n \ r \ n” que es 18 bytes: AT+CIPSEND=4,18
  • Y recibiremos la respuesta del servidor:
 
+IPD,4,559:HTTP/1.0 301 Moved Permanently
Location: http://www.google.com/
Content-Type: text/html; charset=UTF-8
Date: Sat, 12 Nov 2016 16:37:23 GMT
Expires: Mon, 12 Dec 2016 16:37:23 GMT
Cache-Control: public, max-age=2592000
Server: gws
Content-Length: 219
X-XSS-Protection: 1; mode=block
X-Frame-Options: SAMEORIGIN
Connection: close

<HTML><HEAD><meta http-equiv="content-type" content="text/html;charset=utf-8">
<TITLE>301 Moved</TITLE></HEAD><BODY>


<H1>301 Moved</H1>


The document has moved
<A HREF="http://www.google.com/">here</A>.
</BODY></HTML>
4,CLOSED

Actuar como servidor:

  • Comprobar que IP tenemos con AT+CIFSR
  • AT+CIPSERVER=1,1336:  para poner a escuchar en un puerto, en este caso el 1336
  • Desde otro dispositivo en la red: telnet 192.168.1.2 1336
  • En el puerto serie veré todo lo que se escriba por telnet
  • Para responder desde el ESP8266 debo usar AT+CIPSEND=0,8 seguido del texto. En este caso es el canal 0 y mando 8 caracteres.

Hacer lo mismo pero usando Arduino, para ello conectarlo según el esquema superior y cargar el programa:

 
#include <SoftwareSerial.h>
SoftwareSerial BT1(3, 2); // RX | TX

void setup()
{ Serial.begin(9600);
  BT1.begin(115200);
}

void loop()
{ 
  if (BT1.available())
  { char c = BT1.read();
    Serial.print(c);
  }
  if (Serial.available())
  { char c = Serial.read();
    BT1.print(c);
  }
}

Configurar el baud rate de ESP8266 a 9600 para que funcione mejor con el comando “AT+UART_DEF=9600,8,1,0,0”, puesto que a 115200 da problemas con el puerto serie software.

Para hacer una reseteo de la configuración de fábrica usar el comando: “AT+RESTORE

Hacer un programa con Arduino que se conecte automáticamente a una red y nos muestra la IP asignada:

  • AT+CWMODE_DEF=1
  • AT+CWJAP=”SSID”,”paswword”
  • AT+CIFSR: comprobar la IP asignada

NOTA: si no se quiere usar el software serial por las limitaciones de velocidad, se puede hacer la misma conexión entre Arduino y el ESP8266 que hemos usado para programar el firmware, de forma que los conectamos por el puerto serie hardware. En este caso los comandos que mando desde el monitor serie van directos al ESP8266 en lugar de pasar por el microcontrolador de Arduino.

Solución Ejercicio 61: https://github.com/jecrespo/Aprendiendo-Arduino/tree/master/Ejercicio61-ESP8266

Más información:

Hardware Ethernet en Arduino

Para poder añadir conectividad de Ethernet a Arduino disponemos de varios tipos de Ethernet Shield y breakout boards, pero principalmente el chip que tiene el interfaz ethernet y la pila de protocolos TCP/IP es el chip Wiznet W5100 y más recientemente el W5500, pero podemos encontrarnos shields intermedios basados en el W5200. La librería a usar dependerá del chip ethernet usado al estilo de un driver en un ordenador.

Existen otras shields o breakout boards basadas en otros chips y con otras librerías como el ENC28J60:

Cómo elegir la correcta librería para añadir Ethernet cn enc28j60 a Arduino: http://www.homautomation.org/2014/10/27/how-to-choose-the-right-library-to-add-ethernet-enc28j60-to-your-arduino/

Ethernet Shield V1

El Arduino Ethernet Shield V1 nos da la capacidad de conectar un Arduino a una red ethernet. Es la parte física que implementa la pila de protocolos TCP/IP.

Ethernet Shield permite a una placa Arduino conectarse a internet. Está basada en el chip ethernet Wiznet W5100. El Wiznet W5100 provee de una pila de red IP capaz de soportar TCP y UDP. Soporta hasta cuatro conexiones de sockets simultáneas. Usa la librería Ethernet para escribir programas que se conecten a internet usando la shield.

Datasheet de W5100: https://www.sparkfun.com/datasheets/DevTools/Arduino/W5100_Datasheet_v1_1_6.pdf

Para manejar este shield disponemos de la librería Ethernet: http://arduino.cc/en/Reference/Ethernet

El shield provee un conector ethernet estándar RJ45. La ethernet shield dispone de unos conectores que permiten conectar a su vez otras placas encima y apilarlas sobre la placa Arduino.

Arduino usa los pines digitales 10, 11, 12, y 13 (SPI) para comunicarse con el W5100 en la ethernet shield. Estos pines no pueden ser usados para e/s genéricas. El botón de reset en la shield resetea ambos, el W5100 y la placa Arduino.

El jumper soldado marcado como “INT” puede ser conectado para permitir a la placa Arduino recibir notificaciones de eventos por interrupción desde el W5100, pero esto no está soportado por la librería Ethernet. El jumper conecta el pin INT del W5100 al pin digital 2 de Arduino.

La shield contiene varios LEDs para información:

  • ON: indica que la placa y la shield están alimentadas
  • LINK: indica la presencia de un enlace de red y parpadea cuando la shield envía o recibe datos
  • 100M: indica la presencia de una conexión de red de 100 Mb/s (de forma opuesta a una de 10Mb/s)
  • RX: parpadea cuando el shield recibe datos
  • TX: parpadea cuando el shield envía datos

Un tutorial sencillo para comenzar con el shield ethernet en: http://www.artinteractivo.com/arduino-ethernet

Para cualquier duda sobre el ethernet Shield consultar: http://arduino.cc/en/Main/ArduinoEthernetShield

Puntos a recordar del Ethernet Shield:

  • Opera a 5V suministrados desde la placa de Arduino
  • El controlador ethernet es el W5100 con 16K de buffer interno. No consume memoria.
  • El shield se comunica con el microcontrolador por el bus SPI, por lo tanto para usarlo siempre debemos incluir la libreria SPI.h: http://arduino.cc/en/Reference/SPI
  • Soporta hasta 4 conexiones simultáneas
  • Usar la librería Ethernet para manejar el shield: http://arduino.cc/en/Reference/Ethernet
  • El shield dispone de un lector de tarjetas micro-SD que puede ser usado para guardar ficheros y servirlos sobre la red. Para ello es necesaria la librería SD: http://arduino.cc/en/Reference/SD
  • Al trabajar con la SD, el pin 4 es usado como SS.

Nuestro Arduino UNO se comunica con W5100 y la tarjeta SD usando el bus SPI a través del conector ICSP. Por este motivo los pines 10, 11, 12 y 13 en el UNO y los 50, 51, 52 y 53 en el Mega no podrán usarse. En ambas placas los pines 10 y 4 se usan para seleccionar el W5100 y la tarjeta SD.

El W5100 y el SD no pueden trabajar simultáneamente y debemos tener cuidado al usar ambos de forma conjunta.

El esquemático lo podéis encontrar en: http://arduino.cc/en/uploads/Main/arduino-ethernet-shield-06-schematic.pdf

El Ethernet shield es compatible con PoE gracias a un módulo adicional que extrae la energía eléctrica del cable ethernet, anteriormente inyectada desde el switch.

Las características del módulo PoE:

  • IEEE802.3af compliant
  • Low output ripple and noise (100mVpp)
  • Input voltage range 36V to 57V
  • Overload and short-circuit protection
  • 9V Output
  • High efficiency DC/DC converter: typ 75% @ 50% load
  • 1500V isolation (input to output)

Data sheet: http://arduino.cc/en/uploads/Main/PoE-datasheet.pdf

Ethernet Shield V2

Arduino Ethernet Shield V1 es una placa que aparece en la web de arduino.cc como retirado, pero sigue estando disponible como clones o versiones derivadas.

Existe una nueva versión del Ethernet Shield llamada Arduino Ethernet Shield 2 con el nuevo Wiznet 5500: https://www.arduino.cc/en/Main/ArduinoEthernetShield

Este Shield usa la librería Ethernet 2 cuya sintaxis es igual que la librería Ethernet: https://www.arduino.cc/en/Reference/Ethernet

Data sheet de W5500: https://www.sos.sk/productdata/15/26/12/152612/W5500_datasheet_v1.0.2_1.pdf

Mejoras de W5500: https://feilipu.me/2014/11/16/wiznet-w5500-ioshield-a

Arduino Ethernet Shield 2:

Otros Arduinos con Ethernet

Existe un Arduino Ethernet que es casi igual a un arduino UNO + Ethernet Shield: https://www.arduino.cc/en/Main/arduinoBoardEthernet

También existe el Arduino Leonardo ETH que es casi lo mismo que un Arduino Leonardo + un Ethernet Shield 2: https://www.arduino.cc/en/Main/ArduinoBoardLeonardoEth

Para las tarjetas basadas en el chip wiznet 5200:

Power over Ethernet

El Ethernet shield es compatible con PoE gracias a un módulo adicional que extrae la energía eléctrica del cable ethernet, anteriormente inyectada desde el switch.

Las características del módulo PoE:

  • IEEE802.3af compliant
  • Low output ripple and noise (100mVpp)
  • Input voltage range 36V to 57V
  • Overload and short-circuit protection
  • 9V Output
  • High efficiency DC/DC converter: typ 75% @ 50% load
  • 1500V isolation (input to output)

Data sheet: http://arduino.cc/en/uploads/Main/PoE-datasheet.pdf

Más información sobre el Power Over Ethernet:

Como funciona PoE: http://www.bb-elec.com/Learning-Center/All-White-Papers/Ethernet/Power-over-Ethernet-PoE.aspx

Phantom Feeding:

Alimentación sobre cables libres:

Práctica: Uso Ethernet Shield

IP Dinámica con Arduino. DHCP

Configurar Arduino con el ethernet shield de forma que coja la IP dinámicamente por DHCP y lo muestre por pantalla.

Solución: https://github.com/jecrespo/aprendiendoarduino-Curso_Arduino_2017/tree/master/Ejercicio32-DHCP

IP Fija con Arduino

Configurar Arduino con el ethernet shield de forma que le asignamos una IP fija con la siguiente configuración:

  • IP: 192.168.6.1YY. Siendo YY el número = 30 + número del kit. Por ejemplo para el kit 4 la IP es la 192.168.6.134 y para el kit 16 la IP es es 192.168.6.146.
  • Subnent: 255.255.255.0
  • Gateway: 192.168.6.1
  • DNS: 8.8.8.8

Solución: https://github.com/jecrespo/aprendiendoarduino-Curso_Arduino_2017/tree/master/Ejercicio33-Configurar_IP

Grabar Datos en Tarjeta SD

El Ethernet shield tiene disponible una ranura para tarjetas microSD. Arduino es capaz de leer y escribir en la tarjeta microSD mediante la librería SD: https://www.arduino.cc/en/Reference/SD

Leer la documentación de la librería SD y entender qué hace cada una de las clases y sus métodos.

Insertar una tarjeta microSD y hacer un programa que grabe los datos de temperatura en un archivo llamado temp_log.csv cada 5 segundos. Los datos a guardar son: segundos desde inicio con la función millis() y la temperatura del sensor TMP36.

Opcionalmente crear un menú con 3 opciones:

  • 1 – Muestra el último dato guardado en la SD
  • 2 – Vuelca el contenido del fichero temp_log.csv por consola
  • 3 – Borra el contenido del fichero

Esquema de conexión:

Solución: https://github.com/jecrespo/aprendiendoarduino-Curso_Arduino_2017/tree/master/Ejercicio34-SD_Datalogger

Programación Visual con mBlock

mBlock es un entorno gráfico de programación basado en el editor Scratch 2.0 para introducir de forma sencilla la programación y robótica en el aula.

Hemos visto en otro capítulo otro entorno de programación basado también en Scratch, el Scratch 4 Arduino o S4A, que guarda muchas similitudes con mBlock.

mBlock tiene algunas características que lo hacen más adecuado para trabajar con robots. Con S4A, tenemos que tener conexión permanente entre el PC y el Arduino, bien por cable o por Bluetooth. Al usar mBlock no tenemos este problema, ya que nos permite elegir la forma en la que queremos trabajar: ejecutándose en tiempo real en el PC (como en S4A necesitando cargar un firmware en la placa) o cargando el programa en la placa de forma que podamos prescindir del PC.

Cuando cargamos el programa en la placa, como hacemos con el IDE de Arduino, nos permite hacer robots autónomos al no tener que estar siempre conectados al PC. Además al cargar los programas de esta forma se puede ver el equivalente en código del programa que hayamos diseñado con los bloques, de forma que nos puede ayudar durante la transición de entorno gráfico a código.

Otra ventaja es que mBlock nos permite definir qué pines vamos a querer usar como entradas y cuáles como salidas. Por el contrario en S4A vienen predefinidos y a la hora de construir robots puede ser un inconveniente.

También mBlock permite descargar unos paquetes a los que llama extensiones con nuevos bloques que no vienen en la versión estándar que nos descargamos, y gracias a ellos podemos trabajar con componentes que es imposible de utilizar con S4A.

Entorno Programación

El entorno de programación de mBlock es gratuito, funciona con varios tipos de sistemas operativos y se descarga desde http://www.mblock.cc/download/

Al estilo de Arduino, mBlock ha sacado una beta de un entorno de programación on-line en http://editor.makeblock.com/ide.html

Una vez instalado vemos lo siguiente:

mBlock se compone de 5 partes principalmente:

  • Grupo de instrucciones clasificadas por colores en las siguientes categorías:
    • Movimiento: Conjunto de instrucciones relacionadas con el control de los pines de la tarjeta de Arduino, así como el control del movimiento de cualquier personaje del escenario.
    • Apariencia: Instrucciones orientadas a modificar el aspecto de los personajes de nuestra aplicación. Para el caso de Arduino, es un conjunto de instrucciones que apenas se utiliza.
    • Sonido: Conjunto de instrucciones relacionadas con la elaboración de aplicaciones musicales, emitiendo sonidos y notas musicales.
    • Lápiz: Scratch nos ofrece la posibilidad de que los personajes dejen un rastro durante sus movimientos por el escenario como si arrastrase un lápiz durante su trayectoria.
    • Control: Las instrucciones incluídas en esta sección son impresindibles para crear la lógica de nuestros programas. Incluyen condicionales, bucles y llamadas de procedimientos.
    • Sensores: Instrucciones de iteración con el ratón, el teclado, sonidos y los personajes.
    • Operadores: operaciones matemáticas, lógicas y con cadenas de texto.
    • Variables: Instrucciones para el almacenamiento y gestión de datos.
  • Instrucciones de programación: Las instrucciones de cada grupo corresponden a instrucciones de programación.
  • Editor: Es la parte principal donde estructuramos y programamos nuestro programa.
    • Programas: Se compone de todas las instrucciones que hace funcionar el código que programemos.
    • Disfraces: Cada objeto puede tener diferentes apariencias o disfraces para utilizar a lo largo de nuestro programa.
    • Sonido: También es posible añadir o grabar sonidos y guardarlos para futuros usos.
  • Escenario o ventana principal: Es el resultado de nuestro programa.
  • Objetos y sprites: Distinguimos principalmente los objetos de tipo Arduino y Sprites.
    • Los objetos de tipo arduino son aquellos que interactúan con Arduino.
    • Los sprites son similares al entorno de scratch y no interactúan con Arduino.

Modo Ejecutar Programa desde PC

En este modo es necesario siempre tener el Arduino o el robot siempre conectado al PC.

Para usar este modo comenzaremos el programa con un bloque de la categoría “Eventos”, normalmente con el bloque de la bandera verde. Y debajo de este colocamos el resto de bloques del programa.

Para ejecutar el programa desde el PC, primero tenemos que seleccionar la placa y el puerto serie al que esté conectado el Arduino. Conectamos el cable USB al Arduino y seleccionamos la placa en “Placas->Arduino UNO” y el puerto en “Conectar->Puerto Serie”.

A continuación “Conectar->Actualizar Firmware” y esperamos a que termine de cargarlo.

Tutoriales de uso:

Modo Subir Programa a Arduino

En este modo no cargamos un firmware a la placa sino que sube el programa al Arduino. En este modo usamos como inicio del programa el bloque “Programa de Arduino” que se encuentra en la categoría “Robots”.

Para este modo pulsamos sobre el bloque “Programa de Arduino”  o vamos a “Editar->Modo Arduino”. En la parte derecha de la pantalla aparecerá una pantalla con algunas opciones nuevas y el equivalente en código del programa que hemos hecho con los bloques.

Luego para subir el sketch al ordenador pulsamos sobre el botón “Subir a Arduino” y esperamos a que termine de cargar.

Tutorial para usar Arduino con mBlock:

Más información:

GitHub oficial de Makeblock

Donde podrás encontrar todo el código fuente de las librerías, firmware,software, planos … https://github.com/Makeblock-official

Librerías de Makeblock para IDE Arduino https://github.com/Makeblock-official/Makeblock-Libraries que nos permite programar los robots de makeblock con el IDE de Arduino.

Programación con mBlock

Puesto que mBlock está basado en scratch 2.0 la programación es igual a Scratch y solo hay un grupo de bloques adicionales para manejar los puertos de Arduino o de los robots.

Buen tutorial de programación: http://www.atlantistelecom.com/es/downloads2/makeblock_bloques_de_programacion.pdf

Programación de El Cable Amarillo:

Aplicaciones Móviles

Makeblock Aplicación para controlar tus robos desde móviles y tablets con SO Android

Makeblock HD Aplicación para controlar los robots de Makeblock desde iOS e iPad   

mBlockly  Con esta aplicación podrás programar tus robots desde tu iPad mediante un entorno similar a Scratch

MakeBlock

MakeBlock es la marca del hardware para el que está desarrollado mBlock, pero que también podemos usar con Arduino.

Enlaces:

Learn de makeblock: http://learn.makeblock.com/en/

Imprimir en 3D las piezas de MakeBlock: https://grabcad.com/library/data-of-makeblock-parts-1

Placas MakeBlock

Placa basada en Arduino mCore: http://learn.makeblock.com/en/mcore/

Makeblock Orion: http://learn.makeblock.com/en/makeblock-orion/

Shield para convertir un Arduino en un makeblock Me UNO Shield:

Robots Educativos

Kits de Robots: http://store.makeblock.com/robot-kit-series-STEM

Maker Kits: http://store.makeblock.com/maker-kits-STEM

mBot: http://store.makeblock.com/product/mbot-robot-kit

mBot Ranger: http://store.makeblock.com/product/mbot-ranger-robot-kit

Robot Educativo mBot:

Ejercicios Propuestos

Listado de materiales y prácticas de El cable amarillo:

Dos ejemplos con mBlock muy buenos en http://www.prometec.net/mblock/:

  • Coche teledirigido con Bluetooth
  • Robot siguelineas

Propuestas didácticas: