Hackear un Robot Rumble

El objetivo es crear un robot de buscador. Puse dos sensores de ping en esto. Izquierda se ping, luego derecha, luego a la izquierda, luego a la derecha. Estos valores se almacenan en una matriz. Esto da 4 los valores a utilizar para el análisis. El objetivo es detectar el movimiento. He encontrado que hay alguna variación en las mediciones de ping y además, los sensores no están alineados, hay un valor para la tolerancia. Si hay un cambio en el valor entonces se produjo el movimiento y el robot se moverá hacia el movimiento.

Aquí está el bosquejo. Tengo por lo que círculo y buscar. Pero no tengo un robot para que pueda perseguir, que llegará la próxima semana. Lo sentimos el código no es super limpio. Pero eso es un trabajo en progreso.

++++++++++++++++++++++++++++++++++++++++

Esto es para probar cómo hacer funciones de trabajo. Buena.
Parpadeo de LEDs muy bien.
Dos paradita ping y devuelva la distancia en cm.
Esto tiene una matriz de creación de la memoria.
Ahora uso de la medición de la distancia y las decisiones en base a.

vcount int = 0;
int vSonarTime = 0; Este será el valor del tiempo del ping sonar, que es la distancia
int arrSonarPin [] = {}
4.2}; Esto es a la izquierda luego a la derecha de sonar
svar int = 0; variable para algo
int sonarLeft = 0;
int sonarRight = 0;
int vTolerate = 10; se trata de los microsegundos de error en el ping que es ignorado
int arrScanz [96]; Esto es donde van las decisiones sobre las decisiones de comparePing
int arrScanzEnd = 95; número del elemento del extremo de matriz arrScanz
int vScanz = 0; var global alcanzado a registramos resultados del análisis de exploración
int vMovementRight = 3; iniciar con 3 a ver si más adelante hay un error
int vMovementLeft = 3; iniciar con 3 a ver si más adelante hay un error
int vCloserRight = 3;
int vCloserLeft = 3;
int vStayPut = 3;

int aPoints [48]; quiere hacer distancias y puntos de la matriz
int PointsEnd = 47;
vPoint int = 0; Esto es init para el uso como los cada vez más elementos de la matriz donde se almacenan distancias.
Porque esto es mundial nos puede usitilize en funciones. Pero sólo StorePoint() modificará vPoint
int i; para contar para bucles
int LedA = 13; a bordo
int LedB = 12; rojo
int LedC = 9; rojo
int LedD = 8; verde
greenLED int = 8; más fácil de recordar

int arrLed [] = {LedA, LedD LedB, LedC,};
int arrLedEnd = 3; la arrLed de la matriz tiene 4 miembros, última es #3

int motorpinright = 10; perno para motor derecho rojo
int motorpinleft = 11; PIN para el amarillo adelante motor izquierda
int motorpinrevright = 5; perno para motor derecho negro reverso
int motorpinrevleft = 6; perno para motor derecho verde adelante
int vMoveTime = 200; se trata de var para la época que se trasladó
int vDelayTime = 250;

void setup() {}
Serial.Begin(9600);
pinMode(LedA,OUTPUT);
pinMode(LedB,OUTPUT);
pinMode(LedC,OUTPUT);
pinMode(LedD,OUTPUT);
pinMode (motorpinright, salida); Impulsiones del motor---
pinMode (motorpinleft, salida); //------------------------
pinMode (motorpinrevright, salida); //------------------------
pinMode (motorpinrevleft, salida); //------------------------
para (i = 0; i < PointsEnd; i ++) {/ / necesario inicializar la matriz de distancias aPoints]
aPoints [i] = 0;
} / / Fin del bucle for
para (i = 0; i < arrScanzEnd; i ++) {/ / necesario inicializar la matriz [] de arrScanz
arrScanz [i] = 0;
} / / Fin del bucle for

} / / final de bucle vacío

void loop() {}
digitalWrite(13,LOW); bajo para empezar a
Serial.println ("arranque en bucle principal");

blinxAll(arrLedEnd); Llamar a función de culo fantasia. No se asigna un valor externo

ShowArrayContents();

BlinxOne(greenLED,100,6);

DetectMovement(); Hace pings en 3 direcciones

