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:
- http://arduino.cc/en/Reference/StringObject
- http://arduino.cc/en/Reference/StringConstructor – Constructor
- http://arduino.cc/en/Reference/StringCompareTo – Comparador
- http://arduino.cc/en/Reference/StringConcat – Concatenar
- http://arduino.cc/en/Reference/StringGetBytes – copiar a un buffer
- http://arduino.cc/en/Reference/StringIndexOf – localiza un caracter o string
- http://arduino.cc/en/Reference/StringLength – longitud del String
- http://arduino.cc/en/Reference/StringStartsWith – Comprueba si comienza por una cadena que se pasa como parámetro
- http://arduino.cc/en/Reference/StringToCharArray – Pasa de String a string
- http://arduino.cc/en/Reference/StringCharAt – Accede a un caracter concreto del String
- http://arduino.cc/en/Reference/StringReserve – Permite asignar un buffer en memoria para manipular strings.
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.
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:
- http://www.cplusplus.com/reference/cstring/strcat/ (concatena)
- http://www.cplusplus.com/reference/cstring/strncat/ (concatena un nº de caracteres)
- http://www.cplusplus.com/reference/cstring/strcpy/ (copia)
- http://www.cplusplus.com/reference/cstring/memset/ (llena un bloque de memoria)
- http://www.cplusplus.com/reference/cstring/memmove/ (mueve bloques de memoria)
- http://www.cplusplus.com/reference/cstring/memcpy/ (copia bloques de memoria)
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:
- http://arduino.cc/en/Reference/String
- http://en.wikipedia.org/wiki/Null_character (representa el fin de un string)
- http://en.wikipedia.org/wiki/Null-terminated_string
- http://c.conclase.net/curso/?cap=008
- http://c.conclase.net/curso/?cap=010
- https://es.wikibooks.org/wiki/Programaci%C3%B3n_en_C%2B%2B/Arrays_y_cadenas_de_texto
- http://www.cplusplus.com/reference/cstring/
- http://www.cplusplus.com/reference/cstring/strcmp/
- http://www.cplusplus.com/reference/cstring/strcat/
- http://www.cplusplus.com/reference/string/
- http://www.cplusplus.com/reference/string/string/
- http://www.learncpp.com/cpp-tutorial/4-4b-an-introduction-to-stdstring/
- http://www.learncpp.com/cpp-tutorial/66-c-style-strings/
- https://www.arduino.cc/en/Reference/PROGMEM
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
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
Aprendiendo Arduino 