Archivo de la etiqueta: Programación

Funciones Definidas por Usuario

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

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

Una función tiene un nombre y un conjunto de instrucciones que son ejecutadas cuando se llama a la función. Son funciones setup() y loop() de las que ya se ha hablado anteriormente.

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

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

Sintaxis:

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

Anatomía de una función en C:

Para llamar a una función, simplemente:

 
nombreFunción(parámetros);

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

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

Ventajas del uso de funciones:

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

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

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

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

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

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

Nombres de funciones

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

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

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

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

Funciones vs Librerías

Ejemplo de blink usando funciones:

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

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

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

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

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

En Visualino se podría hacer de esta forma:

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

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

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

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

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

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

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

Práctica Final de Funciones

Con todo lo visto de Strings, operadores, estructuras de control y funciones, hacer un ejemplo de un menú interactivo donde se dan varias opciones y pulsando cada una de ellas se ejecuta una acción concreta. Si el valor pulsado no es ninguna de las opciones avisar y volver a mostrar el menú hasta que se pulse una opción correcta.

Opciones:

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

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

Anuncios

Arrays y Strings

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.

Declaración de un array:

 
int miArray[] = {valor0, valor1, valor2…}

Del mismo modo es posible declarar un array indicando el tipo de datos y el tamaño y posteriormente, asignar valores a una posición específica:

 
int miArray[5];
miArray[3] = 10;

Para leer de un array basta con escribir el nombre y la posición a leer:

x = miArray[3];

Las matrices se utilizan a menudo con estamentos de tipo bucle, en los que la variable de incremento del contador del bucle se utiliza como índice o puntero del array. Utilizando un bucle tipo for, el contador comienza en cero 0 y escribe el valor que figura en la posición de índice 0 en la serie que realizada sigue escribiendo en las siguientes posiciones. Con un bucle for podremos recorrer un array ya sea para leerlo o para escribir en él.

int myPins[5];
for (int i = 0; i < 5; i = i + 1) {
  Serial.println(myPins[i]);
}

IMPORTANTE: No se puede crear un array sin definir su tamaño, sino da un error de compilación.

La creación y manejo de arrays con Visualino aun no esté suficientemente desarrollada para poder usarse, recomiendo el uso de código.

Los arrays sólo pueden contener elementos del mismo tipo de datos. Si quisiéramos guardar tipos de datos diferentes en una misma variable, C nos ofrece la opción definir estructuras: http://c.conclase.net/curso/?cap=011

Ver más información en: http://arduino.cc/en/Reference/Array

Es posible definir arrays de varias dimensiones o también llamados matrices, simplemente haciendo un array de arrays

Definición:

 
int matriz[5][5];
matriz[2][0] = 3;

string (char array)

Un string es una cadena de caracteres, o lo que es lo mismo un string es un array de chars. Cuando se trabaja con grandes cantidades de texto, es conveniente usar un array de strings.

Una características de los strings es el carácter de terminación del string que nos indica dónde acaba la cadena de caracteres. Podemos tener un string de tamaño 50 para almacenar una cadena de caracteres, pero unas veces puede tener una sola palabra o una frase completa. Esto permite a funciones como Serial.print() saber hasta dónde debe leer del string para mostrarlo por pantalla.

El carácter de terminación o null termination se representa como ‘\0’ y corresponde al código 0 de ASCII.

Esto significa que un string para almacenar la palabra “hola” debe tener un tamaño de 5 y no de 4 para poder guardar el null termination.

Los strings siempre se definen entre dobles comillas “hola”, mientras que los caracteres siempre se definen con comillas simples ‘h’.

Ver:

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.

Para los nuevos en programación o en Arduino es recomendable usar el Objeto String en lugar de los strings como array de caracteres por su facilidad de uso.

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, tiene funciones asociadas (métodos), operadores y propiedades. Es una abstracción del dato y para aprender a usarlo hay que leerse la documentación correspondiente.

Documentación de Arduino sobre la clase String:

Además de la clase String, podemos utilizar las funciones estándar de C++ para manipular strings y hacer lo mismo que hacemos con la clase String, pero de una forma más compleja, donde tendremos que manejarnos bien con los punteros.

Operadores String (Objeto)

También existen operadores para los Strings (objeto), similares a las operaciones vistas anteriormente:

Visualino implementa el objeto String y sus operadores en los apartados “variables” y “text”

Estructuras de control

En programación, las estructuras de control permiten modificar el flujo de ejecución de las instrucciones de un programa.

Con las estructuras de control se puede:

  • De acuerdo con una condición, ejecutar un grupo u otro de sentencias (If-Then-Else)
  • De acuerdo con el valor de una variable, ejecutar un grupo u otro de sentencias (Select-Case)
  • Ejecutar un grupo de sentencias mientras se cumpla una condición (Do-While)
  • Ejecutar un grupo de sentencias hasta que se cumpla una condición (Do-Until)
  • Ejecutar un grupo de sentencias un número determinado de veces (For-Next)

