Archivo de la etiqueta: operadores

Estructuras Propias de Arduino

Lo visto hasta ahora son estructuras y sintaxis de programación que es casi genérica a C++, pero el core de Arduino incluye algunas funciones propias para el uso de Arduino como la lectura de entradas analógicas y digitales y la escritura de salidas analógicas y digitales.

Para saber más de C y de la API de Arduino:

Veamos estas estructuras más específicas que están documentadas en el reference de Arduino https://www.arduino.cc/en/Reference/HomePage

Cómo Leer el Reference Arduino

En el reference de Arduino tenemos toda la información necesaria para entender cómo funciona el lenguaje o core de programación de Arduino. Está todo perfectamente documentado de cómo funciona cada estructura y cómo se comportan las funciones,

Reference: https://www.arduino.cc/en/Reference/HomePage 

Cuando entramos en el reference y vemos un nuevo método o función deberemos leer:

  • Description: Hace una descripción de lo que hace ese método y función
  • Syntax: Sintaxis de la función con todas las formas de llamarlo y los parámetros a pasar. Puede haber varias formas de llamar a una función, por ejemplo https://www.arduino.cc/en/Reference/EthernetBegin
  • Parameters: Descripción de los parámetros a pasar a esa función. Puede que no haya que pasar ninguno: https://www.arduino.cc/en/Reference/Millis
  • Returns: que valor me devuelve y qué tipo de dato es. Puede que no devuelva nada como https://www.arduino.cc/en/Reference/PinMode
  • Note: Nota sobre el uso de la función
  • Example: Un ejemplo de cómo usar la función
  • See Also: Otras funciones relacionadas

Entradas y Salidas Digitales

En arduino para tratar las entradas y salidas digitales usamos las siguientes funciones:

En la imagen siguiente se muestra el estado por defecto de una I/O digital en un microcontrolador de Arduino. Se ha simplificado con interruptores la compleja electrónica que hay dentro. Por defecto los digital I/O pins están configurados como inputs en un estado de alta impedancia (equivalente a una resistencia de 100 Mohms en frente del pin), es decir, SW3 a ON y no hace falta llamar a la función pinMode() aunque es recomendable para aclarar el código.

  • PinMode(x, INPUT) –> SW3 = ON (resto a OFF). Los valores leídos serán aleatorios si el pin de Arduino está al aire. El pin está en un estado de alta impedancia (resistencia de 100 Mohms).
  • PinMode(x,INPUT_PULLUP) –> SW3 = ON & SW4 = ON (resto a OFF). Los valores leídos sin nada conectado al pin es HIGH. La Resistencia R1 tiene un valor dependiendo del microcontrolador, pero tiene un valor entre 20kOhm y 150kOhm.
  • PinMode(x, OUTPUT) & digitalWrite(x,HIGH) –> SW2 = ON & SW1 = +5V (resto a OFF). Estado de baja impedancia, no hay resistencia interna y es necesario poner una resistencia adecuada a la salida el pin para no superar los 40mA (source) máximos admitidos
  • PinMode(x, OUTPUT) & digitalWrite(x,LOW) –> SW2 = ON & SW1 = GND (resto a OFF). Estado de baja impedancia, no hay resistencia interna y es necesario poner una adecuada para no superar los 40mA (sink) máximos admitidos

Entradas y Salidas Analógicas

En Arduino para tratar las entradas y salidas analógicas usamos las siguientes funciones:

Otras funciones interesantes con entradas/salidas analóicas:

La mayoría de Arduino no tienen salidas analógicas puras sino PWM. Algunos pines digitales pueden usarse como salidas analógicas PWM:

Las Salidas PWM (Pulse Width Modulation) permiten generar salidas analógicas desde pines digitales. Arduino Uno no posee salidas analógicas puras, sin embargo el Arduino Due sí tiene salidas analógicas puras mediante dos DAC. El arduino due, posee dos salidas analógicas puras mediante dos conversores digital a analógico. Estos pines pueden usarse para crear salidas de audio usando la librería correspondiente.

