Archivo de la categoría: Práctica

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:

Anuncios

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);
}

Ejemplos Entradas y Salidas Digitales

Input Pullup

Usar la resistencia interna de pull up de Arduino para detectar la pulsación de un botón (leer estado de una entrada digital) y encender el led 13 (integrado en placa) cuando tenga pulsado el botón y apagarlo cuando lo libere. Adicionalmente sacar por el monitor serie el estado de pulsación del botón con un 1 o un 0, de esta forma abriendo el Serial Plotter es posible ver la señal que recibe Arduino.

Imprimir por pantalla el tiempo de loop, que nos servirá para analizar la importancia de este tiempo en el comportamiento del programa.

NOTA: Al contrario que en anteriores prácticas, usamos un botón conectado al pin digital 2 configurado como INPUT_PULLUP. En este caso al leer el pin 2 con digitalRead() me devuelve 1 cuando no está pulsado el botón (abierto) y me devuelve 0 cuando está pulsado el botón (cerrado)

Esquema de conexión:

Diagrama eléctrico:

Resultado:

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

Solución: https://github.com/jecrespo/aprendiendoarduino-Curso_Arduino_2017/tree/master/Ejercicio16-pullup

NOTA: Ver efecto de la diferencia del tiempo de loop cuando pulso o no pulso el botón debido a el Serial.println que se ejecuta al pulsar el botón.

NOTA: Si el tiempo de loop es muy largo podemos perder pulsaciones rápidas. Probar a poner un delay.

Interruptor

Con la base del ejemplo anterior pero en lugar de mantener pulsado el botón para encender el led, con una pulsación enciende y con otra apaga el led. Ahora el led ponerlo en el pin 10 en lugar del 13. Para hacer esto debemos detectar flancos para encender y apagar.

Más información sobre como detectar flancos: http://rufianenlared.com/flancos/

Esquema de conexión:

Resultado:

Solución: https://github.com/jecrespo/aprendiendoarduino-Curso_Arduino_2017/tree/master/Ejercicio17-pullup_interruptor

Función Detecta Flanco

Hacer tres funciones para detectar que hagan las siguientes funciones y que se le pase como parámetro el pin donde detectar el flanco:

  • Detectar flanco ascendente
  • Detectar flanco descendente
  • Detectar flanco. Devuelve 1 para un flanco ascendente y un -1 para un flanco descendente.

Para usar estas funciones, deben llamarse en cada loop y para no perder un flanco, deben llamarse como máximo cada 300 ms.

Usarla en el ejemplo anterior del interruptor.

Solución:

Comprobar que si quiere detectar flanco en dos pines con una misma función no es posible. Para solucionarlo es necesario usar clases.

Solución:

Contador de pulsos

Usar Arduino para contar pulsaciones de un pulsador. Modificar el ejemplo anterior para contar el número de veces que se pulsa un botón detectando flancos ascendentes o descendentes y sacarlo por el monitor serie. Adicionalmente encender o apagar el led cada vez que haya 4 pulsaciones del botón.

NOTA: comprobar los rebotes y pensar cómo eliminarlos.

Solución: https://github.com/jecrespo/aprendiendoarduino-Curso_Arduino_2017/tree/master/Ejercicio18-cuentapulsos

Ejemplos Arduino con Arrays y Strings

Efectos con leds mejorado

El ejemplo anterior de los LEDs con el efecto del coche fantástico puede hacerse de una forma más eficiente con el uso de los arrays y la estructura de control for. Además hacer otros efectos de luces o cambios en el realizado es mucho más sencillo usando arrays.

Hacer el efecto del coche fantástico usando arrays y la estructura de control for.

Pistas:

 
int pinArray[] = {2, 3, 4, 5, 6};

for (int i = 0; i < 6; i++) {
    digitalWrite(pinArray[i], HIGH);
    delay(timer);
    digitalWrite(pinArray[i], LOW);
    delay(timer);
  }

O simplificado:

 
for (int i = 2; i <= 6; i++) {
    digitalWrite(i, HIGH);
    delay(timer);
    digitalWrite(i, LOW);
    delay(timer);
  }

Tutorial: https://www.arduino.cc/en/Tutorial/KnightRider

Estructura de control for: https://www.arduino.cc/en/Reference/For

Esquema de conexión:

Solución: https://github.com/jecrespo/aprendiendoarduino-Curso_Arduino_2017/tree/master/Ejercicio09-CocheFantasticoMejorado

Control Velocidad del Efecto de Leds

Añadir el cambio de velocidad dentro del código al leer de un potenciómetro de forma que no haya que esperar a un ciclo de loop para cambiar la velocidad: “timer = analogRead(A0);”

Esquema de conexión:

O usando un LDR para el control de velocidad:

Solución: quitar los comentarios de https://github.com/jecrespo/aprendiendoarduino-Curso_Arduino_2017/tree/master/Ejercicio09-CocheFantasticoMejorado

Probar a hacer otros efectos como: https://github.com/jecrespo/Aprendiendo-Arduino/tree/master/Ejercicio48-Efectos_Led

Arrays

