Cómo hacer un robot memorizador de caminos usando arduino

¿Quieres aprender a construir un robot que pueda recordar y seguir caminos? En este artículo te enseñaremos cómo hacerlo utilizando Arduino, una plataforma de desarrollo muy popular entre los entusiastas de la robótica. Descubre cómo convertir tu idea en realidad y crea un robot memorizador de caminos para divertirte y sorprender a todos.

Un coche robot memorizador de caminos simple repite la acción o camino que está almacenado en su memoria. Hacer un robot así puede parecer complicado al principio, pero créeme, es más fácil de lo que piensas. Y al final de este artículo, podrá hacer:

(a) Un coche de control remoto IR inalámbrico con Arduino

(b) Conviértalo en un robot memorizador de rutas sin usar ningún componente adicional y

(c) Cómo usar la EEPROM incorporada de Arduino para almacenar esa ruta para siempre en su memoria.

Videotutorial paso a paso:

¿Cómo funciona un robot memorizador de rutas?

Antes de comenzar el tutorial veamos el objetivo del proyecto y su funcionamiento.

El automóvil se opera manualmente usando los botones de control especificados en el control remoto IR. 2 lo mueve hacia adelante, 4 es para la izquierda, 6 es para la derecha, 8 es para atrás y 0 detiene el automóvil.

Cómo hacer un robot memorizador de caminos usando arduino

La>

Aparte de todo esto, si en algún momento durante la operación, el robot se encuentra con algún error, puede restablecer Arduino fácilmente presionando el botón de reproducción. Tenga en cuenta que puede cambiar cualquier botón que desee para cualquier operación determinada mencionada anteriormente en la sección CÓDIGO.

COMPONENTES:

Para construir este coche robot necesitarás:

  1. Un Arduino Uno
  2. Un control remoto IR y un receptor IR
  3. Dos motores de CC con engranajes
  4. Módulo de controlador de motor
  5. Fuente de alimentación de 9V. Estoy usando 6 pilas AA de 1,5 V aquí
  6. Ruedas robóticas
  7. Chasis robótico
  8. Tablero de circuitos
  9. alambres

¿Cómo construir el camino memorizando ROBOT?

Parte 1: Montaje del chasis

Cómo hacer un robot memorizador de caminos usando arduino
Montaje del chasis

En primer lugar, necesitará un chasis Robot, al que puede colocar motores y neumáticos. Estoy usando 2 motores de CC, 2 neumáticos de goma y una rueda giratoria. Después de terminar el ensamblaje del robot, es hora de la parte electrónica.

Parte 2: Breve Introducción a la Electrónica

Para controlar su automóvil robot desde el control remoto IR, necesitaría un receptor IR. Este receptor IR decodificará la señal recibida para el botón correspondiente presionado y la enviará a Arduino. Arduino actúa como un controlador para su Robot Car y el programa escrito en él brinda la lógica adecuada para controlar los motores. Pero todos sabemos que Arduino no puede suministrar suficiente corriente a un motor de CC. Y es por eso que también necesita un controlador de motor aquí. Puede utilizar cualquier controlador de motor que desee. Como en este caso, estoy usando el IC del controlador de motor L293D para este automóvil Robot.

Parte 3: Receptor IR

Hablemos del control remoto IR que todos usamos en nuestra vida diaria. Sí, un control remoto de TV. Debes haber observado un led blanco frente a él. Este LED blanco es en realidad un transmisor IR. Transmite ondas infrarrojas de diferentes frecuencias dependiendo del botón presionado. Esta onda luego es recibida y decodificada por el receptor IR en el lado del televisor, para averiguar qué botón ha presionado. Vamos a utilizar la misma lógica para construir este proyecto.

Cómo hacer un robot memorizador de caminos usando arduino
control remoto

Ahora, para distinguir entre los botones, a cada botón se le asigna una frecuencia única. Eso significa que debe saber cuál es la frecuencia de cada botón antes de usar un control remoto IR. Pero la verdadera pregunta es cómo. Pues un Arduino nos puede ayudar en esta situación. Así que toma un Arduino y un receptor IR.

Conecte el terminal izquierdo del sensor al pin digital 10 de Arduino. Terminal medio a GND y terminal derecho a pin 5V de Arduino.

Cómo hacer un robot memorizador de caminos usando arduino
Sensor IR con Arduino

Ahora vaya al software Arduino IDE y descargue una biblioteca para el control remoto IR.

Cómo hacer un robot memorizador de caminos usando arduino
biblioteca remota IR

A continuación, vaya a archivos, luego ejemplo–>control remoto IR–>IRreciba un boceto de demostración.

Cómo hacer un robot memorizador de caminos usando arduino
Bosquejo de demostración de IRreceive

Sube este código a tu tablero. Ahora abra el monitor serial y presione cualquier botón en el control remoto IR. Como puede ver aquí, el código hexadecimal correspondiente para el botón está impreso en el monitor serie. Anote el código hexadecimal de todos los botones. Y ahora puedes programar Arduino para realizar una determinada función cuando recibe un determinado código hexadecimal.

Cómo hacer un robot memorizador de caminos usando arduino
códigos hexadecimales

Parte 4: DIAGRAMA DE CIRCUITO

Cómo hacer un robot memorizador de caminos usando arduino
Diagrama de circuito del robot de memorización de rutas

