Hacking een Rumble-Robot

Het doel is het creëren van een asielzoeker robot. Ik heb twee ping sensoren op dit. Links pingt, dan rechts, dan links, dan rechts. Deze waarden worden opgeslagen in een matrix. Dit geeft 4 waarden te gebruiken voor analyse. Het doel is om het verkeer te detecteren. Ik vond dat er enige variatie in de ping-metingen en ook de sensoren zijn niet precies uitgelijnd, is dus er een waarde voor tolerantie is. Er is een verandering in de waarde vervolgens beweging opgetreden en de robot zal bewegen naar het verkeer.

Hier is de schets. Ik heb zodat het zal cirkel en zoeken. Maar ik heb een robot om te jagen, die volgende week zal komen. Sorry de code is niet super schoon. Maar dat is een work in progress.

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

Dit is om te testen hoe om functies werken te maken. Goed.
LED's knipperen prima.
Twee pingers ping en terug te keren van de afstand in cm.
Dit heeft een geheugen creatie matrix.
Nu gebruiken de afstand meten en besluiten op basis van die.

int vcount = 0;
int vSonarTime = 0; Dit zal de waarde van de tijd van de sonar-ping, oftewel de afstand
int arrSonarPin [] {} =
4,2}; Dit is links dan rechts sonar
int antwoord = 0; variabele voor iets
int sonarLeft = 0;
int sonarRight = 0;
int vTolerate = 10; Dit is de microseconden van fout in de ping die wordt genegeerd
int arrScanz [96]; Dit is waar besluiten gaan over comparePing besluiten
int arrScanzEnd = 95; einde element nummer voor matrix arrScanz
int vScanz = 0; Global var gebruikte naar recordresultaten voor scan analyse
int vMovementRight = 3; initialiseren met 3 om te zien of er een fout later
int vMovementLeft = 3; initialiseren met 3 om te zien of er een fout later
int vCloserRight = 3;
int vCloserLeft = 3;
int vStayPut = 3;

int aPoints [48]; matrix-punten en afstanden willen maken
int PointsEnd = 47;
int vPoint = 0; Dit is init zou voor gebruik als de toenemende matrixelementen waar afstanden krijgen opgeslagen.
Want dit globale is kunnen we usitilize in functies. Maar alleen StorePoint() zal wijzigen vPoint
int i; voor het tellen for-lussen
int LedA = 13; aan boord
int LedB = 12; rood
int LedC = 9; rood
int LedD = 8; groen
int greenLED = 8; makkelijker te herinneren

int arrLed [] {LedA, LedB, LedC, LedD} =;
int arrLedEnd = 3; de matrix arrLed heeft 4 leden, dus laatst is #3

int motorpinright = 10; PIN voor rechts motor rood
int motorpinleft = 11; PIN voor linker motor vooruit geel
int motorpinrevright = 5; PIN voor rechts motor omgekeerde black
int motorpinrevleft = 6; PIN voor rechts motor vooruit groen
int vMoveTime = 200; Dit is de tijd verplaatst var
int vDelayTime = 250;

VOID Setup {}
Serial.begin(9600);
pinMode(LedA,OUTPUT);
pinMode(LedB,OUTPUT);
pinMode(LedC,OUTPUT);
pinMode(LedD,OUTPUT);
pinMode (motorpinright, OUTPUT); Motor rijdt---
pinMode (motorpinleft, OUTPUT); //------------------------
pinMode (motorpinrevright, OUTPUT); //------------------------
pinMode (motorpinrevleft, OUTPUT); //------------------------
voor (ik = 0; ik < PointsEnd; i ++) {/ / noodzaak om de afstanden aPoints [] array te initialiseren
aPoints [i] = 0;
} / / End de for-lus
voor (ik = 0; ik < arrScanzEnd; i ++) {/ / noodzaak om de arrScanz [] array te initialiseren
arrScanz [i] = 0;
} / / End de for-lus

} / / void lus end

void loop {}
digitalWrite(13,LOW); laag gesteld om te starten
Serial.println ("Start in main loop");

blinxAll(arrLedEnd); Fancy Ass-functie aanroepen. Niet een externe waarde toewijst

ShowArrayContents();

BlinxOne(greenLED,100,6);

