Archivo de la etiqueta: Curso Programación Arduino

Qué es la Programación

Un lenguaje de programación es un lenguaje formal diseñado para realizar procesos que pueden ser llevados a cabo por máquinas como las computadoras.

Pueden usarse para crear programas que controlen el comportamiento físico y lógico de una máquina, para expresar algoritmos con precisión, o como modo de comunicación.

Está formado por un conjunto de símbolos y reglas sintácticas y semánticas que definen su estructura y el significado de sus elementos y expresiones. Al proceso por el cual se escribe, se prueba, se depura, se compila (de ser necesario) y se mantiene el código fuente de un programa informático se le llama programación.

También la palabra programación se define como el proceso de creación de un programa de computadora, mediante la aplicación de procedimientos lógicos, a través de los siguientes pasos:

  • El desarrollo lógico del programa para resolver un problema en particular.
  • Escritura de la lógica del programa empleando un lenguaje de programación específico (codificación del programa).
  • Ensamblaje o compilación del programa hasta convertirlo en lenguaje de máquina.
  • Prueba y depuración del programa.
  • Desarrollo de la documentación.

Existe un error común que trata por sinónimos los términos ‘lenguaje de programación’ y ‘lenguaje informático’. Los lenguajes informáticos engloban a los lenguajes de programación y a otros más, como por ejemplo HTML (lenguaje para el marcado de páginas web que no es propiamente un lenguaje de programación, sino un conjunto de instrucciones que permiten estructurar el contenido de los documentos).

En el caso de Arduino estamos programando un microcontrolador y su comportamiento físico. Programar en general y en Arduino en particular es traducir al lenguaje de programación las acciones que queremos hacer.

Más información: https://es.wikipedia.org/wiki/Lenguaje_de_programaci%C3%B3n 

Paradigmas de programación

Un paradigma de programación es una propuesta tecnológica adoptada por una comunidad de programadores y desarrolladores cuyo núcleo central es incuestionable en cuanto que únicamente trata de resolver uno o varios problemas claramente delimitados. Un paradigma de programación representa un enfoque particular o filosofía para diseñar soluciones. Los paradigmas difieren unos de otros, en los conceptos y la forma de abstraer los elementos involucrados en un problema, así como en los pasos que integran su solución del problema, en otras palabras, el cómputo.

El paradigma de programación que actualmente es el más utilizado es la “orientación a objetos” (OO). El núcleo central de este paradigma es la unión de datos y procesamiento en una entidad llamada “objeto”, relacionable a su vez con otras entidades “objeto”.

Los paradigmas de programación más comunes son:

  • Programación imperativa o por procedimientos: es el más usado en general, se basa en dar instrucciones al ordenador de como hacer las cosas en forma de algoritmos. La programación imperativa es la más usada y la más antigua, el ejemplo principal es el lenguaje de máquina. Ejemplos de lenguajes puros de este paradigma serían el C, BASIC o Pascal.
  • La programación estructurada es un paradigma de programación orientado a mejorar la claridad, calidad y tiempo de desarrollo de un programa, utilizando únicamente subrutinas y tres estructuras: secuencia, selección (if y switch) e iteración (bucles for y while), considerando innecesario y contraproducente el uso de la instrucción de transferencia incondicional (GOTO), que podría conducir a “código estropajo”, que es mucho más difícil de seguir y de mantener, y era la causa de muchos errores de programación.
  • Programación orientada a objetos: está basada en el imperativo, pero encapsula elementos denominados objetos que incluyen tanto variables como funciones. Está representado por C++, C#, Java o Python entre otros.
  • Programación dirigida por eventos: la programación dirigida por eventos es un paradigma de programación en el que tanto la estructura como la ejecución de los programas van determinados por los sucesos que ocurran en el sistema, definidos por el usuario o que ellos mismos provoquen.
  • Programación multiparadigma: es el uso de dos o más paradigmas dentro de un programa. El lenguaje Lisp se considera multiparadigma. Al igual que Python, que es orientado a objetos, reflexivo, imperativo y funcional
  • La programación reactiva nos lleva a una nueva forma de construir nuestros programas, los cuales deben ser pensados como un conjunto de flujos de datos (streams), que serán programados para que el sistema “reaccione” ante la presencia de cada uno de éstos datos asíncronos en el tiempo. Ejemplos:

Más información: https://es.wikipedia.org/wiki/Paradigma_de_programaci%C3%B3n 