Enlace al archivo Tinkercad: https://www.tinkercad.com/things/73bMPNPUEKh

Conecte el controlador de motor IC a su placa Arduino y motores de CC. Estoy usando L293D IC y la imagen de arriba es el esquema de la misma. Si está utilizando L293D, conéctelo, como se muestra en el diagrama del circuito. Y ahora que hemos terminado las conexiones del circuito, es hora de pasar al Código Arduino:

Parte 5: Programa Arduino A— Coche de control remoto IR normal

Este es un simple programa de coche de control remoto IR sin ninguna funcionalidad de memorización. El objetivo final es controlar el automóvil con un control remoto IR. En primer lugar, descargue e incluya la biblioteca IRremote desde el administrador de la biblioteca. A continuación, escriba algunas macros para que pueda cambiar fácilmente los pines de Arduino directamente desde aquí:

/*
***********************IR Remote Control Car**************************
* 
* Created on: May 27, 2021
* Author: Ankit Negi 
* 
* Youtube: www.youtube.com/theelectronicguy
* Website: www.eTechnophiles.com
*/

#include <IRremote.h>

/*
   Left Motor
*/
// IN 1
#define LM_IN1    2
// IN 2
#define LM_IN2    4
/*
   Right Motor
*/
// IN 3
#define RM_IN3    5
// IN 4
#define RM_IN4    7


// IR receiver
# define RECV_PIN 10

IRrecv irrecv(RECV_PIN);

decode_results results;

//HEX codes for buttons
#define FWD       0xFD8877 // go forward
#define LFT       0xFD28D7 // go left
#define RGT       0xFD6897 // go right
#define BWD       0xFD9867 // go backward
#define STOP      0xFD30CF // stop
#define RESET     0xFD00FF // Resets the Arduino Board(RED)

unsigned long int value=0;

/*
 ************Arduino Reset Pin**************
 */
#define RESET_PIN A0

void setup() {
  
  // set mode of the pins as output
  for (int i = 2; i <= 7; i++) {
    pinMode(i, OUTPUT);
  }


  // start serial communication
  Serial.begin(9600);
  // In case the interrupt driver crashes on setup, give a clue
  // to the user what's going on.
  Serial.println("Enabling IRin");
  irrecv.enableIRIn(); // Start the receiver
  Serial.println("Enabled IRin");

}

void loop() {
  if (irrecv.decode(&results)) {
    value = results.value;
    Serial.println(value, HEX);
    irrecv.resume(); // Receive the next value
    delay(200);
  }

  delay(100);
  check_Inst(value);
  value=0;
}

void check_Inst(long int value) {

  switch (value) {
    case FWD:
      go_Forward();
      break;
    case LFT:
      go_Left();
      break;
    case RGT:
      go_Right();
      break;
    case BWD:
      go_Backward();
      break;
    case STOP:
      go_Stop();
      break;
    case RESET:
      pinMode(RESET_PIN,OUTPUT);
      digitalWrite(RESET_PIN,HIGH);   
      break;  

    default:
      value = 0;
  }
}

void go_Forward() {
 
  movement_Inst_Fwd();
  delay(10);
}

void go_Left() {
   
  movement_Inst_Lft();
  delay(10);
}

void go_Right() {
  
  movement_Inst_Rgt();
  delay(10);
}

void go_Backward(){

  movement_Inst_Bwd();
  delay(10);
}  

void go_Stop(){
  
  movement_Inst_Stp();
  delay(10);
}  

/*
 * These movement instruction are repeated several times in the code
 */
void movement_Inst_Fwd(void){
  Serial.println("Going_Forward");
  
  // forward movement instructions
  digitalWrite(LM_IN1,HIGH);
  digitalWrite(LM_IN2,LOW);
  digitalWrite(RM_IN3,HIGH);
  digitalWrite(RM_IN4,LOW);   
  } 
  
void movement_Inst_Lft(void){
  Serial.println("Going_Left");
  
  // Left movement instructions
  digitalWrite(LM_IN1,LOW);
  digitalWrite(LM_IN2,LOW);
  digitalWrite(RM_IN3,HIGH);
  digitalWrite(RM_IN4,LOW);  
  delay(500);
  digitalWrite(LM_IN1,LOW);
  digitalWrite(LM_IN2,LOW);
  digitalWrite(RM_IN3,LOW);
  digitalWrite(RM_IN4,LOW);    
  delay(500);
  }
  
void movement_Inst_Rgt(void){
  Serial.println("Going_Right");  
  
  // Rgt movement instructions
  digitalWrite(LM_IN1,HIGH);
  digitalWrite(LM_IN2,LOW);
  digitalWrite(RM_IN3,LOW);
  digitalWrite(RM_IN4,LOW); 
  delay(500);
  digitalWrite(LM_IN1,LOW);
  digitalWrite(LM_IN2,LOW);
  digitalWrite(RM_IN3,LOW);
  digitalWrite(RM_IN4,LOW); 
  delay(500);
    
  }
  
void movement_Inst_Bwd(void){
  Serial.println("Going_Backward"); 
    
  // Bwd movement instructions
  digitalWrite(LM_IN1,LOW);
  digitalWrite(LM_IN2,HIGH);
  digitalWrite(RM_IN3,LOW);
  digitalWrite(RM_IN4,HIGH);   
  }
  