DetectMovement(); Doet pings in 3 richtingen

DecideWhichWay(); Als er geen beweging gedetecteerd dan verplaatsen en zoeken
einde de beslissing om te verhuizen

vMoveTime = 200;
Serial.Print ("Just uit sonarx. vSonarTime = ");
Serial.println(vSonarTime);
Serial.println ("van de functie blinxAll");
arrLedEnd = 3;

int vMovementRight = 3; initialiseren met 3 om te zien of er een fout later
int vMovementLeft = 3; initialiseren met 3 om te zien of er een fout later
int vStayPut = 3;

} / / einde van de lus
//+++++++++++++++++++++++++++++++++++++++++++
*** Verklaren functies ***
//+++++++++++++++++++++++++++++++++++++++++++
int sonarx (int vpin) {/ / deze functie zal de sonar module om te pingen en een retourwaarde voor de ping call
int x = 5;
int vPingDist = 0; geen onger nodig
int vDuration; , inch, cm;
x = vpin; Dit is het pin-nummer
Serial.Print ("in de sonarx en de waarde vpin is:");
Serial.Print(x);
pinMode (vpin, OUTPUT);
digitalWrite (vpin, laag);
delayMicroseconds(2);
digitalWrite (vpin, hoge);
delayMicroseconds(5);
digitalWrite (vpin, laag);

Dezelfde pincode wordt gebruikt voor het lezen van het signaal van de PING))): een hoog
Pulse waarvan de duur de tijd (in microseconden) van de verzending is
voor de ping naar de receptie van de echo off van een object.
pinMode (vpin, INPUT);
vDuration = pulseIn (vpin, hoge);

cm = microsecondsToCentimeters(vDuration);

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

Return vDuration;
}
//+++++++++++++++++++++++++++++++++++++++++++

int microsecondsToCentimeters (int microseconden)
{
De snelheid van het geluid is 340 m/s of 29 microseconden per vierkante centimeter.
De ping reist uit en terug, zo vind je de afstand van de
we de helft van de afgelegde afstand nemen-object.
retourneren van microseconden / 29 / 2;
}

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

Serial.Print ("In de blinxAll functie, waarde is:");
Serial.println(arrLedEndi);
delay(100);

for (int i = 0; ik < = arrLedEndi; i ++) {}
ivar1 = arrLed [i]; / * ik is de plek in de matrix, en dit verandert elke lus.
De waarde van de matrix wordt toegewezen. Dit is het pin-nummer van de LED
dat zal outputted.* /
Serial.Print ("de waarde van ivar1 is:");
Serial.Print(ivar1);
digitalWrite(ivar1,HIGH);
delay(100);
digitalWrite(ivar1,LOW);
delay(100);
} / / Einde van de cyclus voor via array

Serial.println ("End of functie blinxAll");

} / / End function
//+++++++++++++++++++++++++++++++++++++++++++
VOID BlinxOne (int vLED, int vDelay, int numBlinks) {/ / vLED heeft keuzen van bovenaf. vDelay is
int vLED;
vDelay = 100;
Serial.Print ("In de BlinxOne functie, waarde is:");
Serial.println(vLED);
delay(vDelay);
for (int i = 0; ik < = numBlinks; i ++) {}
digitalWrite(vLED,HIGH);
delay(vDelay);
digitalWrite(vLED,LOW);
delay(vDelay);
} //End van for-lus
Serial.println ("End of functie BlinxOne");

} / / End function BlinxOne
//+++++++++++++++++++++++++++++++++++++++++++
VOID MoveAhead() {}
int ivar1 = LedD;
digitalWrite(ivar1,HIGH);

int v2MoveTime = vMoveTime;
Serial.Print ("vMoveTime MoveAhead is de moeite waard:");
Serial.println(v2MoveTime);
Dit zal gaan bot voor een tijd doorgegeven aan de functie
analogWrite (motorpinleft, 0); de linker motor stop
analogWrite (motorpinright, 0); de juiste motor stop
analogWrite (motorpinleft, 255); de linker motor stop
analogWrite (motorpinright, 255); de juiste motor stop
delay(vMoveTime);
analogWrite (motorpinleft, 0); de linker motor stop
analogWrite (motorpinright, 0); de juiste motor stop

