Siempre creciendo, siempre aprendiendo. Cultura Maker.

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!.

 

 

 

Ratio: 0 / 5

Inicio desactivadoInicio desactivadoInicio desactivadoInicio desactivadoInicio desactivado

¡Saludos, estudiantes!.

¡En efecto!. Hoy vamos a acercarnos al control de servomotores mediante Arduino del modo más sencillo, eficiente y rápido que se me ocurre, y que consiste, simplemente, en conectar uno directamente a la tarjeta, volcar el código que os voy a dar, y ver el efecto que éste produce, para a continuación ir introduciendo modificaciones que nos ayuden a entender el algoritmo original.

¿Qué es un servomotor?

En primer lugar, ¿qué es un serServovo?. Un servomotor es un dispositivo alimentado por corriente continua que puede controlar de modo muy exacto o su posición (de 0º a 180º) o su velocidad (en revoluciones por minuto, rpm, en sentido horario o antihorario).

Los servomotores tienen tres pines de conexiones: alimentación (5 V, normalmente), tierra o GND la patilla de señal, a través de la cual el sistema de control emitirá una señal PWM (Pulse Width Modulation, una sucesión de unos y ceros de periodo controlado que intentan emular el resultado de una señal analógica) que indicará al servomotor la posición o la velocidad que le corresponde alcanzar.

Sí, lo sé. Para aquél que entra en este mundillo por primera vez puede resultar algo complicado. Así que, si lo tenéis a bien, entremos directamente en harina con un montaje sencillísimo:

Ratio: 0 / 5

Inicio desactivadoInicio desactivadoInicio desactivadoInicio desactivadoInicio desactivado

¡Bienvenidos!

¡Hola una vez más!. ¡Pasad!, ¡pasad!, ¡ponéos cómodos!. ¡Al fondo queda sitio!.

¡Muchas gracias por volver a visitarnos, de verdad!. Espero de corazón estar haciendo algo que os resulte util. Durante este artículo, trataré de llevaros por uno de los conceptos más importante a la hora de trabajar con cualquier dispositivo electrónico: distinguir entre entradas y salidas.

En el artículo anterior, trabajábamos con una única salida: el LED que conectábamos a la patilla 13 de Arduino (aprovechando que la mayoría de las placas llevan un built-in, o led integrado en la misma Arduino, asociado a dicho pin).  El objetivo de esas primeras prácticas no era tanto empezar a programar la Arduino como que os familiarizárais con su IDE y aprendiérais a conectar la placa al ordenador, asi como realizar la compilación y el volcado del código a su memoria.

Lo que vamos a hacer hoy no es mucho más complicado. Partimos del siguiente axioma:

  • Un pin funciona como salida cuando puede encender/activar elementos electrónicos (mover un motor, encender un LED...)
  • Un pin funciona como entrada cuando puede leer la información de un dispositivo (pulsador abierto/cerrado, presencia/ausencia de tension, etc...)

Así que vamos a conectar algunos diodos LED como salidas, mientras que utilizaremos varios elementos como entrada: potenciómetros, un pulsador y una resistencia LDR. Recordad siempre que todas las conexiones tienen que acabar en la patilla GND (tierra), que simboliza el polo negativo de la "pila virtual" que estamos utilizando para proporcionar energía eléctrica al circuito. Al fin y al cabo, la corriente eléctrica sólo puede fluir si le proporcionamos un camino cerrado mediante elementos conductores desde el polo positivo al polo negativo de la fuente de alimentación (lo cual, desde el punto de vista de la Física, también es falso, pero mira... de eso ya nos encargaremos en otra ocasión).

¡La impaciencia me corroe!. ¡Vamos allá!

Ok. Aquí tenéis el esquema de montaje que os propongo:

 

practicaArduinoGeneral1ProtoboardBuenapracticaArduinoGeneral1Protoboard

 

¡Tranquilos! No vamos a empezar con todo a la vez. Si sabéis conectar elementos en una protoboard (asumo que sí), veréis que el esquema no es tan complejo como puede parecer a primera vista:

  1. Hemos conectado tres diodos LED(a través de la correspondiente resistencia de 100-220 Ω en serie para que no se quemen) a los pines 5, 6 y 7. Esto son tres salidas.
  2. Hemos conectado un pulsador según la siguiente secuencia: de 5 V a pulsador, de pulsador a resistencia (1 kΩ o más), de resistencia a tierra, y en el punto en que se tocaban el pulsador y la resistencia, lo hemos conectado al pin 8. Esto constituirá una entrada digital.
  3. Hemos conectado las patillas del potenciómetro de la derecha a 5 V, A0 y tierra (GND). Esto será una entrada analógica.
  4. Por último, hemos conectado un segundo potenciómetro de modo que uno de sus extremos toca a 5 V, el pin central (el variable) va conectado a una resistencia LDR y, finalmente, el otro extremo de la LDR va a tierra. El tercer pin del potenciómetro no necesita ser conectado. Este último montaje nos permitirá utilizar una resistencia dependiente de la luz LDR como un sensor analógico de luz ambiental, en un intento de dar un uso real a lo que expliquemos en esta serie de artículos.

¡Bufff! ¡Cuánto cable! Pero ya está conectado. ¡Empieza a explicar!

No os preocupéis. Os he propuesto este montaje para que vayáis haciendo "dedos" pelando cable y aprendiendo a hacer conexiones, normalmente a base de equivocarnos. Lo que vamos a ir haciendo es utilizar sólo una parte del circuito cada vez, e ir combinando partes después para enriquecer nuestro resultado. De hecho, en diferentes partes de este conjunto de prácticas redibujaremos el circuito para que aparezca sólo la parte que nos interesa, con el fin de simplificar y mejorar la comprensión del funcionamiento de dicha parte.

 

Aprendiendo a trabajar con salidas

 

Ésta es la parte del circuito que vamos a utilizar ahora: tres diodos LED conectados (resistencia serie mediante) a las patillas 5, 6 y 7 de Arduino:

 tresLED bb tresLED esquema 

En primer lugar, vamos a familiarizarnos con el concepto de salida. Volcad este código en vuestra Arduino, tal y como aprendísteis en el anterior artículo:


int led1=5;
void setup(){
pinMode(led1,OUTPUT);
}
void loop(){
digitalWrite(led1,HIGH);
delay(1000);
digitalWrite(led1,LOW);
delay(1000);
}

Si haces la prueba, verás que en esta ocasión, el diodo conectado al pin 5 titilará como pasaba con el integrado en la placa (asociado al pin 13) en el artículo anterior. Este código tiene tres partes:

a) Declaración de variables: el código int led1=5; indica que hay una variable llamada led1, que queremos que valga 5 (el pin al que va conectado el led). La palabra int significa que la variable es de tipo integer, es decir, de tipo entero (no hay decimales).

b) Función setup: El término en inglés significa algo así como configuración. Todo lo que escribamos entre las dos llaves que lleva esa función se cumplirá en el orden en que las escribamos, y al cumplir el último comando pasará a ejecutar la función loop. En este caso, sólo hay una instrucción, pinMode(led1,OUTPUT); dicha instrucción indica que queremos poner el pin led1 (o sea, el 5) en modo OUTPUT, es decir, queremos que actúe como una salida.

c) Función loop: en inglés, este vocablo significa rizo o bucle. Pues eso. Cumplirá las órdenes que encuentre en el orden en el que estén escritas. Al llegar a la última orden, volverá al principio de la función y volverá a empezar. La rapidez del micro hará que normalmente este conjunto de ordenes se repita varias veces por segundo.

 

Las órdenes que se incluyen en este programa son:

  • pinMode(numeroPin,INPUT/OUTPUT); pondrá al pin numeroPin en modo INPUT(entrada) o OUTPUT(salida).
  • digitalWrite(numeroPIN, HIGH/LOW); escribe HIGH (encendido, o sea, 5 voltios) o LOW (apagado, 0 voltios) en el numeroPin especificado. Lo que haya conectado al pin (un LED, en nuestro caso) lucirá cuando escribamos HIGH, y se apagará en el caso de LOW.
  • delay(x); espera durante x milisegundos. Es decir delay(1000); espera durante 1 segundo.

IMPORTANTE: EN CUALQUIER PROGRAMA EN PROCESSING, TODOS LOS COMANDOS FINALIZAN CON UN PUNTO Y COMA. SI SE TE OLVIDA ALGUNO, EL COMPILADOR TE SEÑALARÁ EL ERROR.

También hay que señalar que tanto setup como loop se escriben  normalmente con la palabra void delante y acaban con ambos paréntesis (), por razones que no vienen aún al caso. Como funciones que son, encierran entre llaves los conjuntos de comandos que incluyan. La falta de llaves también parara el compilador, indicándonos el tipo de error.

