Einen Rumble Roboter hacken

Das Ziel ist die Schaffung einen Sucher-Roboter. Ich habe zwei Ping Sensoren auf dies. Linken Seite pingt, dann rechts, dann links, dann rechts. Diese Werte werden in einem Array gespeichert. Dies gibt 4 Werte, für die Analyse zu nutzen. Ziel ist es, die Bewegung zu erkennen. Ich fand, dass es einige Variationen in die Ping-Messungen und auch die Sensoren sind nicht genau ausgerichtet, so gibt es ein Wert für Toleranz. Wenn es eine Änderung im Wert dann Bewegung aufgetreten und der Roboter bewegt sich in Richtung der Bewegung.

Hier ist die Skizze. Ich habe damit es Kreisen und suchen wird. Aber ich habe keinen Roboter zu jagen, der nächste Woche kommen wird. Leider ist der Code nicht super sauber. Aber das ist ein Work In Progress.

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

Dies ist, wie man Funktionen arbeiten zu testen. Gute.
LEDs blinken ganz gut.
Zwei Pingern ping und den Abstand in cm zurück.
Dies hat eine Speichergruppe erstellen.
Jetzt die Distanzmessung und Entscheidungen auf dieser Basis.

Int Vcount = 0;
Int vSonarTime = 0; Dies wird den Wert der Zeit des Sonar-Ping, der ist der Abstand
Int ArrSonarPin [] = {}
4,2}; Dies ist links, dann rechts sonar
Int Svar = 0; Variable für etwas
Int SonarLeft = 0;
Int SonarRight = 0;
Int vTolerate = 10; Dies ist die Mikrosekunden der Fehler in der Ping-Befehl wird ignoriert
Int ArrScanz [96]; Dies ist, wo Entscheidungen über ComparePing Entscheidungen gehen
Int ArrScanzEnd = 95; Ende Elementnummer für Array arrScanz
Int vScanz = 0; globale Var zugegriffen, um ein Rekordergebnis von Scan-Analyse
Int vMovementRight = 3; mit 3 zu sehen, ob ein Fehler später vorliegt initialisieren
Int vMovementLeft = 3; mit 3 zu sehen, ob ein Fehler später vorliegt initialisieren
Int vCloserRight = 3;
Int vCloserLeft = 3;
Int vStayPut = 3;

Int aPoints [48]; Array-Punkte und Entfernungen machen wollen
Int PointsEnd = 47;
Int vPoint = 0; Dies ist der Speicherort erhalten Entfernungen Init würde für den Einsatz als die zunehmende Array-Elemente.
Weil dies global ist, können wir Usitilize es in Funktionen. Aber nur StorePoint() ändert vPoint
Int i; für die Zählung for-Schleifen
Int LedA = 13; an Bord
Int LedB = 12; rot
Int LedC = 9; rot
Int LedD = 8; Grün
Int GreenLED = 8; leichter zu erinnern

Int ArrLed [] = {LedA, LedB, LedC, LedD};
Int ArrLedEnd = 3; das Array ArrLed hat 4 Mitglieder, zuletzt ist #3

Int Motorpinright = 10; PIN für rechts motor rot
Int Motorpinleft = 11; PIN für linken motor nach vorne gelb
Int Motorpinrevright = 5; PIN für rechts motor reverse schwarz
Int Motorpinrevleft = 6; PIN für rechts motor vorwärts grün
Int vMoveTime = 200; Dies ist für die Zeit, zog var
Int vDelayTime = 250;

