Paso 11: Haga interesante
longitudes de pies de pesca línea y atar cada uno en a través del agujero en el centro de la
poleas. Atar los otros extremos de la línea a una abrazadera de resorte y de la abrazadera en un
marcador. Monte el libro blanco sobre la tabla de la lona con cinta o abrazaderas.
Digamos los motores paso a paso para dibujar en direcciones aleatorias por defecto y entonces
a comportarse como lo hicieron antes cuando alguien está cubriendo una célula fotoeléctrica. Esta voluntad
crear un dibujo como los SADbot realizado en Galería de ventana de Eyebeam. ¡ Disfrute! Juega con las fotocélulas para que pueda interactuar con SADbot y hacer dibujos interesantes.
/*
SADbot v.03
SADbot dibujará una distancia al azar en dirección aleatoria hasta un
fotocélula está bloqueada. Cuando SADbot detecta una fotocélula ha sido bloqueada, se
se recurrirá a ella. Motores paso a paso son conducidos a través de Sparkfun
EasyDriver v4.3
CC-GNU GPL por Ben Leduc-molinos y Dustyn Roberts
Creado: 2010.06
*/
Biblioteca de #include //import paso a paso
#define 200 pasos / / 360/1.8 (ángulo de paso) = 200 pasos/revolución
declarar objetos nuevos pasos de biblioteca paso a paso (uno por motor)
Right_motor paso a paso (pasos, 6, 7); 6 = DIR, 7 = PASO
Left_motor paso a paso (pasos, 11, 12); 11 = DIR, 12 = PASO
int distancia; hasta dónde deben llegar motores
int menor; para almacenar el valor más bajo de la fotocélula
int i; para bucle
variables para 4 fotocélulas
int photo_up;
int photo_down;
int photo_left;
int photo_right;
Establecer el tamaño de la lona. 1000 pasos es aproximadamente.4 pulgadas
#define CANVASWIDTH 32000
#define CANVASHEIGHT 20000
distancia total de comprobación de límites
SADbot comienza en el centro (canvaswidth/2 y canvasheight/2)
flotador totalWidth = CANVASWIDTH 2;
flotador totalHeight = CANVASHEIGHT 2;
int randomDirection;
int randomDistance;
void setup() {}
Serial.Begin(9600); iniciar impresión serie para que podamos ver cosas
ajustar la velocidad del motor (en RPM)
right_motor.SETSPEED(200);
left_motor.SETSPEED(200);
utilizar semilla aleatoria para obtener mejores números aleatorios
* ajuste a un pin analógico que no usas
randomSeed(analogRead(4));
} / / fin de programa de instalación
void loop() {}
leer e imprimir los valores de los sensores de pernos analógicos 0-3
photo_up = analogRead(0);
Serial.Print("up");
Serial.println(photo_up);
photo_down = analogRead(1);
Serial.Print("Down");
Serial.println(photo_down);
photo_left = analogRead(2);
Serial.Print("left");
Serial.println(photo_left);
photo_right = analogRead(3);
Serial.Print("Right");
Serial.println(photo_right);
Delay(1000); me da tiempo a leer en el monitor
antes de dibujar, ver las totalHeight totalWidth
Serial.Print("totalHeight:");
Serial.println(totalHeight);
Serial.Print("totaWidth:");
Serial.println(totalWidth);
Delay(1000); me da tiempo a leer en el monitor
almacenar valores de fotocélula en una matriz
int photoValues [] = {photo_up, photo_down, photo_left, photo_right};
menor = 9999; Ajuste este parámetro superiores a valores posibles de la fotocélula
lazo para encontrar el valor más bajo de la fotocélula
para (i = 0; i < 4; i ++) //4 = número de sensores
{
Serial.println(photoValues[i]); Imprime la matriz de photoValue
asignar valor de fotocélula real a la variable "menor" si es menor
que lo "más bajo" se establece en (comienza a 9999)
Si (menor > = photoValues [i]) {}
menor = photoValues [i];
}
Imprima para confirmar que el valor más bajo está siendo seleccionado
Serial.Print("Lowest:");
Serial.println(Lowest);
Delay(1000); Espere un segundo antes de bucle por lo que podemos leer los valores
} //end para
distancia = más bajo; establecer la distancia de recorrido = menor valor
Si el valor más bajo indica una fotocélula cubierta, dibujar hacia más bajo
cambiar este umbral dependiendo de la iluminación
Si (bajo < 550)
{
encontrar el sensor que coincidió con la marcha más baja, esa dirección,
pero sólo si SADbot está dentro de los límites del lienzo
Si ((menor == photoValues[0]) & & ((totalHeight + distance) <
CANVASHEIGHT))
{
(distancia);
totalHeight += distancia; variable de incremento totalHeight
}
else if ((menor == photoValues[1]) & & ((totalHeight-distance) > 0))
{
abajo (distancia);
totalHeight = distancia; decremento totalHeight variable
}
else if ((menor == photoValues[2]) & & ((totalWidth-distance) > 0))
{
izquierda (distancia);
totalWidth = distancia; decremento de totalWidth variable
}
else if ((menor == photoValues[3]) & & ((totalWidth + distance) <
CANVASWIDTH))
{
derecho (distancia);
totalWidth += distancia; variable de totalWidth incremento
}
} //end si
de lo contrario, nadie está cubriendo los sensores, sorteo según al azar
otra cosa
{
selección de número aleatorio de 1 a 9 para asignar a la dirección
randomDirection = al azar (1, 9);
Serial.Print ("dirección al azar:");
Serial.println(randomDirection);
escoger al azar número del 1 al 200 para asignar a distancia
randomDistance = al azar (1, 200);
Serial.Print ("distancia al azar:");
Serial.println(randomDistance);
direcciones para cualquier valor de randomDirection generado
interruptor (randomDirection)
{
caso 1: //go a
Si ((totalHeight + randomDistance) < CANVASHEIGHT)
{
up(randomDistance);
totalHeight += randomDistance;
}
rotura;
caso 2: //go abajo
Si ((totalHeight-randomDistance) > 0)
{
Down(randomDistance);
totalHeight = randomDistance;
}
rotura;
caso 3: //go a la izquierda
Si ((totalWidth-randomDistance) > 0)
{
Left(randomDistance);
totalWidth = randomDistance;
}
rotura;
caso 4: derecho de //go
Si ((totalWidth + randomDistance) < CANVASWIDTH)
{
Right(randomDistance);
totalWidth += randomDistance;
}
rotura;
caso 5: vertical //go
Si (((totalWidth + randomDistance) < CANVASWIDTH) & & ((totalHeight
+ randomDistance) < CANVASHEIGHT))
{
upRight(randomDistance);
totalWidth += randomDistance;
totalHeight += randomDistance;
}
rotura;
caso 6: upLeft //go
Si (((totalWidth-randomDistance) > 0) & & ((totalHeight +
randomDistance) < CANVASHEIGHT))
{
upLeft(randomDistance);
totalWidth = randomDistance;
totalHeight += randomDistance;
}
rotura;
caso 7: //go es
Si (((totalWidth + randomDistance) < CANVASWIDTH) & & ((totalHeight-randomDistance) > 0))
{
downRight(randomDistance);
totalWidth += randomDistance;
totalHeight = randomDistance;
}
rotura;
caso 8: //go downLeft
Si (((totalWidth-randomDistance) > 0) & & ((totalHeight-randomDistance) > 0))
{
downLeft(randomDistance);
totalWidth = randomDistance;
totalHeight = randomDistance;
}
rotura;
por defecto: //just en caso
Left(0);
} //end interruptor
} //end más
} //end loop()
/*
Aquí están las funciones direccionales. Tamaño del lazo = distancia.
Números de paso positivo hacia la derecha, negativo hacia la izquierda
*/
void a (int distancia)
{
para (i = 0; i < distancia; i ++) {}
right_motor.Step(1);
left_motor.Step(-1);
}
}
void a (int distancia)
{
para (i = 0; i < distancia; i ++) {}
right_motor.Step(-1);
left_motor.Step(1);
}
}
Anular izquierdo (int distancia)
{
para (i = 0; i < distancia; i ++) {}
right_motor.Step(-1);
left_motor.Step(-1);
}
}
anular derecho (int distancia)
{
para (i = 0; i < distancia; i ++) {}
right_motor.Step(1);
left_motor.Step(1);
}
}
vacío en posición vertical (distancia de int)
{
para (i = 0; i < distancia; i ++) {}
right_motor.Step(2);
left_motor.Step(-.2);
}
}
void upLeft(int distance)
{
para (i = 0; i < distancia; i ++) {}
right_motor.Step(.2);
left_motor.Step(-2);
}
}
vacío es (int distancia)
{
para (i = 0; i < distancia; i ++) {}
right_motor.Step(-.2);
left_motor.Step(2);
}
}
void downLeft(int distance)
{
para (i = 0; i < distancia; i ++) {}
right_motor.Step(-2);
left_motor.Step(.2);
}
}
