Wallbots : Autonomous Robots magnétiques que parcourir les Surfaces verticales (11 / 12 étapes)

Etape 11 : Télécharger le Code sur l’Arduino

/*
Code Wallbots
Stacey Kuznetsov
6 mai 2009
pour rendre les choses Interactive, printemps ' 09

C’est le code de base pour le mouvement robotique de 2 moteurs sevo basé sur l’entrée de la route
de 4 capteurs de lumière. Motion prend en charge plusieurs paramètres, basés sur le mode de robot.
Les robots rouges se déplacent vite, vers les objets (lorsque la lumière capteurs détectent des ténèbres)
Verts robots se déplacent à une vitesse moyenne, l’écart d’objets (loin des zones plus foncées)
Déplacent slowerly robots jaunes et arrêtent de clignoter lorsque les objets sont détectés

Le but de ces robots est de passer sur les murs à l’aide de roues magnétiques.
Mouvement de prise en charge inclut à droite, directions vers l’avant et à gauche. Plusieurs
vitesses sont mises en œuvre selon le mode de robot.

Les capteurs de lumière auto-étalonnage sur remise à zéro ou lorsque le capteur haut est couvert
pendant plus de 3 secondes.

*/

#include < Servo.h >

Servos de droite et gauche
Servo servo1 ;
Servo servo2 ;

Capteurs de lumière
int topSensor = 0 ; 700
int leftSensor = 1 ; Seuil est 400
int frontSensor = 2 ; 400
int rightSensor = 3 ; 300

Seuils de codé en dur (ne pas utilisés car nous auto-étalonnage)
int topThreshhold = 400 ;
int leftThreshhold = 550 ;
int frontThreshhold = 200 ;
int rightThreshhold = 650 ;

Type de robot actuel (gree rouge ou jaune)
État int = 0 ;

Valeurs de l’États
int rouge = 0 ;
int vert = 1 ;
int ORANGE = 2 ;

Broches pour conduire la LED tricolore haut de la page
int redPin = 5 ;
int greenPin = 6 ;

Values pour contenir les lectures du capteur
int avant ;
droit int ;
int gauche ;
haut int ;

Auto-étalonnage seuils capteur de lumière
void calibrate() {}
Serial.println("Calibrating") ;
long int val = 0 ;
pour (int i = 0; i < 5; i ++) {}
Val += analogRead(frontSensor) ;
Delay(10) ;
}
frontThreshhold = (val 5) - 80 ;
Val = 0 ;

pour (int i = 0; i < 5; i ++) {}
Val = val + analogRead(topSensor) ;
Serial.println(analogRead(topSensor)) ;
Serial.println(Val) ;
Delay(10) ;
}

topThreshhold = (val 5) -200 ;

Val = 0 ;
pour (int i = 0; i < 5; i ++) {}
Val += analogRead(rightSensor) ;
}
rightThreshhold = (val 5) - 100 ;
Val = 0 ;
pour (int i = 0; i < 5; i ++) {}
Val += analogRead(leftSensor) ;
}
leftThreshhold = (val 5) - 100 ;

Imprimer les valeurs de seuil pour le débogage
Serial.Print ("top:") ;
Serial.println(topThreshhold) ;
Serial.Print ("raison:") ;
Serial.println(rightThreshhold) ;
Serial.Print ("gauche:") ;
Serial.println(leftThreshhold) ;
Serial.Print ("front:") ;
Serial.println(frontThreshhold) ;

}

void setup()
{
tourner sur la broche 13 pour debug
pinMode (13, sortie) ;
digitalWrite (13, HIGH) ;
broches de capteur d’installation
pour (int i = 0; i < 4; i ++) {}
pinMode (i, entrée) ;
}
Serial.Begin(9600) ;
CALIBRATE() ;
générer un état aléatoire
État = aléatoire (0, 3) ;
setColor(STATE) ;
}

FONCTIONS MOTRICES

Sub turnLeft()
{
Serial.println("left") ;

Start() ;
Delay(20) ;
pour (int i = 0; i < 20; i ++) {}
Servo2.Write(179) ;
SERVO1.Write(1) ;
Delay(20) ;
}
Stop() ;
Delay(20) ;
}

