Aspirateur robot bricolage bricolage sur Arduino bricolage

/*
Programme de contrôle d'un robot à deux moteurs.
Le robot tourne lorsque les moteurs changent de vitesse et de direction.
Les pare-chocs avant sur les côtés gauche et droit détectent les obstacles.
Les sonars à ultrasons peuvent être connectés à des entrées analogiques (testés sur LV-MaxSonar-EZ1):
- placez les broches dans les sonarPins du tableau dans l'ordre suivant: gauche, droite, avant, autres ..
Exemples:
1. uniquement les sonars gauche et droit connectés aux broches 2 et 3: sonarPins [] = {2,3}
2. sondeurs gauche, droit et avant connectés aux broches 2, 3 et 5: sonarPins [] = {2,3,5}
3. seul sonar avant connecté à la broche 5: sonarPins [] = {-1, -1.5}
4. seul sonar gauche connecté à la broche 2: sonarPins [] = {2}
5. seul sonar droit connecté aux broches 3: sonarPins [] = {-1,3}
6,5 sonars connectés aux broches 1,2,3,4,5: sonarPins [] = {1,2,3,4,5}
Le bouclier moteur est utilisé pour faire fonctionner les moteurs.
*/
const int Baud = 9600; // Vitesse du port UART

// Propriétés du sondeur
int sonarPins [] = {1, 2}; // Analog Pin Nums to sonar sensor Pin AN
const long MinLeftDistance = 20; // Distance gauche minimale autorisée
const long MinRightDistance = 20; // Distance droite minimale autorisée
const long MinFrontDistance = 15; // Distance frontale minimale autorisée
const int SamplesAmount = 15; // plus d'échantillons - mesure plus fluide et décalage plus important
const int SonarDisplayFrequency = 10; // affiche une seule de ces lignes - pas toutes
int sonarDisplayFrequencyCount = 0;
const long Factor = 2,54 / 2;
échantillons longs [sizeof (sonarPins)] [SamplesAmount];
int sampleIndex [sizeof (sonarPins)];

// côté droit
const int pinRightMotorDirection = 4; // ceci peut être marqué sur le bouclier du moteur comme "DIR A"
const int pinRightMotorSpeed ​​= 3; // ceci peut être marqué sur le bouclier du moteur comme "PWM A"
const int pinRightBumper = 2; // où le pare-chocs droit est connecté

// côté gauche
const int pinLeftMotorDirection = 7; // ceci peut être marqué sur le bouclier du moteur comme "DIR B"
const int pinLeftMotorSpeed ​​= 6; // ceci peut être marqué sur le bouclier du moteur comme "PWM B"
const int pinLeftBumper = 8; // où le pare-chocs droit est connecté

// décommenter les 2 lignes suivantes si le bouclier moteur est cassé
// const int pinRightMotorBreak = PUT_BREAK_PIN_HERE; // ceci peut être marqué sur le bouclier du moteur comme "BREAKE A"
// const int pinLeftMotorBreak = PUT_BREAK_PIN_HERE; // cela peut être marqué sur le bouclier du moteur comme "BREAKE B"

// champs
const int turnRightTimeout = 100;
const int turnLeftTimeout = 150;
// définir dans le compteur pendant combien de temps un moteur recule: N / 10 (en millisecondes)
int countDownWhileMovingToRight;
int countDownWhileMovingToLeft;

// Initialisation
void setup () {
Serial.begin (Baud);
initPins ();

// décommenter les 4 lignes suivantes si le bouclier moteur est cassé
// pinMode (pinLeftMotorBreak, OUTPUT);
// pinMode (pinRightMotorBreak, OUTPUT);
// digitalWrite (pinLeftMotorBreak, LOW); // désactiver les pauses
// digitalWrite (pinRightMotorBreak, LOW); // désactiver les pauses

runRightMotorForward ();
runLeftMotorForward ();
startMotors ();
}

// Boucle principale
boucle vide () {

verifyAndSetRightSide ();
verifyAndSetLeftSide ();

processRightSide ();
processLeftSide ();

delay (10); // répéter toutes les 10 millisecondes
}

//---------------------------------------------------
void initPins () {
pinMode (pinRightMotorDirection, OUTPUT);
pinMode (pinRightMotorSpeed, OUTPUT);
pinMode (pinRightBumper, INPUT);
pinMode (pinLeftMotorDirection, OUTPUT);
pinMode (pinLeftMotorSpeed, OUTPUT);
pinMode (pinLeftBumper, INPUT);
pour (int i = 0; i pinMode (sonarPins [i], INPUT);
}

void startMotors () {
setMotorSpeed ​​(pinRightMotorSpeed, 255);
setMotorSpeed ​​(pinLeftMotorSpeed, 255);
}

void waitWhileAnyBumperIsPressed () {
while (checkBumperIsNotPressed (pinRightBumper)
&& checkBumperIsNotPressed (pinLeftBumper)) {
delay (20); // contrôle toutes les 20 millisecondes
}
}

void processRightSide () {
if (countDownWhileMovingToRight MinFrontDistance) // vérifie si la distance avant minimale autorisée n'est pas atteinte
retour
if (checkCounterIsNotSet (countDownWhileMovingToLeft)) // si le compteur n'est pas encore décompté
runLeftMotorBackward (); // exécuter le moteur droit vers l'arrière
countDownWhileMovingToLeft = turnLeftTimeout; // définir le compteur sur la valeur maximale pour démarrer le décompte
}

bool checkCounterIsNotSet (int counter) {
compteur de retour = SamplesAmount)
sampleIndex [pinIndex] = 0;
samples [pinIndex] [sampleIndex [pinIndex]] = valeur;
return true;
}

long CalculateAvarageDistance (int pinIndex) {
moyenne longue = 0;
pour (int i = 0; i moyenne + = échantillons [pinIndex] [i];
return average / SamplesAmount;
}