Problema con emision y/o recepcion de datos- rover telecomandado - envio de varios datos en un solo paquete - cambio de posicion de datos en array

oscarenrico · November 21, 2023, 8:32pm

Hola mi nombre es Oscar Bocchino soy ingeniero civil, vivo en italia, es mi primera vez en este forum.

Estoy aqui porque estoy desarrollando algunos proyectos relacionados con la electronica, la domotica y la robotica.

Ultimamente he estado desarrollando un pequeno "rovers" como prototipo en pocas palabras, un pequeno carrito telecomandado, cuenta con:

Cuatro (4) ruedas impulsadas por motores de 6v (4) a 280rpm alimentados por una bateria de 6v a 2400mAh.
Dos (2) controladores L298N por cada dos (2) ruedas. (aunque estoy pensando en conectar las cuatro a un solo controlador).
Un (1) modulo bluetooth 4.0 HM-10 programado en modo esclavo para la recepcion de datos.
Algunos otros sensores complementarios.

-Un (1) arduino MEGA 2560 alimentada por una bateria de 9v 850 mAh recargable. para procesar toda la informacion.

El control de comando consiste en:

Un (1) arduino uno. alimentado por bat 9v 850mAh rec.
Un (1) modulo Joystick
Un (1) modulo bluetooth 4.0 HM-10, progrmado en modo maestro para la emision de datos.

La logica es simple y funciona bien.
El arduino uno lee los datos de Joystick y a traves del modulo bluetooth envia un paquete de datos arreglados en un array de 3 puestos, ya que son tres los datos que necesito por ahora.

la forma en la cual envio los datos tiene la siguiente forma

Serial.write(RVar,3);

Donde Rvar es un arreglo que contiene los tres parametros que quiero enviar.
Rvar[0] = Direccion (adelante, atras, izquierda, derecha, diagonales)
Rvar [1] = Valor analogico mapeado en direccion X
Rvar[2] = Valor analogico mapeado en direccion Y

como los valores analogicos van desde 0 a 1023 me conviene realizar el mapeado para obtener valores compatible a PWM es decir de 0 a 255. de esta forma mi receptor recibe los valores que necesito sin necesidad de aplicar mas codigo y mejorar asi la velocidad. ya que no quiero congestionar los tiempos de reaccion del rover.

por otro lado, el modulo bluetooth esclavo recibe los datos y los envia al arduino mega 2560 y desde alli proceso toda la informacion para controlar los movimientos.

con un un serial.println() veo en el monitor serial el valor y el orden de los datos que estoy recibiendo, esto es importante ya que de esta manera extraigo cada dato los cuales me serviran para establecer condicionales.

Mi problema empieza "aqui" en la recepcion de datos. Anteriormente enviaba los datos como cadenas tipo strings, luego recibia la cadena y la descomponia, para ese momento usaba los modulos bluetooth 2.0 HC-05, y la verdad la velocidad era precaria ademas la descomposicion de los parametros era perfecta pero tomaba su proceso, el resultado era un retardo de entre 4 y 6 segundo en el control de rovers para tomar direcciones y velocidad era algo que debia mejorar. asi que decidi por introducir el HM y simplificar el codigo al envio y recepcion por bytes. los resultados fueron satisfactorios y los tiempos se redujeron por debajo del segundo, yo diria que casi instantaneo. bueno al menos en un rango inferior a los 10 metros.

El problema que estoy presentando al recibir los datos, es que mi arreglo ya en el rover y entiendase en el arduino mega, los parametros me cambian de posicion esto es:

EL valor Rvar[0], Rvar[1] y Rvar[2] deben llegar en ese orden, pero no es asi, se intercambian de puesto, por lo que puedo tener el primer parametro en el puesto 2 o en el 1, y esto hace que no funcione correctamente mis condiciones y por lo tanto mi codigo, mi rovers se queda quieto.

el problema lo soluciono momentaneamente cuando desconecto los pines de RX y RY entre el arduino uno y el bluetooth, asi se vuelve todo como deberia, sin embargo cuando utilizo los sensores (como el sensor ultranosonico), todo se vuelve a distorsionar.

No entiendo por cual razon, los valores de mi arreglo se intercambian de puesto, nunca me habia pasado algo asi.
no se si sera que no es la forma correcta de programar este tipo de mecanismo, o sera por la velocidad de transmision ocurre interferencia, no entiendo el motivo de esta inestabilidad.

queria saber, que opciones tengo para programar mas eficazmente una recepcion y emision de datos que lleve almenos 3 parametros entre uno y el otro o si bien alguien entienda este problema y me ayude a mejorar el codigo.

adjunto el codigo.

Control - Arduino uno

//CODIGO MAESTRO

int xPin = A0;
int yPin = A1;

int RxVal;
int RyVal;

byte RVar[3] = {9,0,0}; // {1° Direccion, 2° Lectura en X, 3° Lectura en Y}

//String datos;

//int del = 8;

void setup() {
  // put your setup code here, to run once:  
  
  Serial.begin(38400);
  Serial.println("Inicializando sistema...");
  delay(2500);
  pinMode(xPin, INPUT);
  pinMode(yPin, INPUT); 

  delay(2500); 
  Serial.println("Dispositivo Listo");
}

void loop() {
  // put your main code here, to run repeatedly:

  //LECTURA DE DATOS DESDE RESISTENCIA VARIABLE
  RxVal = analogRead(xPin);
  RyVal = analogRead(yPin);

  //CONDICIONES PARA EL CONTROL JOYSTICK Y ENVIO DATOS AL MODULO BLUETOOTH HC-05
  if (RyVal >= 520 && RxVal > 480 && RxVal < 520) {  //AVANZAR
    RVar[0] = 1;
    RVar[1] = 0;
    RVar[2] = map(RyVal, 520, 1023, 0, 255);
    delay(5);
    //Serial.write(RVar,3);


  } else if (RyVal <= 480 && RxVal > 480 && RxVal < 520) {          //RETROCEDER
    RVar[0] = 2;
    RVar[1] = 0;
    RVar[2] = map(RyVal, 480, 0, 0, 255);
    delay(5);
    //Serial.write(RVar,3);


  } else if (RxVal >= 520 && RyVal > 480 && RyVal < 520) {          //GIRO IZQUIERDA
    RVar[0] = 3;
    RVar[1] = map(RxVal, 520, 1023, 0, 255);
    RVar[2] = 0;
    delay(5);
    //Serial.write(RVar,3);

  } else if (RxVal <= 480 && RyVal > 480 && RyVal < 520) {          //GIRO DERECHA
    RVar[0] = 4;
    RVar[1] = map(RxVal, 480, 0, 0, 255);
    RVar[2] = 0;
    delay(5);
    //Serial.write(RVar,3);

  } else if (RxVal >= 520 && RyVal >= 520) {                        //ROTACION GRADUAL IZQUIERDA ADELANTE
    RVar[0] = 5;
    RVar[1] = map(RxVal, 520, 1023, 0, 255);
    RVar[2] = 0;
    delay(5);
    //Serial.write(RVar,3);

  } else if (RxVal >= 520 && RyVal < 480) {                         //ROTACION GRADUAL IZQUIERDA RETROCESO
    RVar[0] = 6;
    RVar[1] = map(RxVal, 520, 1023, 0, 255);
    RVar[2] = 0;
    delay(5);
    //Serial.write(RVar,3);

  } else if (RxVal <= 480 && RyVal >= 520) {                        //ROTACION GRADUAL DERECHA ADELANTE
    RVar[0] = 7;
    RVar[1] = map(RxVal, 480, 0, 0, 255);
    RVar[2] = 0;
    delay(5);
    //Serial.write(RVar,3);

  } else if (RxVal <= 480 && RyVal < 480) {                         //ROTACION GRADUAL DERECHA RETROCESO
    RVar[0] = 8;
    RVar[1] = map(RxVal, 480, 0, 0, 255);
    RVar[2] = 0;
    delay(5);
    //Serial.write(RVar,3);

  } else {                                                         //DETENER
    RVar[0] = 9;
    RVar[1] = 0;
    RVar[2] = 0;
    delay(5);
    //Serial.write(RVar,3);

  }

  Serial.write(RVar,3);
  //millis();

  //Serial.println(datos);

  //Leer informacion disponible en el Modulo y lo envia al arduno
  //if (BT.available()){
  //Serial.write(BT.read());
  //}

  //Lee Informacion disponible de Arduino y lo envia al Modulo
  //if (Serial.available()){
  //BT.write(Serial.read());
  //}
}

Codigo esclavo - Arduino Mega 2560 - Rover

//CODIGO ESCLAVO

//Rotacion derecha

int IN1 = 23;
int IN2 = 22;
int ENA = 2;

int IN12 = 48;
int IN22 = 49;
int ENA2 = 3;

//Rotacion izquierda

int IN3 = 25;
int IN4 = 24;
int ENB = 8;

int IN32 = 46;
int IN42 = 47;
int ENB2 = 9;

//Variables de lectura analogica


int speedmotor;                           //Velocidad de ambos motores
int LSPM;                                 //Velocidad motores izquierdo
int RSPM;                                 //Vecocidad motores derecho

//Comando operacional movimiento
byte dato;
int Rx;
int Ry;

//Sensores

//Sensor Ultrasonico HC-SR04

int trig = 35;
int eco = 34;
int duracion;
float distancia;

//Zumbador Buzzer
int buzz = 29;


void Avanzar(int vy);
void Retroceder(int vy);
void Izquierda(int vx);
void Derecha(int vx);
void Izq_avanzar(int vx);
void Izq_retro(int vx);
void der_avanzar(int vx);
void der_retro(int vx);
void detener();
float distance();
void buzzer(float zx);
void DatosRecibidos();
//void zumb(float v);


byte InData[3] = { 9, 0, 0 };



void setup() {
  // put your setup code here, to run once:

  Serial1.begin(38400);
  Serial.begin(38400);
  Serial.println("Esperando comunicacion: ");
  delay(2500);

  pinMode(IN1, OUTPUT);
  pinMode(IN2, OUTPUT);
  pinMode(ENA, OUTPUT);

  pinMode(IN12, OUTPUT);
  pinMode(IN22, OUTPUT);
  pinMode(ENA2, OUTPUT);

  pinMode(IN3, OUTPUT);
  pinMode(IN4, OUTPUT);
  pinMode(ENB, OUTPUT);

  pinMode(IN32, OUTPUT);
  pinMode(IN42, OUTPUT);
  pinMode(ENB2, OUTPUT);

  pinMode(trig, OUTPUT);
  pinMode(eco, INPUT);
  pinMode(buzz, OUTPUT);

  delay(1500);
}

void loop() {
  

  DatosRecibidos();
  delay(5);
  distancia = distance();
  buzzer(distancia);

  if (InData[0] == 1) {
    Avanzar(Ry);

  } else if (dato == 2) {
    Retroceder(Ry);

  } else if (dato == 3) {
    Izquierda(Rx);

  } else if (dato == 4) {
    Derecha(Rx);

  } else if (dato == 5) {
    Izq_avanzar(Rx);

  } else if (dato == 6) {
    Izq_retro(Rx);

  } else if (dato == 7) {
    der_avanzar(Rx);

  } else if (dato == 8) {
    der_retro(Rx);


  } else {
    detener();
  }

  //Lee Informacion disponible de Arduino y lo envia al Modulo
  //if(Serial.available()){
  //s = Serial.read();
  //Serial1.print(s);
  //}

  

  

}

//void separa(String comando) {
//int L_String = comando.length();
//for (int i = 0; i <= L_String; i++) {
//if (comando.charAt(i) == ',') {
//Pos_i[suma] = i;
//suma = suma + 1;
//}
//}

//String dir = comando.substring(0);
//String x = comando.substring(Pos_i[0] + 1, Pos_i[1]);
//String y = comando.substring(Pos_i[1] + 1, L_String);

//dato = dir.toInt();
//Rx = x.toInt();
//Ry = y.toInt();
//Serial.println(Rx);
//Pos_i[0] = 0;
//Pos_i[1] = 0;
//suma = 0;
//}

void DatosRecibidos(){
  //Comunicacion Modulo HC-05 y Arduino
  //Leer informacion disponible en el Modulo y lo envia al arduino
  //Informacion de entra en el modulo bluetooth y se procesa en arduino
  while (Serial1.available() > 0) {

    //DECODIFICANDO
    //Command = Serial1.readStringUntil('\n');
    //Command = Command.substring(0, Command.length() - 1);
    //Command = Serial1.read();

    Serial1.readBytes(InData, 3);
    Serial.println(String(InData[0]) + ',' + String(InData[1]) + ',' + String(InData[2]));

    dato = InData[0];
    Rx = InData[1];
    Ry = InData[2];

  }
}

float distance(){
  digitalWrite(trig, HIGH);
  delay(1);
  digitalWrite(trig, LOW);
  duracion = pulseIn(eco, HIGH);
  return  duracion / 58.2;
}

void buzzer(float zx){
  if (zx <= 20 && zx >= 0){
    digitalWrite(buzz, HIGH);
    delay(zx * 10);
    digitalWrite(buzz, LOW);
  }
}




//AVANZAR
void Avanzar(int vy) {



 

  //Control de velocidad

  //speedmotor = map(vy, 520, 1023, 0, 255);
  speedmotor = vy;

  analogWrite(ENA, speedmotor);
  analogWrite(ENB, speedmotor);

  analogWrite(ENA2, speedmotor);
  analogWrite(ENB2, speedmotor);

  //Control de direccion

  //Motor delantero izquierdo
  digitalWrite(IN1, LOW);
  digitalWrite(IN2, HIGH);

  //Motor delantero derecho
  digitalWrite(IN3, LOW);
  digitalWrite(IN4, HIGH);

  //Motor trasero derecho
  digitalWrite(IN12, LOW);
  digitalWrite(IN22, HIGH);

  //Motor trasero izuierdo
  digitalWrite(IN32, LOW);
  digitalWrite(IN42, HIGH);


}

//RETROCEDER
void Retroceder(int vy) {

  //speedmotor = map(vy, 480, 0, 0, 255);
  speedmotor = vy;

  analogWrite(ENA, speedmotor);
  analogWrite(ENB, speedmotor);

  analogWrite(ENA2, speedmotor);
  analogWrite(ENB2, speedmotor);

  //Motor delantero izquierdo
  digitalWrite(IN1, HIGH);
  digitalWrite(IN2, LOW);

  //Motor delantero derecho
  digitalWrite(IN3, HIGH);
  digitalWrite(IN4, LOW);

  //Motor trasero derecho
  digitalWrite(IN12, HIGH);
  digitalWrite(IN22, LOW);

  //Motor trasero izuierdo
  digitalWrite(IN32, HIGH);
  digitalWrite(IN42, LOW);
}

//GIRO IZQUIERDA
void Izquierda(int vx) {

  //Control de velocidad

  //speedmotor = map(vx, 520, 1023, 0, 255);
  speedmotor = vx;
  analogWrite(ENA, speedmotor);                                                 //ENCENDIDO MOTOR DELANTERO DERECHO
  analogWrite(ENB, speedmotor);                                                 //ENCENDIDO MOTOR DELANTERO IZQUIERDO

  analogWrite(ENA2, speedmotor);                                                //ENCENDIDO MOTOR TRASERO IZQUIERDO
  analogWrite(ENB2, speedmotor);                                                //ENCENDIDO MOTOR TRASERO DERECHO

  //Control de direccion

  //Motor delantero izquierdo
  digitalWrite(IN3, HIGH);                                                      // Anti - Horario  HIGH
  digitalWrite(IN4, LOW);                                                       // Horario

  //Motor trasero izquierdo
  digitalWrite(IN12, HIGH);                                                     // Anti - Horario  HIGH
  digitalWrite(IN22, LOW);                                                      // Horario

  //Motor delantero derecho
  digitalWrite(IN1, LOW);                                                       //Giro Anti Horario
  digitalWrite(IN2, HIGH);                                                      //Giro Horario

  //Motor trasero derecho
  digitalWrite(IN32, LOW);                                                      //Giro Anti Horario
  digitalWrite(IN42, HIGH);                                                     //Giro Horario
}

//GIRO DERECHA
void Derecha(int vx) {

  //Control de velocidad

  //speedmotor = map(vx, 480, 0, 0, 255);
  speedmotor = vx;

  analogWrite(ENA, speedmotor);                                               //ENCENDIDO MOTOR DELANTERO DERECHO
  analogWrite(ENB, speedmotor);                                               //ENCENDIDO MOTOR DELANTERO IZQUIERDO

  analogWrite(ENA2, speedmotor);                                              //ENCENDIDO MOTOR TRASERO IZQUIERDO
  analogWrite(ENB2, speedmotor);                                              //ENCENDIDO MOTOR TRASERO DERECHO

  //Control de direccion

  //Motor delantero izquierdo
  digitalWrite(IN3, LOW);                                                    // Anti - Horario
  digitalWrite(IN4, HIGH);                                                   // Horario HIGH

  //Motor trasero izquierdo
  digitalWrite(IN12, LOW);                                                    // Anti - Horario
  digitalWrite(IN22, HIGH);                                                   // Horario HIGH

  //Motor delantero derecho
  digitalWrite(IN1, HIGH);                                                     //HIGH
  digitalWrite(IN2, LOW);

  //Motor trasero derecho
  digitalWrite(IN32, HIGH);                                                         //HIGH
  digitalWrite(IN42, LOW);
}

