Archivo de la etiqueta: Práctica

Práctica: Funciones Definidas de Usuario

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

Función Detecta flanco

Señales digitales:

Hacer una función que detecte flancos ascendentes y descendentes, para ser reutilizada en otros proyectos.

Ponerla en un ejemplo con alguno de los botones.

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

Para ejercicio detecta flanco, probar con dos botones en los pines 2 y 3. 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

Dado Digital

Usando las funciones de números aleatorios hacer un dado digital que genere un número aleatorio entre 1 y 4 y encienda un led aleatorio cada vez que se pulse el botón A.

Usar la función de detección de flanco hecha en el anterior ejercicio.

Random Numbers

  • randomSeed() – Inicializa el generador de número pseudo-aleatorios
  • random() – Genera números pseudo-aleatorios

Paso 1 – Generar un valor aleatorio entre 1 y 4 al pulsar el botón

Paso 2 – Apagar el led anteriormente encendido y encender el nuevo led.

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

Ejercicio propuesto. Hacer una ruleta electrónica con un neopixel ring

Anuncios

Tratamiento Avanzado de Strings

Como ya se ha visto anteriormente el tratamiento de strings es un parte muy importante en Arduino puesto que se usa muy frecuentemente y principalmente usamos en las comunicaciones, ya sea puerto serie, bluetooth, XBee, http, etc…

El uso de strings hace un uso intensivo de memoria lo que hace que podamos tener comportamientos extraños en los sketchs o incluso tengamos desbordamiento de memoria.

A la hora de usar strings en Arduino, podemos hacer uso de la clase String https://www.arduino.cc/reference/en/language/variables/data-types/stringobject/ que nos ofrece unos métodos y es muy sencilla de usar, a cambio de ser poco eficiente a nivel de SRAM o usar los stringshttps://arduino.cc/reference/en/language/variables/data-types/string/ como arrays de chars https://arduino.cc/reference/en/language/variables/data-types/char/ que es más complejo de manejar pero más potente y tenemos más control del uso de memoria y pueden usarse muchas de las funciones estandard de C++.

String (Objeto)

Arduino nos ofrece una clase llamada String que facilita el uso de de las cadenas de caracteres con unos métodos muy sencillos de usar y poder usar los operadores que conocemos para los Strings.

Se trata de una clase que permite usar y manipular cadenas de texto de una forma más sencilla que los strings. Puedes concatenar, añadir, buscar, etc… usando los métodos/funciones que ofrece esta clase.

Los Strings tienen un uso intensivo de memoria, pero son muy útiles y se van a utilizar mucho en el apartado de comunicación, por ese motivo es importante aprender a manejar los Strings.

Tener en cuenta que al no ser un tipo de dato propiamente dicho sino una clase, tienes unas funciones asociadas (métodos), operadores y unas propiedades. Es una abstracción del dato y para aprender a usarlo hay que leerse la documentación correspondiente.

Toda la información de la clase String está en: https://arduino.cc/reference/en/language/variables/data-types/stringobject/

Ver documentación de Arduino sobre la clase String:

Tutoriales de uso de String:https://arduino.cc/en/Tutorial/BuiltInExamples#strings

Prácticas Manejo de Strings

Ejecutar el ejemplo https://arduino.cc/en/Tutorial/StringLengthTrim donde se hace uso de las funciones length() y trim().

Ejecutar el ejemplo https://arduino.cc/en/Tutorial/StringStartsWithEndsWith donde se hace uso de las funciones StartsWith() y EndsWith().

Ejecutar el ejemplo https://arduino.cc/en/Tutorial/StringSubstring donde se hace uso de la función substring().

Ejecutar el ejemplo https://arduino.cc/en/Tutorial/StringToInt donde se hace uso de la función toInt()

Otra de las funciones más útiles de String es IndexOf() con ejemplos en https://www.arduino.cc/en/Tutorial/StringIndexOf

Ejercicio: Conectarse a www.aprendiendoarduino.com y analizar el texto descargado. El texto descargado es una página web que contiene datos de una música a tocar por el buzzer

Hacerlo usando la clase String.

Obtener y sacar por el puerto serie:

  • Tamaño de la web (número de caracteres)
  • Localizar las cadenas: “Inicio Notas”, “Fin Notas”, “Inicio Duración” y “Fin Duración”
  • Obtener las notas (frecuencia) y la duración de las notas. Luego reproducirlo.