La modulación por ancho de pulsos (también conocida como PWM, siglas en inglés de pulse-width modulation) de una señal o fuente de energía es una técnica en la que se modifica el ciclo de trabajo de una señal periódica (una senoidal o una cuadrada, por ejemplo), ya sea para transmitir información a través de un canal de comunicaciones o para controlar la cantidad de energía que se envía a una carga.

El ciclo de trabajo de una señal periódica es el ancho relativo de su parte positiva en relación con el período. duty cycle = (tiempo que la salida está a uno o HIGH)/ (periodo de la función)

Diferentes valores de una señal PWM:

Entradas y Salida Avanzadas

Advanced I/O:

  • tone() – Genera una onda cuadrada (ciclo y 50% de servicio) de la frecuencia especificada en un pin. Una duración se puede especificar, de lo contrario la onda continúa hasta una llamada a noTone (). El pin puede ser conectado a un zumbador piezo u otro altavoz para reproducir tonos.
  • noTone() – Detiene la generación de una onda cuadrada provocada por tone(). No tiene ningún efecto si no se está generando el tono.
  • shiftOut() – Desplaza un byte de datos de un bit cada vez. Comienza a partir del más o menos significativo. Cada bit es escrito en un pin cada vez que se produce un pulso de reloj.
  • shiftIn() – Desplaza un byte de datos de un bit cada vez. Comienza a partir dell más o menos significativo. Para cada bit, el reloj es puesto a HIGH, el siguiente bit es leído de la línea de datos y entonces el reloj es puesto a LOW.
  • pulseIn() – Lee un pulso de un pin. Si el valor es HIGH, la función espera a que el pin se ponga a HIGH, comienza a temporizar y espera hasta que el pin vuelve a LOW, devolviendo la longitud del pulso en microsegundos.

Ejemplo de uso: https://www.arduino.cc/en/Tutorial/ShiftOut 

Bits y Bytes

