Étape 11 : Le rendent intéressant
longueurs de FT de pêche ligne et attacher chacun sur le trou dans le centre de la
poulies. Attachez l’autre extrémité de la ligne à une pince à ressort et pince sur un
marqueur. Monter le livre blanc sur votre planche de toile avec du ruban ou colliers.
Nous allons dire les moteurs pas à pas à dessiner dans des directions aléatoires par défaut, puis
de se comporter comme ils le faisaient avant lorsque quelqu'un est couvrant une cellule photoélectrique. Cette volonté
créer un dessin comme ceux fait de SADbot dans la Galerie de fenêtre de Eyebeam. Profitez ! Jouer avec les cellules photoélectriques, ainsi vous pouvez interagir avec SADbot et faire des dessins intéressants.
/*
SADbot v.03
SADbot dessinera une distance aléatoire dans une direction aléatoire jusqu'à un
cellule photoélectrique est bloqué. Lorsque SADbot détecte une cellule photoélectrique a été bloquée, il
tirera vers lui. Moteurs pas à pas sont conduits par le biais de Sparkfun
V4.3 EasyDriver
CC-GNU GPL par Ben Leduc-Mills et Fab Roberts
Créé : 2010.06
*/
#include //import bibliothèque de stepper
#define 200 étapes / / 360/1.8 (angle de pas) = 200 pas/tour
déclarer les nouveaux objets de moteurs pas à pas de la bibliothèque de stepper (un par moteur)
Stepper right_motor (marches, 6, 7) ; 6 = DIR, 7 = ÉTAPE
Stepper left_motor (marches, 11, 12) ; 11 = DIR, 12 = ÉTAPE
distance de l’int ; jusqu’où doivent aller moteurs
int le plus bas ; pour stocker la plus faible valeur de la cellule photoélectrique
int i ; pour une boucle
variables pour 4 cellules photoélectriques
int photo_up ;
int photo_down ;
int photo_left ;
int photo_right ;
Définissez la taille du canevas. 1000 marches est d’environ 4 pouces
#define CANVASWIDTH 32000
#define CANVASHEIGHT 20000
distance totale pour la vérification de limites
SADbot démarre au Centre (canvaswidth/2 et canvasheight/2)
flotteur totalWidth = CANVASWIDTH 2 ;
float totalHeight = CANVASHEIGHT 2 ;
int randomDirection ;
int randomDistance ;
void setup() {}
Serial.Begin(9600) ; lancer imprimé série alors nous pouvons voir les choses
régler la vitesse du moteur (en tr/min)
right_motor.setSpeed(200) ;
left_motor.setSpeed(200) ;
graine aléatoire permet d’obtenir mieux les nombres aléatoires
* la valeur une broche analogique que vous n’utilisez pas
randomSeed(analogRead(4)) ;
} / / fin d’installation
void loop() {}
lire et imprimer toutes les valeurs de capteur des broches analogiques 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) ; Donnez-moi le temps de les lire dans le moniteur
avant l’application, vérifiez nos totalHeight et totalWidth
Serial.Print("totalHeight:") ;
Serial.println(totalHeight) ;
Serial.Print("totaWidth:") ;
Serial.println(totalWidth) ;
Delay(1000) ; Donnez-moi le temps de les lire dans le moniteur
stocker les valeurs de cellule dans un tableau
int photoValues [] = {photo_down, photo_left, photo_up, photo_right} ;
plus bas = 9999 ; Ceci réglé plus haut que les valeurs de cellule photo-électrique possible
boucle pour trouver la plus petite valeur de la cellule photoélectrique
pour (i = 0; i < 4; i ++) //4 = nombre de capteurs
{
Serial.println(photoValues[i]) ; imprime les photoValue tableau
assigner des cellule réelle valeur à la variable « plus basse » si elle est inférieure
que tout ce qui est « plus bas » est défini sur (commence à 9999)
Si (le plus bas > = photoValues [i]) {}
plus bas = photoValues [i] ;
}
Imprimez-le pour confirmer que la valeur la plus faible est sélectionnée
Serial.Print("lowest:") ;
Serial.println(lowest) ;
Delay(1000) ; attendre une seconde avant une boucle de sorte que nous pouvons lire les valeurs
} //end pour
distance = plus bas ; Définissez la distance de transport = valeur la plus basse
Si la valeur la plus basse indique une photocellule couverte, attirer vers le plus bas
modifier ce seuil selon éclairage
Si (le plus bas < 550)
{
trouver le capteur qui correspondait à l’aller plus bas, cette direction,
mais seulement si SADbot est dans les limites de la toile
Si ((plus bas == photoValues[0]) & & ((totalHeight + distance) <
CANVASHEIGHT))
{
(distance) ;
totalHeight += distance ; variable totalHeight incrément
}
ElseIf ((plus bas == photoValues[1]) & & ((totalHeight-distance) > 0))
{
vers le bas (à distance) ;
totalHeight = distance ; décrémente la variable totalHeight
}
ElseIf ((plus bas == photoValues[2]) & & ((totalWidth-distance) > 0))
{
gauche (distance) ;
totalWidth = distance ; décrémente la variable totalWidth
}
ElseIf ((plus bas == photoValues[3]) & & ((totalWidth + distance) <
CANVASWIDTH))
{
droit (à distance) ;
totalWidth += distance ; variable totalWidth incrément
}
} //end si
dans le cas contraire, personne ne couvre tous les capteurs, tirage au sort selon aléatoire
d’autre
{
Choisissez un chiffre aléatoire 1 à 9 pour mapper à la direction
randomDirection = aléatoire (1, 9) ;
Serial.Print ("direction aléatoire:") ;
Serial.println(randomDirection) ;
Choisissez le nombre aléatoire de 1 à 200 et à la carte à distance
randomDistance = aléatoire (1, 200) ;
Serial.Print ("distance aléatoire:") ;
Serial.println(randomDistance) ;
indications pour n’importe quelle valeur randomDirection généré
Switch (randomDirection)
{
cas 1: //go vers le haut
Si ((totalHeight + randomDistance) < CANVASHEIGHT)
{
Up(randomDistance) ;
totalHeight += randomDistance ;
}
rupture ;
cas 2: //go vers le bas
Si ((totalHeight-randomDistance) > 0)
{
Down(randomDistance) ;
totalHeight = randomDistance ;
}
rupture ;
case 3: //go à gauche
Si ((totalWidth-randomDistance) > 0)
{
Left(randomDistance) ;
totalWidth = randomDistance ;
}
rupture ;
case 4: droit //go
Si ((totalWidth + randomDistance) < CANVASWIDTH)
{
Right(randomDistance) ;
totalWidth += randomDistance ;
}
rupture ;
cas 5: position verticale //go
Si (((totalWidth + randomDistance) < CANVASWIDTH) & & ((totalHeight
+ randomDistance) < CANVASHEIGHT))
{
upRight(randomDistance) ;
totalWidth += randomDistance ;
totalHeight += randomDistance ;
}
rupture ;
case 6: //go upLeft
Si (((totalWidth-randomDistance) > 0) & & ((totalHeight +
randomDistance) < CANVASHEIGHT))
{
upLeft(randomDistance) ;
totalWidth = randomDistance ;
totalHeight += randomDistance ;
}
rupture ;
cas 7: //go carrément
Si (((totalWidth + randomDistance) < CANVASWIDTH) & & ((totalHeight-randomDistance) > 0))
{
downRight(randomDistance) ;
totalWidth += randomDistance ;
totalHeight = randomDistance ;
}
rupture ;
cas 8: //go downLeft
Si (((totalWidth-randomDistance) > 0) & & ((totalHeight-randomDistance) > 0))
{
downLeft(randomDistance) ;
totalWidth = randomDistance ;
totalHeight = randomDistance ;
}
rupture ;
par défaut : //just en cas
Left(0) ;
} //end commutateur
} else //end
} //end loop()
/*
Voici les fonctions directionnelles. Taille de boucle = distance.
Numéros de mesure positive sont dans le sens horaire, négatif dans le sens antihoraire
*/
Sub (int distance)
{
pour (i = 0; i < distance; i ++) {}
right_motor.Step(1) ;
left_motor.Step(-1) ;
}
}
Sub vers le bas (int distance)
{
pour (i = 0; i < distance; i ++) {}
right_motor.Step(-1) ;
left_motor.Step(1) ;
}
}
vide laissé (int distance)
{
pour (i = 0; i < distance; i ++) {}
right_motor.Step(-1) ;
left_motor.Step(-1) ;
}
}
Sub droit (int distance)
{
pour (i = 0; i < distance; i ++) {}
right_motor.Step(1) ;
left_motor.Step(1) ;
}
}
Sub vertical (int distance)
{
pour (i = 0; i < distance; i ++) {}
right_motor.Step(2) ;
left_motor.Step(-.2) ;
}
}
Sub upLeft(int distance)
{
pour (i = 0; i < distance; i ++) {}
right_motor.Step(.2) ;
left_motor.Step(-2) ;
}
}
vide carrément (int distance)
{
pour (i = 0; i < distance; i ++) {}
right_motor.Step(-.2) ;
left_motor.Step(2) ;
}
}
Sub downLeft(int distance)
{
pour (i = 0; i < distance; i ++) {}
right_motor.Step(-2) ;
left_motor.Step(.2) ;
}
}
