Archivo de la categoría: Visualino

Programación Visual con Visualino

3 respuestas

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:

Bloques en Visualino

Visualino dispone de 12 bloques divididos de la siguiente forma:

  • Functions: para definir y llamar a funciones.
  • Control: estructuras de control if, switch, while, etc…
  • Logic: operaciones lógicas
  • Math: operaciones aritméticas y matemáticas
  • Variables: declaración, uso y asignación de variables
  • Text: uso y manipulación de Strings
  • Communication: uso del puerto serie y módulo bluetooth
  • Zum bloqs: manejo de los módulos de bq https://www.bq.com/es/zum-kit
  • Octopus bloqs: manejo de más módulos de bq
  • Pin functions: uso de las entradas y salidas analógicas y digitales
  • LCD bloqs: manejo de los módulos o pantallas LCD
  • Servo: para manejar servos tanto normales como de rotación continua

LCD bloqs

Communications:

Servo:

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:

Anuncio publicitario

Entradas y Salidas Analógicas Arduino. PWM

5 respuestas

Una señal eléctrica analógica es aquella en la que los valores de la tensión o voltaje varían constantemente y pueden tomar cualquier valor. En el caso de la corriente alterna, la señal analógica incrementa su valor con signo eléctrico positivo (+) durante medio ciclo y disminuye a continuación con signo eléctrico negativo (–) en el medio ciclo siguiente.

Un sistema de control (como un microcontrolador) no tiene capacidad alguna para trabajar con señales analógicas, de modo que necesita convertir las señales analógicas en señales digitales para poder trabajar con ellas.

La señal digital obtenida de una analógica tiene dos propiedades fundamentales:

En el caso de un arduino Uno, el valor de 0 voltios analógico es expresado en digital como B0000000000 (0) y el valor de 5V analógico es expresado en digital como B1111111111 (1023). Por lo tanto todo valor analógico intermedio es expresado con un valor entre 0 y 1023, es decir, sumo 1 en binario cada 4,883 mV.

Arduino Uno tiene una resolución de 10 bits, es decir, unos valores entre 0 y 1023.

Arduino Due tiene una resolución de 12 bits, es decir, unos valores entre 0 y 4095.

Diferencia entre señales analógicas y digitales:

Entradas Analógicas en Arduino

Los microcontroladores de Arduino contienen en la placa un conversor analógico a digital de 6 canales. El conversor tiene una resolución de 10 bits, devolviendo enteros entre 0 y 1023. Los pines analógicos de Arduino también tienen todas las funcionalidades de los pines digitales. Por lo tanto, si necesitamos más pines digitales podemos usar los pines analógicos. La nomenclatura para los pines analógicos es A0, A1, etc…

En arduino los pines analógicos se definen y tienen las propiedades siguientes: http://arduino.cc/en/Tutorial/AnalogInputPins

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

En Visualino disponemos de las funciones para leer de entradas analógicas y escribir en salidas analógicas en la agrupación de bloques “Pin Functions”.

Otras funciones interesantes con entradas/salidas analógicas:

En Visualino estás disponibles las funciones map y random en la agrupación “Math”

Salidas Analógicas. PWM

Como hemos dicho Arduino Uno tiene entradas analógicas que gracias a los conversores analógico digital puede entender ese valor el microcontrolador, pero no tiene salidas analógicas puras y para solucionar esto, usa la técnica de 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 función para hacer una salida PWM en un pin es:

En Visualino disponemos de la función analogWrite() para escribir entradas analógicas con PWM en la agrupación de bloques “Pin Functions”.

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:

En este ejemplo se ve cómo simular con PWM una onda sinusoidal analógica.

En Arduino la frecuencia de PWM es de 500Hz. Pero es un valor que puede modificarse en caso que lo necesitemos.

En la actualidad existen muchos circuitos integrados en los que se implementa la modulación PWM, por ejemplo para lograr circuitos funcionales que puedan controlar fuentes conmutadas, controles de motores, controles de elementos termoeléctricos, choppers para sensores en ambientes ruidosos y algunas otras aplicaciones.

Definición de PWM en la web de Arduino: http://arduino.cc/en/Tutorial/PWM

Para ampliar un poco más de información sobre PWM ver: http://rufianenlared.com/que-es-pwm/

Función Tone()

No confundir PWM con la función tone() que es utilizada para generar una onda cuadrada de ciclo de trabajo 50% y frecuencia variable, con el fin de emitir sonidos audibles, modificando la frecuencia.

Más información de tone() en: https://code.google.com/p/rogue-code/wiki/ToneLibraryDocumentation

Funciones Definidas por Usuario

5 respuestas

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

Arrays y Strings

6 respuestas

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”

Tipos de Datos

8 respuestas

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: