Étape 8: L’Arduino Code adapté à mon usage.
Cellbots base de code réécrite.#include < Servo.h >
#include < EEPROM.h >
Servo myservoFR ;
Servo myservoFL ;
Servo myservoRR ;
Servo myservoRL ;
Servo myservoHead ;
#define BUFFERSIZE 20
#define InferFPin 0 //Front goupille analogique de capteur déduit
broche analogique du capteur déduit //Back #define InferBPin 1
#define SonarPin 2 //sonar broche analogique
broche analogique de #define LeftEarPin 3 //left oreille
broche analogique de #define RightEarPin 4 //right oreille /
#define VoltPin 5 //analog broche 5 utilisée pour la détection de VoltageCheck.
#define LEDBlue 5
#define LEDGreen 6
#define LEDRed 7
#define servoPinHead 8 / / Servo contrôle l’angle du téléphone
#define FLpin 9
#define FRpin 10
#define RLpin 11
#define RRpin 12
#define ledPin 13 / / LED s’allume lors de l’exécution des servos
#define régulateur 20
#define OneDeg 5,65 //setting délai rotationnel pour égal à un degré (tapis volant 2)
#define OneDeg 9.04 //setting délai rotationnel pour égal à un degré (feuillus 2 roues)
Contrôle de la tension de la batterie est avéré pour être la chose la plus difficile, j’ai tenté. Après avoir tant batterie connectée et USB connecté...
donne des lectures différentes alors juste la batterie connectée. En fait les lectures analogiques ont été renversés en quelque sorte.
#define shutdownVoltageCheck 978 / / ce numéro est unique pour chaque diviseur de tension et de la batterie combo. Il s’agit de 20 % de la mine.
#define analogvoltconstant 144.6969
int iAnVal ; entrée de capteur sonar
int deg ;
int InferF = 0 ;
int InferB = 0 ;
int soundRT [72] ;
int soundLF [72] ;
distance de l’int [72] ;
int tempvolt ;
unsigned long BatteryIndex = 0 ;
unsigned long BatteryIndexThreshold = 150000 ; une dizaine de minutes.
unsigned long RegulatorIndex ;
unsigned long RegulatorTimerThreshold = 150000 ; intervalle, activer ou désactiver le régulateur de tension. une dizaine de minutes.
int VoltSampleSize = 1000 ;
Char = ' s dir' ; zéro la direction le bot a appris à conduire - vers l’avant, en arrière, à droite, à gauche, stop, définit pour arrêter.
int puissance =-1 ;
Boolean ConservePower = true ; Ceci détermine si le bot utilise power saving mode.
Warm-up int = 1000 ; délai pour démarrer l’installation en millisecondes.
Aucune configuration requise pour ces paramètres
servosActive booléen = false ; suppose que les servos ne se déplacent pas quand on commence
unsigned long stopRegulatorIndex=millis() ; utilisé pour le calcul de la RegulatorIndex course des servos
char incomingByte ; Contient des valeurs sérielles entrants
msg de char [8] ; Pour faire passer des messages retour Séris
char inBytes [BUFFERSIZE] ; Tampon pour la série dans les messages
int serialIndex = 0 ;
int serialAvail = 0 ;
** GAMME trouver ***-réglages sont pour les télémètres à ultrasons. OK pour lave comme-est si vous ne les avez pas sur votre robot
longue dist, microsecondes, cm pouces ; Utilisé par le télémètre pour le calcul des distances
const int rangePinForward = 2 ; Broche numérique pour le télémètre face vers l’avant (pour la distance de l’objet en face de bot)
const int rangeToObjectMargin = 25 ; (bot s’arrete lorsque ne distance plus proche que ce - la valeur 0 si aucun capteur)
const int rangePinForwardGround = 0 ; Broche numérique pour la baisse télémètre face à l’avant (pour bord de détection de la table)
const int rangeToGroundMargin = 0 ; Gamme en cm de la table (bot s’arrête lorsque la distance est supérieure à cette valeur 0 si aucun capteur)
const int rangeSampleCount = 3 ; Nombre de mesures à prendre et pour une valeur plus stable
//=============================================================================
void setup() {}
Serial.println ("start setup!") ;
Delay(Warmup) ;
mode de sortie d’entrée réglée ***
pinMode (LEDBlue, sortie) ;
pinMode (LEDGreen, sortie) ;
pinMode (LEDRed, sortie) ;
pinMode (servoPinHead, sortie) ;
pinMode(FLpin,OUTPUT) ;
pinMode(FRpin,OUTPUT) ;
pinMode(RLpin,OUTPUT) ;
pinMode(RRpin,OUTPUT) ;
pinMode (ledPin, sortie) ;
pinMode (régulateur, sortie) ;
digitalWrite(servoPinHead,0) ;
Serial.Begin(9600) ;
Serial3.Begin(115200) ;
lastNeckValue = readSetting (EEPROM_lastNeckValue, lastNeckValue) ;
Si (lastNeckValue! = DEFAULT_lastNeckValue) {}
myservoHead.attach(servoPinHead) ;
myservoHead.write(lastNeckValue) ;
// }
//***************************** Clear Sensor Map ************************
pour (deg = 0; deg < 72; deg = deg + 1) {}
soundRT [degrés] = 0 ;
soundLF [degrés] = 0 ;
distance [degrés] = 0 ;
}
défaut de servos éteint ***
myservoFR.detach() ;
myservoFL.detach() ;
myservoRR.detach() ;
myservoRL.detach() ;
LEDOff() ;
pinMode (régulateur, sortie) ; Affectez à broche 20 mode de sortie afin que le régulateur de VoltageCheck peut être activé ou désactivée.
digitalWrite (régulateur, faible) ; démarrer le régulateur de VoltageCheck en position d’arrêt.
Serial.println ("end configuration!") ;
}
//====================================================================================
Répond à plus de série et gère une pause et de rinçage les données à traiter avec Android comms série
void serialReply (char * sensorname, char * tmpmsg) {}
Serial3.Print(sensorname) ;
Serial3.Print(":") ;
Serial3.println(tmpmsg) ; Envoyer le message retour à la ligne sérielle
Attendez que le débogueur série se taire
Delay(200) ; Il s’agit d’un nombre magique
Serial3.Flush() ; efface toutes les données entrantes
}
Vérifier si assez RegulatorIndex se soit écoulée pour arrêter le bot et s’il est sûr d’aller de l’avant
Boolean checkIfStopBot() {}
int tempfrontsonar = Averagefive(SonarPin) ;
Serial.Print ("front sonar:") ;
Serial.println(tempfrontsonar) ;
int tempfrontinfer = Averagefive(InferFPin) ;
Serial.Print ("avant de conclure:") ;
Serial.println(tempfrontinfer) ;
int tempbackinfer = Averagefive(InferBPin) ;
Serial.Print ("dos déduire:") ;
Serial.println(tempbackinfer) ;
Serial.println() ;
Si ((dir == « f ») & & ((tempfrontsonar < rangeToObjectMargin) || (tempfrontinfer < 200))) {
Stop() ;
servosActive = false ;
retourne la valeur true ;
} ElseIf (dir == « b ») {}
Si (! () (tempbackinfer < 650) & & (tempbackinfer > 450))) {}
Stop() ;
servosActive = false ;
retourne la valeur true ;
}
}
retourne la valeur false ;
}
Envoyer commande au dispositif de Bluetooth pour débuter pairing
void pairBluetooth() {}
Serial3.Print("\r\n+INQ=1\r\n") ; Il s’agit de Seeedstudio maître/esclave (variation selon les besoins pour votre modèle)
}
Lit entrée série si disponible et analyse des commande lorsque le commandement intégral a été envoyé.
void readSerialInput() {}
serialAvail = Serial3.available() ;
Lire ce qui est disponible
pour (int i = 0; i < serialAvail; i ++) {}
Stocker dans la mémoire tampon.
inBytes [i + serialIndex] = Serial3.read() ;
Vérifier la fin de la commande.
Si (inBytes [i + serialIndex] == « \n » || inBytes [i + serialIndex] == «; » || inBytes [i + serialIndex] == ' >') {//Use ; lorsque vous utilisez le Serial Monitor
inBytes [i + serialIndex] = « \0 » ; fin du char de la chaîne
parseCommand(inBytes) ;
serialIndex = 0 ;
}
else {}
attend plus de la commande à venir plus tard.
serialIndex += serialAvail ;
}
}
}
Nettoie et traite la commande
void parseCommand(char* com) {}
Si (com [0] == « \0 ») {return;} //bit de vérification des erreurs
début int = 0 ;
commencer de commande
tandis que (com [Démarrer]! = ' <') {}
Start ++ ;
Si (com [Démarrer] == « \0 ») {}
ce n’est pas là. Doit être ancienne version
Démarrer = -1 ;
rupture ;
}
}
Start ++ ;
Passer au début
int i = 0 ;
tandis que (com [i + début - 1]! = « \0 ») {}
com [i] = com [start + i] ;
i ++ ;
}
performCommand(com) ;
}
void LEDWhite() {}
digitalWrite (7, faible) ;
digitalWrite (6, faible) ;
digitalWrite (5, faible) ;
}
void LEDOff() {}
digitalWrite (7, HIGH) ;
digitalWrite (6, HIGH) ;
digitalWrite (5, HIGH) ;
}
void Detach() {}
Serial.println ("détacher servos!") ;
myservoFR.detach() ;
myservoFL.detach() ;
myservoRR.detach() ;
myservoRL.detach() ;
Delay(150) ;
}
void Attach() {}
Serial.println ("Attach servos!") ;
myservoFR.attach(FRpin) ;
myservoFL.attach(FLpin) ;
myservoRR.attach(RRpin) ;
myservoRL.attach(RLpin) ;
digitalWrite (régulateur, HIGH) ;
}
void Forew() {}
Serial.println ("*** avant!") ;
dir = « f » ;
Si (pas checkIfStopBot()) {}
Attach() ;
myservoFR.write(180) ;
myservoFL.write(0) ;
myservoRR.write(180) ;
myservoRL.write(0) ;
RegulatorIndex = 0 ;
servosActive = true ;
}
}
void Backw () {}
int Tempdist = Averagefive(InferFPin) ;
Serial.Print ("distance en arrière:") ;
Serial.println(Tempdist) ;
Serial.println() ;
dir = « b » ;
Si (pas checkIfStopBot()) {}
Serial.println ("*** en arrière!") ;
Attach() ;
myservoFR.write(0) ;
myservoFL.write(180) ;
myservoRR.write(0) ;
myservoRL.write(180) ;
RegulatorIndex = 0 ;
servosActive = true ;
}
}
void Stop () {}
Serial.println ("*** Stop!") ;
myservoFR.detach() ;
myservoFL.detach() ;
myservoRR.detach() ;
myservoRL.detach() ;
dir = du ' ;
RegulatorIndex = 0 ;
serialReply ("i", « st ») ; Dire au téléphone que le robot arrêté ###
servosActive = false ;
}
vide laissé () {}
Serial.println ("*** tourner gauche!") ;
Attach() ;
myservoFR.write(180) ;
myservoFL.write(180) ;
myservoRR.write(180) ;
myservoRL.write(180) ;
dir = « l » ;
RegulatorIndex = 0 ;
servosActive = true ;
}
void droite () {}
Serial.println ("*** tourner droite!") ;
Attach() ;
myservoFR.write(0) ;
myservoFL.write(0) ;
myservoRR.write(0) ;
myservoRL.write(0) ;
dir = « r » ;
RegulatorIndex = 0 ;
servosActive = true ;
}
void CircleRt () {}
Serial.println ("*** cercle droit!") ;
Attach() ;
myservoFR.write(95) ;
myservoFL.write(0) ;
myservoRR.write(95) ;
myservoRL.write(0) ;
RegulatorIndex = 0 ;
}
void CircleLf () {}
Serial.println ("*** cercle gauche!") ;
Attach() ;
myservoFR.write(180) ;
myservoFL.write(85) ;
myservoRR.write(180) ;
myservoRL.write(85) ;
RegulatorIndex = 0 ;
}
void mydelay (int degress) {}
Serial.println (« mydelay start") ;
retard (int(OneDeg * degress)) ;
Serial.println ("end mydelay ») ;
}
int Averagefive (int listenpin) {}
moyenne d’int = 12 ;
int écouter [moyenne] ;
int index1 ;
int highindex = 0 ;
haut int = 0 ;
int lowindex = 0 ;
int faible = 1000 ;
total int = 0 ;
pour (index1 = 0; index1 < moyenne ; index1 = index1 + 1) {}
Ecoute [index1] = analogRead(listenpin) ;
Serial.println(Listen[index1]) ;
}
pour (index1 = 0; index1 < moyenne ; index1 = index1 + 1) {}
Si (Ecoute [index1] > haute) {}
élevé = Ecoute [index1] ;
highindex = index1 ;
}
}
pour (index1 = 0; index1 < moyenne ; index1 = index1 + 1) {}
Si (Ecoute [index1] < faible) {}
faible = Ecoute [index1] ;
lowindex = index1 ;
}
}
pour (index1 = 0; index1 < moyenne ; index1 = index1 + 1) {}
Si ((index1! = highindex) & & (index1! = lowindex)) {}
Total = total + Ecoute [index1] ;
}
}
Total = int (total / (moyenne-2)) ;
Serial.Print ("moyenne:") ;
Serial.println(total) ;
retour au total ;
}
Sub {Listen()
Serial.println ("=== Ecoute ===!") ;
pour (deg = 0; deg < 71; deg = deg + 1) {}
soundRT [degrés] = Averagefive(RightEarPin) ; écouter à l’oreille droite et assigner la valeur à tableau
soundLF [degrés] = Averagefive(LeftEarPin) ; écouter à l’oreille gauche et assigner la valeur à tableau
distance [degrés] = Averagefive(SonarPin) ; lire une valeur à partir du capteur
Serial.println(distance[deg]) ; afficher la valeur écrite dans le tableau de la distance pour ce sens
Right() ;
mydelay(5) ;
Stop() ;
}
Stop() ;
}
void Course() {}
int BestDistDeg = 0 ;
int BestDist = 0 ;
pour (deg = 0; deg < 71; deg = deg + 1) {}
soundRT [degrés] = analogRead(RightEarPin) ; écouter à l’oreille droite et assigner la valeur à tableau
soundLF [degrés] = analogRead(LeftEarPin) ; écouter à l’oreille gauche et assigner la valeur à tableau
Si (distance [deg + 1] > {distance[BestDistDeg])}
BestDistDeg = deg + 1 ;
}
Serial.Print("BestDist=") ;
Serial.println(distance[BestDistDeg]) ;
Serial.println(BestDistDeg) ; afficher la valeur écrite dans le tableau de la distance pour ce sens
}
Left() ;
mydelay((71-BestDistDeg) * 5) ; Tournez droite jusqu'à ce que le cours correspondant à plus longue distance est atteinte.
Stop() ;
Forew() ;
}
void ForewardBackward() {}
Serial.println ("*** Foreward Backward test Start!") ;
Forew() ;
Delay(2000) ;
Stop() ;
Delay(2000) ;
Backw() ;
Delay(2000) ;
Stop() ;
Delay(2000) ;
Serial.println ("*** Foreward Backward test fin!") ;
}
Sub base() {}
myservoFR.detach() ;
myservoFL.detach() ;
myservoRR.detach() ;
myservoRL.detach() ;
Delay(2500) ;
myservoFR.attach(FRpin) ;
myservoFL.attach(FLpin) ;
myservoRR.attach(RRpin) ;
myservoRL.attach(RLpin) ;
Serial.println ('envoi 110') ;
myservoFR.write(180) ;
myservoFL.write(0) ;
myservoRR.write(180) ;
myservoRL.write(0) ;
Delay(2500) ;
myservoFR.detach() ;
myservoFL.detach() ;
myservoRR.detach() ;
myservoRL.detach() ;
Delay(2500) ;
myservoFR.attach(FRpin) ;
myservoFL.attach(FLpin) ;
myservoRR.attach(RRpin) ;
myservoRL.attach(RLpin) ;
Serial.println('sending70') ;
myservoFR.write(0) ;
myservoFL.write(180) ;
myservoRR.write(0) ;
myservoRL.write(180) ;
Delay(2500) ;
}
void degreetest() {}
Serial.println ("start degreetest") ;
Stop() ;
Delay(5000) ;
Right() ;
mydelay(360) ;
Serial.println ("end degreetest") ;
}
void Signalblink() {}
LEDWhite() ;
Delay(500) ;
LEDOff() ;
Delay(500) ;
}
void forwardinfertest() {}
Delay(500) ;
Serial.Print ("senor SATTILITE avant:") ;
Serial.println(analogRead(InferFPin)) ;
seuil de danger < 200
}
void backwardinfertest() {}
Delay(500) ;
Serial.Print ("senor SATTILITE vers l’arrière:") ;
Serial.println(analogRead(InferBPin)) ;
seuil de danger < 300
}
void sonartest() {}
Delay(500) ;
Serial.Print ("senor Sonar:") ;
Serial.println(analogRead(SonarPin)) ;
seuil de danger < 30
}
int VoltageCheck() {}
index1 int = 0 ;
double voltsum = 0 ;
int analogvolt = 0 ;
pour (index1 = 0; index1 < VoltSampleSize ; index1 = index1 + 1) {}
voltsum = voltsum + analogRead(VoltPin) ;
}
analogvolt = int (voltsum / VoltSampleSize) ;
Serial.Print ("VoltageCheck:") ;
Serial.Print ("analag volt:") ;
Serial.println(analogvolt) ;
Serial.Print ("volt réel:") ;
Serial.println ((analogvolt / analogvoltconstant)) ;
Serial.println() ;
Return analogvolt ;
}
Sub BatteryCheckLED()
{
Si (VoltageCheck() > shutdownVoltageCheck) {}
digitalWrite (LEDRed, basse) ;
digitalWrite (LEDGreen, élevé) ;
} else {}
digitalWrite (LEDRed, élevé) ;
digitalWrite (LEDGreen, basse) ;
}
BatteryIndex = 0 ;
}
Sub RegulatorControlToggle()
{
puissance = puissance * -1 ;
Si (puissance == 1) {}
digitalWrite (régulateur, HIGH) ;
}
Si (puissance == -1) {}
digitalWrite (régulateur, faible) ;
}
RegulatorIndex = 0 ;
}
Sub Miser()
{
RegulatorIndex = RegulatorIndex + 1 ;
Si (RegulatorIndex == RegulatorTimerThreshold) RegulatorControlToggle() ;
}
//********************************************* end mine *******************************************
void performCommand(char* com) {}
volt de flotteur = 0 ;
Si (strcmp (com, « f ») == 0) {/ / avance
Forew() ;
} else if (strcmp (com, « r ») == 0) {/ / droite
Right() ;
} else if (strcmp (com, « l ») == 0) {/ / gauche
Left() ;
} else if (strcmp (com, « b ») == 0) {/ / vers l’arrière
Backw() ;
} else if (strcmp (com, « s ») == 0) {/ / Stop
Stop() ;
} else if (strcmp (com, « fr ») == 0 || strcmp (com, « fz ») == 0 || strcmp (com, « x ») == 0) {/ / impression face à capteur de distance
Dist = Averagefive(SonarPin) ;
EGTI (dist, msg, 10) ; Transformer un char de l’int dist
serialReply (« x », msg) ; Envoyer la distance sur la ligne série
} else if (strcmp (com, « z ») == 0) {/ / lecture et impression au sol face à capteur de distance
Dist = Averagefive(SonarPin) ; Dist = getDistanceSensor(rangePinForwardGround) ;
EGTI (dist, msg, 10) ; Transformer un char de l’int dist
serialReply (« z », msg) ; Envoyer la distance sur la ligne série
Serial.println(DIST) ;
} else if (strcmp (com, « v ») == 0) {/ / lire et imprimer VoltageCheck
v = VoltageCheck() ;
EGTI (volt, msg, 10) ; Transformer un char de l’int volt
Serial.println(Volt) ;
serialReply (« v », msg) ; Envoyer la distance sur la ligne série
} else if (strcmp (com, « h ») == 0) {/ / Help mode - activer/désactiver le débogage
Signalblink() ;
} ElseIf (com [0] == ' n ') {/ / déplacer la tête vers le haut
sscanf (com, « n %d », & lastNeckValue) ; Analyser l’entrée en plusieurs valeurs
myservoHead.attach(servoPinHead) ;
myservoHead.write(lastNeckValue) ;
EEPROM.write (EEPROM_lastNeckValue, lastNeckValue) ;
Si {(débogage)
Serial.Print ("cou déplacé vers") ;
Serial.println(lastNeckValue) ;
//}
} ElseIf (com [0] == « p ») {/ / initie Bluetooth appairage jusqu'à un autre périphérique peut se connecter
pairBluetooth() ;
} else {}
serialReply ("e", com); / / Echo commande inconnue retour
Si {(débogage)
Serial.Print ("commande inconnue:") ;
Serial.println(com) ;
// }
0-9, w, n, o, i, c, h, d pour démo,
}
}
=== Principaux boucle en cours d’exécution à tous les RegulatorIndexs ===
void loop()
{
readSerialInput() ;
checkIfStopBot() ;
BatteryIndex = BatteryIndex + 1 ;
Si (BatteryIndex == BatteryIndexThreshold) BatteryCheckLED() ;
Si (ConservePower) Miser() ;
}
