Zaklamp gecontroleerd zonne-Aangedreven Arduino Robot ingeschakeld
Dit project is een licht verloop gevoelige robot met zonne-energie opladen mogelijkheden, met andere woorden het wil het licht zelf opladen. Het volbrengt dit probleem met een set van vier lichte gevoelige photoresistors in spanning divider circuits, de eenheid van de Arduino leest de vier waarden die overeenkomen met de intensiteit van het licht door de sensoren door middel van de analoge Lees pins ontvangen. Het geldt dan een hoog voltage over een reed switch rietschakelaar die een circuit tussen een 9v batterij en twee motoren van het speelgoed voltooit, resulterend in draaien of verplaatsen naar het licht. Deze motoren waren niet in staat om rechtstreeks met de Arduino, worden geactiveerd als u kleine genoeg motoren, zonder verlies van functionaliteit kan achterwege blijven de switch gedeelte van dit project. Als een van de vier fotodiodes is veel hoger dan de anderen registreert, wordt gedetecteerd welke fotodiode de verhoogde signaal ontvangt en draait of beweegt in die richting voor zolang het verhoogde signaal wordt ontvangen. Dit licht bijhouden algoritme kan worden gebruikt voor programma zonnepanelen wilt bijhouden op de zon, of voor controle van de robot via zaklamp, zoals hier is aangetoond.
Beschrijving
Foto's en diagrammen van de volledige circuit board zou een beetje rommelig in dit geval, dus ik heb boxed de hoofdonderdelen die 4 en 2 keer respectievelijk in het werkelijke project worden herhaald. Het eerste circuit-subsysteem maakt de scheidingslijn van de spanning op basis van een photoresistor die is viermaal herhaald, met elke fotoweerstand die wordt gelegd op een hele andere kant van je robot. Een fotoweerstand varieert weerstand gebaseerd op licht signaal ontvangen via de photoconductivity van de ontvangende halfgeleidermateriaal. De variabele weerstand produceert een variabele stroom in het circuit volgens de wet van Ohm, V = iR waar de spanning V constant is (5V). Wees voorzichtig niet om de draden leiden tot elke een fotodiode buitensporig lange, zoals je signaal als gevolg van de interne weerstand van de draad verliezen kunt en soldeer verbindingen. Spanning wordt geleverd aan dit gedeelte van het circuit rechtstreeks vanuit de Arduino UNO de 5V / Gnd pinnen. De 5V lijn passeert een weerstand van 10kΩ, via de fotodiode, en terug naar de grond. Een analoge in signaal wordt gelezen tussen de weerstand en de fotodiode via Arduino analoge in pinnen. Een optionele toevoeging is de indicator LED aangetoond dat gaande van de andere kant van de weerstand (positief) grond (negatief), dat deze LED zal veranderen op basis van de ontvangen door de fotodiode signaal intensiteit. Als deze LED's zijn te dicht aan één van de fotodiodes, uw machine kunt u een soort analoge feedback lus in die richting, waar het draait in de richting van eigen LEDs. Ik denk dat ik heb gecodeerd tegen deze mogelijkheid, maar als je ziet dat gedrag, probeer het nemen van de LED's uit zoals ze nuttig zijn alleen tijdens het debuggen van dit gedeelte van het circuit. Vier analog in pinnen moet worden aangesloten op vier iteraties van dit circuit blok. In principe kunt u het aantal iteraties voor verhoogde gevoeligheid van de directionele verhogen, maar dit is niet nodig voor deze toepassing. De schets die met dit project gaat is gevoelig voor een verschil in ontvangen lichtintensiteit, als alle signalen ontvangen zeer vergelijkbaar zijn, dat de robot zal blijven genieten van de omgeving, maar blijven stationaire. Zodra een van de signalen groter is dan de anderen door een drempelwaarde, wordt ingevoerd zijn motie lus. Het bepaalt welke fotoweerstand het maximale signaal ontvangt en vervolgens toegepast huidige naar de motor die de robot in de correcte overeenkomstige richting beweegt. Deze actie blijft, zolang die fotoweerstand maximale intensiteit krijgt, en er een groot verschil tussen de gelezen waarden is.
Het tweede geblokkeerde gedeelte van het circuit is alleen nodig als je meer macht aan de motoren nodig dan de Arduino rechtstreeks van de PWM-uitgang pins leveren kan. Mijn chassis / tracks / motor is uit een Chinese speelgoed, de Arduino had moeite rijden de motoren met de tracks op, zodat ik gebouwd in een switch blok naar het circuit waarmee de PWM uitvoer wilt spiegelen een reed-relais dat is voltooid van een circuit met een 9V batterij. De reed-relaiswerkt via een elektromagneet die wanneer geactiveerd door de lagere huidige (Arduino) oorzaken van de contactpunten binnen de schakeloptie worden gemagnetiseerde en sluiten van het circuit. In principe kunt u zeer grote elektromotoren met dit concept drijven door het selecteren van de juiste reed estafette. Ik hoefde niet veel meer macht, zodat een 9V batterij genoeg was, de switch die ik heb gebruikt is in de delen opdat sectie. Aangezien dit onderdeel wordt beheerd via een elektromagnetisch veld, is het een tijdelijke bescherming diode noodzakelijk, aangezien het instortende magnetisch veld (wanneer de schakelaar uitstaat) leiden een huidige piek tot kan te reizen terug naar de Arduino zoals voorspeld door de Maxwellvergelijkingen. Een goede discussie over het implementeren van deze bijzondere reed-relais schakelen zonder schade aan uw bord kan worden gevonden hier.
Dit gedeelte van het circuit wordt herhaald tweemaal overeenkomt met twee motoren, en zoals gezegd, als u nog aan de macht van uw motoren direct met Arduino, u dit gedeelte van het project zonder verlies van functionaliteit kan weglaten.
Schakelschema
Voltage scheidingslijn:
Circuit Switching:
Onderdelenlijst
Arduino UNO ($14.48)
4 x weerstand, 10 KΩ
4 x foto licht gevoelige Resistor Photoresistor Optoresistor 5mm GL5516 5516
4 x LED
RadioShack® 1,5 zonnepaneel 9V ($5,74)
Toy tracks / platform / motoren (2)
2 x Reed-Switches (OMR-C - 105H)
Code
Const int frontPin = A0;
Const int leftPin = a1 worden verkregen;
Const int rightPin = A2;
Const int backPin = A3;
Const int leftMotor = 9;
Const int rightMotor = 10;
int drempel = 170;
int richting;
int direction1;
int direction2;
int vertraging = 25;
int Delay2 = 25;
VOID Setup
{
pinMode (frontPin, INPUT);
pinMode (leftPin, INPUT);
pinMode (rightPin, INPUT);
pinMode (backPin, INPUT);
pinMode (leftMotor, OUTPUT);
pinMode (rightMotor, OUTPUT);
digitalWrite (leftMotor, hoge);
digitalWrite(rightMotor,HIGH);
delay(100);
digitalWrite (leftMotor, laag);
digitalWrite (rightMotor, laag);
delay(100);
digitalWrite (leftMotor, hoge);
digitalWrite (rightMotor, hoge);
delay(100);
digitalWrite (leftMotor, laag);
digitalWrite (rightMotor, laag);
delay(1500);
Serial.begin(9600);
}
void loop
{
int richting;
int direction1;
int direction2;
int frontSignal = 1023 - analogRead(frontPin);
int leftSignal = 1023 - analogRead(leftPin);
int rightSignal = 1023 - analogRead(rightPin);
int backSignal = 1023 - analogRead(backPin);
Serial.println(frontSignal);
Serial.println(leftSignal);
Serial.println(rightSignal);
Serial.println(backSignal);
frontSignal + leftSignal + rightSignal + backSignal < = drempel
Als (abs(frontSignal-leftSignal)+abs(frontSignal-rightSignal)+abs(frontSignal-backSignal) > = drempel)
{
Serial.println ("beweging lus");
direction1 = max (frontSignal, leftSignal);
direction2 = max (rightSignal, backSignal);
Richting = max (direction1, direction2);
Loop hier wordt ingevoerd, alleen als het licht ontvangen is niet gelijkmatig verdeeld.
Als (frontSignal == richting)
{
doen
{
digitalWrite (leftMotor, hoge);
digitalWrite (rightMotor, hoge);
delay(Delay2);
digitalWrite (leftMotor, laag);
digitalWrite (rightMotor, laag);
delay(delay);
frontSignal = 1023 - analogRead(frontPin);
leftSignal = 1023 - analogRead(leftPin);
rightSignal = 1023 - analogRead(rightPin);
backSignal = 1023 - analogRead(backPin);
direction1 = max (frontSignal, leftSignal);
direction2 = max (rightSignal, backSignal);
Richting = max (direction1, direction2);
Serial.println("Forward");
} terwijl (frontSignal == richting & & abs(frontSignal-leftSignal)+abs(frontSignal-rightSignal)+abs(frontSignal-backSignal) > = drempel);
digitalWrite (leftMotor, laag);
digitalWrite (rightMotor, laag);
}
else if (leftSignal == richting) //Signal is het grootst aan de linkerkant
{
doen
{
Serial.println("left");
digitalWrite (rightMotor, hoge);
delay(Delay2);
digitalWrite (rightMotor, laag);
delay(delay);
frontSignal = 1023 - analogRead(frontPin);
leftSignal = 1023 - analogRead(leftPin);
rightSignal = 1023 - analogRead(rightPin);
backSignal = 1023 - analogRead(backPin);
direction1 = max (frontSignal, leftSignal);
direction2 = max (rightSignal, backSignal);
Richting = max (direction1, direction2);
} terwijl (leftSignal == richting & & abs(frontSignal-leftSignal)+abs(frontSignal-rightSignal)+abs(frontSignal-backSignal) > = drempel);
digitalWrite (rightMotor, laag);
}
else if (rightSignal == richting) //Signal is het grootst aan de rechterkant.
{
doen
{
Serial.println("right");
digitalWrite (leftMotor, hoge);
delay(Delay2);
digitalWrite (leftMotor, laag);
delay(delay);
frontSignal = 1023 - analogRead(frontPin);
leftSignal = 1023 - analogRead(leftPin);
rightSignal = 1023 - analogRead(rightPin);
backSignal = 1023 - analogRead(backPin);
direction1 = max (frontSignal, leftSignal);
direction2 = max (rightSignal, backSignal);
Richting = max (direction1, direction2);
} terwijl (rightSignal == richting & & abs(frontSignal-leftSignal)+abs(frontSignal-rightSignal)+abs(frontSignal-backSignal) > = drempel);
digitalWrite (leftMotor, laag);
}
else if (backSignal == richting) //Signal is grootste achter.
{
doen
{
Serial.println("back");
digitalWrite (leftMotor, hoge);
delay(Delay2);
digitalWrite (leftMotor, laag);
delay(delay);
frontSignal = 1023 - analogRead(frontPin);
leftSignal = 1023 - analogRead(leftPin);
rightSignal = 1023 - analogRead(rightPin);
backSignal = 1023 - analogRead(backPin);
direction1 = max (frontSignal, leftSignal);
direction2 = max (rightSignal, backSignal);
Richting = max (direction1, direction2);
} terwijl (backSignal == richting & & abs(frontSignal-leftSignal)+abs(frontSignal-rightSignal)+abs(frontSignal-backSignal) > = drempel);
digitalWrite (leftMotor, laag);
}
}
anders if(abs(frontSignal-leftSignal)+abs(frontSignal-rightSignal)+abs(frontSignal-backSignal) < = drempel)
{
int verschil = abs(frontSignal-leftSignal)+abs(frontSignal-rightSignal)+abs(frontSignal-backSignal);
Serial.println ("signaal differentieel is gelijk aan");
Serial.println(Difference);
digitalWrite (leftMotor, laag);
digitalWrite (rightMotor, laag);
delay(1000); Anders genieten van de omgeving met een snelheid van 10 hz
}
anders
{
digitalWrite (leftMotor, laag);
digitalWrite (rightMotor, laag);
}
}