//ROTACION GRADUAL IZQUIERDA ADELANTE
void Izq_avanzar(int vx) {


  //Control de velocidad

  //LSPM = map(vx, 520, 1023, 0, 255);
  LSPM = vx;
  RSPM = 0.3 * LSPM;

  analogWrite(ENA, LSPM);
  analogWrite(ENB, RSPM);

  analogWrite(ENA2, RSPM);
  analogWrite(ENB2, LSPM);

  //Control de direccion

  //Motor delantero izquierdo
  digitalWrite(IN3, LOW);   // Anti - Horario
  digitalWrite(IN4, HIGH);  // Horario

  //Motor trasero izquierdo
  digitalWrite(IN12, LOW);   // Anti - Horario
  digitalWrite(IN22, HIGH);  // Horario

  //Motor delantero derecho
  digitalWrite(IN1, LOW);
  digitalWrite(IN2, HIGH);

  //Motor trasero derecho
  digitalWrite(IN32, LOW);
  digitalWrite(IN42, HIGH);
}


//ROTACION GRADUAL IZQUIERDA RETROCESO
void Izq_retro(int vx) {


  //Control de velocidad

  //LSPM = map(vx, 520, 1023, 0, 255);
  LSPM = vx;
  RSPM = 0.3 * LSPM;

  analogWrite(ENA, LSPM);
  analogWrite(ENB, RSPM);

  analogWrite(ENA2, RSPM);
  analogWrite(ENB2, LSPM);

  //Control de direccion

  //Motor delantero izquierdo
  digitalWrite(IN3, HIGH);  // Anti - Horario
  digitalWrite(IN4, LOW);   // Horario

  //Motor trasero izquierdo
  digitalWrite(IN12, HIGH);  // Anti - Horario
  digitalWrite(IN22, LOW);   // Horario

  //Motor delantero derecho
  digitalWrite(IN1, HIGH);
  digitalWrite(IN2, LOW);

  //Motor trasero derecho
  digitalWrite(IN32, HIGH);
  digitalWrite(IN42, LOW);
}

//GIRO GRADUAL DERECHA ADELANTE
void der_avanzar(int vx) {


  //Control de velocidad

  //LSPM = map(vx, 480, 0, 0, 255);
  LSPM = vx;
  RSPM = 0.3 * LSPM;

  analogWrite(ENA, RSPM);
  analogWrite(ENB, LSPM);

  analogWrite(ENA2, LSPM);
  analogWrite(ENB2, RSPM);

  //Control de direccion

  //Motor delantero izquierdo
  digitalWrite(IN3, LOW);   // Anti - Horario
  digitalWrite(IN4, HIGH);  // Horario

  //Motor trasero izquierdo
  digitalWrite(IN12, LOW);   // Anti - Horario
  digitalWrite(IN22, HIGH);  // Horario

  //Motor delantero derecho
  digitalWrite(IN1, LOW);
  digitalWrite(IN2, HIGH);

  //Motor trasero derecho
  digitalWrite(IN32, LOW);
  digitalWrite(IN42, HIGH);
}


//GIRO GRADUAL DERECHA RETROCESO
void der_retro(int vx) {



  //Control de velocidad

  //LSPM = map(vx, 480, 0, 0, 255);
  LSPM = vx;
  RSPM = 0.3 * LSPM;

  analogWrite(ENA, RSPM);
  analogWrite(ENB, LSPM);

  analogWrite(ENA2, LSPM);
  analogWrite(ENB2, RSPM);

  //Control de direccion

  //Motor delantero izquierdo
  digitalWrite(IN3, HIGH);  // Anti - Horario
  digitalWrite(IN4, LOW);   // Horario

  //Motor trasero izquierdo
  digitalWrite(IN12, HIGH);  // Anti - Horario
  digitalWrite(IN22, LOW);   // Horario

  //Motor delantero derecho
  digitalWrite(IN1, HIGH);
  digitalWrite(IN2, LOW);

  //Motor trasero derecho
  digitalWrite(IN32, HIGH);
  digitalWrite(IN42, LOW);
}