Todos los lenguajes de programación modernos tienen estructuras de control similares. Básicamente lo que varía entre las estructuras de control de los diferentes lenguajes es su sintaxis; cada lenguaje tiene una sintaxis propia para expresar la estructura.

En Visualino las estructuras de control se encuentran en el apartado “control”

Estructuras de decisión

if:  es un estamento que se utiliza para probar si una determinada condición se ha alcanzado, como por ejemplo averiguar si un valor analógico está por encima de un cierto número, y ejecutar una serie de declaraciones (operaciones) que se escriben dentro de llaves, si es verdad. Si es falso (la condición no se cumple) el programa salta y no ejecuta las operaciones que están dentro de las llaves.

Referencia Arduino: http://arduino.cc/en/Reference/If

if… else:  viene a ser un estructura que se ejecuta en respuesta a la idea “si esto no se cumple haz esto otro”. Por ejemplo, si se desea probar una entrada digital, y hacer una cosa si la entrada fue alto o hacer otra cosa si la entrada es baja.

else: puede ir precedido de otra condición de manera que se pueden establecer varias estructuras condicionales de tipo unas dentro de las otras (anidamiento) de forma que sean mutuamente excluyentes pudiéndose ejecutar a la vez. Es incluso posible tener un número ilimitado de estos condicionales. Recuerde sin embargo que sólo un conjunto de declaraciones se llevará a cabo dependiendo de la condición probada.

Referencia Arduino: http://arduino.cc/en/Reference/Else

Tutorial if() – Comparar el valor leido de un potenciometro con un umbral y encender un led si el valor leido es mayor que el umbral https://www.arduino.cc/en/Tutorial/ifStatementConditional

Uso de if con Visualino

switch..case: Al igual que if, switch..case controla el flujo del programa especificando en el programa que código se debe ejecutar en función de unas variables. En este caso en la instrucción switch se compara el valor de una variable sobre los valores especificados en la instrucción case.

break es la palabra usada para salir del switch. Si no hay break en cada case, se ejecutará la siguiente instrucción case hasta que encuentre un break o alcance el final de la instrucción.

default es la palabra que se usa para ejecutar el bloque en caso que ninguna de las condiciones se cumpla.

Referencia Arduino: http://arduino.cc/en/Reference/SwitchCase

Uso de switch con Visualino

Tutorial Switch(case) – Leer una fotorresistencia y en función de unos valores predefinidos imprimir la cantidad de luz en 4 valores: noche, oscuro, medio, claro https://www.arduino.cc/en/Tutorial/SwitchCase

Estructuras de repetición

for: La declaración for se usa para repetir un bloque de sentencias encerradas entre llaves un número determinado de veces. Cada vez que se ejecutan las instrucciones del bucle se vuelve a testear la condición. La declaración for tiene tres partes separadas por (;). La inicialización de la variable local se produce una sola vez y la condición se testea cada vez que se termina la ejecución de las instrucciones dentro del bucle. Si la condición sigue cumpliéndose, las instrucciones del bucle se vuelven a ejecutar. Cuando la condición no se cumple, el bucle termina.

Cualquiera de los tres elementos de cabecera puede omitirse, aunque el punto y coma es obligatorio. También las declaraciones de inicialización, condición y expresión puede ser cualquier estamento válido en lenguaje C sin relación con las variables declaradas.

Referencia Arduino: http://arduino.cc/en/Reference/For

Tutorial for() – efecto con leds coche fantastico https://www.arduino.cc/en/Tutorial/ForLoopIteration

while: Un bucle del tipo while es un bucle de ejecución continua mientras se cumpla la expresión colocada entre paréntesis en la cabecera del bucle. La variable de prueba tendrá que cambiar para salir del bucle. La situación podrá cambiar a expensas de una expresión dentro el código del bucle o también por el cambio de un valor en una entrada de un sensor.

Referencia Arduino: http://arduino.cc/en/Reference/While

Tutorial while() – calibrar el valor de un sensor analógico https://www.arduino.cc/en/Tutorial/WhileStatementConditional

do..while: El bucle do while funciona de la misma manera que el bucle while, con la salvedad de que la condición se prueba al final del bucle, por lo que el bucle siempre se ejecutará al menos una vez.

Referencia Arduino: http://arduino.cc/en/Reference/DoWhile

goto: transfiere el flujo de programa a un punto del programa que está etiquetado.

Referencia Arduino: http://arduino.cc/en/Reference/Goto

break: se usa en las instrucciones do, for, while para salir del bucle de una forma diferente a la indicada en el bucle.

Referencia Arduino: http://arduino.cc/en/Reference/Break