Existen otros paradigmas de programación como:

  • De flujo: ejemplo Node red para IoT
  • De cartas: ejemplo IFTTT https://ifttt.com/ 
  • De bloques: Scratch o S4A

Lenguajes Compilados vs Interpretados

Un lenguaje compilado es un lenguaje de programación cuyas implementaciones son normalmente compiladores (traductores que generan código de máquina a partir del código fuente) y no intérpretes (ejecutores paso a paso del código fuente, donde no se lleva a cabo una traducción en la pre-ejecución).

Los programas compilados a código nativo en tiempo de compilación tienden a ser más rápidos que los traducidos en tiempo de ejecución, debido a la sobrecarga del proceso de traducción.

Los lenguajes de programación de bajo nivel son típicamente compilados, en especial cuando la eficiencia es la principal preocupación, en lugar de soporte de plataformas cruzadas. Para los lenguajes de bajo nivel, hay más correspondencias uno a uno entre el código programado y las operaciones de hardware realizadas por el código máquina, lo que hace que sea más fácil para los programadores controlar más finamente la CPU y uso de memoria.

Intérprete es un programa informático capaz de analizar y ejecutar otros programas. Los intérpretes se diferencian de los compiladores o de los ensambladores en que mientras estos traducen un programa desde su descripción en un lenguaje de programación al código de máquina del sistema, los intérpretes sólo realizan la traducción a medida que sea necesaria, típicamente, instrucción por instrucción, y normalmente no guardan el resultado de dicha traducción.

Un lenguaje interpretado es un lenguaje de programación para el que la mayoría de sus implementaciones ejecuta las instrucciones directamente, sin una previa compilación del programa a instrucciones en lenguaje máquina. El intérprete ejecuta el programa directamente, traduciendo cada sentencia en una secuencia de una o más subrutinas ya compiladas en código máquina.

En arduino ejemplo de lenguaje interpretado son:

Más información:

Programación Orientada a Objetos

La programación orientada a objetos (POO) es un paradigma de lenguaje de programación que emplea el concepto de objetos en sus interacciones con el fin de desarrollar programas informáticos. En otras palabras, esta programación utiliza objetos como elementos fundamentales en la construcción de la solución.

Emplea técnicas de programación como: herencia, cohesión, abstracción, polimorfismo, acoplamiento y encapsulamiento.

La POO es diferente de la programación estructurada tradicional, en la que los datos y los procedimientos están separados y sin relación, ya que lo único que se busca es el procesamiento de unos datos de entrada para obtener otros de salida.

Los programadores que emplean POO, definen primero los objetos para luego enviarles mensajes solicitandoles que realicen sus métodos por sí mismos.

Proyecto Final Programacion

Sobre el entorno de trabajo de https://aprendiendoarduino.wordpress.com/2017/07/02/montaje-practicas/, montar paso a paso el siguiente proyecto:

  1. Hacer un data logger del LDR y de la sonda de temperatura y mandar a http://www.aprendiendoarduino.com/servicios/datos/index.html. Mandar los datos  cada 5 segundos mediante la librería timer: https://github.com/JChristensen/Timer (DataLogger.ino)
  2. Mostrar la gráfica del LDR en http://www.aprendiendoarduino.com/servicios/datos/graficas.html. Mandar los datos  cada 5 segundos. (DataLogger.ino)
  3. Al pulsar el botón B mandar un mensaje a http://www.aprendiendoarduino.com/servicios/mensajes/index.html. Usar la librería DetectaFlanco. (Pulsar_Botones.ino)
  4. Al pulsar el botón A mandar un SMS en http://www.aprendiendoarduino.com/servicios/SMS/index.html. Usar la librería DetectaFlanco. (Pulsar_Botones.ino)
  5. Poner un web server donde se pueda encender remotamente un led y mover el servo con un botón en la web. (Web_Server.ino)
  6. Mover con el potenciómetro de un kit el servo de otro kit
  7. Hacer un web server donde configure la IP a manejar remotamente y configurar el arduino para manejar el que le pasas por IP
  8. Hacer una web embebida donde poder testear todo el kit.
  9. Unir todo

Solución: https://github.com/jecrespo/aprendiendoarduino-Curso_Programacion_Arduino/tree/master/Ejercicio19-Proyecto_Final

Debug con Arduino

Que es debugging: http://www.visualmicro.com/page/User-Guide.aspx?doc=Debugging-Explained.html