void setup() {}
Serial.Begin(9600);
pinMode(LedA,OUTPUT);
pinMode(LedB,OUTPUT);
pinMode(LedC,OUTPUT);
pinMode(LedD,OUTPUT);
PinMode (Motorpinright, Ausgang); Motorantriebe---
PinMode (Motorpinleft, Ausgang); //------------------------
PinMode (Motorpinrevright, Ausgang); //------------------------
PinMode (Motorpinrevleft, Ausgang); //------------------------
für (ich = 0; ich < PointsEnd; i ++) {/ / müssen die Abstände aPoints []-Array initialisieren
aPoints [i] = 0;
} / / Ende der for-Schleife
für (ich = 0; ich < ArrScanzEnd; i ++) {/ / müssen die ArrScanz []-Array initialisieren
ArrScanz [i] = 0;
} / / Ende der for-Schleife

} / / leere Schleife beenden

void loop() {}
digitalWrite(13,LOW); zu niedrig eingestellt
Serial.println ("Start ins main Loop");

blinxAll(arrLedEnd); Ausgefallene Ass-Funktion aufrufen. Weisen Sie es kein Außenwert

ShowArrayContents();

BlinxOne(greenLED,100,6);

DetectMovement(); Tut Pings in 3 Richtungen

DecideWhichWay(); Wenn keine Bewegung erkannt dann bewegen und suchen
am Ende der Entscheidung zum Umzug

vMoveTime = 200;
Serial.Print ("nur aus Sonarx. vSonarTime = ");
Serial.println(vSonarTime);
Serial.println ("out of Funktion BlinxAll");
ArrLedEnd = 3;

Int vMovementRight = 3; mit 3 zu sehen, ob ein Fehler später vorliegt initialisieren
Int vMovementLeft = 3; mit 3 zu sehen, ob ein Fehler später vorliegt initialisieren
Int vStayPut = 3;

} / / Ende die Schleife
//+++++++++++++++++++++++++++++++++++++++++++
*** Funktionen deklarieren ***
//+++++++++++++++++++++++++++++++++++++++++++
Int Sonarx (Int Vpin) {/ / Aufrufen dieser Funktion das Sonar-Modul, um ping und ein Rückgabewert des Ping
Int X = 5;
Int vPingDist = 0; keine Onger erforderlich
Int vDuration; , Zoll, cm;
X = Vpin; Dies ist die Pin-Nummer
Serial.Print ("in Sonarx und Wert Vpin ist:");
Serial.Print(x);
PinMode (Vpin, Ausgang);
DigitalWrite (Vpin, LOW);
delayMicroseconds(2);
DigitalWrite (Vpin, HIGH);
delayMicroseconds(5);
DigitalWrite (Vpin, LOW);

Die gleiche Pin wird verwendet, um das Signal von der Ping-Befehl zu lesen))): eine hohe
deren Laufzeit die Zeit (in Mikrosekunden) das Senden von beträgt Puls
der Ping auf den Empfang des sein Echo off eines Objekts.
PinMode (Vpin, Eingabe);
vDuration = PulseIn (Vpin, HIGH);

cm = microsecondsToCentimeters(vDuration);

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

Rückkehr vDuration;
}
//+++++++++++++++++++++++++++++++++++++++++++

Int MicrosecondsToCentimeters (Int Mikrosekunden)
{
Die Schallgeschwindigkeit ist 340 m/s oder 29 Mikrosekunden pro Zentimeter.
Der Ping-Befehl reist heraus und zurück, um den Abstand von der
Objekt nehmen wir die Hälfte der zurückgelegten Entfernung.
Mikrosekunden zurückgeben / 29 / 2;
}

//+++++++++++++++++++++++++++++++++++++++++++
void BlinxAll (Int ArrLedEndi) {}
Int ivar1;

Serial.Print ("In der BlinxAll-Funktion Wert ist:");
Serial.println(arrLedEndi);
Delay(100);

für (Int ich = 0; ich < = ArrLedEndi; i ++) {}
ivar1 = ArrLed [i]; / * ich ist der Ort im Array, und dadurch ändert sich jede Schleife.
Der Wert des Arrays wird zugewiesen. Dies ist die Pin-Nummer der LED
outputted.* werden /
Serial.Print ("der Wert des ivar1 ist:");
Serial.Print(ivar1);
digitalWrite(ivar1,HIGH);
Delay(100);
digitalWrite(ivar1,LOW);
Delay(100);
} / / Ende den For-Zyklus durch Array