Solución: https://github.com/jecrespo/aprendiendoarduino-Curso_Programacion_Arduino/tree/master/Ejercicio16-Strings_Avanzado

string (Array de chars)

Un string es un array de chars. Cuando se trabaja con grandes cantidades de texto, es conveniente usar un array de strings. Puesto que los strings son en si mismo arrays. En el reference de Arduino https://arduino.cc/reference/en/language/variables/data-types/string/

La notación de un string como array de chars es char*

El core de Arduino me ofrece varias funciones de análisis de caracteres: https://arduino.cc/reference/en/language/variables/data-types/string/

Una cadena en C++ es un conjunto de caracteres, o valores de tipo char, terminados con el carácter nulo, es decir el valor numérico 0 (\0). Internamente, en el ordenador, se almacenan en posiciones consecutivas de memoria. Este tipo de estructuras recibe un tratamiento muy especial, ya que es de gran utilidad y su uso es continuo. La manera de definir una cadena es la siguiente: char <identificador> [<longitud máxima>];

Cuando se declara una cadena hay que tener en cuenta que tendremos que reservar una posición para almacenar el carácter nulo terminador, de modo que si queremos almacenar la cadena “HOLA”, tendremos que declarar la cadena como: char Saludo[5]; Las cuatro primeras posiciones se usan para almacenar los caracteres “HOLA” y la posición extra, para el carácter nulo.

También nos será posible hacer referencia a cada uno de los caracteres individuales que componen la cadena, simplemente indicando la posición. Por ejemplo el tercer carácter de nuestra cadena de ejemplo será la ‘L’, podemos hacer referencia a él como Saludo[2].

Se puede manipular las cadenas de caracteres de la misma manera en que manipula cualquier otro tipo de array, sin embargo, es preferible hacer uso de una librería estándar especialmente escrita para manipulación de cadenas de caracteres, se trata de la librería <string.h> y que viene incluida con todo compilador de C, C++.

Reference de C++ para la clase string http://cplusplus.com/reference/string/string/ y http://cplusplus.com/reference/cstring/ con funciones como strcpy para strings null-terminated.

Los compiladores de C, C++ dan soporte a la biblioteca de funciones <string.h>, a la que accede por medio de la directiva #include <string.h>. No veremos en detalle todas las funciones contenidas en dicha biblioteca, y nos limitaremos a mostrar algunos ejemplos de ciertas funciones importantes.

  • strlen(): Obtener longitud de cadenas. Sintaxis: size_t strlen(const char *s);
  • strcpy(): Copiar cadenas. Sintaxis: char *stpcpy(char *dest, const char *src);
  • strcat(): Concatenar cadenas. Sintaxis: char *strcat(char *dest, const char *src);
  • strlwr(): Convertir a minúsculas. Sintaxis: char *strlwr(char *dest);
  • strupr(): Convertir a mayúsculas. Sintaxis: char *strupr(char *dest);
  • strchr(): Buscar carácter (hacia adelante). Sintaxis: char *strchr(char *s, int c);
  • strrchr(): Buscar carácter (hacia atras). Sintaxis: char *strrchr(char *s, int c);
  • strstr(): Buscar subcadena. Sintaxis: char *strstr(const char *s1, char *s2);
  • memset(): Establece el primer num bytes del bloque de memoria apuntado por ptr al valor especificado en value (interpretado como un unsigned char).. Sintaxis: void * memset ( void * ptr, int value, size_t num );

Reference:

En C++ también tenemos soporte a la clase cstring, que no debe confundirse con la <string.h>. Una de las ventajas que ofrece la clase cstring es que, a diferencia de las cadenas estándar, ésta posee la capacidad de crecer o disminuir su tamaño en tiempo de ejecución. Además, entre otras características destacables, la clase string soporta operaciones de asignación tales como: =, +, +=, etc.; y de comparación tales como: ==, <=, etc.

Documentacíon de la librería <string.h>: http://www.cplusplus.com/reference/cstring/

Clase string de C++: http://www.cplusplus.com/reference/string/string/

Ejercicio Strings_vs_strings: Partiendo de la base del ejercicio StringsComparisonOperators intentar hacer las operaciones de comparación de igualdad y distinto de los StringOne y StringTwo con string en lugar de String. Ver como es más complicado y para iniciarse en la programación es mejor usar String (objeto) que string (char array).

