Siempre creciendo, siempre aprendiendo. Cultura Maker.

Ratio: 1 / 5

Inicio activadoInicio desactivadoInicio desactivadoInicio desactivadoInicio desactivado

¡Saludos, estudiantes!. ¡Bienvenidos!. ¡Pasad!, ¡pasad!. ¡Me alegro mucho de veros otra vez!.

En esta ocasión, vamos a tratar de llevar a cabo una práctica que nos sirva de introducción al puerto serie de Arduino. Ya hemos hecho algo así en otro texto en el que teníamos como intención realizar alguna cosita con Bluetooth en un segundo paso. Como el hombre propone y Dios dispone, esa intención de momento no ha abandonado el cielo de los buenos propósitos para encarnarse en un artículo como Dios manda. Sin embargo, y aprovechando que en estas fechas estoy introduciendo a mi alumnado de 4º de ESO de Tecnología Robótica al uso de este utilísimo puerto, vamos a enfocar este mismo aspecto de nuestra queridísima Arduino desde un punto de vista mucho más simplón.

arduino serial port

Ratio: 0 / 5

Inicio desactivadoInicio desactivadoInicio desactivadoInicio desactivadoInicio desactivado

MEDIR DISTANCIAS POR ULTRASONIDOS MEDIANTE EL SENSOR HC-SR04

El código referente a la medida de distancias con ultrasonidos es original de Luis Llamas (lo he modificado para que envíe los datos vía Bluetooth), y lo podéis encontrar aquí.

El sensor de ultrasonidos se conecta así:

arduino-ultrasonidos-montaje

El código para medir y enviar distancias al smartphone es éste:

[code][/code]
[code]
//CÓDIGO ARDUINO PARA MEDIR DISTANCIAS CON HC-SR04
const int EchoPin = 9;
const int TriggerPin = 8;
const int LedPin = 13;
 
void setup() {
   Serial.begin(19200);
   pinMode(LedPin, OUTPUT);
   pinMode(TriggerPin, OUTPUT);
   pinMode(EchoPin, INPUT);
}
 
void loop() {
   int cm = ping(TriggerPin, EchoPin);
   Serial.print(cm);
   Serial.println();
   delay(100);
}
 
int ping(int TriggerPin, int EchoPin) {
   long duration, distanceCm;
  
   digitalWrite(TriggerPin, LOW);  //para generar un pulso limpio ponemos a LOW 4us
   delayMicroseconds(4);
   digitalWrite(TriggerPin, HIGH);  //generamos Trigger (disparo) de 10us
   delayMicroseconds(10);
   digitalWrite(TriggerPin, LOW);
  
   duration = pulseIn(EchoPin, HIGH);  //medimos el tiempo entre pulsos, en microsegundos
  
   distanceCm = duration * 10 / 292/ 2;   //convertimos a distancia, en cm
   return distanceCm;
}
//HASTA AQUÍ EL CÓDIGO
[/code]

SENSOR DE TEMPERATURA Y HUMEDAD DHT11

A continuación, para usar el detector de Temperatura y Humedad (hay que instalar una librería, y quizás no seamos capaces; dejaremos esta parte de la práctica para el final), necesitaremos una resistencia de 10 kΩ para conectarlo:

https://i.pinimg.com/originals/05/b4/90/05b490d00ccdde123f4e833138436707.png

Y el código:

//CÓDIGO PARA USAR SENSOR DE TEMPERATURA Y HUMEDAD DHT11
// Example testing sketch for various DHT humidity/temperature sensors
// Written by ladyada, public domain

#include "DHT.h"

#define DHTPIN 2 // what digital pin we're connected to

// Uncomment whatever type you're using!
#define DHTTYPE DHT11 // DHT 11
//#define DHTTYPE DHT22 // DHT 22 (AM2302), AM2321
//#define DHTTYPE DHT21 // DHT 21 (AM2301)

// Connect pin 1 (on the left) of the sensor to +5V
// NOTE: If using a board with 3.3V logic like an Arduino Due connect pin 1
// to 3.3V instead of 5V!
// Connect pin 2 of the sensor to whatever your DHTPIN is
// Connect pin 4 (on the right) of the sensor to GROUND
// Connect a 10K resistor from pin 2 (data) to pin 1 (power) of the sensor