DecideWhichWay(); Si no detecta ningún movimiento entonces moverse y buscar
extremo la decisión

vMoveTime = 200;
Serial.Print ("justo fuera sonarx. vSonarTime = ");
Serial.println(vSonarTime);
Serial.println ("fuera de la función blinxAll");
arrLedEnd = 3;

int vMovementRight = 3; iniciar con 3 a ver si más adelante hay un error
int vMovementLeft = 3; iniciar con 3 a ver si más adelante hay un error
int vStayPut = 3;

} / / fin del bucle
//+++++++++++++++++++++++++++++++++++++++++++
*** Declarar funciones ***
//+++++++++++++++++++++++++++++++++++++++++++
sonarx int (int vpin) {/ / esta función será llamada el módulo del sonar para hacer ping y devolver un valor de ping
int x = 5;
int vPingDist = 0; no onger necesitada
int vDuration; , pulgadas, cm;
x = vpin; Este es el número de pin
Serial.Print ("en vpin sonarx y valor:");
Serial.Print(x);
pinMode (vpin, salida);
digitalWrite (vpin, LOW);
delayMicroseconds(2);
digitalWrite (vpin, HIGH);
delayMicroseconds(5);
digitalWrite (vpin, LOW);

El mismo pin se utiliza para leer la señal del PING))): un alto
pulso cuya duración es el tiempo (en microsegundos) de envío
del ping a la recepción de su eco de un objeto.
pinMode (vpin, entrada);
vDuration = pulseIn (vpin, HIGH);

cm = microsecondsToCentimeters(vDuration);

Serial.Print ("vDuration:");
Serial.println(vDuration);

volver vDuration;
}
//+++++++++++++++++++++++++++++++++++++++++++

int microsecondsToCentimeters (int microsegundos)
{
La velocidad del sonido es 340 m/s o 29 microsegundos por centímetro.
El ping viaja hacia fuera y hacia atrás, para encontrar la distancia de la
objeto que tomamos la mitad de la distancia recorrida.
volver microsegundos / 29 / 2;
}

//+++++++++++++++++++++++++++++++++++++++++++
void blinxAll (int arrLedEndi) {}
int ivar1;

Serial.Print ("en la función blinxAll, el valor es:");
Serial.println(arrLedEndi);
Delay(100);

para (int i = 0; i < = arrLedEndi; i ++) {}
ivar1 = arrLed [i]; / * i es el lugar de la matriz, y esto cambia cada lazo.
Se asigna el valor de la matriz. Este es el número de pin del LED
que será outputted.* /
Serial.Print ("el valor de ivar1 es:");
Serial.Print(ivar1);
digitalWrite(ivar1,HIGH);
Delay(100);
digitalWrite(ivar1,LOW);
Delay(100);
} / / Fin del ciclo para a través de la matriz

Serial.println ("fin de la función blinxAll");

} / / Fin función
//+++++++++++++++++++++++++++++++++++++++++++
void BlinxOne (int vLED, int vDelay, int numBlinks) {/ / vLED tiene opciones de arriba. vDelay es
vLED int;
vDelay = 100;
Serial.Print ("valor de la función en el BlinxOne, es:");
Serial.println(vLED);
Delay(vDelay);
para (int i = 0; i < = numBlinks; i ++) {}
digitalWrite(vLED,HIGH);
Delay(vDelay);
digitalWrite(vLED,LOW);
Delay(vDelay);
} //End de bucle
Serial.println ("final de la función BlinxOne");

} / / Fin función BlinxOne
//+++++++++++++++++++++++++++++++++++++++++++
void MoveAhead() {}
int ivar1 = LedD;
digitalWrite(ivar1,HIGH);

int v2MoveTime = vMoveTime;
Serial.Print ("vMoveTime vale la MoveAhead:");
Serial.println(v2MoveTime);
Esto moverá bot adelante durante un tiempo pasado a función
analogWrite (motorpinleft, 0); motor izquierdo parada
analogWrite (motorpinright, 0); parada de motor derecha
analogWrite (motorpinleft, 255); motor izquierdo parada
analogWrite (motorpinright, 255); parada de motor derecha
Delay(vMoveTime);
analogWrite (motorpinleft, 0); motor izquierdo parada
analogWrite (motorpinright, 0); parada de motor derecha

digitalWrite(ivar1,LOW); Apague la luz verde
vMoveTime = 0; prevenir bucles sin fin ++ fugitivos que es
}
//+++++++++++++++++++++++++++++++++++++++++++
void MoveBack() {}
Serial.println ("volviendo OK!!");
int v2MoveTime = vMoveTime;
Serial.Print ("vale la pena vMoveTime:");
Serial.println(v2MoveTime);

analogWrite (motorpinrevleft, 255); motor izquierdo parada
analogWrite (motorpinrevright, 255); parada de motor derecha
Delay(vMoveTime);
analogWrite (motorpinrevleft, 0); motor izquierdo parada
analogWrite (motorpinrevright, 0); parada de motor derecha
vMoveTime = 0; prevenir bucles sin fin ++ fugitivos que es
}
//+++++++++++++++++++++++++++++++++++++++++++
void TurnRight90() {}
int v2MoveTime = vMoveTime;
Serial.Print ("vale la pena vMoveTime TurnRight90:");
Serial.println(v2MoveTime);

analogWrite (motorpinrevleft, 255); motor izquierdo parada
analogWrite (motorpinright, 255); parada de motor derecha
Delay(vMoveTime);
analogWrite (motorpinrevleft, 0); motor izquierdo parada
analogWrite (motorpinright, 0); parada de motor derecha
vMoveTime = 0; prevenir bucles sin fin ++ fugitivos que es
}
//+++++++++++++++++++++++++++++++++++++++++++

void TurnLeft45() {}
int vMoveTime2 = (vMoveTime/2);
Serial.Print ("vale la pena vMoveTime TurnLeft45:");
Serial.println(vMoveTime2);

analogWrite (motorpinleft, 0); arranque motor izquierda
Delay(vMoveTime2); Se trata de la mitad para hacer la vuelta
analogWrite (motorpinright, 255); Inicio motor derecho
Delay(vMoveTime);
analogWrite (motorpinleft, 0); motor izquierdo parada
analogWrite (motorpinright, 0); parada de motor derecha
vMoveTime = 0; prevenir bucles sin fin ++ fugitivos que es
}
//+++++++++++++++++++++++++++++++++++++++++++

void TurnRight45() {}
int vMoveTime2 = (vMoveTime/2);
Serial.Print ("vale la pena vMoveTime TurnRight45:");
Serial.println(vMoveTime2);

analogWrite (motorpinleft, 255); arranque motor izquierda
Delay(vMoveTime);
analogWrite (motorpinright, 0); Inicio motor derecho
Delay(vMoveTime2); Se trata de la mitad para hacer la vuelta
analogWrite (motorpinleft, 0); motor izquierdo parada
analogWrite (motorpinright, 0); parada de motor derecha
vMoveTime = 0; prevenir bucles sin fin ++ fugitivos que es
}

//+++++++++++++++++++++++++++++++++++++++++++
void TurnLeft90() {}
int v2MoveTime = vMoveTime;
Serial.Print ("vale la pena vMoveTime TurnLeft90:");
Serial.println(v2MoveTime);