digitalWrite(ivar1,LOW); uitschakelen van groen licht
vMoveTime = 0; voorkomen van eindeloze lussen ++ weglopers die is
}
//+++++++++++++++++++++++++++++++++++++++++++
VOID MoveBack() {}
Serial.println ("Moving terug OK!");
int v2MoveTime = vMoveTime;
Serial.Print ("vMoveTime is de moeite waard:");
Serial.println(v2MoveTime);

analogWrite (motorpinrevleft, 255); de linker motor stop
analogWrite (motorpinrevright, 255); de juiste motor stop
delay(vMoveTime);
analogWrite (motorpinrevleft, 0); de linker motor stop
analogWrite (motorpinrevright, 0); de juiste motor stop
vMoveTime = 0; voorkomen van eindeloze lussen ++ weglopers die is
}
//+++++++++++++++++++++++++++++++++++++++++++
VOID TurnRight90() {}
int v2MoveTime = vMoveTime;
Serial.Print ("vMoveTime TurnRight90 is de moeite waard:");
Serial.println(v2MoveTime);

analogWrite (motorpinrevleft, 255); de linker motor stop
analogWrite (motorpinright, 255); de juiste motor stop
delay(vMoveTime);
analogWrite (motorpinrevleft, 0); de linker motor stop
analogWrite (motorpinright, 0); de juiste motor stop
vMoveTime = 0; voorkomen van eindeloze lussen ++ weglopers die is
}
//+++++++++++++++++++++++++++++++++++++++++++

VOID TurnLeft45() {}
int. vMoveTime2 = (vMoveTime/2);
Serial.Print ("vMoveTime TurnLeft45 is de moeite waard:");
Serial.println(vMoveTime2);

analogWrite (motorpinleft, 0); Start links motor
delay(vMoveTime2); Dit is de helft om de beurt
analogWrite (motorpinright, 255); Start rechts motor
delay(vMoveTime);
analogWrite (motorpinleft, 0); de linker motor stop
analogWrite (motorpinright, 0); de juiste motor stop
vMoveTime = 0; voorkomen van eindeloze lussen ++ weglopers die is
}
//+++++++++++++++++++++++++++++++++++++++++++

VOID TurnRight45() {}
int. vMoveTime2 = (vMoveTime/2);
Serial.Print ("vMoveTime TurnRight45 is de moeite waard:");
Serial.println(vMoveTime2);

analogWrite (motorpinleft, 255); Start links motor
delay(vMoveTime);
analogWrite (motorpinright, 0); Start rechts motor
delay(vMoveTime2); Dit is de helft om de beurt
analogWrite (motorpinleft, 0); de linker motor stop
analogWrite (motorpinright, 0); de juiste motor stop
vMoveTime = 0; voorkomen van eindeloze lussen ++ weglopers die is
}

//+++++++++++++++++++++++++++++++++++++++++++
VOID TurnLeft90() {}
int v2MoveTime = vMoveTime;
Serial.Print ("vMoveTime TurnLeft90 is de moeite waard:");
Serial.println(v2MoveTime);

analogWrite (motorpinleft, 255); de linker motor stop
analogWrite (motorpinrevright, 255); de juiste motor stop
delay(vMoveTime);
analogWrite (motorpinleft, 0); de linker motor stop
analogWrite (motorpinrevright, 0); de juiste motor stop
vMoveTime = 0; voorkomen van eindeloze lussen ++ weglopers die is
}
//+++++++++++++++++++++++++++++++++++++++++++
VOID AllStop() {}
analogWrite (motorpinleft, 0); de linker motor stop
analogWrite (motorpinright, 0); de juiste motor stop
analogWrite (motorpinrevright, 0); juiste rev motor stoppen
analogWrite (motorpinrevleft, 0); linker rev motor stoppen

}
//+++++++++++++++++++++++++++++++++++++++++++
functie StorePoint slaat puntenwaarden in een array
VOID StorePoint () {}
Als (vPoint < = PointsEnd) {}
aPoints [vPoint] = sonarx(svar); dit ergens een functie maken
vPoint ++; Increment vPoint variabele
}
else {}
vPoint = 0;
aPoints [vPoint] = sonarx(svar); dit ergens een functie maken
}
}
//+++++++++++++++++++++++++++++++++++++++++++
functie StoreScanz
VOID StoreScanz (int vfScan) {}
Als (vScanz < = arrScanzEnd) {}
arrScanz [vScanz] = vfScan;
vScanz ++; _ / / verhogen de vScanz de teller
} else
{
vScanz = 0;
arrScanz [vScanz] = vfScan;
}
}
//+++++++++++++++++++++++++++++++++++++++++++
ongeldig get4pings() {}
2 sets van links en rechts waarden krijgt.
voor (int f = 0; f < = 1; f ++) {}
Doe de ping-functie, eerst links dan rechts.
voor (int b = 0; b < = 1; b ++) {}
antwoord = arrSonarPin [b]; Kies de links dan rechts ping pin: 4 is nu verlaten
vSonarTime = sonarx(svar); Bel functie sonarx voor het meten van de tijd van de afstand van de ping.
Deze waarde toe te wijzen aan vSonarTime is waarschijnlijk nutteloos
StorePoint(); sonarx functie heet in deze functie vPoint is een wereldwijde Var