Solución: https://github.com/jecrespo/Aprendiendo-Arduino/tree/master/Ejercicio18-strings/_5-String_vs_string

Más información:

Ejercicios Avanzados  Strings

Ejercicio: Mandar un SMS mediante un módulo SIM800L, donde pido por consola el número y el mensaje en formato” <numero_telefono>-<mensaje>!”. Analizar esta cadena y separar en teléfono y mensaje y mandar mediante la función bool sendSms(char* number,char* text);

El primer análisis hacerlo con la clase String y luego pasar las variables teléfono y mensaje a char* que es lo que pide la librería.

Librería disponible en el gestor de librerías: https://github.com/VittorioEsposito/Sim800L-Arduino-Library-revised

HW: https://es.aliexpress.com/item/SIM800L-V2-0-5V-Wireless-GSM-GPRS-MODULE-Quad-Band-W-Antenna-Cable-Cap/32465895576.html

Solución: https://github.com/jecrespo/Aprendiendo-Arduino/tree/master/Ejercicio68-toCharArray

Ejercicio: Manejo de JSON mediante la librería disponible en el gestor de librerías ArduinoJson https://arduinojson.org y repositorio https://github.com/bblanchon/ArduinoJson

JSON: https://es.wikipedia.org/wiki/JSON

Abrir el ejemplo JsonParserExample de la librería y probarlo.

PROGMEM

El uso de strings como cadena de caracteres en Arduino, en lugar de usar la clase String, nos permite también almacenar los strings en la memoria flash en lugar de la SRAM gracias a PROGMEM https://arduino.cc/reference/en/language/variables/utilities/progmem/

A menudo es conveniente cuando se trabaja con grandes cantidades de texto, como un proyecto con una pantalla LCD o en comunicaciones, usar PROGMEM con arrays de strings.  Estos tienden a ser grandes estructuras, así que ponerlas en memoria de programa (flash) es a menudo deseable. El código siguiente ilustra la idea.

 
#include <avr/pgmspace.h>
const char string_0[] PROGMEM = "String 0";   // "String 0" etc are strings to store - change to suit.
const char string_1[] PROGMEM = "String 1";
const char string_2[] PROGMEM = "String 2";
const char string_3[] PROGMEM = "String 3";
const char string_4[] PROGMEM = "String 4";
const char string_5[] PROGMEM = "String 5";

// Then set up a table to refer to your strings.

const char* const string_table[] PROGMEM = {string_0, string_1, string_2, string_3, string_4, string_5};

char buffer[30];    // make sure this is large enough for the largest string it must hold

void setup()
{
  Serial.begin(9600);
  while(!Serial);
  Serial.println("OK");
}

void loop()
{
   for (int i = 0; i < 6; i++)
  {
    strcpy_P(buffer, (char*)pgm_read_word(&(string_table[i]))); // Necessary casts and dereferencing, just copy.
    Serial.println(buffer);
    delay( 500 );
  }
}

Utilidades de PROGMEM: https://www.nongnu.org/avr-libc/user-manual/group__avr__pgmspace.html

Usar la tabla de cadenas en la memoria de programa (flash) requiere el uso de funciones especiales para recuperar los datos. La función strcpy_P copia un string desde el espacio del programa (flash) en un string en la memoria RAM (“buffer”). Debemos asegurarnos de que la cadena de recepción en la memoria RAM es lo suficientemente grande como para alojar cualquier string que está recuperando desde el espacio del programa

Las funciones para manejar PROGMEM están en http://www.nongnu.org/avr-libc/user-manual/group__avr__pgmspace.html que podemos ver son iguales que las de <string.h>, pero seguidas de “_P”

Tener en cuenta que las variables deben ser definidas de forma global y como constantes, o definido con la palabra clave static, con el fin de trabajar con PROGMEM.

Recordar que podemos usar la macro F() junto con el métodos print y println de forma que todo lo que hay dentro de los métodos se guarda en la memoria flash.

Ejemplo: Serial.println(F(“This string will be stored in flash memory”));

Para saber como funciona PROGMEM ver  la pagina 347 y 354 de http://www.atmel.com/Images/Atmel-42735-8-bit-AVR-Microcontroller-ATmega328-328P_datasheet.pdf y donde lo metes lo de MEMPROG

Prácticas Repaso Arduino