analogWrite (motorpinleft, 255); motor izquierdo parada
analogWrite (motorpinrevright, 255); parada de motor derecha
Delay(vMoveTime);
analogWrite (motorpinleft, 0); motor izquierdo parada
analogWrite (motorpinrevright, 0); parada de motor derecha
vMoveTime = 0; prevenir bucles sin fin ++ fugitivos que es
}
//+++++++++++++++++++++++++++++++++++++++++++
void AllStop() {}
analogWrite (motorpinleft, 0); motor izquierdo parada
analogWrite (motorpinright, 0); parada de motor derecha
analogWrite (motorpinrevright, 0); parar motor rev de derecho
analogWrite (motorpinrevleft, 0); parar motor izquierda rev

}
//+++++++++++++++++++++++++++++++++++++++++++
función StorePoint almacenará valores de punto en una matriz
void StorePoint () {}
Si (vPoint < = PointsEnd) {}
aPoints [vPoint] = sonarx(svar); hacer esto una función en algún momento
vPoint ++; vPoint variable de incremento
}
Else {}
vPoint = 0;
aPoints [vPoint] = sonarx(svar); hacer esto una función en algún momento
}
}
//+++++++++++++++++++++++++++++++++++++++++++
función StoreScanz
void StoreScanz (int vfScan) {}
Si (vScanz < = arrScanzEnd) {}
arrScanz [vScanz] = vfScan;
vScanz ++; incrementar el contador de vScanz
} else
{
vScanz = 0;
arrScanz [vScanz] = vfScan;
}
}
//+++++++++++++++++++++++++++++++++++++++++++
void get4pings() {}
Haz 2 sets de valores izquierdos y derecho.
para (int f = 0; f < = 1; f ++) {}
Do la función ping, primera a la izquierda luego derecha.
para (int b = 0; b < = 1; b ++) {}
SVAR = arrSonarPin [b]; Elija el pin de ping de izquierda y derecha: 4 queda ahora
vSonarTime = sonarx(svar); Llamar función sonarx para medir el tiempo de distancia del ping.
asignar este valor a vSonarTime es probablemente inútil
StorePoint(); se llama función sonarx en esta función vPoint es un Var Global

la distancia actual se almacena en un elemento de matriz
{if(b==0)}
Serial.Print ("sonarx asignado mano izquierda vPoint valor =");
Serial.println(vPoint); vPoint es la Variable global a utilizar.
}
Else {}
Serial.Print ("sonarx asignado mano derecha vPoint valor =");
Serial.println(vPoint); vPoint es la Variable global a utilizar.
} / / fin del if else
} / / final de bucle for. Dos valores asignados en la matriz de memoria. 2 valores de conjuntos de izquierda y derecho.
} / / Fin del bucle que obtiene 4 valores
} //End valores de get4 de la función
//++++++++++++++++++++++++++++++++++++++++++++
Una función para imprimir el contenido de la matriz.

void ShowArrayContents() {}
se utiliza para el diagnóstico y solución de problemas.
para (i = 0; i < = PointsEnd; i ++) / impresión hacia fuera de la matriz de distancias medidas
{
Serial.Print ("i =");
Serial.Print(i);
Serial.Print ("aPoints valor es =");
Serial.Print(aPoints[i]);
Serial.println();
} / / Fin del bucle for.
} / / Fin función ShowArrayContents
//+++++++++++++++++++++++++++++++++++++++++++++
int comparePings() / / si conocemos la posición de la última matriz elemento escrito, entonces podemos comparar thingz
{/ / comienzo de la función
int s = 1; Esto pasará sólo por una vez.
int t = 2;
int vComparePingsLD = abs ((aPoints[vPoint-1]) - (aPoints[vPoint-3])); esta muestra ' D'epth movimiento
int vComparePingsRD = abs ((aPoints[vPoint-0]) - (aPoints[vPoint-2]));
int vComparePingsRC = abs ((aPoints[vPoint-0]) - (aPoints[vPoint-1])); Esto demuestra de qué lado ha ' C'losest ping
int vComparePingsLC = abs ((aPoints[vPoint-3]) - (aPoints[vPoint-4]));

Serial.Print ("vComparePingsLD valor es:");
Serial.println (vComparePingsLD);
Serial.Print ("vComparePingsRD valor es:");
Serial.println (vComparePingsRD);
Serial.Print ("vComparePingsRC valor es:");
Serial.println (vComparePingsRC);
Serial.Print ("vComparePingsLC valor es:");
Serial.println (vComparePingsLC);

mientras que (s < t) {/ / resaon mirar allí es un tiempo bucle sólo funcionó una vez.
Si ((aPoints [vPoint-1] == aPoints[vPoint-3]) || (vComparePingsLD < = vTolerate))
{//if son eqivalent entonces no hay ningún movimiento hacia o lejos de pinger
arrScanz [vScanz] = 0; no hay movimiento
Serial.Print ("los puntos de profundidad del lado izquierdo son equivalentes:");
Serial.Print (aPoints[vPoint-3]);
Serial.Print ("");
Serial.println (aPoints[vPoint-1]);
vScanz ++;
vScanz ++;
}
Else {}
vMovementLeft = 1;
arrScanz [vScanz] = 1; hubo movimiento
vScanz ++;
vScanz ++;
}

Si (((aPoints[vPoint]) == (aPoints[vPoint-2])) || (vComparePingsRD < = vTolerate))
{//if son eqivalent entonces no hay ningún movimiento hacia o lejos de pinger
arrScanz [vScanz] = 0; no hay movimiento
Serial.Print ("los puntos de profundidad del lado derecho son equivalentes:");
Serial.Print (aPoints[vPoint-2]);
Serial.Print ("");
Serial.println (aPoints[vPoint]);
vScanz ++;
}
Else {}
vMovementRight = 1;
arrScanz [vScanz] = 1; hubo movimiento
vScanz ++;
vScanz ++;
}