void movement_Inst_Stp(void){  
  Serial.println("Stopping");    
  
  // Stp movement instructions
  digitalWrite(LM_IN1,LOW);
  digitalWrite(LM_IN2,LOW);
  digitalWrite(RM_IN3,LOW);
  digitalWrite(RM_IN4,LOW);  
  }

Parte 6: Programa B de Arduino: robot de memorización de ruta (temporal)

/*
*********************Path Memorizing Robot(temp)************************
* 
* Created on: May 27, 2021
* Author: Ankit Negi 
* 
* Youtube: www.youtube.com/theelectronicguy
* Website: www.eTechnophiles.com
*/

#include <IRremote.h>

/*
   Left Motor
*/
// IN 1
#define LM_IN1    2
// IN 2
#define LM_IN2    4
/*
   Right Motor
*/
// IN 3
#define RM_IN3    5
// IN 4
#define RM_IN4    7


// IR receiver
# define RECV_PIN 10

IRrecv irrecv(RECV_PIN);

decode_results results;

//HEX codes for buttons
#define FWD       0xFD8877 // go forward
#define LFT       0xFD28D7 // go left
#define RGT       0xFD6897 // go right
#define BWD       0xFD9867 // go backward
#define STOP      0xFD30CF // stop
#define RPEAT     0xFD708F // repeat the stored sequence of movement from the temporary memory(automatically stores)
#define DEL       0xFDB04F // delete the stored sequence of movement from temporary memory(EQ)
#define RESET     0xFD00FF // Resets the Arduino Board(RED)


unsigned long int value = 0; // stores the incoming hex value
byte seq = 0; //stores the current number of executed sequences
byte seq_Array[50];// array to store the movement sequence in terms of integers(1 for FWD, 2 for LEFT and so on..)

//counter for counting the number of times program pass through a movement function(fwd, lft etc.)
int fwd_Counter = -1;
int lft_Counter = -1;
int rgt_Counter = -1;
int bwd_Counter = -1;
int stp_Counter = -1;

//global "current time" variables for different movement functions(fwd, lft etc.)
unsigned long int current_Time0 = 0;// for FWD movement
unsigned long int current_Time1 = 0;// for LEFT movement
unsigned long int current_Time2 = 0;// for RIGHT movement
unsigned long int current_Time3 = 0;// for BWD movement
unsigned long int current_Time4 = 0;// for STOP

//total time spend by the pgm in executing the movement(fwd, lft etc.) for a particular movement counter
unsigned long int total_Fwd_Time[10];
unsigned long int total_Lft_Time[10];
unsigned long int total_Rgt_Time[10];
unsigned long int total_Bwd_Time[10];
unsigned long int total_Stp_Time[10];

/*
 ************Arduino Reset Pin**************
 */
#define RESET_PIN A0

void setup() {

  // set mode of the pins as output
  for (int i = 2; i <= 7; i++) {
    pinMode(i, OUTPUT);
  }


  // start serial communication
  Serial.begin(9600);
  // In case the interrupt driver crashes on setup, give a clue
  // to the user what's going on.
  Serial.println("Enabling IRin");
  irrecv.enableIRIn(); // Start the receiver
  Serial.println("Enabled IRin");

}

void loop() {
  if (irrecv.decode(&results)) {
    value = results.value;
    Serial.println(value, HEX);
    irrecv.resume(); // Receive the next value
    delay(200);
  }

  delay(100);
  check_Inst(value);
  value=0;
}

void check_Inst(long int value) {

  switch (value) {
    case FWD:
      go_Forward();
      delay(10);
      break;
    case LFT:
      go_Left();
      delay(10);
      break;
    case RGT:
      go_Right();
      delay(10);
      break;
    case BWD:
      go_Backward();
      delay(10);
      break;
    case STOP:
      go_Stop();
      delay(10);
      break;
    case RPEAT:
      go_In_Seq();
      delay(10);
      break;
    case DEL:
      del_From_Local_Mem();
      delay(10);
      break;
    case RESET:
      pinMode(RESET_PIN,OUTPUT);
      digitalWrite(RESET_PIN,HIGH);   
      break;  
      
    default:
      value = 0;
  }
}

void go_Forward() {
  
  movement_Inst_Fwd();

  current_Time0 = millis();
  int i = seq_Array[(seq - 1)];
  switch (i) {
    case 2:
      total_Lft_Time[lft_Counter + 1] = (current_Time0 - current_Time1);
      lft_Counter++;
      break;

    case 3:
      total_Rgt_Time[rgt_Counter + 1] = (current_Time0 - current_Time2);
      rgt_Counter++;
      break;

    case 4:
      total_Bwd_Time[bwd_Counter + 1] = (current_Time0 - current_Time3);
      bwd_Counter++;
      break;

    case 5:
      total_Stp_Time[stp_Counter + 1] = (current_Time0 - current_Time4);
      stp_Counter++;
      break;
  }

  seq_Array[seq] = 1;
  seq++;
}

void go_Left() {

  movement_Inst_Lft();

  current_Time1 = millis();
  int i = seq_Array[(seq - 1)];
  switch (i) {
    case 1:
      total_Fwd_Time[fwd_Counter + 1] = (current_Time1 - current_Time0);
      fwd_Counter++;
      break;

    case 3:
      total_Rgt_Time[rgt_Counter + 1] = (current_Time1 - current_Time2);
      rgt_Counter++;
      break;

    case 4:
      total_Bwd_Time[bwd_Counter + 1] = (current_Time1 - current_Time3);
      bwd_Counter++;
      break;

    case 5:
      total_Stp_Time[stp_Counter + 1] = (current_Time1 - current_Time4);
      stp_Counter++;
      break;
  }

  seq_Array[seq] = 2;
  seq++;
}