Serial.println ("Ende der Funktion BlinxAll");

} / / End Funktion
//+++++++++++++++++++++++++++++++++++++++++++
void BlinxOne (Int vDelay, Int NumBlinks, Int vLED) {/ / vLED hat Entscheidungen von oben. vDelay ist
Int vLED;
vDelay = 100;
Serial.Print ("In the BlinxOne Funktion Wert ist:");
Serial.println(vLED);
Delay(vDelay);
für (Int ich = 0; ich < = NumBlinks; i ++) {}
digitalWrite(vLED,HIGH);
Delay(vDelay);
digitalWrite(vLED,LOW);
Delay(vDelay);
} //End der for-Schleife
Serial.println ("Ende der Funktion BlinxOne");

} / / End Funktion BlinxOne
//+++++++++++++++++++++++++++++++++++++++++++
void MoveAhead() {}
Int ivar1 = LedD;
digitalWrite(ivar1,HIGH);

Int v2MoveTime = vMoveTime;
Serial.Print ("vMoveTime MoveAhead lohnt:");
Serial.println(v2MoveTime);
Dies wird Bot eine Zeitlang übergebene Funktion vorankommen
AnalogWrite (Motorpinleft, 0); linken Motor abstellen
AnalogWrite (Motorpinright, 0); passenden Motor zu stoppen
AnalogWrite (Motorpinleft, 255); linken Motor abstellen
AnalogWrite (Motorpinright, 255); passenden Motor zu stoppen
Delay(vMoveTime);
AnalogWrite (Motorpinleft, 0); linken Motor abstellen
AnalogWrite (Motorpinright, 0); passenden Motor zu stoppen

digitalWrite(ivar1,LOW); Schalten Sie grünes Licht
vMoveTime = 0; endlose-Schleifen verhindern ++ Fluchten, die
}
//+++++++++++++++++++++++++++++++++++++++++++
void MoveBack() {}
Serial.println ("Umzug zurück OK!!");
Int v2MoveTime = vMoveTime;
Serial.Print ("vMoveTime lohnt sich:");
Serial.println(v2MoveTime);

AnalogWrite (Motorpinrevleft, 255); linken Motor abstellen
AnalogWrite (Motorpinrevright, 255); passenden Motor zu stoppen
Delay(vMoveTime);
AnalogWrite (Motorpinrevleft, 0); linken Motor abstellen
AnalogWrite (Motorpinrevright, 0); passenden Motor zu stoppen
vMoveTime = 0; endlose-Schleifen verhindern ++ Fluchten, die
}
//+++++++++++++++++++++++++++++++++++++++++++
void TurnRight90() {}
Int v2MoveTime = vMoveTime;
Serial.Print ("vMoveTime TurnRight90 lohnt:");
Serial.println(v2MoveTime);

AnalogWrite (Motorpinrevleft, 255); linken Motor abstellen
AnalogWrite (Motorpinright, 255); passenden Motor zu stoppen
Delay(vMoveTime);
AnalogWrite (Motorpinrevleft, 0); linken Motor abstellen
AnalogWrite (Motorpinright, 0); passenden Motor zu stoppen
vMoveTime = 0; endlose-Schleifen verhindern ++ Fluchten, die
}
//+++++++++++++++++++++++++++++++++++++++++++

void TurnLeft45() {}
Int vMoveTime2 = (vMoveTime/2);
Serial.Print ("vMoveTime TurnLeft45 lohnt:");
Serial.println(vMoveTime2);

