Archivo de la etiqueta: Visualino

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:

Variables en Arduino

¿Que es una variable? Una variable es un lugar donde almacenar un dato, tiene un nombre, un valor y un tipo.

Los nombres de variables pueden tener letras, números y el símbolo ’_’. Deben empezar por una letra (pueden empezar por ’_ ’ pero no es recomendable pues es el criterio que usan las rutinas de la biblioteca).

Pueden llevar mayúsculas y minúsculas. En C se distingue entre mayúsculas y minúsculas. La costumbre es que las variables van en minúscula y las constantes en mayúscula

Usa las mismas reglas dentro del código para el nombramiento de variables, ya sea en minúscula con palabras separadas con guiones bajos, tantos como sea necesario para mejorar la legibilidad o utilizar la convención “CapWords” (palabras que comienzan con mayúsculas), aunque generalmente la primera palabra se pone en minúsculas.

Usa un solo guión bajo como prefijo para métodos no públicos y variables de instancia.

Las palabras reservadas if, else,etc . . . no pueden usarse como nombres de variables.

Nombres para evitar: Nunca uses los caracteres ‘l’ (letra ele en minúscula), ‘O’ (letra o mayúscula), o ‘I’ (letra i mayúscula) como simples caracteres para nombres de variables, para evitar confusiones a la hora de leer el código.

Declaración de variables.

Una variable tiene un nombre, un valor y un tipo. Con la asignación, se puede cambiar el valor de la variable.

Todas las variables deben ser declaradas antes de su uso. Las declaraciones deben aparecer al principio de cada función o bloque de sentencias. Al declarar una variable se debe indicar primero el tipo de variable y luego su nombre, opcionalmente se le puede dar un valor, lo que se llama inicializar la variable.

La declaración consta de un tipo de variable y una lista de variables separadas por coma.

  • int i,j;
  • float x,pi;
  • unsigned long longitud, contador;

Las variables pueden inicializarse en la declaración

  • float pi=3.1416;
  • unsigned long contador=0;

Puede utilizarse el modificador const para indicar que la variable no puede ser cambiada en tiempo de ejecución.

  • const float e=2.7182;

La declaración de una variable sólo debe hacerse una vez en un programa, pero el valor de la variable se puede cambiar en cualquier momento usando aritmética y reasignaciones diversas.

Una variable puede ser declarada en una serie de lugares del programa y en función del lugar en donde se lleve a cabo la declaración, esto determinará en qué partes del programa se podrá hacer uso de ella, es lo que se denomina ámbito de la variable o scope.

C y C++ se dice que son lenguajes de tipado estático, es decir, la comprobación de tipificación se realiza durante la compilación, y no durante la ejecución, por lo tanto no podemos cambiar el tipo de una variable en tiempo de ejecución. Otros lenguajes, generalmente interpretados, son de tipado dinámico y una misma variable puede tomar valores de distinto tipo en distintos momentos, como PHP o python.

La explicación de www.arduino.cc de las variables: http://arduino.cc/en/Tutorial/Variables y http://arduino.cc/en/Reference/VariableDeclaration

Usando Visualino tenemos de un apartado de variables donde tenemos los bloques para declarar, asignar y llamar las variables.

Ámbito de una variable

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

Con Visualino es posible declarar variables locales y globales:

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.

La variables estáticas solo se crean e inicializan la primera vez que la función es llamada. Ver ejemplo en: http://arduino.cc/en/Reference/Static

Con Visualino no es posible declarar variables estáticas.

Probar este ejercicio y luego añadir static a la variable valor. Ver la diferencia.

Solución: https://github.com/jecrespo/aprendiendoarduino-Curso_Arduino_2017/tree/master/Ejercicio03-Visualino_Variables

Constantes

En programación, una constante es un valor que no puede ser alterado/modificado durante la ejecución de un programa, únicamente puede ser leído. Una constante corresponde a una longitud fija de un área reservada en la memoria principal del ordenador, donde el programa almacena valores fijos. Por ejemplo el valor de PI = 3.1416.

El modificador const, modifica el comportamiento de una variable haciéndola “read-only”, esto significa que puede usarse como cualquier otra variable pero su valor no puede ser cambiado.

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

El entorno de programación de Aduino también tiene predefinidas unas constantes o expresiones, que facilitan la lectura del código: http://arduino.cc/en/Reference/Constants

En C++ las constantes también pueden ser definidas a nivel de módulo antes de compilar, de forma que no ocupan memoria y su nombre es sustituido por el valor definido en el proceso de compilación. Estas constantes por norma se escriben con letras en mayúscula y guiones bajos separando palabras. Por ejemplo, MAX_OVERFLOW y TOTAL. Se usa la palabra clave #define para definirlas.