void go_Right() {

  movement_Inst_Rgt();

  current_Time2 = millis();
  int i = seq_Array[(seq - 1)];
  switch (i) {
    case 1:
      total_Fwd_Time[fwd_Counter + 1] = (current_Time2 - current_Time0);
      fwd_Counter++;
      break;

    case 2:
      total_Lft_Time[lft_Counter + 1] = (current_Time2 - current_Time1);
      lft_Counter++;
      break;

    case 4:
      total_Bwd_Time[bwd_Counter + 1] = (current_Time2 - current_Time3);
      bwd_Counter++;
      break;

    case 5:
      total_Stp_Time[stp_Counter + 1] = (current_Time2 - current_Time4);
      stp_Counter++;
      break;
  }

  seq_Array[seq] = 3;
  seq++;
}

void go_Backward() {
  
  movement_Inst_Bwd();

  current_Time3 = millis();
  int i = seq_Array[(seq - 1)];
  switch (i) {
    case 1:
      total_Fwd_Time[fwd_Counter + 1] = (current_Time3 - current_Time0);
      fwd_Counter++;
      break;

    case 2:
      total_Lft_Time[lft_Counter + 1] = (current_Time3 - current_Time1);
      lft_Counter++;
      break;

    case 3:
      total_Rgt_Time[rgt_Counter + 1] = (current_Time3 - current_Time2);
      rgt_Counter++;
      break;

    case 5:
      total_Stp_Time[stp_Counter + 1] = (current_Time3 - current_Time4);
      stp_Counter++;
      break;
  }

  seq_Array[seq] = 4;
  seq++;
}

void go_Stop() {

  movement_Inst_Stp();

  current_Time4 = millis();
  int i = seq_Array[(seq - 1)];
  switch (i) {
    case 1:
      total_Fwd_Time[fwd_Counter + 1] = (current_Time4 - current_Time0);
      fwd_Counter++;
      break;

    case 2:
      total_Lft_Time[lft_Counter + 1] = (current_Time4 - current_Time1);
      lft_Counter++;
      break;

    case 3:
      total_Rgt_Time[rgt_Counter + 1] = (current_Time4 - current_Time2);
      rgt_Counter++;
      break;

    case 4:
      total_Bwd_Time[bwd_Counter + 1] = (current_Time4 - current_Time3);
      bwd_Counter++;
      break;
  }

  seq_Array[seq] = 5;
  seq++;
}

void go_In_Seq(void) {
  value = 0;
  for (int i = 0; i < (seq + 1); i++) {
    int value1 = 0;
    value1 = seq_Array[i];
    switch (value1) {
      case 1:
        static int j = 0;
        go_Forward_Seq(j);
        j++;
        break;
      case 2:
        static int k = 0;
        go_Left_Seq(k);
        k++;
        break;
      case 3:
        static int l = 0;
        go_Right_Seq(l);
        l++;
        break;
      case 4:
        static int m = 0;
        go_Backward_Seq(m);
        m++;
        break;
      case 5:
        static int n = 0;
        go_Stop_Seq(n);
        n++;
        break;
      default:
        j = 0; k = 0; l = 0; m = 0; n = 0;
    }
  }
}

void del_From_Local_Mem() {
  //set the movement counters to their default values
  fwd_Counter = -1;
  lft_Counter = -1;
  rgt_Counter = -1;
  bwd_Counter = - 1;
  stp_Counter = - 1;

  //set the total movement time to its default value
  for (int i = 0; i < 10; i++) {
    total_Fwd_Time[i] = 0;
    total_Lft_Time[i] = 0;
    total_Rgt_Time[i] = 0;
    total_Bwd_Time[i] = 0;
    total_Stp_Time[i] = 0;
  }

  // Reset the sequence array(stored movement instructions)
  for (int i = 0; i < 50; i++) {
    seq_Array[i] = 0;
  }

  seq = 0;
  value = 0;
}

 
/**********************************************************************************************************
     These function moves the car in a direction for the time specified/stored in the total_x_time array
************************************************************************************************************/
void go_Forward_Seq(int j) {
  //go in forward direction sequence
  movement_Inst_Fwd();//
  delay(total_Fwd_Time[j]);
}

void go_Left_Seq(int k) {
  //go in Left direction sequence
  movement_Inst_Lft();
  delay(total_Lft_Time[k]);
}

void go_Right_Seq(int l) {
  //go in right direction sequence
  movement_Inst_Rgt();
  delay(total_Rgt_Time[l]);
}

void go_Backward_Seq(int m) {
  //go in backward direction sequence
  movement_Inst_Bwd();
  delay(total_Bwd_Time[m]);
}

void go_Stop_Seq(int n) {
  //go in Stop sequence
  movement_Inst_Stp();
  delay(total_Stp_Time[n]);
}

