Archivo de la etiqueta: JSON

Node-RED

Node-RED es una herramienta muy potente que sirve para comunicar hardware y servicios de una forma muy rápida y sencilla. Simplifica enormemente la tarea de programar del lado del servidor gracias a la programación visual.

Fue creada por Nick O’Leary y Dave Conway-Jones del grupo de Servicios de Tecnologías Emergentes de IBM en el año 2013. Su objetivo es dar solución a la complejidad que surge cuando queremos integrar nuestro hardware con otros servicios.

Su punto fuerte es la sencillez. Nos permite utilizar tecnologías complejas sin tener que profundizar hasta el más mínimo detalle en todas ellas. Nos quedamos en una capa inicial donde nos centramos en lo importante y dejamos de lado aquello que no es práctico.

Wikipedia: https://en.wikipedia.org/wiki/Node-RED

La estructura mínima son los nodos. Estos se arrastran a través de la interfaz gráfica y nos permiten hacer una tarea concreta. Recibir una llamada HTTP, un mensaje MQTT o la activación de un pulsador.

Todos estos nodos se organizan en flujos o flows que agrupan nodos que se conectan entre ellos. Todo de una forma visual, sin apenas tener que programar.

Node-RED es un motor de flujos con enfoque IoT, que permite definir gráficamente flujos de servicios, a través de protocolos estándares como REST, MQTT, Websocket, AMQP… ademas de ofrecer integración con apis de terceros, tales como Twitter, Facebook, Yahoo!…

Se trata de una herramienta visual muy ligera, programada en NodeJS y que puede ejecutarse desde en dispositivos tan limitados como una Raspberry, hasta en plataformas complejas como IBM Bluemix, Azure IoT o Sofia2 Platform.

Web: https://nodered.org/

Node-RED es una herramienta de código abierto, estando este disponible en github.

Repositorio: https://github.com/node-red/node-red

Una de las características más notables de Node-RED es la sencillez con la que se pueden crear nuevos nodos e instalarlos, en el siguiente enlace disponemos de toda la documentación necesaria: http://nodered.org/docs/creating-nodes/, en él, podemos ver que desarrollar un nuevo nodo es tan sencillo como crear un fichero HTML con el formulario de configuración mostrado en la imagen anterior para el nodo en concreto, y un fichero JS, con la lógica del nodo escrita en NodeJS.

De este modo, cualquier persona u organización puede crearse sus propios nodos, adaptando el motor de flujo a las necesidades de su negocio.

Los flujos programados en Node-RED se almacenan internamente en formato JSON y son portables entre distintas instalaciones de Node-RED, siempre que el Node-RED de destino tenga instalados los nodos utilizados en el flujo.

De este modo un flujo Node-RED consiste en un fichero con este aspecto:

La facilidad de desarrollo de nuevos nodos, así como la portabilidad de los flujos, confieren a Node-RED un marcado enfoque social. Gran parte de su éxito se fundamenta en que los nodos y flujos desarrollados por una persona u organización, pueden ser aprovechados por otras. En este sentido, en el sitio oficial de Node-RED encontramos una sección de contribuciones de terceros, con más de 1000 nodos y flujos subidos por la comunidad y listos para utilizar.

Node-RED Library: https://flows.nodered.org

Getting Started Node-RED: https://nodered.org/#get-started

Comunidad Node-RED: https://nodered.org/#community

Documentación Node-RED: https://nodered.org/docs/

En cuanto a cómo instalar Node-RED, existen dos alternativas:

  • Modo Standalone: Donde se ejecuta como un proceso NodeJS independiente del resto de procesos.
  • Modo Embebido: Donde forma parte de una aplicación mayor, de forma que es responsabilidad de esta controlar el ciclo de vida del propio Node-RED

Ambas instalaciones son securizables tanto a nivel control de acceso con usuario y contraseña, como con certificado SSL para acceder al editor por protocolo seguro HTTPS.