void detener() {

  analogWrite(ENA, LOW);
  analogWrite(ENB, LOW);
  analogWrite(ENA2, LOW);
  analogWrite(ENB2, LOW);

  digitalWrite(IN1, LOW);
  digitalWrite(IN2, LOW);
  digitalWrite(IN3, LOW);
  digitalWrite(IN4, LOW);

  digitalWrite(IN12, LOW);
  digitalWrite(IN22, LOW);
  digitalWrite(IN32, LOW);
  digitalWrite(IN42, LOW);
}

Agradezco enormemente su ayuda como comunidad... estoy a disposicion tambien en compartir conocimientos. El codigo lo estoy mejorando constantemente.

17006019377151920×2560 287 KB

mancera1979 · November 22, 2023, 1:12am

Qué tal si pruebas con

if(Serial1.available() > 3) {

?

mancera1979 · November 22, 2023, 1:28am

oscarenrico:

if (InData[0] == 1) {
    Avanzar(Ry);

  } else if (dato == 2) {
    Retroceder(Ry);

  } else if (dato == 3) {
    Izquierda(Rx);

  } else if (dato == 4) {
    Derecha(Rx);

  } else if (dato == 5) {
    Izq_avanzar(Rx);

  } else if (dato == 6) {
    Izq_retro(Rx);

  } else if (dato == 7) {
    der_avanzar(Rx);

  } else if (dato == 8) {
    der_retro(Rx);


  } else {
    detener();
  }

Puedes escribir esto así:

switch (dato) {
   case 1:
      Avanzar(Ry);
      break;

   case 2:
     Retroceder(Ry);
     break;

…

   case 8:
     der_retro(Rx);
     break;

   default:
     detener();
     break;
}

https://www.arduino.cc/reference/en/language/structure/control-structure/switchcase/

oscarenrico · November 22, 2023, 4:44pm

Hola Mancera1979, gracias por tu respuesta, voy a probar a modificar el codigo con tu recomendacion y luego actualizare el post con los resultados que obtuve, la verdad estoy estancado con este proyecto por el defecto que mencione. gracias nuevamente.

mancera1979 · November 22, 2023, 7:35pm

Más que pensar en que los datos cambian de lugar o que se transmiten o reciben en desorden, yo pienso que es un problema de sincronía.

Parece que el programa que lee la posición del joystick envia los datos, espera 5ms y repite sin cesar.

Por otro lado, el programa que recibe los datos tiene algunos delays, como éste:

y este:

Entonces es un problema de sincronización. Llega un momento en que el Uno inició el envío de sus tres bytes cuando el Mega estaba ocupado, y cuando se desocupó empezó a leer cuando ya llegaba el 2° o 3r byte.

Puedes resolver esto haciendo que el Uno agregue un inicio de secuencia (digamos “$$”) y hacer que el Mega espere a recibirlo para entonces leer los tres bytes. Propongo dos bytes porque “$” es un valor válido (ASCII 36) para el segundo o tercer bytes, pero no ambos, ya que el otro siempre es cero. También puedes sincronizar usando un carácter de start y otro de end.

mancera1979 · November 22, 2023, 8:12pm

Si tu aplicación permite cambiar esto a
map(___, 520, 1023, 0, 254);
Puedes usar 255 como delimitador inicial de la secuencia de caracteres y utilizar solamente un byte de inicio. Esto simplifica un poco el código.

oscarenrico · November 22, 2023, 8:30pm

gracias por el enfoque mancera1979, estoy tomando nota de lo que haz escrito acerca de la sincronizacion entre los arduinos de esto no tenia ni sospecha anteriormente, posiblemente haz dado en el clavo con repecto a esto, voy a pensar a ver como puedo reconstruir el codigo tomando en cuenta esto.

como habia dicho, apenas lo tenga claro vuelvo. si sabes algo mas no dudes porfavor en comertar, muchas gracias

oscarenrico · November 22, 2023, 9:58pm

Actualizo, he modificado el codigo por la serie de comando switchcase sin embargo el proble aun persiste.

el rover funciono perfectamente pero una vez que los parametros cambian de posicion deja de funcionar.

digamos que en el monitor seria la informacion que aparece cuando muestro los valores de InData[3] seria algo asi como:

0,9,0
0,9,0
0,9,0 ...
...

esto seria el dato 9 que seria la condicion "detener" pues logicamente no estoy haciendo uso del joystick, si muevo el joystick hacia adelante mi monitor serial mostraria algo como:

0,1,235
0, 1,238
0,1,245
0,1,255
0,1,255
0,1,255...
...

esto activa la condicion "avanzar" con el valor Ry (PWM) en partiendo de 0 a 255 , claro esta que esta indicacion es falsa por que los valores estan en las posiciones incorrectas.
la informacion correcta deberia ser

1,0,255
1,0,255
1,0,255...
...

para indicar la correctamente la condicion avanzar y mi rover pueda funcionar correctamente. para lograr esto lo que hago es desconectar y conectar los cables rx y tx entre el arduino uno y el modulo bluetooth, alli se arregla todo, hasta el momento en el que se activa el sensor ultrasonico, en ese caso se vuelve a desconfigurar.

Me queda por probar como sincronizar los arduinos...

oscarenrico · November 22, 2023, 10:11pm

la verdad es que no tengo mucha idea de como hacer esto, pero voy a averiguar, si tienes algun ejemplo practico o sencillo qe me puedas recomendar, lo agradeceria mucho

mancera1979 · November 22, 2023, 11:21pm

Aquí comentan ese tema: https://forum.arduino.cc/t/arduino-mega-2560-cant-seem-to-use-serial-readbytes-more-than-once-per-second/1066382

mancera1979 · November 22, 2023, 11:28pm

Y si se hubieran perdido 2 bytes en el camino estaríamos hablando de
9,0,0
9,0,0
9,0,0
Y aquí

de
1,235,0
1,238,0
1,245,0
Etc.

Antes de cambiar los programas para lograr la sincronización puedes enviar 4 bytes, y que por ejemplo el cuarto siempre sea 123. Es un cambio sencillo a ambos programas y te va a dar mucha luz sobre si el problema es sincronización o inversión de bytes

oscarenrico · November 23, 2023, 7:57pm

Hola mancera, te comento lo siguiente, me he puesto nuevamente a modificar el codigo y tome en cuenta esto que me dices,

if(Serial1.available() > 3) {

te puedo asegurar que el problema esta casi resuelto con esta recomendacion, con esta modificacion se ha impedido por completo que los datos llegue en desorden, solo que existe en este caso una pequenisima perdida muy despreciable sin embargo, lo resolvi con un delay(15) en el arduino uno, con estas dos modificaciones el programa receptor recibe casi perfectamente los datos.

habia dicho que el problema esta casi resuelto por que si te haz dado cuenta tengo un sensor ultrasonico que activa un buzzer y este buzzer tiene el delay `

delay(zx * 10);

entonces tengo un retardo que se acentua cuando me acerco mas y mas a un obstaculo, pero lo importante es que los parametros de movimiento siguen manteniendose donde tienen que estar.

ahora para resolver este retardo tengo pensando en algo asi como una macro o la ejecucion de multiples variables.

voy a completar este proyecto y publicar este codigo.

te saludo, gracias nuevamente.

mancera1979 · November 23, 2023, 8:18pm

Cuando estés listo estudia el enfoque de máquinas de estado (finite state machine, o FSM).

Eso te ayuda a ver las soluciones a muchos problemas “difíciles”, y simplifica mucho los programas.

Hay mucho material sobre este tema en el foro

system · May 21, 2024, 8:18pm

This topic was automatically closed 180 days after the last reply. New replies are no longer allowed.

Topic		Replies	Views
Best Way to Control Servos via Python to Arduino Interfacing w/ Software on the Computer	22	265	November 25, 2025
Problema con trasferimento di variabili Software	22	394	September 12, 2024
Arduino Mega with 3 Serial communications 3rd Party Boards	8	596	November 1, 2023
P1 poort data lezen/gebruiken Nederlands	54	2331	July 6, 2025
Mandare piu pacchetti alla volta utilizzando nrf24l01 Software	36	1026	December 21, 2023

Problema con emision y/o recepcion de datos- rover telecomandado - envio de varios datos en un solo paquete - cambio de posicion de datos en array

Related topics