continue: se usa en las instrucciones do, for, while para saltar el resto de las instrucciones que están entre llaves y se vaya a la siguiente ejecución del bucle comprobando la expresión condicional.

Referencia Arduino: http://arduino.cc/en/Reference/Continue

En Visualino están disponibles todas las estructuras de repetición

Y por su puesto ante cualquier duda: http://arduino.cc/en/Reference/HomePage

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

Tipos de Datos

En programación, un tipo de dato informático o simplemente tipo es un atributo de los datos que indica al ordenador (y/o al programador) sobre la clase de datos que se va a trabajar. Esto incluye imponer restricciones en los datos, como qué valores pueden tomar y qué operaciones se pueden realizar.

Los tipos de datos comunes son: números enteros, números con signo (negativos), números de coma flotante (decimales), cadenas alfanuméricas, estados (booleano), etc.

Algunos tipos de datos usados en C++:

byte

Byte almacena un valor numérico de 8 bits sin decimales. Tienen un rango entre 0 y 255. Sin signo.  http://arduino.cc/en/Reference/Byte

int (entero)

Enteros son un tipo de datos primarios que almacenan valores numéricos de 16 bits sin decimales comprendidos en el rango 32,767 a -32,768.

Nota: Las variables de tipo entero “int” pueden sobrepasar su valor máximo o mínimo como consecuencia de una operación. Por ejemplo, si x = 32767 y hacemos x++, entonces x pasará a ser -32.768. ¿Porque ocurre esto? → http://en.wikipedia.org/wiki/Two%27s_complement

Ver:

Las constantes enteras son números utilizados en el sketch, estos números son tratados como enteros, pero podemos cambiar su comportamiento.

Las constantes enteras son tratadas como base 10 (Decimal), pero con una notación especial podemos cambiar su representación en otras bases.

  • Binario – B00001110
  • Octal – 0173
  • Hexadecimal – 0x7C3
  • Para forzar a formato unsigned: 78U ó 78u
  • Para forzar a formato long: 1000L ó 1000l
  • Para forzar a formato unsigned long: 2521UL ó 2521ul

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

long (entero largo)

El formato de variable numérica de tipo extendido “long” se refiere a números enteros (tipo 32 bits = 4 bytes) sin decimales que se encuentran dentro del rango -2147483648 a 2147483647.

Ver más información en:

float (decimales)

El formato de dato del tipo “coma flotante” o “float” se aplica a los números con decimales. Los números de coma flotante tienen una mayor resolución que los de 32 bits que ocupa con un rango comprendido 3.4028235E+38 a -3.4028235E+38.

Los números de punto flotante no son exactos, y pueden producir resultados extraños en las comparaciones. Los cálculos matemáticos de coma flotante son también mucho más lentos que los del tipo de números enteros, por lo que debe evitarse su uso si es posible. En Arduino el tipo de dato double es igual que el float.

Ver:

Las constantes de coma flotante se usan para facilitar la lectura del código, pero aunque no se use, el compilador no va a dar error y se ejecutará normalmente.

  • 10.0 se evalúa como 10
  • 2.34E5 ó 67e-12 (expresado en notación científica)

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

Para entenderlo mejor: la representación de coma flotante (en inglés floating point, ‘punto flotante’) es una forma de notación científica usada en las CPU, GPU, FPU, etc, con la cual se pueden representar números racionales extremadamente grandes y pequeños de una manera muy eficiente y compacta, y con la que se pueden realizar operaciones aritméticas. El estándar para la representación en coma flotante es el IEEE 754. http://es.wikipedia.org/wiki/Coma_flotante

  • Signo (s)  1: negativo , 0: positivo (bit 31)
  • Mantisa (M)  La mantisa incluye 23 bits (bit 0.. 22). Representa la parte derecha de número decimal.
  • Exponente (e)  El exponente incluye 8 bits (bit 23..30).

boolean

Un booleano solo tiene dos valores true y false. Cada booleano ocupa un byte de memoria. Ver:

char (carácter)

Un char representa un carácter que ocupa 1 byte de memoria. Los caracteres simples se representan con comillas simples ‘a’ y para múltiples caracteres o strings se representan con comillas dobles “Hola!”.

Recordar que los caracteres se almacenan como números usando la codificación ASCII, lo que significa que es posible hacer operaciones aritméticas con los caracteres.

Ver lo siguientes enlaces del Arduino reference:

Sistemas de codificación utilizados:

  • Binario.
  • BCD (Binario codificado a decimal)
  • Hexadecimal.
  • ASCII

Tipos de Datos en Visualino

En Visualino podemos definir los tipos de datos tanto en variables locales como globales:

  • int
  • long
  • byte
  • float
  • String

Conversiones de tipos (Casting)

En ocasiones es necesario forzar el cambio de tipo de dato (casting). Podemos usar las siguientes funciones: