Descripción:Este pequeño y simple robot escribe la hora sobre su pequeño pizarrón, cada minuto borra la hora anterior y la actualiza
Hardware a utilizar:
1 Juego de piezas MDF y Acrílico 3mm corte láser
3 Servos Tower Pro SG90
1 Juego de tornillos con tuerca de seguridad
1 Organizador de cables
1 Borrador impreso en 3D
1 Gotero pegamento blanco
Kit de hardware completo aquí .
Paso 1: Identificando y pegando las piezas
Identifica las siguientes piezas, utiliza el pegamento blanco y pégalas como se indica en las siguientes imágenes
Pon atención a la orientación de las patas, los orificios del eje de rotación deben coincidir hacia el mismo lado
Monta los servos con los engranes hacia el centro de la pieza como se indica en la siguiente imagen, utiliza los tornillos largos que vienen con cada servo, los tornillos entran por el lado del servo
Deja este módulo a un lado e identifica las siguientes piezas:
Pega las siguientes piezas, pon atención a la orientación de las mismas
Monta el servo, observa de qué lado debe quedar el engrane, utiliza los dos tornillos largos que vienen con el servo, entran del lado del servo como se aprecia en la siguiente imagen
pega el resto de las piezas que forman la base, observa las imágenes, cuida la orientación
Por último pega el pizarrón de acrílico en su lugar
Identifica las siguientes piezas, también necesitarás dos hélices cortas de los servos
Pega el semicírculo en el brazo que sostiene el plumón como se indica en la siguiente imagen
Monta las hélices de los servos en sus respectivos brazos, fíjalas al brazo con los tornillos M1.4X5
Utiliza 3 tornillos M3X10 con sus respectivas tuercas de seguridad para ensamblar la base con el módulo de servos
Ten cuidado al apretar las tuercas, no aprietes de más, las articulaciones deben quedar firmes pero con movimiento libre
Identifica las siguientes piezas
NOTA IMPORTANTE: el corte láser es ligeramente cónico, prueba la pieza de acrílico blanco en el engrane del servo, de un lado entra con facilidad
Utiliza un tornillo M3X10 con su respectiva tuerca de seguridad para unir la pieza de acrílico con el brazo curvo de MDF como se muestra en la siguiente imagen. No aprietes en exceso
Ensambla el otro eje utilizando el tornillo M3X16, dos espaciadores de MDF y la tuerca de seguridad, no aprietes en exceso
No ensambles la pieza de acrílico al engrane del servo de elevación todavía, primero hay que realizar la calibración.
monta los dos brazos con hélice en sus respectivos servos como se muestra en la siguiente imagen
Conecta los servos a tu placa Arduino utilizando el organizador de conexiones
Las patas largas van a los pines 2, 3 y 4
Utilizando los cables Dupont conecta negro a GND y rojo a 5V
Ahora conecta los servos de la siguiente manera:
Servo de elevación al PIN 2
Servo izquierdo al PIN 3
Servo derecho al PIN 4
Descarga la librería Time.zip
Si tienes problemas para compilar el Sketch es muy probable que necesites una versión anterior del IDE de Arduino, puedes descargar el que a mi me funcionó sin problemas haciendo clic AQUÍ
Abre el IDE de Arduino, selecciona tu placa Arduino y el puerto COM correspondiente. Agrega la librería Time al IDE de Arduino
Copia y pega el siguiente Sketch o descárgalo AQUÍ .
/* RobotReloj
Johannes Heberlein 2014
v 1.02 ES
Conexiones entre Servos y Arduino:
Servo de elevacion -> Pin 2 del Arduino (cable Naranja del servo)
Servo izquierdo -> Pin 3 del Arduino (cable Naranja del servo)
Servo derecho -> Pin 4 del Arduino (cable Naranja del servo)
Los cables rojos de los Servos deben conectarse al Pin de 5V del Arduino
Los cables Marron de los Servos deben conectarse al Pin GND del Arduino
Primero debe calibrar los brazos para que varíen en Angulo de 90 grados exactos y de forma cruzada entre el servo derecho e izquierdo.
Después de Calibrar, borre o marque como comentario la línea siguiente */
#define CALIBRACION
// En modo de calibración, ajuste el factor siguiente hasta que los servos se mueven exactamente 90 grados
#define SERVOFAKTOR 640 //#define SERVOFAKTOR 620
/* En modo de calibración, ajuste los valores NULL para que los brazos de los servos esten en todo momento paralelos Ya sea al eje X o Y */
#define SERVOLEFTNULL 1800 //#define SERVOLEFTNULL 1900
#define SERVORIGHTNULL 1000 //#define SERVORIGHTNULL 984
#define SERVOPINELEVADOR 2 // Pin 2 conexión del servo elevador
#define SERVOPINIZQUIERDO 3 // Pin 3 conexión del servo izquierdo
#define SERVOPINDERECHA 4 // Pin 4 conexión del servo derecho
// definir posiciones del servo elevador
#define LIFT0 1080 // en la superficie de dibujo
#define LIFT1 925 // elevación entre escritura de numeros
#define LIFT2 825 //#define LIFT2 725 // yendo con el borrador
// velocidad de brazo elevador, un número mayor es más lento
#define VELOCIDADELEVADOR 1500
// longitud de los brazos
#define L1 35
#define L2 60 //#define L2 55.1
#define L3 13.2
// puntos de origen de servo izquierda y derecha
#define O1X 22
#define O1Y -25
#define O2X 47
#define O2Y -25
#include <Time.h> // descargar esta librería en http://elprofegarcia.com/?page_id=2
#include <Servo.h>
int servoLift = 1500;
Servo servo1; //
Servo servo2; //
Servo servo3; //
volatile double lastX = 75;
volatile double lastY = 47.5;
int last_min = 0;
void setup()
{
// Ajuste la hora actual, sólo el primero en valores,: hh, mm es necesario
setTime(18,01,0,0,0,0);
drawTo(75.2, 47);
lift(0);
servo1.attach(SERVOPINELEVADOR); // servo elevador
servo2.attach(SERVOPINIZQUIERDO); // servo izquierdo
servo3.attach(SERVOPINDERECHA); // servo derecho
delay(1000);
}
void loop()
{
#ifdef CALIBRACION
// los brazos de los servos tendran 90 ° entre los movimientos, paralelo al eje X e Y
drawTo(-3, 29.2);
delay(500);
drawTo(74.1, 28);
delay(500);
#else
int i = 0;
if (last_min != minute()) {
if (!servo1.attached()) servo1.attach(SERVOPINELEVADOR);
if (!servo2.attached()) servo2.attach(SERVOPINIZQUIERDO);
if (!servo3.attached()) servo3.attach(SERVOPINDERECHA);
lift(0);
hour();
while ((i+1)*10 <= hour())
{
i++;
}
number(3, 3, 111, 1);
number(5, 25, i, 0.9);
number(19, 25, (hour()-i*10), 0.9);
number(28, 25, 11, 0.9);
i=0;
while ((i+1)*10 <= minute())
{
i++;
}
number(34, 25, i, 0.9);
number(48, 25, (minute()-i*10), 0.9);
lift(2);
drawTo(74.2, 47.5);
lift(1);
last_min = minute();
servo1.detach();
servo2.detach();
servo3.detach();
}
#endif
}
// Escribir el numeral de bx por ser el punto de origen parte inferior izquierda. La escala 1 es igual a una alta fuente de 20 mm.
// La estructura sigue a este principio: mover al primer punto de inicio del numeral, levante hacia abajo, dibuje numeral, levante
void number(float bx, float by, int num, float scale) {
switch (num) {
case 0:
drawTo(bx + 12 * scale, by + 6 * scale);
lift(0);
bogenGZS(bx + 7 * scale, by + 10 * scale, 10 * scale, -0.8, 6.7, 0.5);
lift(1);
break;
case 1:
drawTo(bx + 3 * scale, by + 15 * scale);
lift(0);
drawTo(bx + 10 * scale, by + 20 * scale);
drawTo(bx + 10 * scale, by + 0 * scale);
lift(1);
break;
case 2:
drawTo(bx + 2 * scale, by + 12 * scale);
lift(0);
bogenUZS(bx + 8 * scale, by + 14 * scale, 6 * scale, 3, -0.8, 1);
drawTo(bx + 1 * scale, by + 0 * scale);
drawTo(bx + 12 * scale, by + 0 * scale);
lift(1);
break;
case 3:
drawTo(bx + 2 * scale, by + 17 * scale);
lift(0);
bogenUZS(bx + 5 * scale, by + 15 * scale, 5 * scale, 3, -2, 1);
bogenUZS(bx + 5 * scale, by + 5 * scale, 5 * scale, 1.57, -3, 1);
lift(1);
break;
case 4:
drawTo(bx + 10 * scale, by + 0 * scale);
lift(0);
drawTo(bx + 10 * scale, by + 20 * scale);
drawTo(bx + 2 * scale, by + 6 * scale);
drawTo(bx + 12 * scale, by + 6 * scale);
lift(1);
break;
case 5:
drawTo(bx + 2 * scale, by + 5 * scale);
lift(0);
bogenGZS(bx + 5 * scale, by + 6 * scale, 6 * scale, -2.5, 2, 1);
drawTo(bx + 5 * scale, by + 20 * scale);
drawTo(bx + 12 * scale, by + 20 * scale);
lift(1);
break;
case 6:
drawTo(bx + 2 * scale, by + 10 * scale);
lift(0);
bogenUZS(bx + 7 * scale, by + 6 * scale, 6 * scale, 2, -4.4, 1);
drawTo(bx + 11 * scale, by + 20 * scale);
lift(1);
break;
case 7:
drawTo(bx + 2 * scale, by + 20 * scale);
lift(0);
drawTo(bx + 12 * scale, by + 20 * scale);
drawTo(bx + 2 * scale, by + 0);
lift(1);
break;
case 8:
drawTo(bx + 5 * scale, by + 10 * scale);
lift(0);
bogenUZS(bx + 5 * scale, by + 15 * scale, 5 * scale, 4.7, -1.6, 1);
bogenGZS(bx + 5 * scale, by + 5 * scale, 5 * scale, -4.7, 2, 1);
lift(1);
break;
case 9:
drawTo(bx + 9 * scale, by + 11 * scale);
lift(0);
bogenUZS(bx + 7 * scale, by + 15 * scale, 5 * scale, 4, -0.5, 1);
drawTo(bx + 5 * scale, by + 0);
lift(1);
break;
case 111:
lift(0);
drawTo(70, 46);
drawTo(65, 43);
drawTo(65, 49);
drawTo(5, 49);
drawTo(5, 45);
drawTo(65, 45);
drawTo(65, 40);
drawTo(5, 40);
drawTo(5, 35);
drawTo(65, 35);
drawTo(65, 30);
drawTo(5, 30);
drawTo(5, 25);
drawTo(65, 25);
drawTo(65, 20);
drawTo(5, 20);
drawTo(60, 44);
drawTo(75.2, 47);
lift(2);
break;
case 11:
drawTo(bx + 5 * scale, by + 15 * scale);
lift(0);
bogenGZS(bx + 5 * scale, by + 15 * scale, 0.1 * scale, 1, -1, 1);
lift(1);
drawTo(bx + 5 * scale, by + 5 * scale);
lift(0);
bogenGZS(bx + 5 * scale, by + 5 * scale, 0.1 * scale, 1, -1, 1);
lift(1);
break;
}
}
void lift(char lift) {
switch (lift) {
// sitio para optimizar !
case 0: //850
if (servoLift >= LIFT0) {
while (servoLift >= LIFT0)
{
servoLift--;
servo1.writeMicroseconds(servoLift);
delayMicroseconds(VELOCIDADELEVADOR);
}
}
else {
while (servoLift <= LIFT0) {
servoLift++;
servo1.writeMicroseconds(servoLift);
delayMicroseconds(VELOCIDADELEVADOR);
}
}
break;
case 1: //150
if (servoLift >= LIFT1) {
while (servoLift >= LIFT1) {
servoLift--;
servo1.writeMicroseconds(servoLift);
delayMicroseconds(VELOCIDADELEVADOR);
}
}
else {
while (servoLift <= LIFT1) {
servoLift++;
servo1.writeMicroseconds(servoLift);
delayMicroseconds(VELOCIDADELEVADOR);
}
}
break;
case 2:
if (servoLift >= LIFT2) {
while (servoLift >= LIFT2) {
servoLift--;
servo1.writeMicroseconds(servoLift);
delayMicroseconds(VELOCIDADELEVADOR);
}
}
else {
while (servoLift <= LIFT2) {
servoLift++;
servo1.writeMicroseconds(servoLift);
delayMicroseconds(VELOCIDADELEVADOR);
}
}
break;
}
}
void bogenUZS(float bx, float by, float radius, int start, int ende, float sqee) {
float inkr = -0.05;
float count = 0;
do {
drawTo(sqee * radius * cos(start + count) + bx,
radius * sin(start + count) + by);
count += inkr;
}
while ((start + count) > ende);
}
void bogenGZS(float bx, float by, float radius, int start, int ende, float sqee) {
float inkr = 0.05;
float count = 0;
do {
drawTo(sqee * radius * cos(start + count) + bx,
radius * sin(start + count) + by);
count += inkr;
}
while ((start + count) <= ende);
}
void drawTo(double pX, double pY) {
double dx, dy, c;
int i;
// dx dy of new point
dx = pX - lastX;
dy = pY - lastY;
// Longitud de la trayectoria en mm, 4 veces equivale a 4 pasos por mm
c = floor(4 * sqrt(dx * dx + dy * dy));
if (c < 1) c = 1;
for (i = 0; i <= c; i++) {
// dibuja la línea punto por punto
set_XY(lastX + (i * dx / c), lastY + (i * dy / c));
}
lastX = pX;
lastY = pY;
}
double return_angle(double a, double b, double c) {
// regla del coseno para el angulo entre c y a
return acos((a * a + c * c - b * b) / (2 * a * c));
}
void set_XY(double Tx, double Ty)
{
delay(1);
double dx, dy, c, a1, a2, Hx, Hy;
//calcular triangulo entre marcador, servo izquierdo y brazo
// cartesiano dx/dy
dx = Tx - O1X;
dy = Ty - O1Y;
// longitud polar (c) y el angulo (a1)
c = sqrt(dx * dx + dy * dy);
a1 = atan2(dy, dx);
a2 = return_angle(L1, L2, c);
servo2.writeMicroseconds(floor(((a2 + a1 - M_PI) * SERVOFAKTOR) + SERVOLEFTNULL));
// calcular el punto del brazo joinr para el triángulo del servo derecho y el brazo
a2 = return_angle(L2, L1, c);
Hx = Tx + L3 * cos((a1 - a2 + 0.621) + M_PI); //36,5°
Hy = Ty + L3 * sin((a1 - a2 + 0.621) + M_PI);
// calcular el triángulo entre el marcador, servo derecho y el brazo
dx = Hx - O2X;
dy = Hy - O2Y;
c = sqrt(dx * dx + dy * dy);
a1 = atan2(dy, dx);
a2 = return_angle(L1, (L2 - L3), c);
servo3.writeMicroseconds(floor(((a1 - a2) * SERVOFAKTOR) + SERVORIGHTNULL));
}
Revisa y sube el Sketch a tu placa Arduino, en este momento el robot reloj se encuentra en modo CALIBRACIÓN, los brazos se moverán de un lado al otro, desconecta la placa Arduino cunado los brazos se encuentren ya sea en posición derecha o izquierda, desacopla los brazos, ponlos en la posición correcta y vuelve a conectar tu placa Arduino, el movimiento debe coincidir con el siguiente dibujo
Como se aprecia en la imagen, cuando los brazos están en posición IZQUIERDA el brazo izquierdo queda en posición horizontal y el derecho en posición vertical (dibujo gris). Cuando los brazos están en posición DERECHA el brazo izquierdo queda vertical y el derecho horizontal (dibujo blanco).
Una vez finalizada la calibración puedes poner los tornillos centrales que fijan las hélices a los engranes de los servos y terminar de armar los brazos utilizando los tornillos M3X10 con sus respectivas tuercas de seguridad. No aprietes en exceso
Modifica el Sketch eliminando o comentando la línea 21, debe quedar como en la siguiente imagen
Vuelve a revisar y cargar el Sketch a tu placa Arduino, esta vez el robot realizará la secuencia de borrado, escribirá la nueva hora y se moverá a la posición de REPOSO, es en esta posición donde lo debes desconectar el robot para ajustar el servo de elevación.
Pega un pedacito de tela o esponja delgada a la base del borrador y coloca el plumón en su lugar, el borrador también debe ser colocado en la posición de reposo. Acopla la pieza de acrílico del servo de elevación de manera que el plumón quede aproximadamente a la altura que se muestra en la siguiente imagen
Conecta tu placa Arduino, el robot realizará la secuencia de borrado y escribirá la hora, es muy probable que tengas que reajustar la altura: Desacopla, ajusta y vuelve a acoplar la pieza de acrílico del servo de elevación, repite la operación hasta que encuentres el punto exacto de calibración. Una vez calibrado pon el tornillo central del engrane del servo de elevación con su respectiva rondana plana.
El robot reloj no tiene forma de saber la hora actual, necesitaríamos agregar un módulo RTC (Real Time Clock) para que siempre tuviera la hora exacta, por el momento el robot tendrá que ser programado con la hora cada vez que se pone en operación. El robot mantendrá la hora correcta mientras no sea desconectado.
En el Sketch ve a la línea 72, cambia los dos primeros valores para ajustar la hora, revisa y sube el Sketch, el robot debe escribir la hora programada.