¡Bueno!. Seguro que ya comprendes el principio de las cuatro instrucciones que van en loop : encender el led conectado al pin 5 escribiendo un HIGH, esperar un segundo, apagarlo escribiendo un LOW, esperar otro segundo, y volver a empezar.

¿Cómo podríamos hacer ahora que se encendieran y apagaran los tres diodos al unísono?. La solución más sencilla sería conectarlos en paralelo al pin 5, pero como queremos hacer otras cosas más complicadas después, las asociaremos a los pines 6 y 7. ¿Cómo sería el código? Seguro que sabes hacerlo. De todos modos, te lo dejo aquí:

 
//Notad que las barras  de la tecla 7 me permiten escribir comentarios
//Declaro tres variables led1, led2, led3 int led1=5;
int led2=6;
int led3=7;
//en setup ponemos como OUTPUT los tres pines
void setup(){
pinMode(led1,OUTPUT);
pinMode(led1,OUTPUT);
pinMode(led1,OUTPUT);
}

void loop(){
//encendemos los tres pines
digitalWrite(led1,HIGH);
digitalWrite(led2,HIGH);
digitalWrite(led3,HIGH);
delay(1000);
//apagamos los tres pines
digitalWrite(led1,LOW);
digitalWrite(led2,LOW);
digitalWrite(led3,LOW);
delay(1000);
}

 

 ¡Lo pillo!. ¿Y si quisiera hacer, digamos, un semáforo?

Pues sólo tienes que experimentar tú solo con el código. Procura conseguir diodos de los tres colores (rojo, ámbar, verde), y piensa qué tiempos quieres asignar a cada parte de la secuencia. Pongamos, por ejemplo, que el rojo está en el pin 7, el ámbar en el 6 y el verde en el 5. Digamos, por otro lado, que queremos que tanto rojo como verde debería tener el mismo tiempo asignado, digamos 5 segundos, mientras que el ámbar necesita ajustarse a un plazo más corto, por ejemplo 1,5 segundos. El código sería algo así:

 

int verde=5;
int ambar=6;
int rojo=7;
//en setup ponemos como OUTPUT los tres pines
void setup(){
pinMode(rojo,OUTPUT);
pinMode(ambar,OUTPUT);
pinMode(verde,OUTPUT);
}

void loop(){
//empezamos en ROJO
digitalWrite(rojo,HIGH);
digitalWrite(ambar,LOW);
digitalWrite(verde,LOW);
delay(5000);
//toca VERDE
digitalWrite(rojo,LOW);
digitalWrite(ambar,LOW);
digitalWrite(verde,HIGH);
delay(5000);
//ahora AMBAR con menos tiempo
digitalWrite(rojo,LOW);
digitalWrite(ambar,HIGH);
digitalWrite(verde,LOW);
delay(1500);

}

 

 

Ratio: 4 / 5

Inicio activadoInicio activadoInicio activadoInicio activadoInicio desactivado

¡Buenos días, buenas tardes, buenas noches, mis pequeños aprendices!. ¡Pasad!, ¡pasad!, ¡sed todos muy bienvenidos!.

Hoy quiero hablaros de música. Y es que aunque mis aptitudes musicales estén más bien bajo cero, no podemos negar que uno de los aspectos más maravillosos del ser humano es la posibilidad de despertar emociones mediante el sonido. Sí, lo sé, no es una de las definiciones más acertadas que veréis por esta web, ejem... ejem... Mejor pasemos directamente a la acción.

Como ejercicio introductorio, vamos a hacer este montaje. Necesitarás un altavoz piezoeléctrico, un pulsador y una resistencia de cualquier valor (220 ohmios, por ejemplo):

botonPiezoelectrico

botonPiezoelectricoEsquema

 

Ratio: 3 / 5

Inicio activadoInicio activadoInicio activadoInicio desactivadoInicio desactivado

¡Saludos, estudiantes!. Lo que os traigo hoy es una idea que vi en alguna red social y que me encantó. Se trata de un juego muy sencillo, pero espectacular. Sobre una plataforma tenemos, sujeto por ambos extremos, un alambre doblado de forma caprichosa, haciendo formas extrañas. Por otra parte, el jugador empuña otro trozo de alambre en forma de mango, cuyo extremo está arrollado en una circunferencia a lo largo del alambre principal. Se trata de deslizar el mango a lo largo de la sinuosa trayectoria que el juguete ofrece SIN TOCARSE AMBOS ALAMBRES. Si así sucediera, un traidor piezoeléctrico zumbará, indicándote que no tienes pulso para robar en una tienda de panderetas.

Aquí el vídeo:

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