Como hemos visto podemos hacer debug con un HW externo adecuado para el microcontrolador y el puerto de debug correspondiente más una herramienta SW como Atmel Studio.

Generalmente con Arduino no disponemos de estas herramientas, pero podemos hacer debug usando el puerto serie y las directivas de preprocesamiento.

A la hora de hacer depuración de un sketch, tanto al desarrollarlo como cuando esté en producción y se detecten fallos, disponemos del puerto serie para que muestre datos de errores o datos de variables internas para la comprobación del funcionamiento interno que nos permite saber si todo va bien o que está fallando.

Es similar a cuando vemos a un técnico que conecta una consola a un equipo como una máquina climatizadora o en el taller cuando colocan la máquina de diagnóstico al coche para saber qué está pasando.

A la hora de realizar nuestro programa debemos establecer qué parámetros queremos tener monitorizados y sacarlos por el puerto serie para hacer el debug. Incluso podemos pensar en poner una pantalla LED que nos saque por un segundo puerto serie y nos sirva de pantalla de debug.

Un técnica para hacer debug es usar la directiva de preprocesamiento #define que permite asociar a una palabra un valor sin que ocupe espacio en memoria, lo que hace el compilador es sustituir esa palabra por el valor definido. Más información en: http://arduino.cc/en/pmwiki.php?n=Reference/Define

Además para mejorar la funcionalidad de #define tenemos otras directivas de preprocesamiento: #if y #endif que son directivas lógicas, es decir, no sólo no se ejecutan sino que ni se compilan. Las directivas de preprocesamiento nos permiten añadir o quitar código a nuestro antojo antes de compilar para tener una versión para debug o detección de errores y otra versión de producción.

Para hacer debug de nuestro sketch, usaremos Serial.print y sacaremos por el puerto serie para leer por consola aquellas variables o elementos que nos interese monitorizar y saber lo que está pasando con ellas en tiempo real.

Ejemplo:

 
#define DEBUG 0
void setup(){
  inicializa();
}
void loop(){
  compruebaTemperatura();
#if DEBUG
  imprimeVariablesDebug();
#endif
}

Ejercicio20: Hacer un programa sencillo que imprima cosas por puerto serie, la memoria libre, etc… y seleccionar que haga una cosas u otras en función de la directiva de preprocesamiento activada. Comprueba los tiempos de loop, el tamaño ocupado en la flash y el uso de memoria con las opciones DEBUG y VERBOSE y sin ellas.

Solución: https://github.com/jecrespo/Aprendiendo-Arduino/tree/master/Ejercicio20-Debug

I2C

Al comenzar a usar Arduino puede resultar algo complejo entender las diferencias entre los diferentes tipos de interfaces de comunicación (y protocolos asociados).

Dentro la comunicación serie integrada en los microcontroladores de Arduino tenemos:

  • UART (recepción-transmisión asíncrona universal) es uno de los protocolos serie más utilizados. La mayoría de los microcontroladores disponen de hardware UART. Usa una línea de datos simple para transmitir y otra para recibir datos. Comúnmente, 8 bits de datos son transmitidos de la siguiente forma: un bit de inicio, a nivel bajo, 8 bits de datos y un bit de parada a nivel alto. UART se diferencia de SPI y I2C en que es asíncrono y los otros están sincronizados con señal de reloj. La velocidad de datos UART está limitado a 2Mbps
  • SPI es otro protocolo serie muy simple. Un maestro envía la señal de reloj, y tras cada pulso de reloj envía un bit al esclavo y recibe un bit de éste. Los nombres de las señales son por tanto SCK para el reloj, MOSI para el Maestro Out Esclavo In, y MISO para Maestro In Esclavo Out. Para controlar más de un esclavo es preciso utilizar SS (selección de esclavo).

I2C es un protocolo síncrono. I2C usa solo 2 cables, uno para el reloj (SCL) y otro para el dato (SDA). Esto significa que el maestro y el esclavo envían datos por el mismo cable, el cual es controlado por el maestro, que crea la señal de reloj. I2C no utiliza selección de esclavo, sino direccionamiento.

I2C es un bus de comunicaciones en serie. Su nombre viene de Inter-Integrated Circuit (Inter-Circuitos Integrados). La versión 1.0 data del año 1992 y la versión 2.1 del año 2000, su diseñador es Philips. La velocidad es de 100 kbit/s en el modo estándar, aunque también permite velocidades de 3.4 Mbit/s. Es un bus muy usado en la industria, principalmente para comunicar microcontroladores y sus periféricos en sistemas integrados (Embedded Systems) y generalizando más para comunicar circuitos integrados entre si que normalmente residen en un mismo circuito impreso.