Práctica: Ejemplos Básicos con Arduino

Repasar cada uno de los ejemplos básicos:

  • Leer entradas digitales
  • Leer entrada digital sin referencia externa
  • Leer entradas analógicas
  • Leer entrada analógica mejorada
  • Escribir salida analógica
  • Escribir salida digital con acción de un botón
  • Mejora de botón para evitar rebotes
  • Contar pulsaciones

Ejemplos básicos con Arduino: http://jecrespo.github.io/ArduinoBasicExamples/

Práctica: Detectar Flanco

Hacer un sistema de encendido y apagado de un led mediante una pulsación. Con una pulsación enciende y con otra apaga el led. Para hacer esto debemos detectar flancos al encender y apagar.

Usar la resistencia interna de pull up de Arduino para detectar la pulsación de un botón en el pin 2 (leer estado de una entrada digital) y encender/apagar el led puesto en el pin 10 (no olvidar la resistencia) al detectar un flanco ascendente. Adicionalmente sacar por el monitor serie el estado de pulsación del botón con un 1 (pulsado) o un 0 (no pulsado) y en la misma línea el estado del led con un 3 (led encendido) y 0 (led apagado), de esta forma abriendo el Serial Plotter es posible ver cuando se enciende y apaga el led al detectar flancos.

Esquema de conexión:

Resultado:

Solución Ejercicio01: https://github.com/jecrespo/aprendiendoarduino-Curso_Arduino_Avanzado_2017/tree/master/Ejercicio01-Detectar_Flanco

Solución a los Rebotes (Debounce)

Los rebotes son las falsas pulsaciones que se producen al hacer falsos contactos en el interruptor.

Para ello esperar un tiempo llamado debounceDelay para comprobar que el cambio de estado se mantiene y no son rebotes (ruido).

Para ello crear una variable “debounceDelay” que pueda cambiar su valor y sea el tiempo mínimo en ms que debe estar la señal estable para considerar que no es un rebote. En cada loop comprobar el tiempo desde el último cambio de estado de la señal digital y si es mayor que “debounceDelay” proceder a hacer las comprobaciones de flanco y encender o apagar el LED.

Más información https://www.arduino.cc/en/Tutorial/Debounce

Solución Ejercicio02: https://github.com/jecrespo/aprendiendoarduino-Curso_Arduino_Avanzado_2017/tree/master/Ejercicio02-Detectar_Flanco_Debounce

Otra forma de solucionar los rebotes por código:

http://miarduinounotieneunblog.blogspot.com.es/2016/01/pulsador-antirrebote-con-contador-de.html ¿véis algún problema con esta solución? Si hay ruido o la señal cambia continuamente, nunca sale del bucle y el programa no puede hacer otras cosas.

Solución: El código puede quedarse durante mucho tiempo en la función antirrebote(), bloqueado Arduino para hacer otras tareas.

Solucionar rebotes por HW:

Calculadora de valores para debouncing: http://protological.com/debounce-calaculator/

Práctica: Medir valor de un Condensador

Usar un Arduino para medir el valor de un Condensador. En este ejercicio se usan pines digitales de entrada y salida para manejar las corrientes y una entrada analógica para leer el voltaje.

Ver: https://www.arduino.cc/en/Tutorial/CapacitanceMeter

Esquema de conexión:

¡ATENCIÓN! Poner un condensador de 100uF y asegurarse de poner correctamente la polaridad. Símbolo – (patilla con símbolo – – – -) a masa.

La resistencia R tiene un valor de 10Kohms.

Al conectar un condensador en serie con una resistencia, a una fuente de tensión eléctrica (o comúnmente, fuente de alimentación), la corriente empieza a circular por ambos. El condensador va acumulando carga entre sus placas. Cuando el condensador se encuentra totalmente cargado, deja de circular corriente por el circuito.

TC = R * C

  • R resistencia de carga en ohms
  • C capacidad del condensador en faradios