Leer las entradas analógicas de la A0 a la A5 y almacenar en un array para mostrarlo cada 5 segundos. Hacer lo mismo con las entradas digitales de la 2 a la 7.

Solución: https://github.com/jecrespo/aprendiendoarduino-Curso_Arduino_2017/tree/master/Ejercicio49-Arrays

Leer Strings por Puerto Serie

Aprender a manejar cadenas de caracteres es muy importante, a lo largo del curso se va a usar muy a menudo para comunicaciones y para interaccionar con el usuario.

Tutoriales para aprender a usar los Strings:

Hacer un programa donde al iniciar Arduino pregunta que introduzca un string cualquiera y lo mando a Arduino por puerto serie usando el monitor serie. Luego lo almacena en una variable y muestra lo leído por el puerto serie.

No olvidar poner en el setup() la inicialización del puerto serie: Serial.begin(9600);

Para leer por el puerto serie usar este código:

 
String cadena_leida;

while (Serial.available() == 0){
    //No hago nada
  }
  do{
    caracter_leido = Serial.read();
    cadena_leida += caracter_leido;
    delay(5);
  }  while (Serial.available() > 0);

La función Serial.available() me devuelve el número de bytes (caracteres) disponibles para leer del puerto serie. Estos son datos que han llegado al puerto serie de Arduino y se almacenan en el buffer de lectura de la UART. Más información: https://www.arduino.cc/en/Serial/Available

Serial.read() lee un caracter del puerto serie y los quita del buffer. Más información: https://www.arduino.cc/en/Serial/Read

NOTA para entender lo que está haciendo el programa poner la constante DEBUG a valor 1

Solución: https://github.com/jecrespo/aprendiendoarduino-Curso_Arduino_2017/tree/master/Ejercicio10-LeerStringSerie

Encender LED por Puerto Serie

Modificar el ejemplo anterior para que encienda el led de Arduino (pin 13) cuando mande la cadena “enciende” y lo apague cuando mande la cadena “apaga”.

Esquema de conexión:

Para comparar el texto introducido se proponen dos opciones, probar con ambas:

 
if (leido.startsWith("enciende"))

if (leido == "enciende")

Solución: https://github.com/jecrespo/aprendiendoarduino-Curso_Arduino_2017/tree/master/Ejercicio11-EncenderLedSerie

NOTA: Al igual que leemos y analizamos un valor con lo recibido por el puerto serie, la forma de trabajar si la comunicación es por ethernet, wifi, bluetooth, XBee, etc… es la misma, Arduino está escuchando por el puerto de comunicación y cuando recibe una petición válida ejecuta una acción. Los módulos de comunicación hablan con el microcontrolador a través los puertos serie (UART), I2C o SPI, cuyo funcionamiento es similar a lo visto en estas dos últimas prácticas.

Ejemplos Arduino con Estructuras de Control

Alarma Umbral

Partiendo del sketch https://www.arduino.cc/en/Tutorial/ifStatementConditional modificarlo para que en lugar de encender un led cuando supere el valor de umbral, simular un envío de un mensaje de alarma mediante Serial.println() cada vez que haya una alarma y se supere el umbral (solo cuando lo sobrepase la primera vez, no de forma continua) y otro mensaje de recuperación cada vez el valor este por debajo del umbral (solo cuando baje la primera vez, no de forma continua).

Esquema de conexión:

Ejecutar el sketch https://www.arduino.cc/en/Tutorial/ifStatementConditional y comprobar su funcionamiento.

El siguiente paso es añadir un texto de alarma y recuperación cuando se supere y cuando esté por debajo. Una vez comprobado que manda continuamente el texto, pensar cómo modificar el sketch para que lo mande solo cuando se supera la primera vez o cuando vuelve al estado normal la primera vez. Esto también sirve para para usar el digitalWrite una vez en lugar de hacerlo continuamente.

Diagrama de flujo:

Solución: https://github.com/jecrespo/aprendiendoarduino-Curso_Arduino_2017/tree/master/Ejercicio07-Detectar_Alarma

Solución Visualino:

Ver en el serial plotter la representación gráfica de lo que está ocurriendo.

  • rojo: umbral
  • verde: estado alarma
  • azul: lectura del potenciómetro

Si comentamos la zona de “print values” veremos que solo se imprime por pantalla “alarma” y “alarma recuperada” cuando se pasa por el umbral, pero no continuamente.

Histéresis

Comprobar el efecto del programa cuando estamos justo en el umbral donde tendremos continuas alarmas y recuperaciones. Para solucionar esto añadir histéresis.

Diagrama de flujo:

Solución: https://github.com/jecrespo/aprendiendoarduino-Curso_Arduino_2017/tree/master/Ejercicio08-Detectar_Alarma_Histeresis

Solución Visualino:

Cambio de comportamiento con un umbral medio de 400 y una histéresis de 50. Ver como cambia el umbral al pasar de estado de alarma a recuperado y viceversa.

Hacer este mismo ejemplo con la sonda de temperatura TMP36 https://www.arduino.cc/documents/datasheets/TEMP-TMP35_36_37.pdf con y sin histéresis.

Esquema de conexión:

Más ejemplos en: https://www.arduino.cc/en/Tutorial/BuiltInExamples