/*********************************************************************************************
          These movement instruction are repeated(required) several times in the code
**********************************************************************************************/
void movement_Inst_Fwd(void) {
  Serial.println("Going_Forward");
  // forward movement instructions
  digitalWrite(LM_IN1, HIGH);
  digitalWrite(LM_IN2, LOW);
  digitalWrite(RM_IN3, HIGH);
  digitalWrite(RM_IN4, LOW);
}

void movement_Inst_Lft(void) {
  Serial.println("Going_Left");
  // Left movement instructions
  digitalWrite(LM_IN1, LOW);
  digitalWrite(LM_IN2, LOW);
  digitalWrite(RM_IN3, HIGH);
  digitalWrite(RM_IN4, LOW);
  delay(500);
  digitalWrite(LM_IN1, LOW);
  digitalWrite(LM_IN2, LOW);
  digitalWrite(RM_IN3, LOW);
  digitalWrite(RM_IN4, LOW);
  delay(500);
}

void movement_Inst_Rgt(void) {
  Serial.println("Going_Right");
  // Rgt movement instructions
  digitalWrite(LM_IN1, HIGH);
  digitalWrite(LM_IN2, LOW);
  digitalWrite(RM_IN3, LOW);
  digitalWrite(RM_IN4, LOW);
  delay(500);
  digitalWrite(LM_IN1, LOW);
  digitalWrite(LM_IN2, LOW);
  digitalWrite(RM_IN3, LOW);
  digitalWrite(RM_IN4, LOW);
  delay(500);

}

void movement_Inst_Bwd(void) {
  Serial.println("Going_Backward");
  // Bwd movement instructions
  digitalWrite(LM_IN1, LOW);
  digitalWrite(LM_IN2, HIGH);
  digitalWrite(RM_IN3, LOW);
  digitalWrite(RM_IN4, HIGH);
}

void movement_Inst_Stp(void) {
  Serial.println("Stopping");
  // Stp movement instructions
  digitalWrite(LM_IN1, LOW);
  digitalWrite(LM_IN2, LOW);
  digitalWrite(RM_IN3, LOW);
  digitalWrite(RM_IN4, LOW);
}

Parte 7: Código Arduino C—Robot memorizador de ruta EEPROM (permanente)

/*
************************Path Memorizing Robot****************************
* 
* Created on: May 27, 2021
* Author: Ankit Negi 
* 
* Youtube: www.youtube.com/theelectronicguy
* Website: www.eTechnophiles.com
*/

#include <IRremote.h>// IR remote library
#include <EEPROM.h>// EEPROM pre-installed library


/*
   ***********Left Motor***********
*/

// IN 1
#define LM_IN1    2
// IN 2
#define LM_IN2    4
/*
   ************Right Motor************
*/
// IN 3
#define RM_IN3    5
// IN 4
#define RM_IN4    7


/*
   ********************IR Receiver**********************
*/
# define RECV_PIN 10// Pin to which IR reciever is connected

IRrecv irrecv(RECV_PIN);// Pass the pin number to the function

decode_results results;// variable results stores the decoded hex values

/*
 ************HEX code of all the buttons used in the project**************
 */
#define FWD       0xFD8877 // go forward(2)
#define LFT       0xFD28D7 // go left(4)
#define RGT       0xFD6897 // go right(6)
#define BWD       0xFD9867 // go backward(8)
#define STOP      0xFD30CF // stop(0)
#define RPEAT     0xFD708F // repeat the stored sequence of movement from the temporary memory(automatically stores) (REPT)
#define DEL       0xFDB04F // delete the stored sequence of movement from temporary memory(EQ)
#define PERST     0xFD40BF // copy the sequence from temp. memory to the peramanent memory(EEPROM)
#define PLAYEPROM 0xFD609F // repeat the sequence stored in EEPROM(FASTFWD)
#define RESET     0xFD00FF // Resets the Arduino Board(RED)
                  


/*
 ************Global Variables and Arrays**************
 */
 
unsigned long int value = 0; // stores the incoming hex value
byte seq = 0; //stores the current number of executed sequences
byte seq_Array[50];// array to store the movement sequence in terms of integers(1 for FWD, 2 for LEFT and so on..)

//counter for counting the number of times program pass through a movement function(fwd, lft etc.)
int fwd_Counter = -1;
int lft_Counter = -1;
int rgt_Counter = -1;
int bwd_Counter = -1;
int stp_Counter = -1;

//global "current time" variables for different movement functions(fwd, lft etc.)
unsigned long int current_Time0 = 0;// for FWD movement
unsigned long int current_Time1 = 0;// for LEFT movement
unsigned long int current_Time2 = 0;// for RIGHT movement
unsigned long int current_Time3 = 0;// for BWD movement
unsigned long int current_Time4 = 0;// for STOP

//total time spend by the pgm in executing the movement(fwd, lft etc.) for a particular movement counter
unsigned long int total_Fwd_Time[10];
unsigned long int total_Lft_Time[10];
unsigned long int total_Rgt_Time[10];
unsigned long int total_Bwd_Time[10];
unsigned long int total_Stp_Time[10];

/*
 ************Arduino Reset Pin**************
 */
#define RESET_PIN A0

 
void setup() {

  // set mode of the pins as output
  for (int i = 2; i <= 7; i++) {
    pinMode(i, OUTPUT);
  }


  // start serial communication
  Serial.begin(9600);
  // In case the interrupt driver crashes on setup, give a clue
  // to the user what's going on.
  Serial.println("Enabling IRin");
  irrecv.enableIRIn(); // Start the receiver
  Serial.println("Enabled IRin");

}