Más información en: https://www.arduino.cc/en/Reference/Define

En Visualino no está disponible la opción de declarar constantes, pero se pueden declarar variables globales y luego añadir el modificador const.

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 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 o 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 que ya hemos visto anteriormente.

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

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:

Características de C:

  • Es el lenguaje de programación de propósito general asociado al sistema operativo UNIX.
  • Es un lenguaje de medio nivel. Trata con objetos básicos como caracteres, números, etc… también con bits y direcciones de memoria.
  • Posee una gran portabilidad
  • Se utiliza para la programación de sistemas: construcción de intérpretes, compiladores, editores de texto, etc

Un buen libro de referencia para C:

Y un libro que se puede descargar gratuitamente Essential C: http://cslibrary.stanford.edu/101/EssentialC.pdf

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

C++ es un lenguaje de programación diseñado a mediados de los años 1980 por Bjarne Stroustrup. La intención de su creación fue el extender al exitoso lenguaje de programación C con mecanismos que permitan la manipulación de objetos. En ese sentido, desde el punto de vista de los lenguajes orientados a objetos, el C++ es un lenguaje híbrido.

Posteriormente se añadieron facilidades de programación genérica, que se sumó a los otros dos paradigmas que ya estaban admitidos (programación estructurada y la programación orientada a objetos). Por esto se suele decir que el C++ es un lenguaje de programación multiparadigma. Actualmente existe un estándar, denominado ISO C++.

C# es un lenguaje propietario de Microsoft que mezcla las características básicas de C++ (no las avanzadas) simplificandolas al estilo Java y ofreciendo un framework. C# forma parte de la plataforma .NET

Elementos básicos en la programación de Arduino

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:

{} entre llaves

Las llaves sirven para definir el principio y el final de un bloque de instrucciones. Se utilizan para los bloques de programación setup(), loop(), if.., etc.

Una llave de apertura “{“ siempre debe ir seguida de una llave de cierre “}”, si no es así el compilador dará errores. El entorno de programación de Arduino incluye una herramienta de gran utilidad para comprobar el total de llaves. Sólo tienes que hacer click en el punto de inserción de una llave abierta e inmediatamente se marca el correspondiente cierre de ese bloque (llave cerrada).

Usando programación mediante bloques las llaves no son necesarias ya que todo lo que está dentro de un bloque ejecutar, es lo que va entre llaves.

; punto y coma

El punto y coma “;” se utiliza para separar instrucciones en el lenguaje de programación C. También se utiliza para separar elementos en una instrucción de tipo “bucle for”.

Nota: Si olvidáis poner fin a una línea con un punto y coma se producirá en un error de compilación.

/*… */ bloque de comentarios

Los bloques de comentarios, o comentarios multi-línea son áreas de texto ignorados por el programa que se utilizan para las descripciones del código o comentarios que ayudan a comprender el programa. Comienzan con / * y terminan con * / y pueden abarcar varias líneas.

Debido a que los comentarios son ignorados por el compilador y no ocupan espacio en la memoria de Arduino pueden ser utilizados con generosidad.

En Visualino no es posible poner comentarios.

// línea de comentarios

Una línea de comentario empieza con / / y terminan con la siguiente línea de código. Al igual que los comentarios de bloque, los de línea son ignoradas por el compilador y no ocupan espacio en la memoria. Una línea de comentario se utiliza a menudo después de una instrucción, para proporcionar más información acerca de lo que hace esta o para recordarla más adelante.

Guia de Estilo de programación

A la hora de programar Arduino, es fundamental usar la referencia que disponemos online en http://arduino.cc/en/Reference/HomePage o en la ayuda del IDE de Arduino. Cualquier duda sobre un comando, función, etc… debemos consultar en la referencia de Arduino.

Existe una guía de estilo para escribir código claro de Arduino y que sea fácil de entender. No es obligatorio, pero es una recomendación:

  • Documentar al máximo
  • Usar esquemas
  • Predominar la facilidad de lectura sobre la eficiencia del código
  • Poner el setup() y loop() al principio del programa
  • Usar variables descriptivas
  • Explicar el código al principio
  • Usar identación

Guia de estilo: http://arduino.cc/en/Reference/StyleGuide

También disponemos de varias cheat sheets o chuletas para cuando se empieza a programar:

Una buena guía de estilo de C++: http://informatica.uv.es/iiguia/AED/laboratorio/Estilocpp.pdf