AnalogWrite (Motorpinleft, 0); linken Motor starten
Delay(vMoveTime2); Dies ist die Hälfte der abbiegen
AnalogWrite (Motorpinright, 255); passenden Motor starten
Delay(vMoveTime);
AnalogWrite (Motorpinleft, 0); linken Motor abstellen
AnalogWrite (Motorpinright, 0); passenden Motor zu stoppen
vMoveTime = 0; endlose-Schleifen verhindern ++ Fluchten, die
}
//+++++++++++++++++++++++++++++++++++++++++++

void TurnRight45() {}
Int vMoveTime2 = (vMoveTime/2);
Serial.Print ("vMoveTime TurnRight45 lohnt:");
Serial.println(vMoveTime2);

AnalogWrite (Motorpinleft, 255); linken Motor starten
Delay(vMoveTime);
AnalogWrite (Motorpinright, 0); passenden Motor starten
Delay(vMoveTime2); Dies ist die Hälfte der abbiegen
AnalogWrite (Motorpinleft, 0); linken Motor abstellen
AnalogWrite (Motorpinright, 0); passenden Motor zu stoppen
vMoveTime = 0; endlose-Schleifen verhindern ++ Fluchten, die
}

//+++++++++++++++++++++++++++++++++++++++++++
void TurnLeft90() {}
Int v2MoveTime = vMoveTime;
Serial.Print ("vMoveTime TurnLeft90 lohnt:");
Serial.println(v2MoveTime);

AnalogWrite (Motorpinleft, 255); linken Motor abstellen
AnalogWrite (Motorpinrevright, 255); passenden Motor zu stoppen
Delay(vMoveTime);
AnalogWrite (Motorpinleft, 0); linken Motor abstellen
AnalogWrite (Motorpinrevright, 0); passenden Motor zu stoppen
vMoveTime = 0; endlose-Schleifen verhindern ++ Fluchten, die
}
//+++++++++++++++++++++++++++++++++++++++++++
void AllStop() {}
AnalogWrite (Motorpinleft, 0); linken Motor abstellen
AnalogWrite (Motorpinright, 0); passenden Motor zu stoppen
AnalogWrite (Motorpinrevright, 0); richtige Rev Motor abstellen
AnalogWrite (Motorpinrevleft, 0); linken Rev Motor abstellen

}
//+++++++++++++++++++++++++++++++++++++++++++
Funktion StorePoint speichern Point-Werte in einem Array.
void StorePoint () {}
Wenn (vPoint < = PointsEnd) {}
aPoints [vPoint] = sonarx(svar); machen Sie diese Funktion irgendwann
vPoint ++; Inkrement vPoint variable
}
Else {}
vPoint = 0;
aPoints [vPoint] = sonarx(svar); machen Sie diese Funktion irgendwann
}
}
//+++++++++++++++++++++++++++++++++++++++++++
Funktion StoreScanz
void StoreScanz (Int VfScan) {}
Wenn (vScanz < = ArrScanzEnd) {}
ArrScanz [vScanz] = VfScan;
vScanz ++; vScanz der Zähler inkrementieren
} else
{
vScanz = 0;
ArrScanz [vScanz] = VfScan;
}
}
//+++++++++++++++++++++++++++++++++++++++++++
void get4pings() {}
2 Sätze der linken und rechten Werte zu erhalten.
für (Int f = 0; f < = 1; f ++) {}
Die Ping-Funktion, erst links dann rechts zu tun.
für (Int b = 0; b < = 1; b ++) {}
Svar = ArrSonarPin [b]; Wählen Sie den linken und rechten Ping Pin: 4 ist jetzt links
vSonarTime = sonarx(svar); Rufen Sie die Funktion Sonarx um die Ferne Zeit der Ping messen.
vSonarTime dieser Wert zuweisen, wird wahrscheinlich nutzlos
StorePoint(); Sonarx Funktion wird aufgerufen, in dieser Funktion vPoint ist eine globale Var