void turnRight() {}
Serial.println("Right") ;
Start() ;
Delay(20) ;
pour (int i = 0; i < 20; i ++) {}

Servo2.Write(1) ;
SERVO1.Write(179) ;
Delay(20) ;
}
Stop() ;
Delay(20) ;
}

goForward Sub (int del = 20) {}
Serial.println("Forward") ;
Start() ;
Delay(20) ;
pour (int i = 0; i < 20; i ++) {}
SERVO1.Write(179) ;
Servo2.Write(179) ;
Delay(del) ;
}
Stop() ;
Delay(20) ;
}

stop() Sub {}
SERVO1.Detach() ;
Servo2.Detach() ;
Delay(10) ;
}

void start() {}
SERVO1.Attach(10) ;
Servo2.Attach(9) ;

}

Ensemble en fonction de la couleur de la LED tricolore haut de la page sur l’état actuel
void setColor (int couleur) {}
Si (color = RED) {}
digitalWrite (greenPin, 0) ;
analogWrite (redPin, 180) ;
}
ElseIf (couleur == vert) {}
digitalWrite (redPin, 0) ;
analogWrite (greenPin, 180) ;
}
ElseIf (couleur == ORANGE) {}
analogWrite (redPin, 100) ;
analogWrite (greenPin, 100) ;
}
}

Cligner des yeux la couleur jaune (lorsque le robot est confondue)
void blinkOrange() {}
pour (int i = 0; i < 5; i ++) {}
analogWrite (redPin, 100) ;
analogWrite (greenPin, 100) ;
Delay(300) ;
digitalWrite (redPin, 0) ;
digitalWrite (greenPin, 0) ;
Delay(300) ;
}

analogWrite (redPin, 100) ;
analogWrite (greenPin, 100) ;

}

void loop()
{

Top = analogRead(topSensor) ;
temps d’int = millis() ;
tandis que (analogRead(topSensor) < topThreshhold) {}
Delay(10) ; Bien qu’il y a une vague de bras de l’utilisateur ne font rien
}
Si ((millis()-time) > 3000) {}
Si le capteur a été couvert pendant plus de 3 secondes, ré-étalonner
CALIBRATE() ;
}

Si le capteur haut était couvert, nous changeons d’État
Si (haut < topThreshhold) {}
ÉTAT = (ÉTAT + 1) 3 %;
setColor(STATE) ;
Serial.Print (« état modifié: ") ;
Serial.println(State) ;
}

Lire les autres capteurs
droite = analogRead(rightSensor) ;
gauche = analogRead(leftSensor) ;
avant = analogRead(frontSensor) ;

Si (état == rouge) {}
aller vers les objets
Si (avant < frontThreshhold) {}
goForward() ;
} ElseIf (droite < rightThreshhold) {}
turnRight() ;
} ElseIf (gauche < leftThreshhold) {}
turnLeft() ;
} else {}
goForward() ;
}
}
Si (état == vert) {}
Éloignez-vous des objets
Si (avant < frontThreshhold) {}
int dir = random(0,2) ;
Si (dir == 0 & & droit > rightThreshhold) {}
turnRight() ;
} ElseIf (dir == 1 & & gauche > leftThreshhold) {}
turnLeft() ;
}
} ElseIf (droite < rightThreshhold) {}
Si (gauche > leftThreshhold) {}
turnLeft() ;
} else {}
goForward() ;
}
} ElseIf (gauche < leftThreshhold) {}
Si (droite > rightThreshhold) {}
turnRight() ;
} else {}
goForward() ;
}
} else {}
goForward() ;
}
Delay(200) ;
}

Si (État == ORANGE) {}
déplacer uniquement s’il y a qu'aucun mouvements de main-autrement cligner des yeux
int dir = aléatoire (0, 3) ;
Si (gauche < leftThreshhold || droite < rightThreshhold ||
avant < leftThreshhold) {}
blinkOrange() ;
} else {}
Si (dir == 0) {}
goForward() ;
} ElseIf (dir == 1) {}
turnRight() ;
} ElseIf (dir == 2) {}
turnLeft() ;
}
Delay(1000) ;
}
Delay(10) ;
}
}