Carrito seguidor de linea - Arduino

Objetivo: Crear un seguidor de linea con la programación en arduino para controlar los puentes H, y controlar los motorreductores, en función con los sensores infrarrojos para detectar la linea negra o blanca.

Materiales:
- 2 sensores CNY70
- 2 Motorreductor
- 2 LLantas
- Protoboard
- Silicón
- Palos de madera
- Cables
- Pila de 9v
- Puente H L298N
- PowerBank
- Arduino Uno

Vídeo realizado por el equipo sobre el proyecto del carrito seguidor de linea: https://www.youtube.com/watch?v=d-PIamGGue0&feature=youtu.be

Código utilizado:
Realizado por:THEFENIX-THE FENIX-EMIC TRON.*/
int infraPin1 = 10;    // pin del infrarrojos utilizado como entrada digital en el lado derecho(#1).
int infraPin2 = 11;    // pin del infrarrojos utilizado como entrada digital en el lado izquierdo(#2).
int valorInfra1 = 0;  // Valor inicial de la lectura digital del infrarrojo #1.
int valorInfra2 = 0;  // Valor inicial de la lectura digital del infrarrojo #2.
int ENB = 5; //ENB conectado al pin 5 con señal PWM
int ENA = 9; //ENA conectado al pin 9 con señal PWM
int OUTPUT4 = 4;    // Output4 conectada al pin 4.
int OUTPUT3 = 3;    // Output3 conectada al pin 3.
int OUTPUT2 = 6;    // Output2 conectada al pin 6.
int OUTPUT1 = 7;    // Output1 conectada al pin 7.

void setup() {
  Serial.begin(9600); // Comenzamos comunicacion serial.
  pinMode(infraPin1, INPUT);     // Inicializa el pin 1 como entrada digital.
  pinMode(infraPin2, INPUT);     // Inicializa el pin 2 como entrada digital.
  pinMode (ENA, OUTPUT);     // Inicializa el pin 7  como salida digital.
  pinMode (ENB, OUTPUT);     // Inicializa el pin 6 como salida digital.
  pinMode (OUTPUT1, OUTPUT);     // Inicializa el pin 7  como salida digital.
  pinMode (OUTPUT2, OUTPUT);     // Inicializa el pin 6 como salida digital.
  pinMode (OUTPUT3, OUTPUT);     // Inicializa el pin 3 como salida digital.
  pinMode (OUTPUT4, OUTPUT);     // Inicializa el pin 4 como salida digital. 
  }
void loop() {
 
  valorInfra1 = digitalRead(infraPin1);   // Lee el valor de la entrada 10, esto es, el valor que lee el infrarrojo #1.
  Serial.print("SENSOR1 ");         //Imprimimos el texto "SENSOR1 "
  Serial.println(valorInfra1);    //Imprimimos la lectura del infrarrojo #1.
  valorInfra2 = digitalRead(infraPin2);    // Lee el valor de la entrada 11, esto es, el valor que lee el infrarrojo #2.
  Serial.print("SENSOR2 ");       //Imprimimos el texto "SENSOR2 "
  Serial.println(valorInfra2);    //Imprimimos la lectura del infrarrojo #2.
  
  if(valorInfra1==0)   // Si la lectura del infrarrojo #1 es 0, entonces se cumplira una de las siguientes condiciones:
  {
  if(valorInfra2==0){  // Si la lectura del infrarrojo #2 es 0, es decir los dos sensores estan sobre la linea negra, entonces los dos motores avanzaran en linea recta.
  digitalWrite(OUTPUT1,0);
  digitalWrite(OUTPUT2,1);
  digitalWrite(OUTPUT3,1);
  digitalWrite(OUTPUT4,0);
  analogWrite(ENA,150); // El pin ENA maneja los pines output1 y output2
  analogWrite(ENB,150); // El pin ENA maneja los pines output3 y output4
  }
  else // Si la lectura del infrarrojo #2 es 1, el sensor#1 esta sobre la linea negra y el sensor#2 esta fuera de la linea negra, entonces solo una rueda gira y esto causara el giro.
  {
  digitalWrite(OUTPUT1,0);
  digitalWrite(OUTPUT2,0);
  digitalWrite(OUTPUT3,1);
  digitalWrite(OUTPUT4,0);
  analogWrite(ENA,0);
  analogWrite(ENB,150);
  }
  }
  else // Si la lectura del infrarrojo #1 no es 0, sera 1, se daran las siguientes posibilidades:
  {if(valorInfra2==0)  // Como el sensor#1 esta fuera de la linea negra y el sensor#2 esta sobre la linea negra, entonces solo una rueda gira y esto causara el giro.
  {
  digitalWrite(OUTPUT3,0);
  digitalWrite(OUTPUT4,0);
  digitalWrite(OUTPUT1,0);
  digitalWrite(OUTPUT2,1);
  analogWrite(ENA,150);
  analogWrite(ENB,0);
  }
  else{ // si ambos sensores dan lectura 1, los dos estan fuera de la linea negra, para que vuelva a su trayectoria tiene que retroceder.
  digitalWrite(OUTPUT1,1);
  digitalWrite(OUTPUT2,0);
  digitalWrite(OUTPUT3,0);
  digitalWrite(OUTPUT4,1);
  analogWrite(ENA,150);
  analogWrite(ENB,150);
  }   
  }
  }