de huidige afstand wordt opgeslagen in een array-element
if(b==0) {}
Serial.Print ("sonarx linkerhand vPoint waarde toegewezen =");
Serial.println(vPoint); vPoint is de globale variabele te gebruiken.
}
else {}
Serial.Print ("sonarx rechterhand vPoint waarde toegewezen =");
Serial.println(vPoint); vPoint is de globale variabele te gebruiken.
} / / end if else
} / / einde van for-lus. Twee waarden toegewezen in memory array. 2 sets van linker- en waarden.
} / / End de for-lus die 4 waarden krijgt
} //End get4 functiewaarden
//++++++++++++++++++++++++++++++++++++++++++++
Een functie voor het afdrukken van de inhoud van de matrix.

VOID ShowArrayContents() {}
Dit wordt gebruikt voor diagnostiek bij het oplossen van problemen.
voor (ik = 0; ik < = PointsEnd; ik ++) / / print uit de matrix van gemeten afstanden
{
Serial.Print ("ik =");
Serial.Print(i);
Serial.Print ("aPoints waarde is =");
Serial.Print(aPoints[i]);
Serial.println();
} / / End de for-lus.
} / / End function ShowArrayContents
//+++++++++++++++++++++++++++++++++++++++++++++
int comparePings() / / als we de positie van de laatste array element geschreven weten, dan kunnen we vergelijken e.e.a.
{/ / start van functie
int s = 1; Dit zal alleen gaan door eens.
int t = 2;
int vComparePingsLD = abs ((aPoints[vPoint-1]) - (aPoints[vPoint-3])); Hieruit blijkt ' D'epth verkeer
int vComparePingsRD = abs ((aPoints[vPoint-0]) - (aPoints[vPoint-2]));
int vComparePingsRC = abs ((aPoints[vPoint-0]) - (aPoints[vPoint-1])); Dit toont welke kant heeft ' C'losest ping
int vComparePingsLC = abs ((aPoints[vPoint-3]) - (aPoints[vPoint-4]));

Serial.Print ("vComparePingsLD waarde is:");
Serial.println (vComparePingsLD);
Serial.Print ("vComparePingsRD waarde is:");
Serial.println (vComparePingsRD);
Serial.Print ("vComparePingsRC waarde is:");
Serial.println (vComparePingsRC);
Serial.Print ("vComparePingsLC waarde is:");
Serial.println (vComparePingsLC);

terwijl (s < t) {/ / de resaon te kijken er is een tijdje lus werkte slechts eenmaal.
Als ((aPoints [vPoint-1] == aPoints[vPoint-3]) || (vComparePingsLD < = vTolerate))
{//if die eqivalent zijn dan is er geen beweging naar of uit de buurt van pinger
arrScanz [vScanz] = 0; geen beweging
Serial.Print ("de linkerkant diepte punten zijn gelijk:");
Serial.Print (aPoints[vPoint-3]);
Serial.Print ("");
Serial.println (aPoints[vPoint-1]);
vScanz ++;
vScanz ++;
}
else {}
vMovementLeft = 1;
arrScanz [vScanz] = 1; Er was verkeer
vScanz ++;
vScanz ++;
}

Als (((aPoints[vPoint]) == (aPoints[vPoint-2])) || (vComparePingsRD < = vTolerate))
{//if die eqivalent zijn dan is er geen beweging naar of uit de buurt van pinger
arrScanz [vScanz] = 0; geen beweging
Serial.Print ("de rechterkant diepte punten zijn gelijk:");
Serial.Print (aPoints[vPoint-2]);
Serial.Print ("");
Serial.println (aPoints[vPoint]);
vScanz ++;
}
else {}
vMovementRight = 1;
arrScanz [vScanz] = 1; Er was verkeer
vScanz ++;
vScanz ++;
}