// Initialize DHT sensor.
// Note that older versions of this library took an optional third parameter to
// tweak the timings for faster processors. This parameter is no longer needed
// as the current DHT reading algorithm adjusts itself to work on faster procs.
DHT dht(DHTPIN, DHTTYPE);

void setup() {
Serial.begin(9600);
Serial.println("DHTxx test!");

dht.begin();
}

void loop() {
// Wait a few seconds between measurements.
delay(2000);

// Reading temperature or humidity takes about 250 milliseconds!
// Sensor readings may also be up to 2 seconds 'old' (its a very slow sensor)
float h = dht.readHumidity();
// Read temperature as Celsius (the default)
float t = dht.readTemperature();
// Read temperature as Fahrenheit (isFahrenheit = true)
float f = dht.readTemperature(true);

// Check if any reads failed and exit early (to try again).
if (isnan(h) || isnan(t) || isnan(f)) {
Serial.println("Failed to read from DHT sensor!");
return;
}

// Compute heat index in Fahrenheit (the default)
float hif = dht.computeHeatIndex(f, h);
// Compute heat index in Celsius (isFahreheit = false)
float hic = dht.computeHeatIndex(t, h, false);

Serial.print("Humidity: ");
Serial.print(h);
Serial.print(" %\t");
Serial.print("Temperature: ");
Serial.print(t);
Serial.print(" *C ");
Serial.print(f);
Serial.print(" *F\t");
Serial.print("Heat index: ");
Serial.print(hic);
Serial.print(" *C ");
Serial.print(hif);
Serial.println(" *F");
}
//HASTA AQUÍ EL CÓDIGO

 
USO DE SENSORES DE DOBLADO (FLEX SENSORS):