Diagrama:



Comentarios

Publicar un comentario

Entradas populares de este blog

2.12 Instrucciones lógicas.

Imagen
Ensamblador cuenta con un grupo de cuatro instrucciones lógicas a nivel de bit, las cuales con excepción de la primera requieren de dos operandos, estas son las siguientes: NOT: La instrucción NOT o negación requiere un solo operando y su función es cambiar el estado de los bits del mismo, es decir, cambiar los ceros por unos y los unos por ceros. Ejemplo: NOT ax  Se aplica la negación al valor del registro ax. AND: Esta instrucción también conocida como producto lógico requiere de dos operandos y su valor será igual a uno cuando los bits que se comparen ambos sean uno. Ejemplo: AND ax,bx  Se aplica el producto lógico a los valores de ax y bx. OR: La instrucción OR también conocida como suma lógica requiere de dos operandos y su valor será uno si alguno de los bits que compara es uno. Ejemplo: OR ax,bx Se aplica la suma lógica a los valores de ax y bx. XOR: La instrucción XOR o suma lógica exclusiva requiere dos operandos, los cuales se comparan y...
Leer más

2.9 Instrucciones aritméticas.

Dentro de ensamblador se pueden llevar a cabo las 4 instrucciones aritméticas básicas, cada una de ellas cuenta con su propia función: Instrucción de Suma ADD: Suma los operandos que se le dan y guarda el resultado en el primer operando. Ejemplo ADD al, bl:  Suma los valores guardados en los registros al y bl, almacenando el resultado en al. Instrucción de Resta SUB: Resta el primer operando al segundo y almacena el resultado en el primero. Ejemplo: SUB al, bl:  Resta el valor de AL al de BL y almacena el resultado en AL. Instrucción de multiplicación MUL: Multiplica el contenido del acumulador por el operando, a diferencia de los métodos anteriores, solo es necesario indicar el valor por el que se multiplicará, ya que el resultado siempre es almacenado en el registro AX. Ejemplo: MUL DX:  Multiplica el valor del registro acumulador (AX) por el de DX. Instrucción de división DIV: Divide un numero contenido en el acumulador entre el operando...
Leer más

2.10 Manipulación de la pila.

Imagen
La pila es un grupo de localidades de memoria que se reservan para contar con un espacio de almacenamiento temporal cuando el programa se está ejecutando. La pila es una estructura de datos del tipo LIFO (Last In First Out), esto  quiere decir que el último dato que es introducido en ella, es el primero que saldrá al sacar datos de la pila. Para la manipulación de la pila ensamblador cuenta con dos instrucciones especificas, las cuales son las siguientes: Push: Esta instrucción permite almacenar el contenido del operando dentro de la última posición de la pila. Ejemplo: Push ax    El valor contenido en ax es almacenado en el último espacio de la pila. Pop: Esta instrucción toma el último dato almacenado en la pila y lo carga al operando. Ejemplo: Pop bx       El valor contenido en el último espacio de la pila se almacena en el registro El siguiente ejemplo muestra como implementar la instrucción XCHG por medio de las instrucc...
Leer más