Explicación del sketch:

  • Configurar el pin de descarga a INPUT (alta impedancia de modo que no pueda descargar el condensador). Pin 11.
  • Registre el tiempo de inicio con millis ()
  • Establecer el pin de carga en OUTPUT y ponerlo a HIGH. Pin 13.
  • Compruebe la tensión repetidamente en un bucle hasta que llegue a 63.2% de la tensión total.
  • Después de cargar, restar el tiempo actual de la hora de inicio para averiguar cuánto tiempo le costó al condensador para cargar.
  • Dividir el Tiempo en segundos por la resistencia de carga en ohmios para encontrar la Capacitancia.
  • Imprimir por serial el valor con serial.print
  • Descargue el condensador. Para hacer esto:
    • Poner a LOW el pin de carga en la entrada
    • Configurar el de descarga en OUTPUT y haga que sea LOW
    • Leer el voltaje para asegurarse de que el condensador está completamente descargado
    • Loop y hacerlo de nuevo

Para asegurarse que el condensador está descargado, asegurarse de quitar alimentación cuando lo indique el sketch por pantalla.

Solución Ejercicio03: https://github.com/jecrespo/aprendiendoarduino-Curso_Arduino_Avanzado_2017/tree/master/Ejercicio03-Medidor_Condensadores

Para ampliar la explicación del ejercicio https://www.arduino.cc/en/Tutorial/CapacitanceMeter

Más Prácticas

Otros ejemplos sencillos de prácticas con Arduino en https://aprendiendoarduino.wordpress.com/2017/07/04/ejemplos-sencillos-arduino/, usando este montaje de prácticas https://aprendiendoarduino.wordpress.com/2017/07/02/montaje-practicas/

  • Leer LDR
  • Contar Pulsos
  • Mover Servo

Proyectos Básicos con Arduino

Proyectos básicos de programación Arduino con mBlock. mBlock es un entorno gráfico de programación por bloque para Arduino, que permite introducir de forma sencilla la programación y robótica en el aula.

mBlock se compone de 5 partes principalmente:

  • Grupo de instrucciones clasificadas por colores en las siguientes categorías:
    • Movimiento: Conjunto de instrucciones relacionadas con el control de los pines de la tarjeta de Arduino, así como el control del movimiento de cualquier personaje del escenario.
    • Apariencia: Instrucciones orientadas a modificar el aspecto de los personajes de nuestra aplicación. Para el caso de Arduino, es un conjunto de instrucciones que apenas se utiliza.
    • Sonido: Conjunto de instrucciones relacionadas con la elaboración de aplicaciones musicales, emitiendo sonidos y notas musicales.
    • Lápiz: Scratch nos ofrece la posibilidad de que los personajes dejen un rastro durante sus movimientos por el escenario como si arrastrase un lápiz durante su trayectoria.
    • Control: Las instrucciones incluídas en esta sección son impresindibles para crear la lógica de nuestros programas. Incluyen condicionales, bucles y llamadas de procedimientos.
    • Sensores: Instrucciones de iteración con el ratón, el teclado, sonidos y los personajes.
    • Operadores: operaciones matemáticas, lógicas y con cadenas de texto.
    • Variables: Instrucciones para el almacenamiento y gestión de datos.
  • Instrucciones de programación: Las instrucciones de cada grupo corresponden a instrucciones de programación.
  • Editor: Es la parte principal donde estructuramos y programamos nuestro programa.
    • Programas: Se compone de todas las instrucciones que hace funcionar el código que programemos.
    • Disfraces: Cada objeto puede tener diferentes apariencias o disfraces para utilizar a lo largo de nuestro programa.
    • Sonido: También es posible añadir o grabar sonidos y guardarlos para futuros usos.
  • Escenario o ventana principal: Es el resultado de nuestro programa.
  • Objetos y sprites: Distinguimos principalmente los objetos de tipo Arduino y Sprites.
    • Los objetos de tipo arduino son aquellos que interactuán con Arduino.
    • Los sprites son similares al entorno de scratch y no interactúan con Arduino.

Instalar mBlock es muy sencillo, toda las instrucciones están disponibles desde la web: https://www.makeblock.es/soporte/mblock/

Web de descarga: http://www.mblock.cc/software/

mBlock ha sacado una beta de un entorno de programación on-line en http://editor.makeblock.com/ide.html

Más información sobre mBlock: https://aprendiendoarduino.wordpress.com/2017/09/08/programacion-visual-con-mblock/

Modo Ejecutar Programa desde PC

En este modo es necesario siempre tener el Arduino o el robot siempre conectado al PC.

Para usar este modo comenzaremos el programa con un bloque de la categoría “Eventos”, normalmente con el bloque de la bandera verde. Y debajo de este colocamos el resto de bloques del programa.