Para documentar nuestros sketchs: http://busyducks.com/wp_4_1/2015/11/16/ascii-art-arduino-pinouts/

Programación Visual con Visualino

Visualino es un entorno de programación visual que me permite hacer un programa con bloques tipo scratch y ver el código que se genera.

Al contrario que S4A y mBlock, Visualino está solo centrando en la programación de Arduino con un lenguaje de programación por bloques, como se de un traductor de bloques a código se tratara. Pero además, permite programar directamente la placa de Arduino y por tanto, hace innecesaria la conexión permanente al PC.

Los bloques generan el código de C/C++ en tiempo real en una ventana. El entorno es similar al del IDE de Arduino, con las mismas opciones principales: Verificar, Subir, Guardar, Cargar y Monitor.

Visualino ha sido creado por Víctor Ruiz: http://rvr.linotipo.es/

Visualino está basado en blockly de Google al igual que bitBloq http://bitbloq.bq.com/ de BQ: https://developers.google.com/blockly/

Web del proyecto: http://www.visualino.net/

Código fuente: https://github.com/vrruiz/visualino/

Descargar: http://www.visualino.net/downloads/

Tutorial de uso: http://procomun.educalab.es/es/ode/view/1453974406581

Foro: http://www.visualino.net/forum/

Tutoriales de uso:

Más información

Instalación Visualino

Como instalar Visualino: http://www.visualino.net/docs/windows.es.html

Visualino necesita el Arduino IDE para transferir los programas a la placas de Arduino, para ello es necesario configurar la ruta del IDE de Arduino en Visualino.

Una configuración importante es la ruta del IDE de Arduino. Esta es la ruta al fichero ejecutable (EXE) que Visualino llamará para compilar y transferir los programas a las placas de Arduino. Si este fichero ejecutable no se encuentra, no podrá programar las placas, así que tenga cuidado.

En windows la ruta por defecto es: C:\Program Files (x86)\Arduino\arduino.exe

Entorno de programación:

Ejercicios

Hacer el ejemplo de blink con Visualino y comparar el código con el de la práctica https://aprendiendoarduino.wordpress.com/2017/06/18/primer-proyecto-blink-3/

Solución: https://github.com/jecrespo/aprendiendoarduino-Curso_Arduino_2017/tree/master/Ejercicio01-Visualino-Blink

Hacer la versión mejorada del blink enviando al puerto serie el estado del led.

Solución: https://github.com/jecrespo/aprendiendoarduino-Curso_Arduino_2017/tree/master/Ejercicio02-Visualino-Blink_Mejorado

Otros ejemplos con Visualino:

Programación Visual con Visualino

Visualino es un entorno de programación visual que me permite hacer un programa con bloques tipo scratch y ver el código que se genera.

Al contrario que S4A y mBlock, Visualino está solo centrando en la programación de Arduino con un lenguaje de programación por bloques. Pero además, permite programar directamente la placa de Arduino y por tanto, hace innecesaria la conexión permanente al PC.

Los bloques generan el código de C/C++ en tiempo real en una ventana. El entorno es similar al del IDE de Arduino, con las mismas opciones principales: Verificar, Subir, Guardar, Cargar y Monitor.

Visualino ha sido creado por Víctor Ruiz: http://rvr.linotipo.es/

Visualino está basado en blockly al igual que bitBloq http://bitbloq.bq.com/ de BQ: https://developers.google.com/blockly/

Web: http://www.visualino.net/

Código: https://github.com/vrruiz/visualino/

Descargar: http://www.visualino.net/downloads/

Tutorial de uso: http://procomun.educalab.es/es/ode/view/1453974406581

Más información

Instalación Visualino

Como instalar Visualino: http://www.visualino.net/docs/windows.es.html

Visualino necesita el Arduino IDE para transferir los programas a la placas de Arduino.

Una configuración importante es la ruta del IDE de Arduino. Esta es la ruta al fichero ejecutable (EXE) que Visualino llamará para compilar y transferir los programas a las placas de Arduino. Si este fichero ejecutable no se encuentra, no podrá programar las placas, así que tenga cuidado.

Ejercicios

Medir voltaje con Visualino: http://rvr.typepad.com/wind/2015/04/visualino-how-to-measure-voltage-with-arduino.html

PDF con muchas más prácticas: https://lacienciaparatodos.files.wordpress.com/2017/02/prc3a1cticas-arduino-javier-fernc3a1ndez-panadero-05-02-2017.pdf

Más prácticas: http://agrega.educacion.es/visualizador-1/es/pode/presentacion/visualizadorSinSecuencia/visualizar-datos.jsp