Si (((aPoints[vPoint]) == (aPoints[vPoint-1])) || (vComparePingsRC < = vTolerate))
{//check para ver qué forma tiene el objeto más cercano
Serial.Print ("el más reciente dos distancias de izquierda y derecha se queda:");
Serial.Print (aPoints[vPoint-1]);
Serial.Print ("luego a la derecha:");
Serial.println (aPoints[vPoint]);
vScanz ++;
}
Else {}
Si ((aPoints [vPoint - 1]) < (aPoints[vPoint])) {/ / comenzar si
vCloserLeft = 1;
vCloserRight = 0;
} / / fin si
otra cosa
{
vCloserLeft = 0;
vCloserRight = 1;
arrScanz [vScanz] = 1; hubo movimiento
vScanz ++;
vScanz ++;
} / / fin otra
} / / fin otra

Si (((aPoints[vPoint-3]) == (aPoints[vPoint-4])) || (vComparePingsLC < = vTolerate))
{//check para ver qué forma tiene el objeto más cercano
Creo que necesito esto actualmente. Hmmmm
Serial.Print ("quedan mayores dos distancias de izquierda y derecha:");
Serial.Print (aPoints[vPoint-4]);
Serial.Print ("luego a la derecha:");
Serial.println (aPoints[vPoint-3]);
vScanz ++;
}
otra cosa
{
arrScanz [vScanz] = 1; hubo movimiento
vScanz ++;
}
terminar si
s + +; incrementar el tiempo bucle
} //end la mientras la función
Delay(500); Para que me deje leer al Monitor serie. Retire esto más adelante.
} / / fin de la función
//++++++++++++++++++++++++++++++++++++++++++++
void DetectMovement() {//Does pings en 3 direcctions
ir left45 ping right45 (que es el centro) luego right45 luego decidir si hay movimiento.
int s = 0;
int t = 2; Esto se puede ajustar para exploraciones más
fDelay int = 100; número interno del retraso entre exploraciones
vMoveTime = 500; Esta es una variable global que ha cambiado mucho
TurnLeft45(); Esto es el movimiento inicial arbitrario. Que ordenar los datos de exploración más fácil.
Serial.println ("left45 de turno, obtener valores");

mientras que (s < t) {}
get4pings();
Delay(fDelay);
comparePings(); Cuando se llama a esto las comparaciones decidirá movimiento o no movimiento

s = s + +;
TurnRight45();
Serial.println ("right45 de turno, obtener valores");
} / / fin mientras
s = 0; restablecer la variable de función

Comparar los valores recogidos.

Delay(fDelay);

} / / Fin función DetectMovement
//++++++++++++++++++++++++++++++++++++++++++++
void DecideWhichWay() {}

Si (aPoints [vPoint] > 200) {}
vMoveTime = (aPoints[vPoint]/10); da una escala a utilizar en función de distancia
}
Else {/ / demasiado así que a su vez sólo
vMovementLeft = 0;
vMovementRight = 0;
}

Si (vMovementLeft == 1) {}
TurnLeft45 ();
MoveAhead ();
} / / fin si
else if (vMovementRight == 1) {}
TurnRight45 ();
MoveAhead ();
} //
else if (vStayPut == 0) {}
vMoveTime = vMoveTime;
MoveAhead();
} //

Else {/ / permanecer en el lugar, pero girar derecha 90 para explorar la nueva zona.
TurnRight90();
AllStop();
} / / fin otra

} / / Fin función DecideWhichWay
//+++++++++++++++++++++++++++++++++++++++++++++