Para ejecutar el programa desde el PC, primero tenemos que seleccionar la placa y el puerto serie al que esté conectado el Arduino. Conectamos el cable USB al Arduino y seleccionamos la placa en “Placas->Arduino UNO” y el puerto en “Conectar->Puerto Serie”.

A continuación “Conectar > Actualizar Firmware” y esperamos a que termine de cargarlo.

Tutoriales de uso:

Modo Subir Programa a Arduino

En este modo no cargamos un firmware a la placa sino que sube el programa al Arduino. En este modo usamos como inicio del programa el bloque “Programa de Arduino” que se encuentra en la categoría “Robots”.

Para este modo pulsamos sobre el bloque “Programa de Arduino”  o vamos a “Editar->Modo Arduino”. En la parte derecha de la pantalla aparecerá una pantalla con algunas opciones nuevas y el equivalente en código del programa que hemos hecho con los bloques.

Luego para subir el sketch al ordenador pulsamos sobre el botón “Subir a Arduino” y esperamos a que termine de cargar.

Tutorial para usar Arduino con mBlock:

Más información:

Semáforo Simple

En esta práctica vamos a crear un semáforo simple con una frecuencia de cambio de 5 segundos en verde y rojo, y 1 segundo durante su estado en ámbar.

Tutorial: https://github.com/ElCableAmarillo/Listado-de-practicas/tree/master/Salidas-digitales/Sem%C3%A1foro-simple

Movimiento de un Servomotor

En esta práctica el servomotor se mueve desde su posición origen a su posición final en ángulos de 10° repetidamente.

Tutorial: https://github.com/ElCableAmarillo/Listado-de-practicas/tree/master/Salidas-anal%C3%B3gicas/Movimiento-de-un-servomotor

Pulsador Simple

En esta práctica vamos a programar un interruptor para encender un led en un momento dado.

Tutorial: https://github.com/ElCableAmarillo/Listado-de-practicas/tree/master/Entradas-digitales/Pulsador-simple

Detectando Colores

En esta práctica tenemos que detectar los colores por los cuales se mueve nuestro personaje para activar los diferentes diodos Led de la placa de prototipado.

Tutorial: https://github.com/ElCableAmarillo/Listado-de-practicas/tree/master/Pr%C3%A1cticas-de-iniciaci%C3%B3n/mBlock/Detectando-colores

Brújula con Servo

En esta práctica vamos a mover un servo mediante las flechas del teclado y activando sendos diodos Led al final de carrera.

Tutorial: https://github.com/ElCableAmarillo/Listado-de-practicas/tree/master/Pr%C3%A1cticas-de-iniciaci%C3%B3n/mBlock/Br%C3%BAjula-con-servo

Más sobre programación por bloques en el Taller de Programación Visual Arduino: https://www.aprendiendoarduino.com/talleres-arduino/arduino-day-2018-logrono/taller-programacion-visual-arduino/

Más información:

Uso de Motores con Arduino

Motor DC Básico

Mover un motor DC variando la velocidad y sentido mediante un potenciómetro.

Basado en http://diymakers.es/control-velocidad-y-sentido-de-motor-dc/

Esquema de conexión.

Señales mandadas desde Arduino:

Solución: https://github.com/jecrespo/aprendiendoarduino-Curso_Arduino_2017/tree/master/Ejercicio25-MotorDC_Basico

Ver las señales reales con un osciloscopio en los pines 9 y 10 y en la alimentación del motor.

Mover Servo

Controlar la posición de un servo con un potenciómetro.

Esquema de conexión:

Esquemático:

Tutorial: http://arduino.cc/en/Tutorial/Knob

Solución: https://github.com/jecrespo/aprendiendoarduino-Curso_Arduino_2017/tree/master/Ejercicio27-Servo

Barrido con Servo

Programar un barrido continuo del 0 a 180º en un servo. Activar y desactivar el barrido con una pulsación de un botón. p.e. activación de un limpiaparabrisas. Hacer tres velocidades de barrido, cada pulsación sube de velocidad y la cuarta lo para.

Tutorial: http://arduino.cc/en/Tutorial/Sweep

Solución: https://github.com/jecrespo/aprendiendoarduino-Curso_Arduino_2017/tree/master/Ejercicio28-Barrido_Servo

Servo Serial