void loop() {
  if (irrecv.decode(&results)) {
    value = results.value;
    Serial.println(value, HEX);
    irrecv.resume(); // Receive the next value
    delay(200);
  }

  delay(100);
  check_Inst(value);
  value=0;

}

void check_Inst(long int value) {

  switch (value) {
    case FWD:
      go_Forward();
      delay(10);
      break;
    case LFT:
      go_Left();
      delay(10);
      break;
    case RGT:
      go_Right();
      delay(10);
      break;
    case BWD:
      go_Backward();
      delay(10);
      break;
    case STOP:
      go_Stop();
      delay(10);
      break;
    case RPEAT:
      go_In_Seq();
      delay(10);
      break;
    case DEL:
      del_From_Local_Mem();
      delay(10);
      break;
    case PERST:
      write_To_Permt_Mem();
      delay(10);
      break;  
    case PLAYEPROM:
      Read_Permt_Mem();
      delay(10);
      break;   
    case RESET:
      pinMode(RESET_PIN, OUTPUT);
      digitalWrite(RESET_PIN,HIGH);   
      break;
                
     default:
      value = 0;
  }
}

void go_Forward() {
  movement_Inst_Fwd();

  current_Time0 = millis();
  int i = seq_Array[(seq - 1)];
  switch (i) {
    case 2:
      // total time elaspsed since Left button is pressed including rest time 
      total_Lft_Time[lft_Counter + 1] = (current_Time0 - current_Time1);
      lft_Counter++;
      break;

    case 3:
      // total time elaspsed since Right button is pressed including rest time 
      total_Rgt_Time[rgt_Counter + 1] = (current_Time0 - current_Time2);
      rgt_Counter++;
      break;

    case 4:
      total_Bwd_Time[bwd_Counter + 1] = (current_Time0 - current_Time3);
      bwd_Counter++;
      break;

    case 5:
      total_Stp_Time[stp_Counter + 1] = (current_Time0 - current_Time4);
      stp_Counter++;
      break;
  }

  seq_Array[seq] = 1;
  seq++;
}

void go_Left() {
  movement_Inst_Lft();

  current_Time1 = millis();
  int i = seq_Array[(seq - 1)];
  switch (i) {
    case 1:
      total_Fwd_Time[fwd_Counter + 1] = (current_Time1 - current_Time0);
      fwd_Counter++;
      break;

    case 3:
      total_Rgt_Time[rgt_Counter + 1] = (current_Time1 - current_Time2);
      rgt_Counter++;
      break;

    case 4:
      total_Bwd_Time[bwd_Counter + 1] = (current_Time1 - current_Time3);
      bwd_Counter++;
      break;

    case 5:
      total_Stp_Time[stp_Counter + 1] = (current_Time1 - current_Time4);
      stp_Counter++;
      break;
  }

  seq_Array[seq] = 2;
  seq++;
}

void go_Right() {
  movement_Inst_Rgt();

  current_Time2 = millis();
  int i = seq_Array[(seq - 1)];
  switch (i) {
    case 1:
      total_Fwd_Time[fwd_Counter + 1] = (current_Time2 - current_Time0);
      fwd_Counter++;
      break;

    case 2:
      total_Lft_Time[lft_Counter + 1] = (current_Time2 - current_Time1);
      lft_Counter++;
      break;

    case 4:
      total_Bwd_Time[bwd_Counter + 1] = (current_Time2 - current_Time3);
      bwd_Counter++;
      break;

    case 5:
      total_Stp_Time[stp_Counter + 1] = (current_Time2 - current_Time4);
      stp_Counter++;
      break;
  }

  seq_Array[seq] = 3;
  seq++;
}

void go_Backward() {
  movement_Inst_Bwd();

  current_Time3 = millis();
  int i = seq_Array[(seq - 1)];
  switch (i) {
    case 1:
      total_Fwd_Time[fwd_Counter + 1] = (current_Time3 - current_Time0);
      fwd_Counter++;
      break;

    case 2:
      total_Lft_Time[lft_Counter + 1] = (current_Time3 - current_Time1);
      lft_Counter++;
      break;

    case 3:
      total_Rgt_Time[rgt_Counter + 1] = (current_Time3 - current_Time2);
      rgt_Counter++;
      break;

    case 5:
      total_Stp_Time[stp_Counter + 1] = (current_Time3 - current_Time4);
      stp_Counter++;
      break;
  }

  seq_Array[seq] = 4;
  seq++;
}

void go_Stop() {
  movement_Inst_Stp();

  current_Time4 = millis();
  int i = seq_Array[(seq - 1)];
  switch (i) {
    case 1:
      total_Fwd_Time[fwd_Counter + 1] = (current_Time4 - current_Time0);
      fwd_Counter++;
      break;

    case 2:
      total_Lft_Time[lft_Counter + 1] = (current_Time4 - current_Time1);
      lft_Counter++;
      break;

    case 3:
      total_Rgt_Time[rgt_Counter + 1] = (current_Time4 - current_Time2);
      rgt_Counter++;
      break;

    case 4:
      total_Bwd_Time[bwd_Counter + 1] = (current_Time4 - current_Time3);
      bwd_Counter++;
      break;
  }

  seq_Array[seq] = 5;
  seq++;
}

