Arduino alimenté solaire lampe de poche contrôlée activée Robot
Ce projet est un robot sensible dégradé léger avec des capacités de charge solaires, en d’autres termes, il cherche la lumière pour se recharger. Il accomplit ce comportement avec un ensemble de quatre légères photo-résistances sensibles dans les circuits de diviseur de tension, l’appareil de l’Arduino lit les quatre valeurs qui correspondent à l’intensité de la lumière reçue par les capteurs à travers ses tiges de lecture analogiques. Il applique ensuite une haute tension à travers un interrupteur reed qui complète un circuit entre une pile de 9v et deux moteurs de jouets, résultant en tournant ou en se déplaçant vers la lumière. Ces moteurs n’ont pas pu être activé directement avec l’Arduino, si vous obtenez petit assez moteurs, la partie commutation de ce projet peut-être être omise sans perte de fonctionnalité. Si aucun des quatre photodiodes enregistre beaucoup plus élevé que les autres, il détecte quelle photodiode reçoit le signal accru et transforme ou va dans cette direction pour aussi longtemps que le signal accru est reçu. Cette lumière algorithme de suivi permet aux panneaux solaires de programme à suivre sur le soleil, ou pour le contrôle du robot par l’intermédiaire de lampe de poche, comme le démontre ici.
Description
Photos et schémas du circuit imprimé complet serait un peu brouillon dans ce cas, donc j’ai emballé les principaux éléments qui sont répètent 4 et 2 fois respectivement dans le projet réel. Le premier sous-système de circuit est le diviseur de tension basé sur une photorésistance qui est répété quatre fois, avec chaque photorésistance étant placé sur une autre facette de votre robot. Une photorésistance varie résistance basée sur le signal lumineux reçu par la photoconductivité du récepteur matériau semi-conducteur. La résistance variable produit une courant dans le circuit selon la Loi d’Ohm, V variable = iR où la tension V est constante (5V). Veillez à ne pas faire les fils qui entraîna toute une photodiode excessivement longue, que vous pouvez perdre le signal en raison de la résistance interne du fil et des connexions à souder. Tension à cette partie du circuit directement à partir 5V de la Arduino UNO / Gnd épingles. La ligne 5V passe à travers une résistance de 10kΩ, par le biais de la photodiode, puis revenez vers le sol. Analogique en signal est lu situées entre la résistance et la photodiode via Arduino analogique à pins. Un ajout optionnel est l’indicateur LED montré passant de l’autre côté de la résistance (positive) à la masse (négative), que cette LED va changer intensité basée sur le signal reçu par la photodiode. Sont de ces LED trop près à l’un des photodiodes, votre machine peut envahis par une sorte de boucle de rétroaction analogique dans cette direction, où elle tourne dans le sens de ses propres témoins. Je crois que j’ai codé contre cette possibilité, mais si vous voyez ce comportement, essayez de prendre les LEDs car ils sont utiles uniquement lors du débogage de cette portion du circuit. Analog quatre pins doit être connecté à quatre itérations de ce bloc de circuit. En principe, vous pouvez augmenter le nombre d’itérations pour l’augmentation de la sensibilité directionnelle, mais ce n’est pas nécessaire pour cette application. L’esquisse qui accompagne ce projet est sensible à une différence dans l’intensité de la lumière reçue, si tous les signaux reçus sont très semblables, que le robot se poursuivra à déguster son environnement, mais Restez immobile. Dès qu’un des signaux est plus grande que les autres d’une valeur de seuil, le programme insère sa boucle de mouvement. Il détermine quel photorésistance reçoit le signal maximum et applique ensuite le courant vers le moteur qui déplace le robot dans le bon sens correspondant. Cette action se poursuit tant que photorésistance bénéficie d’intensité maximale, et il y a une assez grande différence entre les valeurs lues.
La deuxième partie bloquée du circuit est nécessaire uniquement si vous avez besoin de plus de puissance pour les moteurs alors l’Arduino peut fournir directement à partir de ses broches de sortie PWM. Mon châssis / pistes / moteur est un jouet chinois, l’Arduino a été la difficulté à conduire les moteurs avec les rails, alors j’ai construit dans un bloc de commutation pour le circuit qui permet de la PWM de sortie pour faire basculer un relais reed qui complète un circuit d’une pile de 9V. Le relais reedfonctionne via un électro-aimant qui, une fois activé par inférieurs causes actuelles (Arduino) les points de contact dans l’interrupteur pour devenir aimantés et fermer le circuit. En principe, vous pouvez conduire très gros moteurs électriques avec ce concept en sélectionnant le relais reed correct. Je n’ai pas besoin de beaucoup plus de puissance, donc une pile de 9V était beaucoup, l’interrupteur que j’ai utilisé est dans les parties de peur que l’article. Étant donné que ce composant est alimenté par le champ électromagnétique, une diode de protection transitoire est nécessaire, car le champ magnétique s’effondrent (lorsque l’interrupteur est éteint) peuvent provoquer un pic actuel de voyager vers l’Arduino comme prédit par les équations de Maxwell. Une bonne discussion sur la façon de mettre en œuvre ce relais reed particulier passer sans causant des dommages à votre Conseil d’administration peut être trouvé ici.
Cette portion du circuit est répétée deux fois correspondant à deux moteurs, et comme dit, si vous êtes en mesure d’alimenter vos moteurs directement avec Arduino, vous pouvez omettre cette partie du projet sans perte de fonctionnalité.
Schéma de câblage
Diviseur de tension :
Circuit de commutation :
Liste des pieces
Arduino UNO (14,48$)
4 x résistance, 10 KΩ
4 x Photo lumière sensible résistance photorésistance Optoresistor 5mm GL5516 5516
4 x LED
RadioShack® 1.5W panneau solaire 9V (5,74$)
Les titres de jouets / plate-forme / moteurs (2)
2 x interrupteurs Reed (OMR-C - 105H)
Code
const int frontPin = A0 ;
const int leftPin = A1 ;
const int rightPin = A2 ;
const int backPin = A3 ;
const int leftMotor = 9 ;
const int rightMotor = 10 ;
int threshHold = 170 ;
int Direction ;
direction1 int ;
direction2 int ;
int Delay = 25 ;
int Delay2 = 25 ;
void setup()
{
pinMode (frontPin, entrée) ;
pinMode (leftPin, entrée) ;
pinMode (rightPin, entrée) ;
pinMode (backPin, entrée) ;
pinMode (leftMotor, sortie) ;
pinMode (rightMotor, sortie) ;
digitalWrite (leftMotor, HIGH) ;
digitalWrite(rightMotor,HIGH) ;
Delay(100) ;
digitalWrite (leftMotor, basse) ;
digitalWrite (rightMotor, basse) ;
Delay(100) ;
digitalWrite (leftMotor, HIGH) ;
digitalWrite (rightMotor, HIGH) ;
Delay(100) ;
digitalWrite (leftMotor, basse) ;
digitalWrite (rightMotor, basse) ;
Delay(1500) ;
Serial.Begin(9600) ;
}
void loop()
{
int Direction ;
direction1 int ;
direction2 int ;
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 < = seuil
Si (abs(frontSignal-leftSignal)+abs(frontSignal-rightSignal)+abs(frontSignal-backSignal) > = seuil)
{
Serial.println ("boucle de motion") ;
direction1 = max (frontSignal, leftSignal) ;
direction2 = max (rightSignal, backSignal) ;
Direction = max (direction1, direction2) ;
Boucle ici est entré seulement si la lumière reçue n’est ne pas également répartie.
Si (frontSignal == Direction)
{
faire
{
digitalWrite (leftMotor, HIGH) ;
digitalWrite (rightMotor, HIGH) ;
Delay(Delay2) ;
digitalWrite (leftMotor, basse) ;
digitalWrite (rightMotor, basse) ;
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) ;
Direction = max (direction1, direction2) ;
Serial.println("Forward") ;
} Si (frontSignal == Direction & & abs(frontSignal-leftSignal)+abs(frontSignal-rightSignal)+abs(frontSignal-backSignal) > = seuil) ;
digitalWrite (leftMotor, basse) ;
digitalWrite (rightMotor, basse) ;
}
ElseIf (leftSignal == Direction) //Signal est le plus important sur la gauche
{
faire
{
Serial.println("left") ;
digitalWrite (rightMotor, HIGH) ;
Delay(Delay2) ;
digitalWrite (rightMotor, basse) ;
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) ;
Direction = max (direction1, direction2) ;
} Si (leftSignal == Direction & & abs(frontSignal-leftSignal)+abs(frontSignal-rightSignal)+abs(frontSignal-backSignal) > = seuil) ;
digitalWrite (rightMotor, basse) ;
}
ElseIf (rightSignal == Direction) //Signal est le plus grand sur la droite.
{
faire
{
Serial.println("Right") ;
digitalWrite (leftMotor, HIGH) ;
Delay(Delay2) ;
digitalWrite (leftMotor, basse) ;
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) ;
Direction = max (direction1, direction2) ;
} Si (rightSignal == Direction & & abs(frontSignal-leftSignal)+abs(frontSignal-rightSignal)+abs(frontSignal-backSignal) > = seuil) ;
digitalWrite (leftMotor, basse) ;
}
ElseIf (backSignal == Direction) //Signal est le plus grand derrière.
{
faire
{
Serial.println("Back") ;
digitalWrite (leftMotor, HIGH) ;
Delay(Delay2) ;
digitalWrite (leftMotor, basse) ;
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) ;
Direction = max (direction1, direction2) ;
} Si (backSignal == Direction & & abs(frontSignal-leftSignal)+abs(frontSignal-rightSignal)+abs(frontSignal-backSignal) > = seuil) ;
digitalWrite (leftMotor, basse) ;
}
}
d’autre if(abs(frontSignal-leftSignal)+abs(frontSignal-rightSignal)+abs(frontSignal-backSignal) < = seuil)
{
différence d’int = abs(frontSignal-leftSignal)+abs(frontSignal-rightSignal)+abs(frontSignal-backSignal) ;
Serial.println ("prime de Signal est égal à") ;
Serial.println(difference) ;
digitalWrite (leftMotor, basse) ;
digitalWrite (rightMotor, basse) ;
Delay(1000) ; Échantillon d’autre environnement à une fréquence de 10 hz
}
d’autre
{
digitalWrite (leftMotor, basse) ;
digitalWrite (rightMotor, basse) ;
}
}