La principal característica de I²C es que utiliza dos líneas para transmitir la información: una para los datos y otra para la señal de reloj. También es necesaria una tercera línea, pero esta sólo es la referencia (masa). Como suelen comunicarse circuitos en una misma placa que comparten una misma masa esta tercera línea no suele ser necesaria.

Las líneas se llaman:

  • SDA: datos
  • SCL: reloj
  • GND: tierra

Las dos primeras líneas son drenador abierto, por lo que necesitan resistencias de pull-up.  Dos o más señales a través del mismo cable pueden causar conflicto, y ocurrirían problemas si un dispositivo envía un 1 lógico al mismo tiempo que otro envía un 0. Por tanto el bus es “cableado” con dos resistencia para poner el bus a nivel alto, y los dispositivos envían niveles bajos. Si quieren enviar un nivel alto simplemente lo comunican al bus.

Los dispositivos conectados al bus I2C tienen una dirección única para cada uno. También pueden ser maestros o esclavos. El dispositivo maestro inicia la transferencia de datos y además genera la señal de reloj, pero no es necesario que el maestro sea siempre el mismo dispositivo, esta característica se la pueden ir pasando los dispositivos que tengan esa capacidad. Esta característica hace que al bus I2C se le denomine bus multimaestro.

Las líneas SDA y SCL son del tipo drenaje abierto, es decir, un estado similar al de colector abierto, pero asociadas a un transistor de efecto de campo (o FET). Se deben polarizar en estado alto (conectando a la alimentación por medio de resistores “pull-up”) lo que define una estructura de bus que permite conectar en paralelo múltiples entradas y salidas.

El proceso de comunicación en el bus I2C es:

  • El maestro comienza la comunicación enviando un patrón llamado “start condition”. Esto alerta a los dispositivos esclavos, poniéndolos a la espera de una transacción.
  • El maestro se dirige al dispositivo con el que quiere hablar, enviando un byte que contiene los siete bits (A7-A1) que componen la dirección del dispositivo esclavo con el que se quiere comunicar, y el octavo bit (A0) de menor peso se corresponde con la operación deseada (L/E), lectura=1 (recibir del esclavo) y escritura=0 (enviar al esclavo).
  • La dirección enviada es comparada por cada esclavo del bus con su propia dirección, si ambas coinciden, el esclavo se considera direccionado como esclavo-transmisor o esclavo-receptor dependiendo del bit R/W.
  • Cada byte leído/escrito por el maestro debe ser obligatoriamente reconocido por un bit de ACK por el dispositivo maestro/esclavo.
  • Cuando la comunicación finaliza, el maestro transmite una “stop condition” para dejar libre el bus.

Las transacciones en el bus I2C tienen este formato:

| start | A7 A6 A5 A4 A3 A2 A1 R/W | ACK | … DATA … | ACK | stop | idle |

Cuando los datos son enviados por SDA, los pulsos de reloj son enviados por SCL para mantener el maestro y el esclavo sincronizados. Puesto que los datos son enviados como un bit en cada pulso de reloj, la transferencia de datos es un octavo la frecuencia de reloj. La frecuencia del reloj estándar originalmente se puso a 100 KHz y la mayoría de los integrados y microcontroladores soportan esta velocidad. En posteriores actualizaciones, se introdujo una fast speed de 400 KHz y una high speed de 1.7 a 3.4 MHz. Arduino puede soportar la velocidad estándar y fast speed, BeagleBoard tiene tres buses I2C cada uno a una velocidad distinta y tanto BeagleBoard como Raspberry Pi soportan velocidad estándar y fast speed. Fast speed corresponde a una velocidad de transferencia de 50Kbytes/sec lo que puede ser una velocidad muy baja para algunas aplicaciones de control. Una opción en ese caso es usar SPI en lugar de I2C.

The speed grades:

I2C también se conoce como TWI (Two Wire Interface) y no dispone de un conector estandarizado. Únicamente por motivos de licencia se le denomina TWI, no obstante, la patente caducó en 2006, por lo que actualmente no hay restricción sobre el uso del término I2C.

I2C en Arduino

Arduino dispone de soporte I2C por hardware vinculado físicamente a ciertos pines. También es posible emplear cualquier otro grupo de pines como bus I2C a través de software, pero en ese caso la velocidad será mucho menor.