Asimismo dispone de un API Rest de administración y operación (http://nodered.org/docs/api/) de manera que puede interactuar y ser controlado por un sistema externo.

Estas características son las que hacen que Node-RED sea adecuado para ejecutarse casi en cualquier plataforma, ya que le dan la versatilidad de ser instalado tal cual, por ejemplo en una Raspberry. O poder ser administrado por un sistema mayor, como por ejemplo IBM Bluemix.

Instalación: https://nodered.org/docs/getting-started/

  • Localmente
  • En un dispositivo
  • En la nube

Es posible instalar Node-RED en un portátil y controlar el broker desde el mismo.

Configuración node red: https://nodered.org/docs/configuration

Node-RED con Arduino: https://nodered.org/docs/hardware/arduino

API nodered: https://nodered.org/docs/api/

Más información:

Vídeo Introducción IoT: https://www.youtube.com/watch?time_continue=85&v=vYreeoCoQPI

Curso IoT simatic (Siemens con Node red); http://www.infoplc.net/descargas/109-siemens/comunicaciones/2847-manual-simatic-iot2040-node-red

Instalar Node-RED en Raspberry Pi

Node-Red no viene instalado en Raspberry Pi pero se puede hacer desde add/remove software.

La forma recomendada es desde Menú – Preferencias – Software Recomendado. Si se instala de esta manera, se puede actualizar usando sudo apt-get upgrade.

Luego se puede ejecutar manualmente con el comando “node-red-star” o :

Para iniciar Node-RED en el arranque de Raspberry Pi de forma automática usar:

  • sudo systemctl enable nodered.service

Más información https://nodered.org/docs/hardware/raspberrypi

Para comprobar que funciona abrir en un navegador http://ip-raspberry:1880

pantalla node-red

Para encontrar más nodos y ejemplos de flows ver https://flows.nodered.org/

Para añadir nodos adicionales primero debe instalar la herramienta npm, ya que no está incluida en la instalación predeterminada de Raspbian. Esto no es necesario si ha actualizado a Node.js 8.x.

Los siguientes comandos instalan npm y luego lo actualizan a la última versión.

  • sudo apt-get install npm
  • sudo npm install -g npm

Para poder ver la paleta e instalar nodos, reiniciar el servicio:

  • sudo systemctl restart nodered.service

Y luego para instalar un nodo:

  • cd ~/.node-red
  • npm install node-red-{example node name}

Por ejemplo, podemos suscribirnos a un topic de MQTT, recibir un dato de temperatura y mostrarlo en la pantalla de debug:

Pero no sólo podemos hacer esto, también podemos conectar con servicios de terceros como IFTTT, ThingSpeak, Google Home, ThingerIO, etc…

Alternativamente se puede instalar mediante un script con el comando:

Configurar y Securizar Node-RED

Para configurar Node-RED seguir: https://nodered.org/docs/configuration

El fichero de configuración se encuentra normalmente en $HOME/.node-red/settings.js

Para securizar Node-RED seguir: https://nodered.org/docs/security para añadir usuario y password, así como otras configuraciones de seguridad

Para calcular la contraseña uso https://www.dailycred.com/article/bcrypt-calculator

Command line administration: https://nodered.org/docs/node-red-admin

Para usar https con Node-RED seguir estos tutoriales:

Programación Node-RED

Con respecto a Node-RED, se pueden hacer muchas cosas. Desde encender un LED en remoto, crear una API Rest en 5 minutos o conectar con una base de datos InfluxDB para graficar con Grafana. Aunque es visual, se requieren unos conocimientos técnicos en programación y tecnología medios y/o avanzados.

También permite programar en JavaScript funciones que pueden hacer de todo. Node-RED da mucho juego para muchas cosas.

El editor de flujos de Node-RED consiste en una sencilla interfaz en HTML, accesible desde cualquier navegador, en la que arrastrando y conectando nodos entre sí, es posible definir un flujo que ofrezca un servicio.

Como vemos, el editor se estructura como un entorno gráfico sencillo con:

  • Paleta de Nodos: Muestra todos los nodos que tenemos disponibles en nuestra instalación. Como veremos más adelante, existe un repositorio de nodos desarrollados por otros usuarios e incluso podemos crear e instalar nuestros propios nodos.
  • Editor: Nos permite arrastrar nodos desde la paleta y conectarlos. De este modo iremos creado el flujo de operación. El lienzo de node-red no tiene límites y se puede hacer zoom.

secciones principales node-red

Asimismo, seleccionando cada nodo, se muestra a la izquierda su formulario de configuración, donde es posible establecer las propiedades concretas de dicho nodo:

En node-Red los nodos se comunican entre sí mediante msg, que es un objeto con propiedades y que podemos añadir propiedades. La propiedad principal es payload, pero puedo añadir las que quiera. Puedo añadir otras propiedades como temperatura. Los nodos se unen en flujos que se ejecutan en paralelo.

En los nodos con entrada y salida, lo que entra sale y se mantiene la información salvo la que modifiques en el nodo.

Hay tres datos o propiedades que no se pueden modificar.:

  • número de mensaje
  • topic
  • payload

Disponemos de un debug que nos muestra el objeto y la podemos sacar por pantalla.

Los nodos son la unidad mínima que podemos encontrar en Node-RED. En la parte izquierda de la interfaz podemos ver la lista de nodos que vienen instalados por defecto y organizados en categorías según su funcionalidad.

Hay nodos de entrada, salida, funciones, social, para almacenar datos, etc… Esto muestra la capacidad de Node-RED de comunicarse con otros servicios.

Se pueden clasificar en tres tipos de nodos:

  • Nodos que sólo admiten entradas: sólo admiten datos de entrada para ser enviados a algún sitio como pueda ser una base de datos o un panel de control.
  • Nodos que sólo admiten salidas: son los nodos que sólo ofrecen datos tras recibirlos a través de diferentes métodos como por ejemplo un mensaje MQTT.
  • Nodos que admiten entradas y salidas: estos nodos nos permiten la entrada de datos y luego ofrecen una o varias salidas. Por ejemplo, podemos leer una temperatura, transformarla en grados Celsius y enviarla a otro nodo.

Los nodos los arrastramos al flujo o flow, en inglés. Aquí es donde tendremos la lógica para cada dato a base de ir arrastrando nodos.

Algunos de los nodos disponibles en Node-RED, los nodes de core son: https://nodered.org/docs/user-guide/nodes

  • Inject: para disparar un flujo manualmente. Inyecta una payload a un topic.
  • Debug: sirve para mostrar mensajes en la zona de debug de Node-RED. Puede habilitarse o deshabilitarse.
  • Function: permite programar un nodo mediante JavaScript, pero es mejor buscar nodos hechos que hagan la función deseada, por ejemplo un temporizador.
  • Change: se usa para modificar las propiedades de un mensaje sin usar funciones
  • Switch: permite que los mensajes sean enrutados a diferentes ramas de un flujo mediante un conjunto de reglas contra el mensaje.
  • Template: se usa para generar texto usando las propiedades de un mensaje.

Trabajar con mensajes en Node-RED: https://nodered.org/docs/user-guide/messages

Escribir funciones en Node-RED: https://nodered.org/docs/writing-functions

Existen además muchos tipos de nodos que podemos ver en https://flows.nodered.org/?num_pages=1 que son contribuciones de terceros.

Los nodos se organizan en flujos, para organizar los nodos como queramos. Es recomendable agrupar en flujos tareas que tengan relación entre ellos, pero solo a modo organizativo.

En node-red se puede trabajar con variables:

  • Contexto – solo aplica a un nodo
  • Flujo – aplica solo al flujo
  • globales – aplica a todo.

Cookbook de nodered: https://cookbook.nodered.org/

Node-RED programming guide: http://noderedguide.com/

Administración de node red mediante comando: https://nodered.org/docs/node-red-admin

Running node-red: https://nodered.org/docs/getting-started/running

Más información: https://programarfacil.com/blog/raspberry-pi/introduccion-node-red-raspberry-pi/

Node Red en Cloud

Hosting de node-red gratuito FRED (hasta 50 nodos): https://fred.sensetecnic.com/

FRED: Front End For Node-RED

Web principal de FRED

Google cloud: https://medium.com/google-cloud/deploy-your-node-red-environment-onto-kubernetes-clusters-using-google-cloud-platform-2e4775c2e79f

Más información:

Ejemplos Node-RED

Primer Flujo en Node-RED

Vamos a probar un flujo muy simple. Lo que hará es mostrar un texto por el panel de debug. Arrastra un nodo inject de la categoría input y un nodo debug de la categoría output al flujo. Los tienes que conectar entre ellos arrastrando el punto de la parte derecha del nodo inject sobre el punto de la parte izquierda del nodo debug.

A continuación vamos a editar el nodo inject. Si haces doble click sobre el nodo se abrirá un panel donde nos muestra diferentes parámetros. En este panel tienes que seleccionar del menú desplegable donde pone Payload, la opción que pone String.

En el campo de texto pon cualquier cosa como por ejemplo Hola mundo 🙂

Para guardar la aplicación sólo tienes que dar a Deploy que si te has dado cuenta, ha pasado de estar en un color gris oscuro a rojo.

Una vez que lo hayas pulsado, volverá de nuevo al color gris oscuro. Esto quiere decir que ya tenemos guardados todos los cambios del flujo de Node-RED.

Para probar este primer flujo con Node-RED tenemos que abrir el panel de debug que está situado en la parte derecha. Luego, tienes que hacer click sobre la parte izquierda del nodo inject.

Esto hará que en el panel debug aparezca lo que hemos escrito en la configuración del nodo inject.

Como puedes ver, el mensaje se muestra en el panel debug.

Más información: https://programarfacil.com/blog/raspberry-pi/introduccion-node-red-raspberry-pi/

Node-RED y MQTT

Sólo tienes que arrastrar el nodo mqtt que está en la categoría input al flujo.

Ahora hay que configurarlo. Aquí es donde vemos la potencia de Node-RED. Cuando utilizamos una tecnología, nos centramos en lo superficial. En el caso de MQTT lo único que tenemos que hacer es configurar el broker y el topic.

Al tratarse de un nodo de entrada, lo que hace es recibir los mensajes publicados en un topic es decir, se suscribe al topic. Haz doble click sobre el nodo para que abra el panel de configuración.

En el panel de configuración MQTT vamos a configurar primero el broker MQTT. Haz click en el lápiz que aparece en Server.

Esto abre un nuevo panel de configuración. Pon un nombre al broker MQTT por ejemplo ALARMA PUERTA. En Server tienes que poner la IP donde está instalado el broker MQTT y el puerto que utiliza, normalmente es el 1883.

Esta sería la configuración mínima. No te olvides de hacer click en el botón Add.

Después de esta acción volverás al panel de configuración del nodo mqtt y automáticamente, habrá seleccionado el broker MQTT que acabamos de crear.

Por último, vamos a rellenar el campo de Topic. Debe ser el mismo que hemos puesto en Arduino o el ESP8266, /casa/puerta/alarma. Una vez lo tengas, haz click en Done.

Ahora sólo nos queda probarlo. Para ello vamos a utilizar el mismo nodo debug de la categoría output que hemos utilizado antes.

Arrástralo al flujo, conecta los dos nodos y haz click en el botón Deploy.

Para probar el sistema lo podemos hacer de dos formas. Desde una terminal de Raspberry Pi podemos publicar un mensaje en el topic o directamente conectando la placa y simulando que abren la puerta.

El resultado sería el siguiente.

Nodos Node-RED

Existe una amplia librería de nodos para node-RED que puede consultarse en https://flows.nodered.org/?num_pages=1

Para añadir un nodo: https://nodered.org/docs/getting-started/adding-nodes

Si quieres crear tu propio nodo: https://nodered.org/docs/creating-nodes/first-node

Por defecto vienen unos nodos instalados, pero pueden añadirse otros fácilmente.

Github: https://github.com/node-red/node-red-nodes

Hay más de 1500 nodos, algunos de los más interesantes son:

Más información:

Nodo MySQL

Node de mysql: https://flows.nodered.org/node/node-red-node-mysql

Código del nodo de mysql: https://github.com/node-red/node-red-nodes/tree/master/storage/mysql

Ejemplo: https://flows.nodered.org/flow/13c55d1aa11e864609e24fa534a1fa26

Ejemplo de uso: https://tech.scargill.net/tag/mqtt-and-mysql-on-node-red/

Y nodo interesante para manejo de fechas:

Nodo MongoDB

Nodo MongoDB: https://flows.nodered.org/node/node-red-node-mongodb

Dashboard en Node-RED

Uno de los nodos más populares de Node-RED es el de dashboard, que  permite hacer un dashboard muy sencillo desde Node-RED.

Node dashboard: https://flows.nodered.org/node/node-red-dashboard

Github: https://github.com/node-red/node-red-dashboard

Cómo usarlo: https://randomnerdtutorials.com/getting-started-with-node-red-dashboard/

Más información:

Y se accede al dashboard con http://IP_NodeRED:1880/ui   

Tutoriales node red dashboard

Otro dashboard es el freeboard:

Ejemplo Arduino + MQTT + NodeRed + Dashboard

Hacer un Dashboard como este usando dos sondas o dos potenciómetros que manden datos a varios topic y se muestre en el dashboard, así como un led que pueda encenderse al pulsar un botón del dashboard y dos leds que se enciendan cuando se supere el umbral de temperatura.

Además hacer una pestaña con las gráficas y hacer un flujo de debug para ver los datos.

Todos los datos serán guardarlos en la BBDD MariaDB instalada en las Raspberry Pi

Ejemplo hecho con 4 flujos:

Código node-red: https://github.com/jecrespo/Curso-IoT-Open-Source/blob/master/node-red/node-red.json

Código Arduino: https://github.com/jecrespo/Curso-IoT-Open-Source/blob/master/node-red/arduino-node-red/arduino-node-red.ino

Anuncios

Tratamiento Avanzado de Strings

Como ya se ha visto anteriormente el tratamiento de strings es un parte muy importante en Arduino puesto que se usa muy frecuentemente y principalmente usamos en las comunicaciones, ya sea puerto serie, bluetooth, XBee, http, etc…

El uso de strings hace un uso intensivo de memoria lo que hace que podamos tener comportamientos extraños en los sketchs o incluso tengamos desbordamiento de memoria.

A la hora de usar strings en Arduino, podemos hacer uso de la clase String https://www.arduino.cc/reference/en/language/variables/data-types/stringobject/ que nos ofrece unos métodos y es muy sencilla de usar, a cambio de ser poco eficiente a nivel de SRAM o usar los stringshttps://arduino.cc/reference/en/language/variables/data-types/string/ como arrays de chars https://arduino.cc/reference/en/language/variables/data-types/char/ que es más complejo de manejar pero más potente y tenemos más control del uso de memoria y pueden usarse muchas de las funciones estandard de C++.

String (Objeto)

Arduino nos ofrece una clase llamada String que facilita el uso de de las cadenas de caracteres con unos métodos muy sencillos de usar y poder usar los operadores que conocemos para los Strings.

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.

Toda la información de la clase String está en: https://arduino.cc/reference/en/language/variables/data-types/stringobject/

Ver documentación de Arduino sobre la clase String:

Tutoriales de uso de String:https://arduino.cc/en/Tutorial/BuiltInExamples#strings

Prácticas Manejo de Strings

Ejecutar el ejemplo https://arduino.cc/en/Tutorial/StringLengthTrim donde se hace uso de las funciones length() y trim().

Ejecutar el ejemplo https://arduino.cc/en/Tutorial/StringStartsWithEndsWith donde se hace uso de las funciones StartsWith() y EndsWith().

Ejecutar el ejemplo https://arduino.cc/en/Tutorial/StringSubstring donde se hace uso de la función substring().

Ejecutar el ejemplo https://arduino.cc/en/Tutorial/StringToInt donde se hace uso de la función toInt()

Otra de las funciones más útiles de String es IndexOf() con ejemplos en https://www.arduino.cc/en/Tutorial/StringIndexOf

Ejercicio: Conectarse a www.aprendiendoarduino.com y analizar el texto descargado. El texto descargado es una página web que contiene datos de una música a tocar por el buzzer

Hacerlo usando la clase String.

Obtener y sacar por el puerto serie:

  • Tamaño de la web (número de caracteres)
  • Localizar las cadenas: “Inicio Notas”, “Fin Notas”, “Inicio Duración” y “Fin Duración”
  • Obtener las notas (frecuencia) y la duración de las notas. Luego reproducirlo.

Solución: https://github.com/jecrespo/aprendiendoarduino-Curso_Programacion_Arduino/tree/master/Ejercicio16-Strings_Avanzado

string (Array de chars)

Un string es un array de chars. Cuando se trabaja con grandes cantidades de texto, es conveniente usar un array de strings. Puesto que los strings son en si mismo arrays. En el reference de Arduino https://arduino.cc/reference/en/language/variables/data-types/string/

La notación de un string como array de chars es char*

El core de Arduino me ofrece varias funciones de análisis de caracteres: https://arduino.cc/reference/en/language/variables/data-types/string/

Una cadena en C++ es un conjunto de caracteres, o valores de tipo char, terminados con el carácter nulo, es decir el valor numérico 0 (\0). Internamente, en el ordenador, se almacenan en posiciones consecutivas de memoria. Este tipo de estructuras recibe un tratamiento muy especial, ya que es de gran utilidad y su uso es continuo. La manera de definir una cadena es la siguiente: char <identificador> [<longitud máxima>];

Cuando se declara una cadena hay que tener en cuenta que tendremos que reservar una posición para almacenar el carácter nulo terminador, de modo que si queremos almacenar la cadena “HOLA”, tendremos que declarar la cadena como: char Saludo[5]; Las cuatro primeras posiciones se usan para almacenar los caracteres “HOLA” y la posición extra, para el carácter nulo.

También nos será posible hacer referencia a cada uno de los caracteres individuales que componen la cadena, simplemente indicando la posición. Por ejemplo el tercer carácter de nuestra cadena de ejemplo será la ‘L’, podemos hacer referencia a él como Saludo[2].

Se puede manipular las cadenas de caracteres de la misma manera en que manipula cualquier otro tipo de array, sin embargo, es preferible hacer uso de una librería estándar especialmente escrita para manipulación de cadenas de caracteres, se trata de la librería <string.h> y que viene incluida con todo compilador de C, C++.

Reference de C++ para la clase string http://cplusplus.com/reference/string/string/ y http://cplusplus.com/reference/cstring/ con funciones como strcpy para strings null-terminated.

Los compiladores de C, C++ dan soporte a la biblioteca de funciones <string.h>, a la que accede por medio de la directiva #include <string.h>. No veremos en detalle todas las funciones contenidas en dicha biblioteca, y nos limitaremos a mostrar algunos ejemplos de ciertas funciones importantes.

  • strlen(): Obtener longitud de cadenas. Sintaxis: size_t strlen(const char *s);
  • strcpy(): Copiar cadenas. Sintaxis: char *stpcpy(char *dest, const char *src);
  • strcat(): Concatenar cadenas. Sintaxis: char *strcat(char *dest, const char *src);
  • strlwr(): Convertir a minúsculas. Sintaxis: char *strlwr(char *dest);
  • strupr(): Convertir a mayúsculas. Sintaxis: char *strupr(char *dest);
  • strchr(): Buscar carácter (hacia adelante). Sintaxis: char *strchr(char *s, int c);
  • strrchr(): Buscar carácter (hacia atras). Sintaxis: char *strrchr(char *s, int c);
  • strstr(): Buscar subcadena. Sintaxis: char *strstr(const char *s1, char *s2);
  • memset(): Establece el primer num bytes del bloque de memoria apuntado por ptr al valor especificado en value (interpretado como un unsigned char).. Sintaxis: void * memset ( void * ptr, int value, size_t num );

Reference:

En C++ también tenemos soporte a la clase cstring, que no debe confundirse con la <string.h>. Una de las ventajas que ofrece la clase cstring es que, a diferencia de las cadenas estándar, ésta posee la capacidad de crecer o disminuir su tamaño en tiempo de ejecución. Además, entre otras características destacables, la clase string soporta operaciones de asignación tales como: =, +, +=, etc.; y de comparación tales como: ==, <=, etc.

Documentacíon de la librería <string.h>: http://www.cplusplus.com/reference/cstring/

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

Ejercicio Strings_vs_strings: Partiendo de la base del ejercicio StringsComparisonOperators intentar hacer las operaciones de comparación de igualdad y distinto de los StringOne y StringTwo con string en lugar de String. Ver como es más complicado y para iniciarse en la programación es mejor usar String (objeto) que string (char array).

Solución: https://github.com/jecrespo/Aprendiendo-Arduino/tree/master/Ejercicio18-strings/_5-String_vs_string

Más información:

Ejercicios Avanzados  Strings

Ejercicio: Mandar un SMS mediante un módulo SIM800L, donde pido por consola el número y el mensaje en formato” <numero_telefono>-<mensaje>!”. Analizar esta cadena y separar en teléfono y mensaje y mandar mediante la función bool sendSms(char* number,char* text);

El primer análisis hacerlo con la clase String y luego pasar las variables teléfono y mensaje a char* que es lo que pide la librería.

Librería disponible en el gestor de librerías: https://github.com/VittorioEsposito/Sim800L-Arduino-Library-revised

HW: https://es.aliexpress.com/item/SIM800L-V2-0-5V-Wireless-GSM-GPRS-MODULE-Quad-Band-W-Antenna-Cable-Cap/32465895576.html

Solución: https://github.com/jecrespo/Aprendiendo-Arduino/tree/master/Ejercicio68-toCharArray

Ejercicio: Manejo de JSON mediante la librería disponible en el gestor de librerías ArduinoJson https://arduinojson.org y repositorio https://github.com/bblanchon/ArduinoJson

JSON: https://es.wikipedia.org/wiki/JSON

Abrir el ejemplo JsonParserExample de la librería y probarlo.

PROGMEM

El uso de strings como cadena de caracteres en Arduino, en lugar de usar la clase String, nos permite también almacenar los strings en la memoria flash en lugar de la SRAM gracias a PROGMEM https://arduino.cc/reference/en/language/variables/utilities/progmem/

A menudo es conveniente cuando se trabaja con grandes cantidades de texto, como un proyecto con una pantalla LCD o en comunicaciones, usar PROGMEM con arrays de strings.  Estos tienden a ser grandes estructuras, así que ponerlas en memoria de programa (flash) es a menudo deseable. El código siguiente ilustra la idea.

 
#include <avr/pgmspace.h>
const char string_0[] PROGMEM = "String 0";   // "String 0" etc are strings to store - change to suit.
const char string_1[] PROGMEM = "String 1";
const char string_2[] PROGMEM = "String 2";
const char string_3[] PROGMEM = "String 3";
const char string_4[] PROGMEM = "String 4";
const char string_5[] PROGMEM = "String 5";

// Then set up a table to refer to your strings.

const char* const string_table[] PROGMEM = {string_0, string_1, string_2, string_3, string_4, string_5};

char buffer[30];    // make sure this is large enough for the largest string it must hold

void setup()
{
  Serial.begin(9600);
  while(!Serial);
  Serial.println("OK");
}

void loop()
{
   for (int i = 0; i < 6; i++)
  {
    strcpy_P(buffer, (char*)pgm_read_word(&(string_table[i]))); // Necessary casts and dereferencing, just copy.
    Serial.println(buffer);
    delay( 500 );
  }
}

Utilidades de PROGMEM: https://www.nongnu.org/avr-libc/user-manual/group__avr__pgmspace.html

Usar la tabla de cadenas en la memoria de programa (flash) requiere el uso de funciones especiales para recuperar los datos. La función strcpy_P copia un string desde el espacio del programa (flash) en un string en la memoria RAM (“buffer”). Debemos asegurarnos de que la cadena de recepción en la memoria RAM es lo suficientemente grande como para alojar cualquier string que está recuperando desde el espacio del programa

Las funciones para manejar PROGMEM están en http://www.nongnu.org/avr-libc/user-manual/group__avr__pgmspace.html que podemos ver son iguales que las de <string.h>, pero seguidas de “_P”

Tener en cuenta que las variables deben ser definidas de forma global y como constantes, o definido con la palabra clave static, con el fin de trabajar con PROGMEM.

Recordar que podemos usar la macro F() junto con el métodos print y println de forma que todo lo que hay dentro de los métodos se guarda en la memoria flash.

Ejemplo: Serial.println(F(“This string will be stored in flash memory”));

Para saber como funciona PROGMEM ver  la pagina 347 y 354 de http://www.atmel.com/Images/Atmel-42735-8-bit-AVR-Microcontroller-ATmega328-328P_datasheet.pdf y donde lo metes lo de MEMPROG

Arduino Web Client

Conexión a una web

Crear un cliente ethernet que se conecte a una web y escriba los datos recogidos. También guarde los datos en un string.

Probar a conectar a varias páginas web y usa el servicio DNS poniendo la url en lugar de la IP.

Trata de conectarte a la AEMET para ver si sería posible obtener el tiempo de logroño.

AEMET API: http://www.aemet.es/es/datos_abiertos/catalogo (open data)

Tiempo en logroño: http://www.aemet.es/xml/municipios/localidad_26089.xml

Usa la API de http://www.openweathermap.org/ para obtener los datos del tiempo en una ciudad en concreto.

Avanzado: Obtener la temperatura en logroño actualizada por el display LCD sin necesidad de un sensor de temperatura.

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

Solución: https://github.com/jecrespo/Aprendiendo-Arduino/tree/master/Ejercicio25-EthernetClient

Un poco de información:

Open data:

NTP básico

Montar un Arduino para que recoja y mantenga la fecha y hora de un servidor NTP y así teniendo un Arduino conectado a Internet no siendo necesario usar un RTC para mantener la fecha y hora en Arduino.

Network Time Protocol (NTP) es un protocolo de Internet para sincronizar los relojes de los sistemas informáticos a través del enrutamiento de paquetes en redes con latencia variable. NTP utiliza UDP como su capa de transporte, usando el puerto 123. Está diseñado para resistir los efectos de la latencia variable.

Servidores NTP: http://www.pool.ntp.org/es/use.html

Este es un ejemplo de cliente web, pero UDP en lugar de TCP.

Conceptos a manejar:

Solución: https://github.com/jecrespo/Aprendiendo-Arduino/tree/master/Ejercicio39-NTP

Al igual que hacemos un cliente web con Arduino podríamos hacer un cliente telnet conectándose al puerto correspondiente. Ver ejemplo en https://www.arduino.cc/en/Tutorial/TelnetClient