void go_In_Seq(void) {
  value = 0;
  for (int i = 0; i < (seq + 1); i++) {
    int value1 = 0;
    value1 = seq_Array[i];
    switch (value1) {
      case 1:
        static int j = 0;
        go_Forward_Seq(j);
        j++;
        break;
      case 2:
        static int k = 0;
        go_Left_Seq(k);
        k++;
        break;
      case 3:
        static int l = 0;
        go_Right_Seq(l);
        l++;
        break;
      case 4:
        static int m = 0;
        go_Backward_Seq(m);
        m++;
        break;
      case 5:
        static int n = 0;
        go_Stop_Seq(n);
        n++;
        break;
      default:
        j = 0; k = 0; l = 0; m = 0; n = 0;
    }
  }
}

void del_From_Local_Mem() {
  //set the movement counters to their default values
  fwd_Counter = -1;
  lft_Counter = -1;
  rgt_Counter = -1;
  bwd_Counter = - 1;
  stp_Counter = - 1;

  //set the total movement time to its default value
  for (int i = 0; i < 10; i++) {
    total_Fwd_Time[i] = 0;
    total_Lft_Time[i] = 0;
    total_Rgt_Time[i] = 0;
    total_Bwd_Time[i] = 0;
    total_Stp_Time[i] = 0;
  }

  // Reset the sequence array(stored movement instructions)
  for (int i = 0; i < 50; i++) {
    seq_Array[i] = 0;
  }

  seq = 0;
  
}


/**********************************************************************************************************
     This function copy the data from the arrays to the EEPROM(permanent memory)
************************************************************************************************************/

void write_To_Permt_Mem(){
  // total number of movement is stored in a random address i.e, 100
  EEPROM.write(100,seq);
    
  //writing the movement sequence
  for(int i=0; i<seq; i++){ 
  EEPROM.write(2*i,seq_Array[i]);
  }

  //storing the time bw two successive movements
  for(int i=1; i<seq+1; i++){           
  if(seq_Array[i-1]==1){
    static byte a=0;
    EEPROM.write(2*i-1,(total_Fwd_Time[a])/1000);// Note: One location can store maximum value of 255, hence the time is divided by 1000 here. And then multiplied by 1000 while retreiving the data from EEPROM location
    a++;
    }
  else if(seq_Array[i-1]==2){
    static byte b=0;
    EEPROM.write(2*i-1,(total_Lft_Time[b])/1000);
    b++;
    }
  else if(seq_Array[i-1]==3){
    static byte c=0;
    EEPROM.write(2*i-1,(total_Rgt_Time[c])/1000);
    c++;
    }
  else if(seq_Array[i-1]==4){
    static byte d=0;
    EEPROM.write(2*i-1,(total_Bwd_Time[d])/1000);  
    d++;
    }
  else if(seq_Array[i-1]==5){
    static byte e=0;
    EEPROM.write(2*i-1,(total_Stp_Time[e])/1000);  
    e++;
    }             
  }
 } 

 
/**********************************************************************************************************
     This function reads the stored sequence from the EEPROM(permanent memory)
************************************************************************************************************/

void Read_Permt_Mem(){
  // Read from permanent memory
   byte x = EEPROM.read(100);
   for(int i=0; i<x+1; i++){
    byte r = EEPROM.read(2*i);
    switch(r){
      case 1:
        movement_Inst_Fwd();
        break;
      case 2:
        movement_Inst_Lft();
        break;
      case 3:
        movement_Inst_Rgt();
        break;
      case 4:
        movement_Inst_Bwd();
        break; 
      case 5:
        movement_Inst_Stp();
        break;                          
      }
     delay((EEPROM.read(i+1))*1000);    // multiplied by thousand because the original time was divided by 1000 while storing in EEPROM.
    }
  }
 
/**********************************************************************************************************
     These function moves the car in a direction for the time specified/stored in the total_x_time array
************************************************************************************************************/
void go_Forward_Seq(int j) {
  //go in forward direction sequence
  movement_Inst_Fwd();
  delay(total_Fwd_Time[j]);
}

void go_Left_Seq(int k) {
  //go in Left direction sequence
  movement_Inst_Lft();
  delay(total_Lft_Time[k]);
}

void go_Right_Seq(int l) {
  //go in right direction sequence
  movement_Inst_Rgt();
  delay(total_Rgt_Time[l]);
}

void go_Backward_Seq(int m) {
  //go in backward direction sequence
  movement_Inst_Bwd();
  delay(total_Bwd_Time[m]);
}

void go_Stop_Seq(int n) {
  //go in Stop sequence
  movement_Inst_Stp();
  delay(total_Stp_Time[n]);
}

/*********************************************************************************************
          These movement instruction are repeated(required) several times in the code
**********************************************************************************************/
void movement_Inst_Fwd(void) {
  // forward movement instructions
  Serial.println("Going_Forward");
  digitalWrite(LM_IN1, HIGH);
  digitalWrite(LM_IN2, LOW);
  digitalWrite(RM_IN3, HIGH);
  digitalWrite(RM_IN4, LOW);
}