Bits and Bytes

  • lowByte(): extrae el byte más a la derecha (low-order o menos significativo de una variable.
  • highByte(): extrae el byte más a la izquierda (high-order o más significativo de una variable.
  • bitRead(): lee el bit de una variable numérica. 
  • bitWrite(): escribe el bit de una variable numérica
  • bitSet(): pone a 1 un bit de una variable numérica 
  • bitClear(): pone a 0 un bit de una variable numérica 
  • bit(): Calcula el valor del bit especificado (el bit 0 es 1, el bit 1 es 2, el bit 2 es 4, etc.)

Constantes

Constants;

  • HIGH | LOW – Al leer o escribir en un pin solo hay estas dos posibilidades. Su significado es diferente si el pin está configurado como INPUT o OUTPUT.
  • INPUT | OUTPUT | INPUT_PULLUP – Modo en el que pueden configurarse los pines digitales.
  • LED_BUILTIN – La mayoría de las placas Arduino tienen un pin conectado a un led en la placa y esta constante devuelve el número de pin en función de la placa.
  • true | false – Representación de las constantes booleanes en arduino
  • integer constants – son los números usados directamente en un sketch como ‘123’. Por defecto estos números son tratados como enteros pero puede cambiarse con los modificadores U y L. Las constante enteras se tratan como base 10 (decimal) pero puede usarse otra notación.
  • floating point constants – al igual que las constantes enteras, las constantes de coma flotante permite definir los número decimales. Son posibles varias notaciones para expresar constantes de coma flotante, por ejemplo: n = .005. También pueden expresarse en notación científica como 2.34E5.

Utilidades

Utilities:

  • sizeof() – devuelve el número de bytes en una variable o el número de bytes ocupados por un array.
  • PROGMEM – se usa para guardar en la memoria flash en lugar de en la SRAM. Al usarlo le dice al compilador que ponga la información de la variable en la memoria flash en lugar de la SRAM, donde iría normalmente.

PROGMEM es parte de la librería pgmspace.h http://www.nongnu.org/avr-libc/user-manual/group__avr__pgmspace.html que solo está disponible para la arquitectura AVR, así que para usarlo hay que inclirla al principio del sketch con #include <avr/pgmspace.h>

La macro F() se puede usar para facilitar el manejo de PROGMEM en las instrucciones print, de forma que todo el texto a imprimir (ya sea en Serial, Ethernet u otra librería) se lea de la Flash y no ocupando tamaño en la SRAM. Esta macro está incluida en el core de Arduino.

Operadores Bit a Bit

Bitwise Operators:

  • & (bitwise and)
  • | (bitwise or)
  • ^ (bitwise xor)
  • ~ (bitwise not)
  • << (bitshift left)
  • >> (bitshift right)

Operadores Compuestos

Compound Operators

  • ++ (increment)
  • (decrement)
  • += (compound addition)
  • -= (compound subtraction)
  • *= (compound multiplication)
  • /= (compound division)
  • %= (compound modulo)
  • &= (compound bitwise and)
  • |= (compound bitwise or)

Ambito de las Variables y Calificadores

Variable Scope & Qualifiers

  • variable scope – ámbito de la variable
  • static – hace que el valor de una variable local persista más alla de la función haciendo que su valor se mantenga entre llamadas a funciones
  • volatile – Declarar una variable volátil es una directiva para el compilador. Específicamente, dice al compilador que cargue la variable desde la RAM y no desde un registro de almacenamiento, que es una ubicación de memoria temporal donde se almacenan y manipulan las variables del programa. Bajo ciertas condiciones, el valor de una variable almacenada en registros puede ser inexacto.
  • const – es un cualificador de variable que modifica el comportamiento de la variable haciendo que sea de solo lectura.

Se deben declarar como “volatile” cualquier variable que sea modificada dentro de la función llamada por una interrupción.

Funciones de Tiempo

Funciones para trabajar con el tiempo

  • delay() – Para el programa en unidades de ms
  • delayMicroseconds() – Para el programa en unidades de us
  • micros() – Microsegundos transcurridos desde el inicio o reset de la placa
  • millis() – Milisegundos transcurridos desde el inicio o reset de la placa

Funciones USB

Keyboard – Las funciones del teclado permiten que las tarjetas micro basadas en 32u4 o SAMD envíen las pulsaciones de teclas a un ordenador conectado a través del puerto USB nativo de su micro.

Mouse – Las funciones del ratón permiten a las tarjetas micro basadas en 32u4 o SAMD controlar el movimiento del cursor en un ordenador conectado a través del puerto USB nativo de su micro. Cuando se actualiza la posición del cursor, siempre es relativa a la posición anterior del cursor.

Funciones Matemáticas

La librería math.h ya está incluida por defecto en Arduino. 

Librería math C++: http://www.cplusplus.com/reference/cmath/

Librería math.h de AVR libc:

Algunas de la funciones matemáticas del Reference de Arduino:

Números Pseudoaleatorios

random() – generador de números pseudoaleatorios

randomSeed() – Inicializa el generador de números

Comunicación Serie

Librería Stream de la que heredan las librerías de comunicación serie: https://www.arduino.cc/reference/en/language/functions/communication/stream/

Comunicación serie: https://www.arduino.cc/reference/en/language/functions/communication/serial/

Funciones:

Prácticas: Operadores y Estructuras de Control con Arduino

Montaje Arduino UNO:

Montaje Wemos:

Ejercicio10-Alarma

Ejercicio10: hacer un sistema de alarma que haga sonar el buzzer cuando la temperatura suba de 24 grados. Hacer una constante con #define llamada UMBRAL donde declaramos el umbral.

Encender los leds cuando se supere la temperatura, de forma que con 24 grados se enciendo el primero, con 25 grados el segundo y así hasta encender los 4 leds.

Adicionalmente mandar por el puerto serie y por la pantalla LCD la temperatura en la primera línea y un mensaje de “ALARMA” o “NORMAL” en la segunda línea, cada vez que entre o salga del estado alarma al superar el umbral. Necesitaremos una variable global llamada alarma_temperatura que deberá actualizarse.

Diagrama de flujo (en este caso es el pin 11 donde leo la temperatura con el sensor DHT11, en lugar de A0):

Solución: https://codeshare.io/29wqDB

Hacer commit y pull del código en el repositorio “Curso Programacion Arduino 2019” que esté en una carpeta llamada Ejercicio10-Alarma

Ejercicio11-while

Ejercicio11: Usando un bucle while y las instrucciones continue y break, imprimir por el puerto serie y pantalla LCD los número impares del 0 al 100 usando un delay de 100 ms. Usa una variable contador dentro del bucle while. Al llegar a 100 encender hacer parpadear 5 veces consecutivas los 4 leds.

Solución: https://codeshare.io/ay9VYz

Hacer commit y pull del código en el repositorio “Curso Programacion Arduino 2019” que esté en una carpeta llamada Ejercicio11-While

Ejercicio12-RGB_Wemos

Basándonos en el ejemplo de la librería de los leds RGB del Shield Wemos RGB https://github.com/wemos/D1_mini_Examples/blob/master/examples/04.Shields/RGB_LED_Shield/simple/simple.ino, hacer el efecto un led girando en sentido horario que cada 5 vueltas aumente la velocidad, empezando desde 200 ms mostrando un led hasta 20ms continuamente. La velocidad aumenta restando 20 ms en cada ciclo: 200 – 180 – 160 – 140, etc…

Funciones:

  • leds.setPixelColor(i, leds.Color(R, G, B)); — pone el led i al color con la combinación R, G, B
  • leds.show(); — Muestra la configuración hecha con setPixelColor

Solución: https://codeshare.io/ay9VAo

Hacer commit y pull del código en el repositorio “Curso Programacion Arduino 2019” que esté en una carpeta llamada Ejercicio12-RGB_Wemos

Operadores

Un operador es un elemento de programa que se aplica a uno o varios operandos en una expresión o instrucción. Un operador, es un símbolo que indica al compilador que se lleve a cabo ciertas manipulaciones matemáticas o lógicas.

Los operadores son símbolos que representan una operación como las básicas de suma, resta, multiplicación y división, (+, -, *, /) existen las booleanas (true y false) para las operaciones de comparación como AND, O, NOT, o las de comparación ==, !=, =, que son muy utilizados en las instrucciones de tipo if.

Aritméticos

Los operadores aritméticos que se incluyen en el entorno de programación son suma, resta, multiplicación, división, módulo y asignación. Estos devuelven la suma, diferencia, producto, cociente o resto (respectivamente) de dos operandos.

La operación se efectúa teniendo en cuenta el tipo de datos que hemos definido para los operandos (int, double, float, etc..), por lo que, por ejemplo, si definimos 9 y 4 como enteros “int”, 9 / 4 devuelve de resultado 2 en lugar de 2,25 ya que el 9 y 4 se valores de tipo entero “int” (enteros) y no se reconocen los decimales con este tipo de datos.

Esto también significa que la operación puede sufrir un desbordamiento si el resultado es más grande que lo que puede ser almacenada en el tipo de datos. Recordemos el alcance de los tipos de datos numéricos explicado anteriormente.

Si los operandos son de diferente tipo, para el cálculo del resultado se utilizará el tipo más grande de los operandos en juego. Por ejemplo, si uno de los números (operandos) es del tipo float y otra de tipo integer, para el cálculo se utilizará el método de float es decir el método de coma flotante y el resultado será un float..

Elegir el tamaño de las variables de tal manera que sea lo suficientemente grande como para que los resultados sean lo precisos que deseamos. Para las operaciones que requieran decimales utilizar variables tipo float, pero hay que ser conscientes de que las operaciones con este tipo de variables son más lentas a la hora de realizarse el cómputo.

En Visualino podemos encontrar los operadores aritméticos en el apartado “Math”

Compuestos

Las operadores compuestos combinan una operación aritmética con una variable asignada. Estas son comúnmente utilizadas en los bucles tal como se describe más adelante. Estas asignaciones compuestas pueden ser:

En Visualino no hay operadores compuestos.

Comparación

Operadores de comparación. Las comparaciones de una variable o constante con otra se utilizan con frecuencia en las estructuras condicionales del tipo if, while, etc.. para testear si una condición es verdadera.

En Visualino los operadores de comparación están en el apartado de “Logic”

Booleanos

Los operadores lógicos o booleanos son usualmente una forma de comparar dos expresiones y devuelve un VERDADERO o FALSO dependiendo del operador. Existen tres operadores lógicos, AND (&&), OR (||) y NOT (!), que a menudo se utilizan en estamentos de tipo if.

En Visualino los operadores booleanos están en el apartado de “Logic”

Curiosa forma de explicar las operaciones lógicas mediante un vídeo: http://es.gizmodo.com/las-funciones-de-los-circuitos-brillantemente-explicad-1570812992

Otras funciones disponibles en el core de Arduino

Conclusión

Un resumen de los operadores en C /C++ y más información:

Operadores

Un operador es un elemento de programa que se aplica a uno o varios operandos en una expresión o instrucción. Un operador, es un símbolo que indica al compilador que se lleve a cabo ciertas manipulaciones matemáticas o lógicas.

Aritméticos

Los operadores aritméticos que se incluyen en el entorno de programación son suma, resta, multiplicación, división, módulo y asignación. Estos devuelven la suma, diferencia, producto, cociente o resto (respectivamente) de dos operandos.

La operación se efectúa teniendo en cuenta el tipo de datos que hemos definido para los operandos (int, double, float, etc..), por lo que, por ejemplo, si definimos 9 y 4 como enteros “int”, 9 / 4 devuelve de resultado 2 en lugar de 2,25 ya que el 9 y 4 se valores de tipo entero “int” (enteros) y no se reconocen los decimales con este tipo de datos.

Esto también significa que la operación puede sufrir un desbordamiento si el resultado es más grande que lo que puede ser almacenada en el tipo de datos. Recordemos el alcance de los tipos de datos numéricos explicado anteriormente.

Si los operandos son de diferente tipo, para el cálculo del resultado se utilizará el tipo más grande de los operandos en juego. Por ejemplo, si uno de los números (operandos) es del tipo float y otra de tipo integer, para el cálculo se utilizará el método de float es decir el método de coma flotante y el resultado será un float..

Elegir el tamaño de las variables de tal manera que sea lo suficientemente grande como para que los resultados sean lo precisos que deseamos. Para las operaciones que requieran decimales utilizar variables tipo float, pero hay que ser conscientes de que las operaciones con este tipo de variables son más lentas a la hora de realizarse el cómputo.

En Visualino podemos encontrar los operadores aritméticos en el apartado “Math”

Compuestos

Las operadores compuestos combinan una operación aritmética con una variable asignada. Estas son comúnmente utilizadas en los bucles tal como se describe más adelante. Estas asignaciones compuestas pueden ser:

En Visualino no hay operadores compuestos.

Comparación

Operadores de comparación. Las comparaciones de una variable o constante con otra se utilizan con frecuencia en las estructuras condicionales del tipo if, while, etc.. para testear si una condición es verdadera.

En Visualino los operadores de comparación están en el apartado de “Logic”

Booleanos

Los operadores lógicos o booleanos son usualmente una forma de comparar dos expresiones y devuelve un VERDADERO o FALSO dependiendo del operador. Existen tres operadores lógicos, AND (&&), OR (||) y NOT (!), que a menudo se utilizan en estamentos de tipo if.

En Visualino los operadores booleanos están en el apartado de “Logic”

Curiosa forma de explicar las operaciones lógicas mediante un vídeo: http://es.gizmodo.com/las-funciones-de-los-circuitos-brillantemente-explicad-1570812992

Otras funciones disponibles en el core de Arduino

Conclusión

Un resumen de los operadores en C /C++ y más información: http://es.wikipedia.org/wiki/Anexo:Operadores_de_C_y_C%2B%2B

Repaso Programación Arduino

El lenguaje de programación de Arduino es C++. No es un C++ puro sino que es una adaptación que proveniente de avr-libc que provee de una librería de C de alta calidad para usar con GCC (compilador de C y C++) en los microcontroladores AVR de Atmel y muchas utilidades opensource específicas para las MCU AVR de Atmel como avrdude: https://learn.sparkfun.com/tutorials/pocket-avr-programmer-hookup-guide/using-avrdude

Las herramientas necesarias para programar los microcontroladores AVR de Atmel son avr-binutils, avr-gcc y avr-libc y ya están incluidas en el IDE de Arduino, pero cuando compilamos y cargamos un sketch estamos usando estas herramientas.

Aunque se hable de que hay un lenguaje propio de programación de Arduino, no es cierto, la programación se hace en C++ pero Arduino ofrece unas librerías, también llamado core, que facilitan la programación de los pines de entrada y salida y de los puertos de comunicación, así como otras librerías para operaciones específicas. El propio IDE ya incluye estas librerías de forma automática y no es necesario declararlas expresamente. Otra diferencia frente a C++ standard es la estructuctura del programa ya que no usa la función main(), sino que usa las funciones setup() y loop().

En la mayoría de los casos se puede hacer un proyecto de Arduino de cierta complejidad con la librería que nos ofrece el core de Arduino y no es necesario añadir más instrucciones ni tipos de datos que los que hay en el core. Pero cuando queremos algo más complejo o más rápido o menos consumo o con más memoria, etc… es necesario usar funciones y estructuras no disponibles en el core de Arduino.

Toda la información para programar con el core de Arduino se encuentra en el reference de la web de Arduino: https://www.arduino.cc/en/Reference/HomePage

Una buena chuleta para tener a mano cuando programemos. Cheat Sheet: https://dlnmh9ip6v2uc.cloudfront.net/learn/materials/8/Arduino_Cheat_Sheet.pdf

Lenguaje de programación C++

Es posible usar comandos estándar de C++ en la programación de Arduino siempre que estén incluidos en el avr libc:

En Internet hay muchas webs de referencia donde consultar dudas a la hora de programar en C++:

Un manual sencillo de entender para la programación es el “arduino programming notebook” de brian w. Evans. Puedes consultarlo o descargarlo desde:

Cuando compilamos y cargamos el programa en Arduino esto es lo que ocurre:

Variables

Una variable puede ser declarada al inicio del programa antes de la parte de configuración setup(), a nivel local dentro de las funciones, y, a veces, dentro de un bloque, como para los bucles del tipo if.. for.., etc. En función del lugar de declaración de la variable así se determinará el ámbito de aplicación, o la capacidad de ciertas partes de un programa para hacer uso de ella.

Una variable global es aquella que puede ser vista y utilizada por cualquier función y estamento de un programa. Esta variable se declara al comienzo del programa, antes de setup().

Recordad que al declarar una variable global, está un espacio en memoria permanente en la zona de static data y el abuso de variables globales supone un uso ineficiente de la memoria.

Una variable local es aquella que se define dentro de una función o como parte de un bucle. Sólo es visible y sólo puede utilizarse dentro de la función en la que se declaró. Por lo tanto, es posible tener dos o más variables del mismo nombre en diferentes partes del mismo programa que pueden contener valores diferentes, pero no es una práctica aconsejable porque complica la lectura de código.

En el reference de Arduino hay una muy buena explicación del ámbito de las variables: http://arduino.cc/en/Reference/Scope

El modificador de variable static, es utilizado para crear variables que solo son visibles dentro de una función, sin embargo, al contrario que las variables locales que se crean y destruyen cada vez que se llama a la función, las variables estáticas mantienen sus valores entre las llamadas a las funciones.

Los tipos de variables en Arduino son:

Además de usar este tipo de datos que son los que aparecen en el reference de Arduino (https://www.arduino.cc/en/Reference/HomePage), es posible usar cualquier tipo de variable de C++ estándar con las limitaciones propias de cada microcontrolador.

Tipos de variables estándar en C++:

Más información sobre los tipos de variable Arduino en: https://aprendiendoarduino.wordpress.com/2016/06/29/tipos-de-datos-2/

Arrays

Un array es un conjunto de valores a los que se accede con un número índice. Cualquier valor puede ser recogido haciendo uso del nombre de la matriz y el número del índice. El primer valor de la matriz es el que está indicado con el índice 0, es decir el primer valor del conjunto es el de la posición 0. Un array tiene que ser declarado y opcionalmente asignados valores a cada posición antes de ser utilizado.

Para manejar arrays en C++ dispones de las funciones estándar: http://www.cplusplus.com/reference/array/array/

string (char array)

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 de chars.

Reference de Arduino para string: https://www.arduino.cc/en/Reference/String

Para manejara strings (char array) disponemos de las funciones de string.h que define diversas funciones para manipular strings y arrays http://www.cplusplus.com/reference/cstring/

También es posible usar la clase string de C++: http://www.cplusplus.com/reference/string/string/

Más información para aclarar la diferencia entre string y la clase string: https://www.tutorialspoint.com/cplusplus/cpp_strings.htm

String (Objeto)

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.

Toda la información de la clase String en el reference de Arduino https://www.arduino.cc/en/Reference/StringObject

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.

Operadores

El core de Arduino ofrece una serie de operadores según su reference:

Pero además es posible usar los operadores estnándar de C /C++ y más información: http://es.wikipedia.org/wiki/Anexo:Operadores_de_C_y_C%2B%2B

Estructuras de control

Las estructuras de control en Arduino según el reference son:

Funciones definidas por usuario

Una función es un bloque de código que 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.

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.

Más información sobre las funciones en C++: http://www.cplusplus.com/doc/tutorial/functions/

Práctica: Menú Interactivo

Hacer un menú interactivo a través del puerto serie donde al pulsar la opción 1 enciende el led del pin 9, al pulsar la opción 2 apaga el led del pin 9 y al pulsar la opción 3 mido el voltaje que tengo en la entrada analógica A0 conectada a un potenciómetro y la muestra por pantalla.

Instalación:

Solución Ejercicio16: https://github.com/jecrespo/aprendiendoarduino-Curso_Arduino_Avanzado_2017/tree/master/Ejercicio16-Menu_Interactivo

Prácticas: Función Detecta Flanco y Dado Digital

Hacer los dos ejercicios de https://aprendiendoarduino.wordpress.com/2017/07/07/practica-funciones/

Para ejercicio detecta flanco, el montaje son dos botones en los pines 2 y 3.

Solución Detecta Flanco: https://github.com/jecrespo/aprendiendoarduino-Curso_Programacion_Arduino/tree/master/Ejercicio09-Funcion_Detecta_Flanco

La función detecta flanco solo funciona con un pulsador, pero cuando se intenta usar con dos pulsadores ya no funciona, la solución es crear un objeto.

Código para detectar flanco en dos pulsadores que falla: https://github.com/jecrespo/aprendiendoarduino-Curso_Programacion_Arduino/blob/master/Ejercicio09-Funcion_Detecta_Flanco_Error/Ejercicio09-Funcion_Detecta_Flanco_Error.ino

Función detecta flanco:

 
int detectaFlanco(int pin) {
  //Devuelve 1 flanco ascendente, -1 flanco descendente y 0 si no hay nada
  static boolean anterior_estado = digitalRead(pin);
  boolean estado = digitalRead(pin);

  if (anterior_estado != estado) {
    if (estado == HIGH) {
      anterior_estado = estado;
      return 1;
    }
    else {
      anterior_estado = estado;
      return -1;
    }
  }
  else {
    return 0;
  }
}

Solución Ejercicio Dado: https://github.com/jecrespo/aprendiendoarduino-Curso_Programacion_Arduino/tree/master/Ejercicio10-Dado