Als (((aPoints[vPoint]) == (aPoints[vPoint-1])) || (vComparePingsRC < = vTolerate))
{//check om te zien welke manier heeft dichter object
Serial.Print ("de nieuwste twee afstanden van links en rechts zitten:");
Serial.Print (aPoints[vPoint-1]);
Serial.Print ("vervolgens rechtsaf:");
Serial.println (aPoints[vPoint]);
vScanz ++;
}
else {}
Als ((aPoints [vPoint - 1]) < (aPoints[vPoint])) {/ / start als
vCloserLeft = 1;
vCloserRight = 0;
} / / end als
anders
{
vCloserLeft = 0;
vCloserRight = 1;
arrScanz [vScanz] = 1; Er was verkeer
vScanz ++;
vScanz ++;
} / / end anders
} / / end anders

Als (((aPoints[vPoint-3]) == (aPoints[vPoint-4])) || (vComparePingsLC < = vTolerate))
{//check om te zien welke manier heeft dichter object
Denk niet dat ik dit op dit moment nodig hebben. Hmmmm
Serial.Print ("de oudere twee afstanden van links en rechts zitten:");
Serial.Print (aPoints[vPoint-4]);
Serial.Print ("vervolgens rechtsaf:");
Serial.println (aPoints[vPoint-3]);
vScanz ++;
}
anders
{
arrScanz [vScanz] = 1; Er was verkeer
vScanz ++;
}
eind als
s+ +; _ / / verhogen voor de while lus
} //end de terwijl functie
delay(500); Om mij te laten lezen de seriële Monitor. U kunt deze later verwijderen.
} / / einde van functie
//++++++++++++++++++++++++++++++++++++++++++++
VOID DetectMovement() {//Does pings in 3 direcctions
left45 ping gaan dan gaan right45 (oftewel center) dan right45 dan beslissen of er beweging is.
int s = 0;
int t = 2; Dit kan worden aangepast voor meer scans
int fDelay = 100; intern nummer voor de vertraging tussen scans
vMoveTime = 500; Dit is een globale variabele die een hoop is veranderd
TurnLeft45(); Dit is de eerste arbitary zet. Maakt u de scan gegevens gemakkelijker sorteert.
Serial.println ("Turn left45, get-waarden");

terwijl (s < t) {}
get4pings();
delay(fDelay);
comparePings(); Wanneer dit heet zal dan de vergelijkingen beslissen beweging of geen beweging

s = s+ +;
TurnRight45();
Serial.println ("Turn right45, get-waarden");
} / / end terwijl
s = 0; Reset de functie variabele

Vergelijken de verzamelde waarden.

delay(fDelay);

} / / Einde van DetectMovement functie
//++++++++++++++++++++++++++++++++++++++++++++
VOID DecideWhichWay() {}

Als (aPoints [vPoint] > 200) {}
vMoveTime = (aPoints[vPoint]/10); geeft een schaal om te gebruiken op basis van afstand
}
else {/ / te dicht zo beurt alleen
vMovementLeft = 0;
vMovementRight = 0;
}

Als (vMovementLeft == 1) {}
TurnLeft45 ();
MoveAhead ();
} / / end als
else if (vMovementRight == 1) {}
TurnRight45 ();
MoveAhead ();
} //
else if (vStayPut == 0) {}
vMoveTime = vMoveTime;
MoveAhead();
} //

else {/ / blijven op hun plaats, maar juiste 90 om te scannen op nieuwe gebied draaien.
TurnRight90();
AllStop();
} / / end anders

} / / End function DecideWhichWay
//+++++++++++++++++++++++++++++++++++++++++++++