Los pines a los que está asociado varían de un modelo a otro. La siguiente tabla muestra la disposición en alguno de los principales modelos. Para otros modelos, consultar el esquema de patillaje correspondiente.

MODELO SDA SCK
Uno A4 A5
Nano A4 A5
Mini Pro A4 A5
Mega 20 21

Para usar el bus I2C en Arduino, el IDE Standard proporciona la librería “Wire.h”, que contiene las funciones necesarias para controlar el hardware integrado.

Características de I2C en ATmega328p:

  • Simple, yet Powerful and Flexible Communication Interface, only two Bus Lines Needed
  • Both Master and Slave Operation Supported
  • Device can Operate as Transmitter or Receiver
  • 7-bit Address Space Allows up to 128 Different Slave Addresses
  • Multi-master Arbitration Support
  • Up to 400kHz Data Transfer Speed
  • Slew-rate Limited Output Drivers
  • Noise Suppression Circuitry Rejects Spikes on Bus Lines
  • Fully Programmable Slave Address with General Call Support
  • Address Recognition Causes Wake-up When AVR is in Sleep Mode
  • Compatible with Philips I2C protocol

La librería para manejar el bus I2C en Arduino es Wire: http://arduino.cc/en/reference/wire

Esta librería permite comunicar con I2C/TWI Arduino con otros dispositivos. En las placas Arduino con el diseño R3 (1.0 pinout), la SDA (línea de datos) y SCL (línea de reloj) están en los pines cerca del pin AREF.

Funciones:

  • begin() – Inicia la librería Wire y especifica si es master o slave
  • requestFrom() – Usado por el maestro para solicitar datos del esclavo
  • beginTransmission() – Comenzar transmisión con esclavo.
  • endTransmission() – Finaliza la transmisión que comenzó con un esclavo y transmite los bytes en cola.
  • write() – Escribe datos desde un esclavo como respuesta a una petición del maestro o pone en cola la transmisión de un maestro.
  • available() – Devuelve el número de bytes para leer
  • read() – Lee un byte transmitido desde un esclavo a un maestro o viceversa
  • onReceive() – Llama a una función cuando un esclavo recibe una transmisión de un maestro. Registra una función de callback.
  • onRequest() – Llama a una función cuando un maestro solicita datos de un maestro. Registra una función de callback.

Escaner I2C

Cada componente que conectamos al bus I2C tiene una dirección única, y cada mensaje y orden que transmitimos al bus, lleva anexa esta dirección, indicando cuál de los muchos posibles, es el receptor del mensaje.

Esto implica que sabemos la dirección del componente. Lo normal es comprobar la información técnica del fabricante del componente, y ahí suele decirnos cuál es la dirección por defecto. Pero es posible que tengamos un dispositivo sin documentación, para ello hay un programa para Arduino, que nos informa, de lo que hay en nuestro bus y con qué dirección.

Ver http://playground.arduino.cc/Main/I2cScanner

 
#include "Wire.h"
extern "C" {
    #include "utility/twi.h"
}
void scanI2CBus(byte from_addr, byte to_addr, void(*callback)(byte address, byte result) )
{
  byte rc;
  byte data = 0;
  for( byte addr = from_addr; addr <= to_addr; addr++ ) {
    rc = twi_writeTo(addr, &data, 0, 1, 0);
    callback( addr, rc );
  }
}
void scanFunc( byte addr, byte result ) {
  Serial.print("addr: ");
  Serial.print(addr,DEC);
  Serial.print( (result==0) ? " Encontrado!":"   	");
  Serial.print( (addr%4) ? "\t":"\n");
}

const byte start_address = 8;
const byte end_address = 119;
 
void setup()
{
    Wire.begin();
    Serial.begin(9600);
    Serial.print("Escaneando bus I2C...");
    scanI2CBus( start_address, end_address, scanFunc );
    Serial.println("\nTerminado");
}
 
void loop()
{
    delay(1000);
}

IMU (Inertial Measurement Unit)

Una IMU es un dispositivo capaz de medir la fuerza (aceleración) y la velocidad. Generalmente consta de un Acelerómetro y un Giroscopio. Por lo tanto una IMU no mide ángulos, por lo menos no directamente, requiere algunos cálculos.

Un dispositivo I2C muy interesante es el MPU-6050 que nos sirve para probar e introducirnos en el mundo de los giroscopios y acelerómetros.

Definiciones:

El MPU-6050 es una IMU de 6DOF (se lee “6 Degrees Of Freedom“ o 6 grados de libertad). Esto significa que lleva un acelerómetro y un giroscopio, ambos de 3 ejes (3+3 = 6DOF). Hay IMUs de 9DOF, en ese caso también llevan un magnetómetro. Otras pueden tener 5DOF, en cuyo caso el giroscopio sólo mide dos ejes, etc.

El MPU-6050 opera con 3.3 voltios, aunque algunas versiones llevan un regulador que permite conectarla a 5V. El MPU-6050 utiliza el protocolo de comunicación I2C.

El acelerómetro mide la aceleración. La aceleración puede expresarse en 3 ejes: X, Y y Z, las tres dimensiones del espacio. Por ejemplo, si mueves la IMU hacia arriba, el eje Z marcará un cierto valor. Si es hacia delante, marcará el eje X, etc. La gravedad de la Tierra tiene una aceleración de aprox. 9.8 m/s², perpendicular al suelo como es lógico. Así pues, la IMU también detecta la aceleración de la gravedad terrestre. Gracias a la gravedad terrestre se pueden usar las lecturas del acelerómetro para saber cuál es el ángulo de inclinación respecto al eje X o eje Y.

Supongamos que la IMU esté perfectamente alineada con el suelo. Entonces, como puedes ver en la imagen, el eje Z marcará 9.8, y los otros dos ejes marcarán 0. Ahora supongamos que giramos la IMU 90 grados. Ahora es el eje X el que está perpendicular al suelo, por lo tanto marcará la aceleración de la gravedad.

Si sabemos que la gravedad es 9.8 m/s², y sabemos qué medida dan los tres ejes del acelerómetro, por trigonometría es posible calcular el ángulo de inclinación de la IMU. Una buena fórmula para calcular el ángulo es:

Dado que el ángulo se calcula a partir de la gravedad, no es posible calcular el ángulo Z (giro sobre si mismo) con esta fórmula ni con ninguna otra. Para hacerlo se necesita otro componente: el magnetómetro, que es un tipo de brújula digital. El MPU-6050 no lleva, y por tanto nunca podrá calcular con precisión el ángulo Z. Sin embargo, para la gran mayoría de aplicaciones sólo se necesitan los ejes X e Y.

Ejercicio IMU MPU6050

El MPU6050 que vamos a utilizar es un chip de 6 dof o grados de libertad porque incluye un acelerómetro de 3 ejes y un giróscopo de 3 ejes.

Aunque lo que miden los sensores internos son aceleraciones lineales y angulares el procesador interno del IMU es capaz de realizar cálculos sobre la marcha para darnos informaciones más útiles como los ángulos de inclinación con respecto a los 3 ejes principales. Conseguir los datos en bruto del MPU6050 es la parte fácil, procesarlos y reaccionar es otra historia que se puede complicar un poco más.

El siguiente diagrama muestra la orientación de los ejes de sensibilidad y la polaridad de rotación.

Esquema de conexión

A partir del código https://github.com/jecrespo/Aprendiendo-Arduino/tree/master/Ejercicio62-MPU6050/raw_values que me da los valores en bruto de la IMU, hacer un programa que haga girar el servo en función del ángulo en el que se encuentre el eje Y.

Si sabemos que la gravedad es 9.8 m/s², y sabemos qué medida dan los tres ejes del acelerómetro, por trigonometría es posible calcular el ángulo de inclinación de la IMU. Una buena fórmula para calcular el ángulo es:

Solución Ejercicio17https://github.com/jecrespo/aprendiendoarduino-Curso_Arduino_Avanzado_2017/tree/master/Ejercicio17-I2C_Servo

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/en/Reference/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 strings https://www.arduino.cc/en/Reference/String como arrays de chars https://www.arduino.cc/en/Reference/Char que es más complejo de manejar pero más potente y tenemos más control del uso de memoria.

String (Objeto)

Ahora que ya sabemos que son las clases, 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 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://www.arduino.cc/en/Reference/StringObject

Ver documentación de Arduino sobre la clase String:

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.

El core de Arduino me ofrece varias funciones de análisis de caracteres:

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++.

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 );

Práctica: Manejo de Strings

Ejercicio16: 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.

Github clone link: https://github.com/curso-programacion-arduino/Ejercicio16.git

Solución: https://github.com/jecrespo/aprendiendoarduino-Curso_Programacion_Arduino