Son resistencias que varían su valor CUANDO SE DOBLAN. Así las cosas, necesitaremos conectarlas en divisor de tensión (al modo en que lo hacemos con las LDR a una de las entradas analógicas de nuestra Arduino, por ejemplo, con una resistencia de 10 kΩ:

Example circuit fritzing diagram

Y utilizar un código para leer el valor. El más sencillo sería éste:

void setup() {
// put your setup code here, to run once:
Serial.begin(19200);
}

void loop() {
// put your main code here, to run repeatedly:
int valor=analogRead(A1);
Serial.println(valor);
delay(100);
}
//HASTA AQUÍ EL CÓDIGO

¡Y ya está!. ¡Eso sería todo por hoy!. ¿Qué os ha parecido?. ¡El próximo día, más y mejor!.

Ratio: 0 / 5

Inicio desactivadoInicio desactivadoInicio desactivadoInicio desactivadoInicio desactivado

¡Hola, chicos!. ¡Pasad!. ¡Pasad!. ¡Hacía mucho que no veníais a visitarme!. ¡Poneos cómodos!.

Hoy quiero mostraros un pequeño montaje que se me ocurrió viendo un artículo de Leantec en el que hacían un pasador de diapositivas con un detector de ultrasonidos y una Arduino Leonardo. Como no encuentro por ninguna parte el único ejemplar de esta tarjeta que tengo, y los sensores de ultrasonidos son bastante más caros, se me ocurrió utilizar resistencias LDR (variables con la luz) en un montaje que tiene un enfoque distinto: un detector de barrido izquierda-derecha como el del vídeo, conectado a un programa en Processing (luego me enteré que los amigos de @JuegosRobotica habían lanzado este mismo reto en Twitter, pero eso es otra historia).

Ratio: 5 / 5

Inicio activadoInicio activadoInicio activadoInicio activadoInicio activado

¡Hombreeeee, qué sorpresaaaaa!. ¡Cuánto tiempo sin veros por aquí!. ¡Pasad!, ¡pasad!. ¡Me alegro mucho de veros!.

Hoy vamos a aprovechar una característica muy útil que incorporan nuestras placas Arduino, y que muchas veces no aprovechamos en todo su potencial: el puerto serie. Y para ello, acabaremos haciendo una práctica muy sencilla en la que encenderemos o apagaremos un led RGB mediante una aplicación en nuestro móvil a través de Bluetooth.

El puerto serie

El puerto serie es el modo de comunicarse de Arduino con nuestro ordenador, a través del cable USB. Podría intentar profundizar un poco en su estructura y funcionalidad, pero hoy tengo algo de prisa. Además, posiblemente escribiría un texto muy por debajo de tutoriales como éste de Luis LLamas. ¡Echadle un vistazo después, si queréis!. ¡Está muy bien!

Lo que a nosotros nos interesa, a grandes rasgos, es que Arduino puede enviar y recibir datos de nuestro ordenador cuando está conectado a través del cable USB. Para ello, en el IDE de Arduino, tenemos que pulsar en el siguiente botón:

 

Ya hemos hecho alguna práctica al respecto, como por ejemplo la del sistema automático de iluminación por LDR. Pero hasta ahora, sólo habíamos utilizado el puerto Serie como un canal de SALIDA, esto es, para que Arduino ofreciera datos al ordenador. Nuestra intención hoy es aprender a utilizarlo también como canal de ENTRADA, de modo que podamos dar instrucciones a nuestra placa. Cuando nos hayamos familiarizado con estos conceptos, usaremos este canal de comunicación vía ondas de radio, a través de un canal Bluetooth.

Ratio: 5 / 5

Inicio activadoInicio activadoInicio activadoInicio activadoInicio activado

¡Saludos, estudiantes!

El tutorial de hoy será bastante corto, dado que estoy de profesor de guardia (para los legos, una guardia de aula es una hora lectiva en la que un par de profesores están disponibles para realizar sustituciones o responder a cualquier imprevisto que suceda durante esa hora). De momento, no hay mucho movimiento en el instituto... ¡A ver lo que dura!.

El objetivo de este artículo es generar la documentación que me pide mi amigo y compañero Juanjo Ruano , que es uno de los pioneros que ha gastado su tiempo en imprimir en 3D mi humilde brazo robótico artesanal, y que ahora quiere poder controlar mediante dos joysticks.

Cuando me pidió información sobre el asunto, mi lado perezoso le hizo ver que ya tenía documentación para controlar el brazo por potenciómetros, como éste:

(la documentación la tenéis aquí), en la carpeta controlServosPotenciómetro, ¡e incluso mediante una app que controlaba a la Arduino por Bluetooth!, (como podéis ver al principio de este otro vídeo que aparecía en el artículo anterior):

(NOTA AL PIE: En este punto en el que me sigues leyendo, amable lector, había escrito ya hasta la tercera parte de lo que es el artículo final; como lo estoy haciendo a través de la wifi del instituto, que tan amablemente nos "capó" la Administración con un cortafuegos Fortinet pegajoso, caprichoso y mal configurado, me ha cortado la conexión inopinadamente con la siempre agradable y emocionante sensación que te invade cuando has perdido el larguísimo texto que estaba escribiendo; gracias por tanto, Fortinet).

Volvemos al punto en el que estábamos. Decía que al final me picó la curiosidad. Mediante Whatsapp, estuvimos discutiendo qué pretendíamos hacer en realidad. Juanjo hablaba de controlar el brazo mediante UN solo joystick. Yo le hice notar que el brazo tiene TRES grados de LIBERTAD (sin contar con la pinza, cuyo control obviaremos en este artículo porque nuestro objetivo es comprender la lógica de este sistema), y que un joystick sólo puede proporcionarnos información en sus dos ejes X e Y. Así pues, la elección era obvia: necesitamos al menos dos joystick.

(2ª NOTA AL PIE: Me ha ocurrido lo mismo. Como ahora guardo más repetidamente, sólo he perdido cinco minutos).

Investigando un poco sobre los modelos de joystick disponibles para Arduino y placas similares, y salvando los modelos más complejos, la gran mayoría precisa como mínimo de CUATRO patillas:

  • Vcc (alimentación, 5 V normalmente).
  • Gnd (Tierra, polo negativo... ya hemos hablado de esto suficientes veces).
  • Eje X: en esta patilla, el potenciómetro asociado al eje X devolverá un valor analógico entre 0 V y la alimentación (5 V, necesariamente) que el convertidor A/D de nuestra Arduino convertirá a un valor entre 0 y 1023. Este valor luego deberá transformarse a otro rango entre 0 y 180 º para la posición del servomotor mediante la instrucción map (valor, 0,1023,0,180).
  • Eje Y: lo mismo que el eje X.
  • (OPCIONAL)Botón digital: en muchos modelos de joystick se incorpora un pulsador en pull-up que devuelve 5 V cuando se pulsa la palanca hacia abajo. Nosotros no incluiremos esta posibilidad, de momento, por razones de simplicidad.

Por otro lado, nuestro brazo robot dispone de tres servos: uno para el giro en la base, otro para el brazo principal y otro para el brazo auxiliar. Dichos servos se conectarán a las patillas 9, 10 y 11 de nuestra Arduino UNO. 

Cada servo será gobernado por un eje de un joystick. Así, el primer joystick gobernará los servos 9 y 10 (base y brazo principal), y el eje X del segundo joystick gobernará el brazo auxiliar 11(dejamos el eje Y para posteriores ampliaciones, aunque en nuestro esquema ya está conectado).

Veamos el esquema de conexionado:

brazoporPotenciometros bb

 

Las tres entradas de los joystick se conectarán, respectivamente, a las entradas A0, A1 y A2 de la Arduino. Como anécdota, me gustaría recordaros que estas patillas suelen acabar averiándose con el uso. He incorporado en el código una salida por el puerto Serial para que podáis ver si leen correctamente los resultados de las palancas. Si no fuera así en algún caso, cambiar la patilla en el conexionado y en el código.

 

Y a continuación, el código a verter en nuestra querida Arduino. No es excesivamente complicado, dado que ya hemos visto en otros artículos como puede leerse una entrada analógica y como puede transformarse mediante la instrucción map. A grandes rasgos, el algoritmo consiste en :

  • Conectar y declarar los tres servos motor1, motor2, motor3
  • Declarar las variables que recogerán el valor de los potenciómetros valor1, valor2, valor3, y que se leerán con el comando analogRead(Ax)
  • Declarar las variables que decidirán el ángulo correspondiente en los servomotores posicion1, posicion2, posicion3 que transformarán los valores anteriores mediante el comando posicionx=map(valorx,0,1023,0,180)
  • Escribir dichos valores en los servos, y vuelta a empezar.

¡Ya verás! ¡Es muy fácil!. A continuación, el código:

 

#include<Servo.h>
//Declaramos los servos
Servo motor1,motor2,motor3;
//Declaramos los valores leidos por los potenciometros
int valor1, valor2, valor3;
//Declaramos las posiciones que escribiremos en cada servo (0-180)
int posicion1,posicion2,posicion3;
void setup() {
  // put your setup code here, to run once:
Serial.begin(9600);
pinMode(8,INPUT);
motor1.attach(9);
motor2.attach(10);
motor3.attach(11);
motor1.write(90);
motor2.write(90);
motor3.write(90);
}

void loop() {
//Leemos los valores en los dos joysticks: 
valor1=analogRead(A1);
 valor2=analogRead(A2);
 valor3=analogRead(A3);
 //Pasamos dichos valores por el puerto serie a efectos de monitorizacion
Serial.print(valor1);
Serial.print("\t");
Serial.print(valor2);
Serial.print("\t");
Serial.println(valor3);

posicion1=map(valor1,0,1023,0,180);
posicion2=map(valor2,0,1023,0,180);
 posicion3=map(valor3,0,1023,0,180);
motor1.write(posicion1);
motor2.write(posicion2);
motor3.write(posicion3);
delay(100);
}

Como puedes ver, es sencillo. ¡Ahora es tu turno!. ¡Prueba tú!. Para cualquier duda o consulta, puedes buscarme en mi Twitter o utilizar nuestro sistema de comentarios. ¡Y eso es todo por hoy!. ¡Sed felices!. ¡Siempre creciendo!. ¡Siempre aprendiendo!. ¡Cultura Maker!.

 

 

 

Mientras navegas por esta web, posiblemente interactuemos con tu equipo mediante el uso de cookies. La actual legislación de la UE (European Union) me obliga a informarte de ello, caminante. We use cookies to improve our website and your experience when using it. Cookies used for the essential operation of this site have already been set. To find out more about the cookies we use and how to delete them, see our privacy policy.

  I accept cookies from this site.
EU Cookie Directive Module Information