die aktuelle Distanz wird in ein Array-Element gespeichert.
{If(b==0)}
Serial.Print ("Sonarx linken vPoint Wert zugewiesen =");
Serial.println(vPoint); vPoint ist die globale Variable zu verwenden.
}
Else {}
Serial.Print ("Sonarx Rechte Hand vPoint Wert zugewiesen =");
Serial.println(vPoint); vPoint ist die globale Variable zu verwenden.
} / / end If else
} / / Ende der for-Schleife. Zwei Werte in Speicher-Array zugewiesen. 2 Sätze der linken und rechten Werte.
} / / Ende der for-Schleife, die 4 Werte bekommt
} //End get4 Funktionswerte
//++++++++++++++++++++++++++++++++++++++++++++
Eine Funktion zum Ausdrucken der Array-Inhalte.

void ShowArrayContents() {}
Dies dient zur Diagnose und Fehlersuche.
für (ich = 0; ich < = PointsEnd; ich ++) / / das Array von gemessenen Abständen ausdrucken
{
Serial.Print ("Ich =");
Serial.Print(i);
Serial.Print ("aPoints Wert =");
Serial.Print(aPoints[i]);
Serial.println();
} / / Ende der for-Schleife.
} / / End Funktion ShowArrayContents
//+++++++++++++++++++++++++++++++++++++++++++++
Int comparePings() / / wenn wir wissen, dass die Position des letzten Array-Element geschrieben, dann können wir vergleichen Thingz
{/ / start der Funktion
Int s = 1; Dies wird nur einmal durchlaufen.
Int t = 2;
Int vComparePingsLD = Abs-((aPoints[vPoint-1]) (aPoints[vPoint-3])); Dies zeigt ' D'epth Bewegung
Int vComparePingsRD = Abs-((aPoints[vPoint-0]) (aPoints[vPoint-2]));
Int vComparePingsRC = Abs-((aPoints[vPoint-0]) (aPoints[vPoint-1])); Dies zeigt, welche Seite hat "C'losest Ping
Int vComparePingsLC = Abs-((aPoints[vPoint-3]) (aPoints[vPoint-4]));

Serial.Print ("vComparePingsLD Wert ist:");
Serial.println (vComparePingsLD);
Serial.Print ("vComparePingsRD Wert ist:");
Serial.println (vComparePingsRD);
Serial.Print ("vComparePingsRC Wert ist:");
Serial.println (vComparePingsRC);
Serial.Print ("vComparePingsLC Wert ist:");
Serial.println (vComparePingsLC);

während (s < t) {/ / Resaon anschauen, dort ist eine Weile Schleife nur einmal gearbeitet.
Wenn ((aPoints [vPoint-1] == aPoints[vPoint-3]) || (vComparePingsLD < = vTolerate))
{//if sind diese Universitätsabschlusses, dann gibt es keine Bewegung in Richtung oder Weg von pinger
ArrScanz [vScanz] = 0; keine Bewegung
Serial.Print ("die linke Seite Tiefe Punkte entsprechen:");
Serial.Print (aPoints[vPoint-3]);
Serial.Print ("");
Serial.println (aPoints[vPoint-1]);
vScanz ++;
vScanz ++;
}
Else {}
vMovementLeft = 1;
ArrScanz [vScanz] = 1; gab es Bewegung
vScanz ++;
vScanz ++;
}

Wenn (((aPoints[vPoint]) == (aPoints[vPoint-2])) || (vComparePingsRD < = vTolerate))
{//if sind diese Universitätsabschlusses, dann gibt es keine Bewegung in Richtung oder Weg von pinger
ArrScanz [vScanz] = 0; keine Bewegung
Serial.Print ("die rechten Seite Tiefe Punkte entsprechen:");
Serial.Print (aPoints[vPoint-2]);
Serial.Print ("");
Serial.println (aPoints[vPoint]);
vScanz ++;
}
Else {}
vMovementRight = 1;
ArrScanz [vScanz] = 1; gab es Bewegung
vScanz ++;
vScanz ++;
}

