ARGUS (3 / 5 paso)

Paso 3: programación

la codificación que usé es uno de

Jesper Birk

coche autónoma
Creado por Jesper Birk - 2014

motorPin1 int = 6; cable del motor conectado al pin digital 5
motorPin2 int = 5; cable del motor conectado al pin digital 6
int motorPin3 = 7; volante motor cable conectado al pin digital 7
int motorPin4 = 8; volante motor cable conectado al pin digital 8

int steeringMotorSpeed = 150; Establecer por defecto poder enviar al motor de dirección

int avoidDistance = 25;
int endAvoidDistance = 30;

int goToReverseDistance = 45;
int reverseTime = 2000;

int fullTrottleMinDistance = 150;

int fullTrottleSpeed = 220;
int cruiseSpeed = 160;
int avoidSpeed = 120;
int reverseSpeed = 130;

int sensorDelay = 100; //

largo randNumber;
int avoidDirection = 1;
int avoidCirclesBeforeDirectionChange = 10;
int cuenta = 1;
int distanceCountDown = 1;

#include "Ultrasonic.h"
Ultrasonic(12,13) ultrasónico;

int distancia = (ultrasónico. Ranging(cm));

El método setup() se ejecuta una vez, cuando comienza el bosquejo

void setup() {}

inicializar la comunicación serial a 9600 bits por segundo:
Serial.Begin(9600);

randomSeed(analogRead(0));

Inicializa los pines digitales como salida:
pinMode (motorPin1, salida);
pinMode (motorPin2, salida);
pinMode (motorPin3, salida);
pinMode (motorPin4, salida);
}

//////////// LOOP ////////////

void loop()
{
Serial.println ("Inicio bucle");

Serial.println (ultrasónico. Ranging(cm));

choseMode();

distancia = (ultrasónico. Ranging(cm));

MODO INVERSO / / /
Si (distancia < = goToReverseDistance) {}
avoidDirection = avoidDirection * -1;

while(Distance < avoidDistance) {}
Serial.println ("reverse start");
if(avoidDirection == 1) {/ / girar una forma
analogWrite (motorPin3, steeringMotorSpeed);
digitalWrite (motorPin4, bajo);
} else {/ /... o al revés
analogWrite (motorPin4, steeringMotorSpeed);
digitalWrite (motorPin3, bajo);
}
analogWrite (motorPin2, reverseSpeed); gira hacia atrás motor-
digitalWrite (motorPin1, LOW);
Delay(reverseTime); para el tiempo en reverseTime
Delay(sensorDelay);
distancia = (ultrasónico. Ranging(cm));
// }

digitalWrite (motorPin2, LOW); parada de motores
digitalWrite (motorPin3, bajo);
digitalWrite (motorPin4, bajo);

avoidDirection = avoidDirection * -1; interruptor de dirección dirección

distancia = (ultrasónico. Ranging(cm));
}
///////////////////////////////////////////////

EVITAR EL MODO / / /

distancia = (ultrasónico. Ranging(cm));

if(Distance < avoidDistance) {}
Serial.println ("comienzo Evite");

distancia = (ultrasónico. Ranging(cm));
cuenta regresiva = avoidCirclesBeforeDirectionChange;
distanceCountDown = distancia;

mientras que (distancia < = endAvoidDistance & & distancia > goToReverseDistance) {}
if(avoidDirection == 1) {}
analogWrite (motorPin3, steeringMotorSpeed); girar una forma
digitalWrite (motorPin4, bajo);
} else {}
analogWrite (motorPin4, steeringMotorSpeed); o la otra forma
digitalWrite (motorPin3, bajo);
}

analogWrite (motorPin1, avoidSpeed); gira el motor
digitalWrite (motorPin2, LOW); configurar el Pin motorPin2 baja
Delay(sensorDelay);
distancia = (ultrasónico. Ranging(cm));
if(Distance < distanceCountDown) {cuenta regresiva--;} / / si el obstáculo es cada vez más cercano - contar hacia abajo para cambiar de dirección
Si (cuenta regresiva < 1) {}
avoidDirection = avoidDirection * -1; interruptor de dirección dirección
cuenta regresiva = avoidCirclesBeforeDirectionChange;
distanceCountDown = distancia;
}
Serial.println(Distance);
Serial.println(avoidDirection);
} / / fin mientras que (no)
digitalWrite (motorPin3, bajo);
digitalWrite (motorPin4, bajo);
}
///////////////////////////////

CRUCERO DE MODO / / /
distancia = (ultrasónico. Ranging(cm));
mientras que (distancia > avoidDistance & & distancia < fullTrottleMinDistance) {}
analogWrite (motorPin1, cruiseSpeed); gira el motor
digitalWrite (motorPin2, LOW); configurar el Pin motorPin2 baja
Delay(sensorDelay);
distancia = (ultrasónico. Ranging(cm));
Serial.println("Cruise");
Serial.println(Distance);
} / / fin mientras
VELOCIDAD MÁXIMA MODO / / /
distancia = (ultrasónico. Ranging(cm));
while(Distance > fullTrottleMinDistance) {}
analogWrite (motorPin1, fullTrottleSpeed); gira el motor
digitalWrite (motorPin2, LOW); configurar el Pin motorPin2 baja
Delay(sensorDelay);
distancia = (ultrasónico. Ranging(cm));
Serial.println("Full");
Serial.println(Distance);
} / / fin mientras

Serial.println ("reinicio del bucle");
Serial.println(Distance);

}