void movement_Inst_Lft(void) {
  // Left movement instructions
  Serial.println("Going_Left");
  digitalWrite(LM_IN1, LOW);
  digitalWrite(LM_IN2, LOW);
  digitalWrite(RM_IN3, HIGH);
  digitalWrite(RM_IN4, LOW);
  delay(500);// default delay for smooth rotation.
  digitalWrite(LM_IN1, LOW);
  digitalWrite(LM_IN2, LOW);
  digitalWrite(RM_IN3, LOW);
  digitalWrite(RM_IN4, LOW);
  delay(500);
  // NOTE: The minimum delay for RIGHT/LEFT movement is 1S(inluding .5s ON time & .5s OFF time). Hence subtract 1s before repeating this movement
}

void movement_Inst_Rgt(void) {
  // Rgt movement instructions
  Serial.println("Going_Right"); 
  digitalWrite(LM_IN1, HIGH);
  digitalWrite(LM_IN2, LOW);
  digitalWrite(RM_IN3, LOW);
  digitalWrite(RM_IN4, LOW);
  delay(500);// default delay for smooth rotation.
  digitalWrite(LM_IN1, LOW);
  digitalWrite(LM_IN2, LOW);
  digitalWrite(RM_IN3, LOW);
  digitalWrite(RM_IN4, LOW);
  delay(500);
  // NOTE: The minimum delay for RIGHT/LEFT movement is 1S(inluding .5s ON time & .5s OFF time). Hence subtract 1s before repeating this movement 

}

void movement_Inst_Bwd(void) {
  // Bwd movement instructions
  Serial.println("Going_Backward"); 
  digitalWrite(LM_IN1, LOW);
  digitalWrite(LM_IN2, HIGH);
  digitalWrite(RM_IN3, LOW);
  digitalWrite(RM_IN4, HIGH);
}

void movement_Inst_Stp(void) {
  // Stp movement instructions
  Serial.println("Stopping");
  digitalWrite(LM_IN1, LOW);
  digitalWrite(LM_IN2, LOW);
  digitalWrite(RM_IN3, LOW);
  digitalWrite(RM_IN4, LOW);
}

Error 403 The request cannot be completed because you have exceeded your quota. : quotaExceeded




Preguntas frecuentes sobre cómo hacer un robot memorizador de caminos usando Arduino

Preguntas frecuentes sobre cómo hacer un robot memorizador de caminos usando Arduino

1. ¿Qué es Arduino?

Arduino es una plataforma de desarrollo electrónica de código abierto que se utiliza para crear proyectos interactivos. Se compone de una placa de circuito integrado con entradas y salidas digitales y analógicas, que permite programar su comportamiento.

Puedes obtener más información acerca de Arduino en este enlace.

2. ¿Qué es un robot memorizador de caminos?

Un robot memorizador de caminos es un dispositivo autónomo capaz de desplazarse a través de un entorno controlado mientras registra y recuerda los caminos que ha tomado. Luego puede reproducir esos caminos siguiendo la ruta grabada.

3. ¿Cuáles son los materiales necesarios para hacer un robot memorizador de caminos con Arduino?

  1. Placa Arduino
  2. Motores y ruedas para el movimiento del robot
  3. Sensores, como un sensor ultrasónico para evitar obstáculos o un sensor de línea para seguir una ruta
  4. Batería o fuente de alimentación para el robot
  5. Componentes adicionales según los requisitos específicos del proyecto

4. ¿Qué habilidades de programación son necesarias para desarrollar un robot memorizador de caminos usando Arduino?

Para desarrollar un robot memorizador de caminos con Arduino, es necesario tener conocimientos básicos de programación en el lenguaje Arduino. Se recomienda tener experiencia en la programación de microcontroladores y familiaridad con los conceptos de control de motores y sensores.

5. ¿Dónde puedo encontrar tutoriales o ejemplos para construir un robot memorizador de caminos con Arduino?

Existen numerosos tutoriales y ejemplos disponibles en línea que te ayudarán a construir tu propio robot memorizador de caminos utilizando Arduino. Puedes consultar la página de Arduino en Wikipedia para obtener una introducción general y luego buscar en foros, blogs y comunidades en línea especializadas en Arduino para encontrar proyectos específicos y recursos de aprendizaje.

6. ¿Puedo personalizar mi robot memorizador de caminos?

Sí, puedes personalizar tu robot memorizador de caminos según tus necesidades y preferencias. Puedes agregar más sensores, implementar algoritmos de toma de decisiones más complejos o incluso diseñar e imprimir en 3D tu propio chasis para el robot. ¡Las posibilidades son infinitas!

7. ¿Cómo puedo ampliar las capacidades de mi robot memorizador de caminos?

Puedes ampliar las capacidades de tu robot memorizador de caminos utilizando módulos adicionales y sensores compatibles con Arduino. Por ejemplo, podrías agregar un módulo de comunicación inalámbrica para controlar el robot a través de una aplicación móvil o integrar una cámara para transmitir video en tiempo real.

8. ¿Es necesario tener conocimientos avanzados de electrónica para construir un robot memorizador de caminos con Arduino?

No es necesario tener conocimientos avanzados de electrónica. Arduino simplifica mucho el desarrollo de proyectos electrónicos, y hay muchas guías y documentación disponible que te ayudarán a aprender y aplicar los conceptos necesarios.

Conclusión

Con Arduino, puedes construir tu propio robot memorizador de caminos y llevar la robótica a un nivel emocionante. Esperamos que estas preguntas frecuentes hayan resuelto tus dudas y te hayan brindado una mejor comprensión de cómo empezar.


Deja un comentario