Controlado de la linterna Solar accionado Arduino habilitado Robot
Este proyecto es un robot sensible Gradiente ligero con capacidades de carga solares, en otras palabras busca la luz para cargar a sí mismo. Logra este comportamiento con un conjunto de cuatro fotorresistores sensibles luz en circuitos divisor de tensión, la unidad de Arduino Lee los cuatro valores que corresponden a la intensidad de la luz recibida por los sensores a través de sus pines leerlas analógicos. Luego se aplica un alto voltaje a través de un interruptor reed que completa un circuito entre una batería de 9v y dos motores de juguete, que resulta de girar o moverse hacia la luz. Estos motores no fueron capaces de activar directamente con el Arduino, si tiene pequeñas suficientes motores, la parte de conmutación de este proyecto puede ser omitida sin pérdida de funcionalidad. Si cualquiera de los cuatro fotodiodos registra mucho más alto que los demás, detecta que fotodiodo recibe la señal aumentada y gira o se mueve en esa dirección para siempre y cuando se recibe la señal de una mayor. Este algoritmo de seguimiento de la luz puede utilizarse para paneles solares de programa para rastrear en el sol, o para el control del robot a través de la linterna, como se demuestra aquí.
Descripción
Fotos y diagramas del circuito completo sería un poco desordenados en este caso, así he en caja los componentes principales que se repiten en 4 y 2 veces respectivamente en el proyecto real. El primer subsistema de circuito es el divisor de voltaje basado en un fotoresistor que se repite cuatro veces, con cada fotorresistencia en un lado diferente de su robot. Una fotorresistencia varía basada en la señal recibida a través de la fotoconductividad del material semiconductor recibe la resistencia. La resistencia variable produce una variable corriente en el circuito según la ley de Ohm, V = iR donde el voltaje V es constante (5V). Tenga cuidado de no hacer los cables a cualquier un fotodiodo excesivamente largo, como puede perder señal debido a la resistencia interna del cable y las conexiones de soldadura. Voltaje se suministra a esta porción del circuito directamente 5V de Arduino UNO / pernos de tierra. La línea de 5V pasa a través de un resistor de 10kΩ, a través del fotodiodo y volver a tierra. Un análogo señal se lee entre el resistor y el fotodiodo via Arduino analógico en pins. Una adición opcional es el indicador LED muestra que va desde el otro lado de la resistencia (positivo) a tierra (negativo), que este LED cambiará la intensidad de la señal recibida por el fotodiodo. Si son estos LED demasiado cerca de uno de los fotodiodos, su máquina puede entrar en una especie de bucle de realimentación analógica en esa dirección, donde gira en dirección a su propio LED. Creo que he codificado contra esta posibilidad, pero si usted esta viendo ese comportamiento, trate de tomar los LEDs como son útiles sólo durante esta parte del circuito de depuración. Cuatro análogos de pins deben conectarse a cuatro iteraciones de este bloque de circuito. En principio puede aumentar el número de iteraciones para el aumento de la sensibilidad direccional, pero esto no es necesario para esta aplicación. El bosquejo que va con este proyecto es sensible a una diferencia en intensidad de luz recibida, si todas las señales recibidas son muy similares, que el robot seguirá muestra su entorno, pero siguen siendo inmóviles. Tan pronto como alguna de las señales es mayor que los otros por un valor de umbral, el programa entra en su ciclo de movimiento. Determina qué fotorresistor está recibiendo la señal máxima y entonces se aplica corriente al motor que se mueve el robot en la dirección correspondiente. Esta acción sigue como eso fotorresistencia recibe máxima intensidad, y hay una diferencia tan grande entre los valores leídos.
La segunda parte bloqueada el circuito sólo es necesaria si usted necesita más potencia para los motores luego del Arduino puede suministrar directamente en sus pines de salida PWM. Mi chasis / pistas / el motor es de juguete chino, el Arduino tenía problemas para conducir los motores con las pistas, por lo que he construido en un bloque de conmutación en el circuito que permite el PWM de salida a un relé de láminas que completa un circuito a una pila de 9V del tirón. El relé de láminasfunciona mediante un electroimán que, cuando activado por causas (Arduino) actuales bajas los puntos de contacto en el interruptor al ser magnetizado y cerrar el circuito. En principio puede conducir muy grandes motores eléctricos con este concepto eligiendo el relé reed correcto. No tengo mucho más energía, así una batería de 9V era suficiente, el interruptor usa es en las partes a fin de sección. Puesto que este componente es operado a través de campos electromagnéticos, un diodo de protección contra transitorios es necesario, ya que el campo magnético que se derrumba (cuando está apagado) puede provocar un pico de corriente viajar hacia el Arduino según lo predicho por las ecuaciones de Maxwell. Una buena discusión sobre cómo implementar este relé reed particular interruptor sin causar daño a la placa puede encontrarse aquí.
Esta parte del circuito se repite dos veces correspondiente a dos motores, y como se dijo, si eres capaz alimentar sus motores directamente con Arduino, puede omitir esta parte del proyecto sin pérdida de funcionalidad.
Diagrama del circuito
Divisor de tensión:
Circuito de conmutación:
Lista de piezas
Arduino UNO ($14,48)
4 x resistencia, 10 KΩ
Foto de x 4 luz sensible Resistor fotoresistor Optoresistor 5mm GL5516 5516
4 x LED
RadioShack® 1.5W Panel Solar 9V ($5,74)
Pistas de juguete / plataforma de motores (2)
2 x Reed Switches (OMR-C - 105H)
Código
const int frontPin = A0;
const int leftPin = A1;
const int rightPin = A2;
const int backPin = A3;
const int leftMotor = 9;
const int rightMotor = 10;
Umbral de int = 170;
int dirección;
int direction1;
int direction2;
int retardo = 25;
int Delay2 = 25;
void setup()
{
pinMode (frontPin, entrada);
pinMode (leftPin, entrada);
pinMode (rightPin, entrada);
pinMode (backPin, entrada);
pinMode (leftMotor, salida);
pinMode (rightMotor, salida);
digitalWrite (leftMotor, HIGH);
digitalWrite(rightMotor,HIGH);
Delay(100);
digitalWrite (leftMotor, bajo);
digitalWrite (rightMotor, bajo);
Delay(100);
digitalWrite (leftMotor, HIGH);
digitalWrite (rightMotor, HIGH);
Delay(100);
digitalWrite (leftMotor, bajo);
digitalWrite (rightMotor, bajo);
Delay(1500);
Serial.Begin(9600);
}
void loop()
{
int dirección;
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 < = umbral
Si (abs(frontSignal-leftSignal)+abs(frontSignal-rightSignal)+abs(frontSignal-backSignal) > = umbral)
{
Serial.println ("lazo del movimiento");
direction1 = max (frontSignal, leftSignal);
direction2 = max (rightSignal, backSignal);
Dirección = max (direction1, direction2);
Lazo de aquí se entra sólo si la luz recibida no está uniformemente distribuido.
Si (frontSignal == dirección)
{
hacer
{
digitalWrite (leftMotor, HIGH);
digitalWrite (rightMotor, HIGH);
Delay(Delay2);
digitalWrite (leftMotor, bajo);
digitalWrite (rightMotor, bajo);
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);
Dirección = max (direction1, direction2);
Serial.println("forward");
} mientras que (frontSignal == dirección & & abs(frontSignal-leftSignal)+abs(frontSignal-rightSignal)+abs(frontSignal-backSignal) > = umbral);
digitalWrite (leftMotor, bajo);
digitalWrite (rightMotor, bajo);
}
else if (leftSignal == dirección) //Signal es mayor a la izquierda
{
hacer
{
Serial.println("left");
digitalWrite (rightMotor, HIGH);
Delay(Delay2);
digitalWrite (rightMotor, bajo);
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);
Dirección = max (direction1, direction2);
} mientras que (leftSignal == dirección & & abs(frontSignal-leftSignal)+abs(frontSignal-rightSignal)+abs(frontSignal-backSignal) > = umbral);
digitalWrite (rightMotor, bajo);
}
else if (rightSignal == dirección) //Signal es mayor a la derecha.
{
hacer
{
Serial.println("Right");
digitalWrite (leftMotor, HIGH);
Delay(Delay2);
digitalWrite (leftMotor, bajo);
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);
Dirección = max (direction1, direction2);
} mientras que (rightSignal == dirección & & abs(frontSignal-leftSignal)+abs(frontSignal-rightSignal)+abs(frontSignal-backSignal) > = umbral);
digitalWrite (leftMotor, bajo);
}
else if (backSignal == dirección) //Signal es el más grande detrás.
{
hacer
{
Serial.println("back");
digitalWrite (leftMotor, HIGH);
Delay(Delay2);
digitalWrite (leftMotor, bajo);
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);
Dirección = max (direction1, direction2);
} mientras que (backSignal == dirección & & abs(frontSignal-leftSignal)+abs(frontSignal-rightSignal)+abs(frontSignal-backSignal) > = umbral);
digitalWrite (leftMotor, bajo);
}
}
if(abs(frontSignal-leftSignal)+abs(frontSignal-rightSignal)+abs(frontSignal-backSignal) demás < = umbral)
{
int diferencia = abs(frontSignal-leftSignal)+abs(frontSignal-rightSignal)+abs(frontSignal-backSignal);
Serial.println ("señal diferencial es igual a");
Serial.println(Difference);
digitalWrite (leftMotor, bajo);
digitalWrite (rightMotor, bajo);
Delay(1000); Otra muestra de medio ambiente a un ritmo de 10 hz
}
otra cosa
{
digitalWrite (leftMotor, bajo);
digitalWrite (rightMotor, bajo);
}
}