Controlar la posición del servo como en el ejercicio “Mover servo” pero en lugar de hacerlo con un potenciómetro, hacerlo desde el puerto serie mandando el ángulo al que debe ir. Desde el monitor serie pregunta la posición y se manda un valor entre 0 y 180.

De la misma forma que controlamos desde el puerto serie, se puede extender a controlar el servo desde una aplicación en un ordenador o desde una página web.

Esquema de conexión:

Solución: https://github.com/jecrespo/aprendiendoarduino-Curso_Arduino_2017/tree/master/Ejercicio29-Servo_Serial

Mover un Servo con un Acelerómetro

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

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

Para esta práctica vamos a utilizar una Breakout board bastante típica llamada GY-521, que incluye la IMU MPU-6050 y un regulador de tensión, con lo que podemos alimentar a tanto 3.3V como a 5V.

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

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

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

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

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

Esquema de conexión IMU:

Esquema conexión servo:

Mover el servo en función del ángulo en el eje x obtenido de la IMU.

Solución: https://github.com/jecrespo/aprendiendoarduino-Curso_Arduino_2017/tree/master/Ejercicio30-Servo_IMU

Motor Paso a Paso

Mover un motor paso a paso modelo 28BYJ-48 con su adaptador basado en el chip ULN2003A.

El 28BYJ-48 tiene un paso de 5.625 grados (64 pasos por vuelta). El reductor interno tiene una relación de 1/64. Combinados, la precisión total es de 4096 pasos por vuelta, equivalente a un paso de 0.088º, que es una precisión muy elevada.

Es un motor paso a paso unipolar con las siguientes características:

  • Tensión nominal de entre 5V y 12 V.
  • 4 Fases.
  • Resistencia 50 Ω.
  • Par motor de 34 Newton / metro más o menos 0,34 Kg por cm.
  • Consumo de unos 55 mA.
  • 64 pasos por vuelta (con medios pasos).
  • Reductora de 1 / 64.

Datasheet: http://robocraft.ru/files/datasheet/28BYJ-48.pdf

Vamos a usar la secuencia de medios pasos. Con esta secuencia conseguimos una precisión de la mitad del paso. El par desarrollado varía ya que en algunos pasos activamos dos bobinas y en otras solo una, pero a la vez el giro se encuentra más “guiado”, por lo que en general ambos efectos se compensan y el funcionamiento es bueno, salvo en aplicaciones donde estemos muy al límite del par máximo.

Expresando la secuencia en forma de tabla resulta:

Medio-paso A B A’ B’
1 ON OFF OFF OFF
2 ON ON OFF OFF
3 OFF ON OFF OFF
4 OFF ON ON OFF
5 OFF OFF ON OFF
6 OFF OFF ON ON
7 OFF OFF OFF ON
8 ON OFF OFF ON

Modo de medio paso: secuencia de señal de control 8 pasos (recomendada) 5.625 grados por paso / 64 pasos por una revolución del eje del motor interno. Relación de transmisión 64. Total 64 x 64 = 4096 pasos.

Modo de paso completo: secuencia de señal de control de 4 pasos 11.25 grados por paso / 32 pasos por una revolución de la interna eje de motor. Relación de transmisión 64. Total 64 x 32 = 2048 pasos.

Esquema de conexión:

Conexiones de la placa de driver:

Ejercicio basado en http://www.prometec.net/motor-28byj-48/

Otros tutoriales:

Solución: https://github.com/jecrespo/aprendiendoarduino-Curso_Arduino_2017/tree/master/Ejercicio31-Stepper

La otra manera de programar un motor 28BYJ-48 es utilizar la librería Steper que viene incluida con el entorno de desarrollo oficial de Arduino. Esta librería nos facilita el uso de este tipo de motores y viene adaptada para motores bipolares. En este caso la librería stepper usa el modo de paso completo en lugar del medio paso. En este caso el nº de pasos por vuelta es 2048.

Llevando esta secuencia de encendido a una tabla, que posteriormente usaremos para el código, la secuencia quedaría de la siguiente forma:

Paso A B A’ B’
1 ON OFF OFF OFF
2 OFF ON OFF OFF
3 OFF OFF ON OFF
4 OFF OFF OFF ON

Código para mover el motor:

 
#include <Stepper.h>
#define STEPS 2048

Stepper stepper(STEPS, 8, 9, 10, 11);

void setup() {
  stepper.setSpeed(10);
}

void loop() {
  stepper.step(2048);
}