Wenn (((aPoints[vPoint]) == (aPoints[vPoint-1])) || (vComparePingsRC < = vTolerate))
{//check zu sehen, welche Art und Weise näher Objekt hat
Serial.Print ("die neuesten zwei Entfernungen von links und rechts sind Links:");
Serial.Print (aPoints[vPoint-1]);
Serial.Print ("dann rechts:");
Serial.println (aPoints[vPoint]);
vScanz ++;
}
Else {}
Wenn ((aPoints [vPoint - 1]) < (aPoints[vPoint])) {/ / beginnen, wenn
vCloserLeft = 1;
vCloserRight = 0;
} / / Ende wenn
anderes
{
vCloserLeft = 0;
vCloserRight = 1;
ArrScanz [vScanz] = 1; gab es Bewegung
vScanz ++;
vScanz ++;
} / / sonst Ende
} / / sonst Ende

Wenn (((aPoints[vPoint-3]) == (aPoints[vPoint-4])) || (vComparePingsLC < = vTolerate))
{//check zu sehen, welche Art und Weise näher Objekt hat
Glaube nicht, dass ich das derzeit. hmmmm
Serial.Print ("der ältere zwei Entfernungen von links und rechts sind Links:");
Serial.Print (aPoints[vPoint-4]);
Serial.Print ("dann rechts:");
Serial.println (aPoints[vPoint-3]);
vScanz ++;
}
anderes
{
ArrScanz [vScanz] = 1; gab es Bewegung
vScanz ++;
}
beenden, wenn
s++; erhöht für die While Schleife
} //end der während der Funktion
Delay(500); Um mir den Serien Monitor lesen lassen. Entfernen Sie diese später.
} / / Ende der Funktion
//++++++++++++++++++++++++++++++++++++++++++++
void DetectMovement() {//Does Pings in 3 direcctions
gehen Sie left45 Ping dann gehen Sie right45 (das Zentrum) dann right45 dann entscheiden Sie, ob gibt es Bewegung.
Int s = 0;
Int t = 2; Dies kann für weitere Scans eingestellt werden
Int fDelay = 100; interne Nummer für die Verzögerung zwischen den scans
vMoveTime = 500; Dies ist eine globale Variable, die eine Menge geändert wird
TurnLeft45(); Dies ist der erste beliebigen Zug. Sortierung der Scan-Daten einfacher machen.
Serial.println ("Turn left45, Get-Werte");

während (s < t) {}
get4pings();
Delay(fDelay);
comparePings(); Wenn das nennt man dann entscheidet die Vergleiche Bewegung oder keine Bewegung

s = s + +;
TurnRight45();
Serial.println ("Turn right45, Get-Werte");
} / / end während
s = 0; die Funktion Variable zurücksetzen

Vergleichen Sie die gesammelten Werte.

Delay(fDelay);

} / / Ende DetectMovement Funktion
//++++++++++++++++++++++++++++++++++++++++++++
void DecideWhichWay() {}

Wenn (aPoints [vPoint] > 200) {}
vMoveTime = (aPoints[vPoint]/10); gibt eine Skala verwenden basierend auf Distanz
}
Else {/ / zu nah ja wiederum nur
vMovementLeft = 0;
vMovementRight = 0;
}

Wenn (vMovementLeft == 1) {}
(TurnLeft45);
(MoveAhead);
} / / Ende wenn
ElseIf (vMovementRight == 1) {}
(TurnRight45);
(MoveAhead);
} //
ElseIf (vStayPut == 0) {}
vMoveTime = vMoveTime;
MoveAhead();
} //

Else {/ / Ort bleiben, aber richtige 90 zum neuen Bereich Scannen zu drehen.
TurnRight90();
AllStop();
} / / sonst Ende

} / / End Funktion DecideWhichWay
//+++++++++++++++++++++++++++++++++++++++++++++