Un ROV de agua dulce / A sweet water ROV

[asesorplaza1]

Saludos desde España.

Greetings from Spain

Lo primero pedir disculpas por escribir en el foro en Español, ya he visto que la gran mayoría escribe en Ingles, pero no he visto en las advertencias a recién registrados nada de escribir en un idioma obligatoria mente.

The first thing I apologize for writing in the forum in Spanish, I have seen that the vast majority writes in English, but I have not seen in the warnings to newly registered people anything to write in a mandatory language.

Si la traducción no es muy buena, pido disculpas, mi nivel de Ingles es bastante malo, y estoy utilizando el traductor de Google, por lo que me cuesta bastante escribir el texto en dos idiomas, y dos veces

If the translation is not very good, I apologize, my English level is quite bad, and I am using the Google translator, so I find it difficult to write the text in two languages, and twice.

La idea es construir un Rov con cable de conexión o tether, (internet cat 6) que a bordo del ROV haya un Arduino, que me controle los motores sin escobillas y los ESC, las luces y algún sensor, y una Raspberry pi3, que me mande las imágenes de una cámara USB, a un ordenador portátil en la superficie, y que el control en superficie se haga con otro Arduino y un mando de ps2, hasta aquí vamos bien, una idea muy general de un proyecto muy ambicioso.
El casco sera tubo de PVC de 126 mm, del que se utiliza en los desagües, aprovechando varias ideas de las que me he informado, entre mi amigo de Córdoba, y las perchas de mar que he visto en diversos foros.

the idea is to build a Rov with a connection cable or tether, (internet cat 6) that on board the ROV there is an Arduino, that I control the brushless motors and the ESC, the lights and some sensor, and a Raspberry pi3, that send me the images of a USB camera, a laptop on the surface, and that the surface control is done with another Arduino and a command of ps2, so far we go well, a very general idea of a very ambitious project.
the hull will be PVC pipe to 126 mm, which is used in the drains, taking advantage of several ideas that I have informed, between my friend from Cordoba, and the sea hangers that I have seen in various forums.

Con el casco el único problema que he tenido es como conseguir la cúpula trasparente de la tapadera delantera, por donde tiene que ver la cámara de vídeo, pero tengo un amigo que se ha ofrecido a hacérmela con la resina que se utiliza para hacer los faros de los coches, le he explicado como la quería y me la va ha hacer a medida, la he buscado por medio San Google, en tiendas de repuestos de piscinas, (ninguna me servia), y la de OpenRov, me parece carísima, y a demás tendría que comprar el tubo entero, por las medidas, y eso me costaría muchos mas Euros de los que llevo invertidos en el resto del proyecto.

with the pressure vessel the only problem I have had is how to get the transparent dome of the front cover, where the video camera has to see, but I have a friend who has offered to make it with the resin that is used to make the headlights of the cars, I have explained how I wanted it and I’m going to do it to measure, I searched for it through San Google, in stores of spare parts of swimming pools, (it does not work), and OpenRov, I find it very expensive, and other I would have to buy the whole tube, for the measurements, and that would cost me many more Euros than I have invested in the rest of the project

Donde tengo los problemas de verdad es en la programación de Arduino, no soy ningún experto en programación, solo tengo algunos conocimientos básicos, y eso es lo que me esta rompiendo la cabeza.

where I have the real problems is in the programming of Arduino, I’m no programming expert, I only have some basic knowledge, and that’s what is breaking my mind.

Y con vuestra ayuda, adaptar mi programa de Arduino a Platfor-IO, de momento me estoy peleando con la biblioteca PS2X de Bill Potters, para poder controlar el ROV con el mando de la PS2, de momento la fase de electrónica esta encima de la mesa y funciona con 1 Arduino, y varios potenciometros, así puedo controlar los motores sin escobillas y los servos, y hacer las lecturas de los sensores de humedad DHT22.

and with your help, I can understand and adapt my Arduino program to Platform-IO, at the moment I’m fighting with the PS2X library of Bill Potters, to control the ROV with the command of the PS2, at the moment the electronic phase is over of the table and it works with 1 Arduino, and several potentiometers, so I can control the brushless motors and the servos, and do the readings of the DHT22 humidity sensors.

No es un proyecto comercial, solo lo quiero para mi uso personal.

He conseguido hacer dos programas con Arduino, que no terminan de funcionar todo lo bien que deberían, y consultando en otros foros dedicados a la construcción de maquetas, me han indicado, que la mejor forma de conseguir depurar los códigos, es utilizando el entorno Platform-IO.

Estoy utilizando un ordenador de sobremesa con Windows 10, el programa Atom, como editor, y el programa Platform-IO, y las placas son dos Arduino Mega 2560.

He conseguido pasar los programas del IDE Arduino, a PIO, he instalado las bibliotecas en PIO, y los programas compilan, tanto en el IDE Arduino, como en PIO. He conseguido, que el Arduino que controla los sensores (programa llamado Esclavo), me envíe los datos al Arduino que está en el puesto de control (programa llamado Maestro). Pero no sé porque no consigo enviar las órdenes del mando de PS2 de un Arduino a otro.

Si alguien pudiera ayudarme a continuar, lo agradecería muchísimo.

It’s not a commercial project, I just want it for my personal use.
I have managed to make two programs with Arduino, which do not finish working as well as they should, and consulting in other forums dedicated to the construction of models, have indicated to me, that the best way to get to debug the codes, is by using the Platform-IO environment.

I’m using a windows 10 desktop computer, the Atom program, as an editor, and the Platform-IO program, and the boards are two Arduino Mega 2560.

I have managed to pass the programs of the Arduino IDE, to PIO, I installed the libraries in PIO, and the programs compile, both in the Arduino IDE, and in PIO. I got, that the Arduino that controls the sensors (program called Slave), send me the data to the Arduino that is at the checkpoint (program called Maestro). But I don’t know why I can’t send PS2 command orders from one Arduino to another.

If anyone could help me continue, I’d be very grateful.

[asesorplaza1]

Voy a adjuntar los dos códigos de Arduno que tengo, si me indicáis como sacar el fichero de PIO, también lo podre adjuntar, ahora mismo, no sé donde se guarda el fichero PIO con las librerías importadas de Arduino.

I will attach the two Arduno codes that I have, if you tell me how to take the PIO file, I can also attach it, right now, I do not know where the PIO file is stored with the libraries imported from Arduino

[asesorplaza1]

Como no puedo adjuntar ficheros comprimidos, ni ficheros .ino, voy a intentar poner los códigos como texto, pero son 700 lineas de código, no se si me cabra el código en un solo mensaje.

Since I can’t attach compressed files, or .ino files, I’m going to try to put the codes as text, but it’s 700 lines of code, I don’t know if I get the code in a single message.

[asesorplaza1]

Este es el código Arduino llamado Maestro, que es el que esta en el puesto de control, y tiene conectado el mando de la PS2.

This is the Arduino code called Master, which is the one at the checkpoint, and has the PS2’s command connected

#include <PS2X_lib.h> // Librería PS2 de Bill Porter
#include <EasyTransfer.h> // Librería Easy Transfer de Bill Porter

PS2X ps2x;         // Crea la clase del controlador PS2
int error = 0;     // Crea la clase de error del mando
byte type = 0;     // Crea el tipo de error del mando
byte vibrate = 0;  // Crea la vibracion del mando

EasyTransfer ETin, ETout;  //Cree los objetos de EasyTransfer para la comunicación bidireccional

const int grnLEDpin = 30;       // LED verde    esta encendido en pin Digital 4
const int redLEDpin = 31;       // LED rojo     esta encendido en pin Digital 3
const int yelLEDpin = 32;       // LED amarillo esta encendido en pin Digital 2
const int VwarnLEDpin = 33;     // LED de advertencia de voltaje esta encendido en el Pin digital D5
const int TwarnLEDpin = 34;     // LED de advertencia de temperatura esta encendido en el pin D6
const int pinLedColision = 35;  // LED de advertencia de peligro colisión en el pin 27
const int LowBatVolts10 = 96;   // esto es para mantener el valor de advertencia de voltaje de bateria bajo en el umbral de x10.

int ForwardVal = 0;             // valor leído en palo PS2 derecho arriba/abajo
int YawLeftVal = 0;             // valor leído en palo PS2 derecho derecha/izquierda
int UpVal = 0;                  // valor leído en palo PS2 izquierdo arriba/abajo
int RollLeftVal = 0;            // valor leído en palo PS2 izquierdo derecha/izquierda

boolean PSB_PAD_UPstate = false;     // Genera variable para guardar y mandar los datos del botón Izquierda arriba al Esclavo
boolean PSB_PAD_DOWNstate = false;   // Genera variable para guardar y mandar los datos del botón Izquierda abajo al Esclavo
boolean PSB_PAD_LEFTstate = false;   // Genera variable para guardar y mandar los datos del botón Izquierda izquierdo al Esclavo
boolean PSB_PAD_RIGHTstate = false;  // Genera variable para guardar y mandar los datos del botón Izquierda derecho al Esclavo
boolean PSB_BLUEstate = false;       // Genera variable para guardar y mandar los datos del botón Cruz azul al Esclavo
boolean PSB_GREENstate = false;      // Genera variable para guardar y mandar los datos del botón Triangulo verde al Esclavo
boolean PSB_PINKstate = false;       // Genera variable para guardar y mandar los datos del botón Cuadrado rosa al Esclavo
boolean PSB_REDstate = false;        // Genera variable para guardar y mandar los datos del botón Circulo rojo al Esclavo
boolean PSB_L1state = false;         // Genera variable para guardar y mandar los datos del botón Izquierda delante arriba al Esclavo
boolean PSB_L2state = false;         // Genera variable para guardar y mandar los datos del botón Izquierda delante abajo al Esclavo
boolean PSB_L3state = false;         // Genera variable para guardar y mandar los datos del botón Palo izquierdo abajo al Esclavo
boolean PSB_R1state = false;         // Genera variable para guardar y mandar los datos del botón Derecha delante arriba al Esclavo
boolean PSB_R2state = false;         // Genera variable para guardar y mandar los datos del botón Derecha delante abajo al Esclavo
boolean PSB_R3state = false;         // Genera variable para guardar y mandar los datos del botón Palo derecho abajo al Esclavo

float ROVTMP = 0;                                  // Variable para recibir los datos de la temperatura interior del ROV
float ROVTMP1 = 0;                                 // Variable para recibir los datos de la temperatura motor derecho del ROV
float ROVTMP2 = 0;                                 // Variable para recibir los datos de la temperatura motor izquierdo del ROV
float ROVDHThumid;                                 // Variable para recibir los datos de la humedad interior del ROV
float ROVDHThumid1;                                // Variable para recibir los datos de la humedad del motor derecho del ROV
float ROVDHThumid2;                                // Variable para recibir los datos de la humedad del motor izquierda del ROV
float AccX, AccY, AccZ, Temp, GyroX, GyroY, GyroZ; // Variable para recibir los datos del Giroscopio del ROV
float E18D80NK;                                    // Variable para recibir los datos del sensor E18D80NK del ROV
float sensorDS18B20;                               // Variable para recibir los datos del sensor DS18B20 del ROV
float pressure_bar;                                // Variable para recibir los datos del sensor de presión interior SKU237545 en Bares del ROV
float pressure_psi;                                // Variable para recibir los datos del sensor de presión interior SKU237545 en PSI del ROV
float pressure_bar1;                               // Variable para recibir los datos del sensor de presión exterior SKU237545 en Bares del ROV
float pressure_psi1;                               // Variable para recibir los datos del sensor de presión interior SKU237545 en PSI del ROV
float ROVDepth;                                    // Variable para recibir los datos de la profundidad a la que se encuentra el ROV
float ROVHDG;                                      // Variable para recibir los datos de la dirección del ROV en grados

struct RECEIVE_DATA_STRUCTURE  // estructura de mensaje de datos recibidos de los sensores
{
  int BattVolt;             // Recibe mensaje de voltaje de batería
  int t;                    // Recibe mensaje de temperatura interior del ROV
  int t1;                   // Recibe mensaje de temperatura del motor derecho
  int t2;                   // Recibe mensaje de temperatura del motor izquierdo
  int ROVDepth;             // Recibe mensaje de lectura de profundidad de ROV (m)
  int ROVHDG;               // Recibe mensaje de Dirección del ROV (grados)
  int h;                    // Recibe mensaje de humedad del interior del ROV
  int h1;                   // Recibe mensaje de humedad del motor derecho
  int h2;                   // Recibe mensaje de humedad del motor izquierdo
  int AccX;                 // Recibe mensaje de datos de inclinación del eje X
  int AccY;                 // Recibe mensaje de datos de inclinación del eje Y
  int AccZ;                 // Recibe mensaje de datos de inclinación del eje Z
  int Temp;                 // Recibe mensaje de datos de temperatura del giroscopio
  int GyroX;                // Recibe mensaje de datos de aceleración en el eje X
  int GyroY;                // Recibe mensaje de datos de aceleración en el eje Y
  int GyroZ;                // Recibe mensaje de datos de aceleración en el eje Z
  int E18D80NK;             // Recibe mensaje de lectura del sensor infrarrojo E18-D80NK
  int pinLedColision;       // Recibe mensaje de encender alarma de colisión
  int sensorDS18B20;        // Recibe mensaje de lectura del sensor de temperatura DS18B20
  int pressure_bar;         // Recibe mensaje de lectura del sensor de presión SKU237545 en Bares
  int pressure_psi;         // Recibe mensaje de lectura del sensor de presión SKU237545 en PSI
  int pressure_bar1;        // Recibe mensaje de lectura del sensor de presión SKU237545 Interno en Bares
  int pressure_psi1;        // Recibe mensaje de lectura del sensor de presión SKU237545 Interno en PSI
};

struct SEND_DATA_STRUCTURE  // estructura de mensaje de datos enviados
{
  int upLraw = 0;  //Variables para transportar los datos reales sin procesar de los ESCs
  int upRraw = 0;
  int HLraw = 0;
  int HRraw = 0;
  volatile boolean PSB_PAD_UPstate;     // Manda lectura del botón Izquierda arriba al Esclavo
  volatile boolean PSB_PAD_DOWNstate;   // Manda lectura del botón Izquierda abajo al Esclavo
  volatile boolean PSB_PAD_RIGHTstate;  // Manda lectura del botón Izquierda derecho al Esclavo
  volatile boolean PSB_PAD_LEFTstate;   // Manda lectura del botón Izquierda Izquierda al Esclavo
  volatile boolean PSB_BLUEstate;       // Manda lectura del botón Cruz azul al Esclavo
  volatile boolean PSB_GREENstate;      // Manda lectura del botón Triangulo verde al Esclavo
  volatile boolean PSB_PINKstate;       // Manda lectura del botón Cuadrado rosa al Esclavo
  volatile boolean PSB_REDstate;        // Manda lectura del botón Circulo rojo al Esclavo
  volatile boolean PSB_L1state;         // Manda lectura del botón Izquierda delante arriba al Esclavo
  volatile boolean PSB_L2state;         // Manda lectura del botón Izquierda delante abajo al Esclavo
  volatile boolean PSB_L3state;         // Manda lectura del botón Palo izquierdo abajo al Esclavo
  volatile boolean PSB_R1state;         // Manda lectura del botón Derecha delante arriba al Esclavo
  volatile boolean PSB_R2state;         // Manda lectura del botón Derecha delante abajo al Esclavo
  volatile boolean PSB_R3state;         // Manda lectura del botón Palo derecho abajo al Esclavo
  volatile boolean LEDHdlts;            // Manda que hacer con los Focos, encendidos/apagados
};

//dar un nombre al grupo de datos
RECEIVE_DATA_STRUCTURE rxdata;
SEND_DATA_STRUCTURE txdata;

unsigned long a = millis();  // Se define y se inicia una variable llamada millis

void setup()
{

  Serial.begin(9600);      // Comienza la Comunicación en Serie para hablar con el ordenador a 9600 Baudios
  Serial1.begin(9600);    // Comienza la comunicación Serie en el puerto 1, pines 18 y 19, para hablar con el Arduino Esclavo
  Serial1.flush();         // Depura la información del Puerto Serie
  ETin.begin(details(rxdata), &Serial1);    // Comienza la recepción de datos a través de Serial, en los pines 18 y 19
  ETout.begin(details(txdata), &Serial1);   // Comienza el envío de datos a través de Serial, en los pines 18 y 19

  pinMode(grnLEDpin, OUTPUT);  //se establece grnLEDpin como salida
  pinMode(redLEDpin, OUTPUT);  //se establece redLEDpin como salida
  pinMode(yelLEDpin, OUTPUT);  //se establece yelLEDpin como salida
  pinMode(VwarnLEDpin, OUTPUT);  //se establece el pin de advertencia de batería baja como salida
  pinMode(TwarnLEDpin, OUTPUT);  //se establece el pin de sobre temperatura como salida

  // Pines y ajustes de configuración: GamePad(clock, command, attention, data, Pressures?, Rumble?)
  error = ps2x.config_gamepad(22, 23, 24, 25, false, false);

  if (error == 0)
  {
    Serial.println (F("\n Controlador encontrado y configurado con éxito"));
  }

  else if (error == 1)
    Serial.println (F(" \n No se encontró el controlador, verifique el cableado, consulte readme.txt para habilitar la depuración. Visite www.billporter.info para obtener sugerencias para la solución de problemas"));

  else if (error == 2)
    Serial.println (F(" \n El controlador se encontró, pero no admite comandos. Consulte readme.txt para habilitar la depuración. Visite www.billporter.info para obtener sugerencias para la solución de problemas"));

  else if (error == 3)
    Serial.println (F(" \n El controlador se niega a ingresar en el modo de presiones, puede que no lo admita"));

  // Serial.print(ps2x.Analog(1), HEX);
  type = ps2x.readType();
}

void loop()
{

  if (millis() > a + 100) {


    if (error == 0)
    {
      // Controlador DualShock
      ps2x.read_gamepad();

      //lecturas analógicas del palo
      //traduce las lecturas del palo al las instrucciones del ESC
      //las lecturas de los palos del controlador PS2 son de 0 a 255
      //con el neutro en 128. Las posiciones cero son
      //a la izquierda para movimientos del eje X y arriba para los movimientos del eje Y

      ForwardVal = ps2x.Analog(PSS_RY);
      YawLeftVal = ps2x.Analog(PSS_RX);
      UpVal = ps2x.Analog(PSS_LY);
      RollLeftVal = ps2x.Analog(PSS_LX);

      // Lectura de todos los botones del mando
      // Esto será verdad hasta que algún botón cambie de estado, (activado / desactivado)
      if (ps2x.NewButtonState())
      {
        if (ps2x.ButtonPressed(PSB_PAD_UP))                // Lee el valor del botón Izquierda arriba al Esclavo
        {
          PSB_PAD_UPstate = (!PSB_PAD_UPstate);            // Guarda el dato del botón en su variable
          digitalWrite(yelLEDpin, PSB_PAD_UPstate);        // Enciende el LED Amarillo
        }
        txdata.PSB_PAD_UPstate = (PSB_PAD_UPstate);        // Manda el estado del botón al Esclavo

        if (ps2x.ButtonPressed(PSB_PAD_DOWN))              // Lee el valor del botón Izquierda abajo al Esclavo
        {
          PSB_PAD_DOWNstate = (!PSB_PAD_DOWNstate);            // Guarda el dato del botón en su variable
          digitalWrite(yelLEDpin, PSB_PAD_DOWNstate);      // Enciende el LED Amarillo
        }
        txdata.PSB_PAD_DOWNstate = (PSB_PAD_DOWNstate);    // Manda el estado del botón al Esclavo

        if (ps2x.ButtonPressed(PSB_PAD_RIGHT))             // Lee el valor del botón Izquierda derecho al Esclavo
        {
          PSB_PAD_RIGHTstate = (!PSB_PAD_RIGHTstate);      // Guarda el dato del botón en su variable
          digitalWrite(yelLEDpin, PSB_PAD_RIGHT);          // Enciende el LED Amarillo
        }
        txdata.PSB_PAD_RIGHTstate = (PSB_PAD_RIGHTstate);  // Manda el estado del botón al Esclavo

        if (ps2x.Button(PSB_PAD_LEFT))                     // Lee el valor del botón Izquierda Izquierda al Esclavo
        {
          PSB_PAD_LEFTstate = (!PSB_PAD_LEFTstate);        // Lectura del estado del botón
          txdata.LEDHdlts = PSB_PAD_LEFTstate;             // Guarda que hacer con el estado de los focos, encendido / apagado
          digitalWrite(yelLEDpin, PSB_PAD_LEFTstate);      // Enciende el Led Amarillo
          Serial.print (F("\n Focos apagados"));           // Imprime la frase "Focos apagados"
        }
        else if (!txdata.LEDHdlts)
        {
          digitalWrite(yelLEDpin, LOW);                    // Apaga el led amarillo
          Serial.print (F("\n Focos encendidos"));         // Imprime la frase " Focos encendidos"
        }

        txdata.PSB_PAD_LEFTstate = (PSB_PAD_LEFTstate);    // Manda el estado del botón al Esclavo

        if (ps2x.ButtonPressed(PSB_BLUE))                  // Lee el valor del botón Cruz azul al Esclavo
        {
          PSB_BLUEstate = (!PSB_BLUEstate);                // Guarda el dato del botón en su variable
          digitalWrite(yelLEDpin, PSB_BLUEstate);          // Enciende el Led Amarillo
        }
        txdata.PSB_BLUEstate = (PSB_BLUEstate);            // Manda el estado del botón al Esclavo

        if (ps2x.ButtonPressed(PSB_GREEN))                 // Lee el valor del botón Triangulo verde al Esclavo
        {
          PSB_GREENstate = (!PSB_GREENstate);              // Guarda el dato del botón en su variable
          digitalWrite(yelLEDpin, PSB_GREENstate);         // Enciende el LED Amarillo
        }
        txdata.PSB_GREENstate = (PSB_GREENstate);          // Manda el estado del botón al Esclavo

        if (ps2x.ButtonPressed(PSB_PINK))                  // Lee el valor del botón Cuadrado rosa al Esclavo
        {
          PSB_PINKstate = (!PSB_PINKstate);                // Guarda el dato del botón en su variable
          digitalWrite(yelLEDpin, PSB_PINKstate);          // Enciende el LED Amarillo
        }
        txdata.PSB_PINKstate = (PSB_PINKstate);            // Manda el estado del botón al Esclavo

        if (ps2x.ButtonPressed(PSB_RED))                   // Lee el valor del botón Circulo rojo al Esclavo
        {
          PSB_REDstate = (!PSB_REDstate);                  // Guarda el dato del botón en su variable
          digitalWrite(yelLEDpin, PSB_REDstate);           // Enciende el LED Amarillo
        }
        txdata.PSB_REDstate = (PSB_REDstate);              // Manda el estado del botón al Esclavo

        if (ps2x.ButtonPressed(PSB_L3))                    // Lee el valor del botón Palo izquierdo abajo al Esclavo
        {
          PSB_L3state = (!PSB_L3state);                    // Guarda el dato del botón en su variable
          digitalWrite(yelLEDpin, PSB_L3state);            // Enciende el Led Amarillo
        }
        txdata.PSB_L3state = (PSB_L3state);                // Manda el estado del botón al Esclavo

        if (ps2x.ButtonPressed(PSB_R1))                    // Lee el valor del botón Derecha delante arriba al Esclavo
        {
          PSB_R1state = (!PSB_R1state);                    // Guarda el dato del botón en su variable
          digitalWrite(yelLEDpin, PSB_R1state);            // Enciende el Led Amarillo
        }
        txdata.PSB_R1state = (PSB_R1state);                // Manda el estado del botón al Esclavo

        if (ps2x.ButtonPressed(PSB_R2))                    // Lee el valor del botón Derecha delante abajo al Esclavo
        {
          PSB_R2state = (!PSB_R2state);                    // Guarda el dato del botón en su variable
          digitalWrite(yelLEDpin, PSB_R2state);            // Enciende el Led Amarillo
        }
        txdata.PSB_R2state = (PSB_R2state);                // Manda el estado del botón al Esclavo

        if (ps2x.Button(PSB_R3))                           // Lee el valor del botón Palo derecho abajo al Esclavo
        {
          PSB_R3state = (!PSB_R3state);                    // Guarda el dato del botón en su variable
          digitalWrite(yelLEDpin, PSB_R3state);            // Enciende el Led Amarillo
        }
        txdata.PSB_R3state = (PSB_R3state);                // Manda el estado del botón al Esclavo

        if (ps2x.ButtonPressed(PSB_L1))                    // Lee el valor del botón Izquierda delante arriba al Esclavo
        {
          PSB_L1state = (!PSB_L1state);                    // Guarda el dato del botón en su variable
          digitalWrite(yelLEDpin, PSB_L1state);            // Enciende el Led Amarillo
        }
        txdata.PSB_L1state = (PSB_L1state);                // Manda el estado del botón al Esclavo

        if (ps2x.ButtonPressed(PSB_L2))                    // Lee el valor del botón Izquierda delante abajo al Esclavo
        {
          PSB_L2state = (!PSB_L2state);                    // Guarda el dato del botón en su variable
          digitalWrite(yelLEDpin, PSB_L2state);            // Enciende el Led Amarillo
        }
        txdata.PSB_L2state = (PSB_L2state);                // Manda el estado del botón al Esclavo
      }

      //variables para transportar los datos en bruto reales para los ESCs y servos
      txdata.upLraw = (128 - UpVal) - (128 - RollLeftVal) / 2; //esto será hasta un valor de 192
      txdata.upRraw = (128 - UpVal) + (128 - RollLeftVal) / 2; //esto será hasta un valor de 192
      txdata.HLraw = -(128 - ForwardVal) + (128 - YawLeftVal); //esto será hasta un valor de 256
      txdata.HRraw = -(128 - ForwardVal) - (128 - YawLeftVal); //esto será hasta un valor de 256
      //escala los valores para que sean adecuados para los ESCs y para los Servos
      //estos valores podrán escribirse directamente en los  ESCs y en los Servos
      txdata.upLraw = map(txdata.upLraw, -193, 193, 0, 179);
      txdata.upRraw = map(txdata.upRraw, -193, 198, 0, 179);
      txdata.HLraw = map(txdata.HLraw, -256, 256, 0, 179);
      txdata.HRraw = map(txdata.HRraw, -256, 256, 0, 179);
    }

    // Enviar el mensaje al puerto serie para el Arduino del ROV
    ETout.sendData();

    for (int i = 0; i < 5; i++) {

      a = millis();
    }

    if (ETin.receiveData())    // Recibe el mensaje al puerto serie para el Arduino del ROV
    {
      if (rxdata.BattVolt < LowBatVolts10)
        // el factor de 10 se incluye para coincidir con el factor 10 utilizado en el valor informado que es un int multiplicado
        // Por 10 para dar una precisión de 0.1 al valor. Tiene sentido
      {
        digitalWrite(VwarnLEDpin, HIGH);
        //si el voltaje de la batería es demasiado bajo, enciende el LED de advertencia
      }
      else
      {
        digitalWrite(VwarnLEDpin, LOW);
        //de lo contrario, si el voltaje está por encima del umbral de bajo voltaje definido
        //deje el LED apagado
      }

      ROVTMP = (rxdata.t);    // Recibe los datos del Esclavo
      ROVTMP1 = (rxdata.t1);  // Recibe los datos del Esclavo
      ROVTMP2 = (rxdata.t2);  // Recibe los datos del Esclavo
      //convierte el valor de datos 0-1024 en temperatura

      if (ROVTMP > 50 || ROVTMP1 > 50 || ROVTMP2 > 50)
      {
        // Si la temperatura de cualquiera de los sensores DHT22 es demasiado alta (más de 50 grados C)
        // enciende el LED de advertencia
        digitalWrite(TwarnLEDpin, HIGH);
        Serial.print (F(" \n TEMPERATURA ELEVADA !"));
      }
      else
      {
        digitalWrite(TwarnLEDpin, LOW);
        Serial.print (F(" \n Temperatura Normal"));
        // De lo contrario, si la temperatura interior está en un nivel aceptable
        // Deje el LED apagado y deje el relé de la bomba de refrigeración apagado
      }

      ROVDHThumid = (rxdata.h);    // Recibe los datos del Esclavo
      ROVDHThumid1 = (rxdata.h1);  // Recibe los datos del Esclavo
      ROVDHThumid2 = (rxdata.h2);  // Recibe los datos del Esclavo

      if (rxdata.E18D80NK > 0)    // Si la entrada del E18D80NK es baja, no hay ningún objeto
      {
        digitalWrite(pinLedColision, LOW);    // Apague el LED si no se detecta objeto
        Serial.print (F(" \n Todo Despejado  !"));   // manda imprimir al Monitor Serie la frase
      }
      else                                    // por el contrario, si la entrada del E18D80NK es alta
      {
        digitalWrite(pinLedColision, HIGH);   // encienda el LED de Peligro Colisión
        Serial.print (F(" \n PELIGRO Obstaculo detectado  !")); // manda imprimir la frase
      }

      ROVDepth = (rxdata.ROVDepth);             // Recibe lectura de profundidad de ROV (m)
      ROVHDG = (rxdata.ROVHDG);                 // Recibe lectura de Dirección del ROV (grados)
      AccX = (rxdata.AccX);                     // Recibe lectura de datos de inclinación del eje X
      AccY = (rxdata.AccY);                     // Recibe lectura de datos de inclinación del eje Y
      AccZ = (rxdata.AccZ);                     // Recibe lectura de datos de inclinación del eje Z
      Temp = (rxdata.Temp);                     // Recibe lectura de datos de temperatura del giroscopio
      GyroX = (rxdata.GyroX);                   // Recibe lectura de datos de aceleración en el eje X
      GyroY = (rxdata.GyroY);                   // Recibe lectura de datos de aceleración en el eje Y
      GyroZ = (rxdata.GyroZ);                   // Recibe lectura de datos de aceleración en el eje Z
      //  pinLedColision = (rxdata.pinLedColision); // Recibe lectura de encender alarma de colisión
      sensorDS18B20 = (rxdata.sensorDS18B20);   // Recibe lectura de lectura del sensor de temperatura DS18B20
      pressure_bar = (rxdata.pressure_bar);     // Recibe lectura de lectura del sensor de presión SKU237545 en Bares
      pressure_psi = (rxdata.pressure_psi);     // Recibe lectura de lectura del sensor de presión SKU237545 en PSI
      pressure_bar1 = (rxdata.pressure_bar1);   // Recibe lectura de lectura del sensor de presión SKU237545 Interno en Bares
      pressure_psi1 = (rxdata.pressure_psi1);   // Recibe lectura de lectura del sensor de presión SKU237545 Interno en PSI
      E18D80NK = (rxdata.E18D80NK);             // Recibe estado del sensor de infrarrojos


      // #if DEBUG1 { // CUIDADO CON ESTO, des comentar y cambiar 1 si imprime en Monitor Serie, 0 cero no imprime


      // A partir de aquí repito las ordenes de lcd, cambiándolas por Serial

      Serial.print (F("\n Voltaje del ROV = "));
      Serial.print (float(rxdata.BattVolt) / 10, 1);
      //factor 10 utilizado para obtener precisión adicional del valor entero y luego se muestra con 1 decimal
      Serial.print (F(" \n Temperatura del casco = "));
      Serial.print (ROVTMP);
      Serial.print (F(" *C "));
      Serial.print (F(" \n Temperatura motor DR = "));
      Serial.print (ROVTMP1);
      Serial.print (F(" *C1 "));
      Serial.print (F(" \n Temperatura motor IZ = "));
      Serial.print (ROVTMP2);
      Serial.print (F(" *C2 "));
      Serial.print (F(" \n Humedad en el interior del Casco = "));
      Serial.print (ROVDHThumid);
      Serial.print (F(" %\t"));
      Serial.print (F(" \n Humedad en el motor DR = "));
      Serial.print (ROVDHThumid1);
      Serial.print (F(" %\t"));
      Serial.print (F(" \n Humedad en el motor IZ = "));
      Serial.print (ROVDHThumid2);
      Serial.print (F(" %\t"));
      Serial.print (F(" \n Inclinación del eje X del ROV = "));
      Serial.print (AccX);
      Serial.print (F(" \n Inclinación del eje Y del ROV = "));
      Serial.print (AccY);
      Serial.print (F(" \n Inclinación del eje Z del ROV = "));
      Serial.print (AccZ);
      Serial.print (F(" \n Temperatura del Giro MPU6050 = "));
      Serial.print (Temp / 340.00 + 36.53);
      Serial.print (F(" \n Aceleración en el eje X del Giro MPU6050 = "));
      Serial.print (GyroX);
      Serial.print (F(" \n Aceleración en el eje Y del Giro MPU6050 = "));
      Serial.print (GyroY);
      Serial.print (F(" \n Aceleración en el eje Z del Giro MPU6050 = "));
      Serial.print (GyroZ);
      Serial.print (F(" \n Profundidad = "));
      Serial.print (ROVDepth);      // muestra en el Display la profundidad del ROV en metros
      Serial.print (F(" \n Direccion del ROV = "));
      Serial.print (ROVHDG);  // muestra la dirección del ROV en una brújula
      Serial.print (F(" \n Temperatura sensor DS18B20 = "));
      Serial.print (sensorDS18B20);
      Serial.print (F(" ºC"));
      Serial.print (F(" \n Valor del Sensor de Presión Interno =  "));
      Serial.print (F("   Presión en Bar = "));
      Serial.print (pressure_bar);
      Serial.print (F("    bars"));
      Serial.print (F("  || Presión en PSI = "));
      Serial.print (pressure_psi);
      Serial.print (F("    psi"));
      Serial.print (F(" \n Valor del Sensor de Presión Externo = "));
      Serial.print (F("   Presión en Bar = "));
      Serial.print (pressure_bar1);
      Serial.print (F("    bars"));
      Serial.print (F("  || Presión en PSI = "));
      Serial.print (pressure_psi1);
      Serial.print (F("    psi"));
      Serial.print (F("\n"));
    }
    // } #endif  // des comentar cuando NO quiera imprimir los Serial.print


  }
}

[asesorplaza1]

Como me temía, no me cabe el código entero y he tenido que quitarle la cabecera, donde están las explicaciones del código y las asignaciones de los pines, la pongo aquí, pero esto va encima de la publicación anterior.

As I feared, I don’t fit the whole code and I’ve had to remove the header, where the code explanations and pin assignments are, I put it here, but this goes above the previous post.

/*
  Modificado por asesorplaza1 en las diferentes fechas indicadas
  Las primeras pruebas y cambios del código, se iniciaron en 2.016, debido a la cantidad de modificaciones
  A partir de ahora 30/01/2020, se ponen las fechas y los cambios en la descripción del proyecto
  Para facilitar la búsqueda de errores en los diferentes cambios del código

  30/01/2020 ya se han comentado todas las líneas de control de la cámara y del LCD
  Le añado 2 DHT22 y así estarán los 3 que me hacen falta
  He borrado varias líneas de control de la cámara que no se va a utilizar

  01/02/2020 Le añado los controles del giroscopio facilitados por Dea de www.cambatronics.com

  02/02/2020 No hace falta modificar nada porque ya viene desde el Esclavo solo 1 lectura del sensor X segundo

  04/02/2020 Modifico las líneas de lectura de los sensores, porque hasta ahora solo me imprime en Monitor Serie el texto, no los datos

  06/02/2020 Se depura un poco el código, y se modifica el encabezado del código

  08/02/2020 Se corrige el error de lectura en los sensores, y se corrige la escritura del Monitor Serie

  12/02/2020 Para poder añadir cualquier código hay que seguir unas reglas especificas de programación
  Se modifica la estructura del código siguiendo esas órdenes de programación, según la información obtenida y guardada en la carpeta 01_UNIR_2_CODIGOS
  Se crean varios bloques en el void loop, para el funcionamiento de cada uno de los sensores, eliminando los delay()
  Se añade el sensor de distancia infrarrojo E18-D80NK, sin errores

  13/02/2020 Se incluye la lectura del sensor de temperatura DS18B20

  16/02/2020  Se añade la lectura del sensor de distancia infrarrojo E18-D80NK, sin errores
  Y consigo adaptar un código para leer el sensor de presión SKU237545

  08/03/2020 Se conecta un relé en el pin 12 del Arduino Esclavo, para encender los focos de luz externos, no hace falta cambiar el código

  26/03/2020 Se arregla el envío de datos, separando los datos del Monitor Serie, y los datos que hay que enviar al Arduino Maestro,
  Iniciando dos puertos serie con las órdenes

  Serial.begin(57600);     // Puerto Serie USB

  Serial1.begin(57600);    // Puerto Serie en los pines 18 y 19

  ETin.begin(details(rxdata), &Serial1);    // Comienza la recepción de datos a través de Serial, en los pines 18 y 19

  ETout.begin(details(txdata), &Serial1);   // Comienza el envío de datos a través de Serial, en los pines 18 y 19

  En el Esclavo se incluye una librería específica para el giroscopio MPU6050

  28/03/2020 Se incluyen el envío de todas las instrucciones del mando, para tener todos los botones operativos

  03/04/2020 Se incluye la parte nueva del Giroscopio MPU6050, que muestra los 3 ejes de inclinación, más la temperatura del Giroscopio.
  y se arreglan y ordenan los Serial.print

  11/04/2020 Corrijo el código según las instrucciones de mi amigo Atilano Belinchón

  13/04/2020 Corrijo las lecturas y envío de datos del sensor de infrarrojos E18D80NK

  18/04/2020 Se cambian algunos " if ", por " else if ", para darle agilidad al código

  Entre el día 24/03/2020 y el día 28/04/2020, se hacen varios cambios en el código para mejorarlo y conseguir que el mando funcione,
  Siguiendo las instrucciones de Bigbadbob en las publicaciones del foro

  http://www.homebuiltrovs.com/rovforum/viewtopic.php?f=18&t=1908

  A partir de la página 4

  28/04/2020 Se corrige la ortografía de todo el texto que no son órdenes

  03/05/2020 Se cambian las asignaciones de los pines, según el código de Github

  Las nuevas asignaciones de pines son:

  Salida de 3.3V a PIN rojo PS2
  Pin 24 a PIN amarillo PS2 + resistencia 1k
  Pin 23 a PIN naranja PS2
  Pin 25 a PIN marrón PS2 + resistencia 1k
  Pin 22 a PIN azul PS2

  Se arregla el código para que me salga en el Maestro el estado de los focos, encendidos / apagados.

  04/05/2020 Se depura el código según los consejos de Bigbadbob de http://www.homebuiltrov.com

  05/05/2020 Se incluye la Macro F, en todos los Serial.print, para reducir el consumo de memoria dinámica
  Según los consejos de Bigbadbob de http://www.homebuiltrov.com, pero me da problemas

  06/05/2020 Se depura el código para un mejor funcionamiento, según los consejos de Bigbadbob de http://www.homebuiltrov.com
  y siguen los problemas con la Macro F

  07/05/2020 Se depura el código para un mejor funcionamiento, según los consejos de Bigbadbob de http://www.homebuiltrov.com
  y siguen los problemas con la Macro F

  08/05/2020 Se corrigen los problemas de la Macro F, en todos los Serial.print de texto fijo
  No se puede poner la Macro F, a los Serial.print de datos de los sensores
  Y se consigue reducir el consumo de memoria dinámica considerablemente

  09/05/2020 Se siguen corrigiendo líneas para la depuración del código, según los consejos de Bigbadbob de http://www.homebuiltrov.com
  Pero siguen los problemas con el mando de la PS2

  10/05/2020 Me doy cuenta de un error en la orden de encender los focos y lo corrijo
  Pero el mando sigue sin funcionar como es debido

  11/05/2020 Se modifican varias órdenes del control de los botones, pero el mando sigue sin funcionar correctamente

  16/05/2020 Se hacen diversos cambios, según los consejos de Tsanshon de www.foromodelismonaval.es

 La versión original tomada como punto de partida es la siguiente

  ROVPS2Control_Master8.ino
  Hamish Trolove - 30 de marzo de 2016
  www.techmonkeybusiness.com

  Y toma comandos de control de un mando PS2 y transmite los
  Comandos que utilizan la Biblioteca EasyTransfer de Bill Porter en un serial de 9600 baudios
  Enlace (100m de cable).

  Este boceto está diseñado para un Arduino Nano con un solo puerto serie.

  Aunque yo lo estoy usando en un Mega 2560 y funcionaba, hasta que empece a introducir sensores.



  Para la transmisión del video asesorplaza1 utilizara una Raspberry Pi 3 plus, una cámara USB, y el programa VCL Media Player
  Indicador de luces principales de Pin D4 a LED
  Sensor D5 a LED ROV Batería De bajo voltaje Advertencia
  Pin D6 a LED ROV Advertencia interior de alta temperatura

  Comunicaciones cambiado por Asesorplaza1, el 26/03/2020, para separar los datos que se envían de un Arduino a otro, de los datos del Monitor Serie

  Conexión serie: Parte superior 19 (TX) a ROV 18 (RX)
  Conexión serie: Parte superior 18 (RX) a ROV 19 (TX)
  Conecte el GND en ambos

  La pantalla LCD de 16x2, se cambiara por una pantalla Nextion básica de 5"

  La codificación tira de la biblioteca PSX desarrollada por Bill Porter.
  Vea www.billporter.info para consultar lo último de Bill Porter y descargar las bibliotecas.

  Los controles para el ROV son;
  Stick Derecho - Eje X - Movimiento, Adelante / Atras
  Stick Derecho - Eje Y - Movimiento, Derecha / Izquierda
  Botón R1 movimiento arriba
  Botón R2 movimiento abajo
  Botón Izquierda - Izquierda, interruptor de encendido/apagado de Focos Externos

*/
/*
Modified byplaza advisor1 on the different dates indicated
The first tests and code changes were initiated in 2,016, due to the number of modifications
As of now 30/01/2020, dates and changes are made to the project description
To make it easier to find errors in different code changes

30/01/2020 all camera and LCD control lines have already been commented on
I add 2 DHT22 and so will be the 3 I need
I've erased several control lines from the camera that won't be used

01/02/2020 I add the gyroscope controls provided by Dea de [www.cambatronics.com](https://ssl.microsofttranslator.com/bv.aspx?ref=TAns&from=&to=en&a=www.cambatronics.com)

02/02/2020 No need to modify anything because it already comes from the Slave only 1 sensor reading X second

04/02/2020 I modify the reading lines of the sensors, because until now I only print in Monitor Series the text, not the data

06/02/2020 The code is debugging a little, and the code header is modified

08/02/2020 The reading error in the sensors is fixed, and the Serial Monitor write is corrected

12/02/2020 To be able to add any code you have to follow specific programming rules
The structure of the code is modified according to those programming commands, based on the information obtained and stored in the folder 01_UNIR_2_CODIGOS
Several blocks are created in the void loop, for the operation of each of the sensors, eliminating the delay()
E18-D80NK infrared distance sensor added, no errors

13/02/2020 DS18B20 temperature sensor reading is included

16/02/2020 E18-D80NK infrared distance sensor reading added, no errors
And I can adapt a code to read the pressure sensor SKU237545

08/03/2020 A relay is connected on pin 12 of the Arduino Slave, to turn on the external light bulbs, there is no need to change the code

26/03/2020 It arranges the sending of data, separating the data from the Serial Monitor, and the data to be sent to the Arduino Maestro,
Initiating two serial ports with orders

Serial.begin(57600); USB Series Port

Serial1.begin(57600); Serial port on pins 18 and 19

ETin.begin(details(rxdata), &Serial1); Data reception begins through Serial, at pins 18 and 19

ETout.begin(details(txdata), &Serial1); Start sending data through Serial, at pins 18 and 19

The Slave includes a specific library for the MPU6050 gyroscope

28/03/2020 All instructions on the controller are included, to have all buttons operational

03/04/2020 The new part of the MPU6050 Gyroscope is included, showing the 3 tilt axes, plus the temperature of the Gyroscope.
and they fix and order the [Serial.print](https://ssl.microsofttranslator.com/bv.aspx?ref=TAns&from=&to=en&a=Serial.print)

11/04/2020 I correct the code according to the instructions of my friend Atilano Belinchón

13/04/2020 I correct the readings and sending of data from the E18D80NK infrared sensor

18/04/2020 Some "if" are changed to "else if", to give the code agility

Between 24/03/2020 and 28/04/2020, several code changes are made to improve it and make the controller work,
Following Bigbadbob's instructions in forum posts

[http://www.homebuiltrovs.com/rovforum/viewtopic.php?f=18&t=1908](https://ssl.microsofttranslator.com/bv.aspx?ref=TAns&from=&to=en&a=http%3A%2F%2Fwww.homebuiltrovs.com%2Frovforum%2Fviewtopic.php%3Ff%3D18%26t%3D1908)

From page 4

28/04/2020 Corrects spelling of all non-order text

03/05/2020 Pin assignments are changed, according to Github code

The new pin assignments are:

3.3V output to red PS2 PIN
Pin 24 to PS2 yellow PIN + 1k resistance
Pin 23 to PIN Orange PS2
Pin 25 to PIN brown PS2 + 1k resistance
Pin 22 to PS2 Blue PIN

Fixed the code to get me out in the Master the state of the spotlights, on/off.

04/05/2020 Code is debugged according to Bigbadbob's advice from [http://www.homebuiltrov.com](https://ssl.microsofttranslator.com/bv.aspx?ref=TAns&from=&to=en&a=http%3A%2F%2Fwww.homebuiltrov.com)

05/05/2020 Macro F is included, in all Serial.print, to reduce dynamic memory consumption
According to Bigbadbob's advice from http://www.homebuiltrov.com, but it gives me trouble

06/05/2020 Code is debugged for better performance, according to Bigbadbob's advice from [http://www.homebuiltrov.com](https://ssl.microsofttranslator.com/bv.aspx?ref=TAns&from=&to=en&a=http%3A%2F%2Fwww.homebuiltrov.com)
and the problems with Macro F follow

07/05/2020 Code is debugged for better performance, according to Bigbadbob's advice from [http://www.homebuiltrov.com](https://ssl.microsofttranslator.com/bv.aspx?ref=TAns&from=&to=en&a=http%3A%2F%2Fwww.homebuiltrov.com)
and the problems with Macro F follow

08/05/2020 Fixed Macro F issues in all fixed-text [Serial.prints](https://ssl.microsofttranslator.com/bv.aspx?ref=TAns&from=&to=en&a=Serial.prints)
You can't put Macro F, to [Serial.print](https://ssl.microsofttranslator.com/bv.aspx?ref=TAns&from=&to=en&a=Serial.print) sensor data
And it reduces dynamic memory consumption considerably

09/05/2020 Lines are still corrected for code debugging, according to Bigbadbob's advice from [http://www.homebuiltrov.com](https://ssl.microsofttranslator.com/bv.aspx?ref=TAns&from=&to=en&a=http%3A%2F%2Fwww.homebuiltrov.com)
But the problems with PS2 command continue

10/05/2020 I notice an error in the order to turn on the spotlights and correct it
But the controller still doesn't work properly

11/05/2020 Several button control commands are modified, but the controller still does not work properly

16/05/2020 Various changes are made, according to Tsanshon's advice from [www.foromodelismonaval.es](https://ssl.microsofttranslator.com/bv.aspx?ref=TAns&from=&to=en&a=www.foromodelismonaval.es)

The original version taken as a starting point is as follows

ROVPS2Control_Master8.ino
Hamish Trolove - 30 March 2016
[www.techmonkeybusiness.com](https://ssl.microsofttranslator.com/bv.aspx?ref=TAns&from=&to=en&a=www.techmonkeybusiness.com)

And it takes commands to control a PS2 controller and transmits the
Commands using Bill Porter's EasyTransfer Library on a 9600 baud serial
Link (100m cable).

This sketch is designed for an Arduino Nano with a single serial port.

Although I'm using it on a Mega 2560 and it worked, until I started introducing sensors.

For the transmission of the video advisorplaza1 will use a Raspberry Pi 3 plus, a USB camera, and the program VCL Media Player
Pin D4 to LED headlight indicator
Sensor D5 to LED ROV Low Voltage Battery Warning
Pin D6 to LED ROV High temperature indoor warning

Communications changed by Adviserplaza1, on 26/03/2020, to separate the data that is sent from one Arduino to another, from the Data of the Series Monitor

Serial connection: Top 19 (TX) to ROV 18 (RX)
Serial connection: Top 18 (RX) to ROV 19 (TX)
Connect the GND on both

The 16x2 LCD display will be replaced by a basic Nextion display of 5"

The encoding pulls the PSX library developed by Bill Porter.
See [www.billporter.info](https://ssl.microsofttranslator.com/bv.aspx?ref=TAns&from=&to=en&a=www.billporter.info) for the latest Bill Porter and download libraries.

The controls for the ROV are;
Right Stick - X Axis - Motion, Forward / Back
Right Stick - Y Axis - Motion, Right / Left
R1 button moving up
R2 button moving down
Left button - Left, External Spotlight on/off switch

*/

[asesorplaza1]

Este es el programa llamado Esclavo, que es el que esta dentro del vehículo, pongo primero la cabecera con las explicaciones, y después el código.

This is the program called Slave, which is the one inside the vehicle, I put first the header with the explanations, and then the code.

/*
  Modificado por asesorplaza1 en las diferentes fechas indicadas
  Las primeras pruebas y cambios del código, se iniciaron en 2.016, debido a la cantidad de modificaciones
  A partir de ahora 30/01/2020, se ponen las fechas y los cambios en la descripción del proyecto
  Para facilitar la búsqueda de errores en los diferentes cambios del código

  30/01/2020 ya se han comentado todas las líneas de control de la cámara y del LCD
  Le añado 2 DHT22 y así estarán los 3 que me hacen falta
  He borrado varias líneas de control de la cámara que no se va a utilizar

  01/02/2020 le añado los controles del giroscopio facilitados por Dea de www.cambatronics.com

  02/02/2020 le añado la orden para leer solo 1 vez X segundo el DHT22, truco de José Luis de
  www.cambatronics.com
  y se borran las líneas correspondientes al control de la cámara de video
  No utilizadas por asesorplaza1, en esta modificación del proyecto original

  04/02/2020 modifico las líneas de lectura de los sensores, porque hasta ahora solo me imprime en Monitor Serie el texto, no los datos

  06/02/2020 se depura un poco el código, y se modifica el encabezado del código

  08/02/2020 se corrige el error de lectura en los sensores, y se corrige la escritura del Monitor Serie

  12/02/2020 para poder añadir cualquier código hay que seguir unas reglas especificas de programación
  Se modifica la estructura del código siguiendo esas órdenes de programación, según la información obtenida y guardada
  En la carpeta 01_UNIR_2_CODIGOS
  Se crean varios bloques en el void loop, para el funcionamiento de cada uno de los sensores, eliminando los delay()

  13/02/2020 se incluye el sensor de temperatura DS18B20, ayudado por DEA de www.cambatronics.com

  16/02/2020  Se añade el sensor de distancia infrarrojo E18-D80NK, sin errores
  y consigo adaptar un código para leer el sensor de presión SKU237545

  08/03/2020 se conecta un relé en el pin 12 del Arduino Esclavo, para encender los focos de luz externos, no hace falta cambiar el código

  26/03/2020 Se incluye la librería MPU6050, para controlar el giroscopio
  Se arregla el envió de datos, separando los datos del Monitor Serie, y los datos que hay que enviar al Arduino Maestro,
  iniciando dos puertos serie con las ordenes

  Serial.begin(57600);     // Puerto Serie USB

  Serial1.begin(57600);    // Puerto Serie en los pines 18 y 19

  ETin.begin(details(rxdata), &Serial1);    // Comienza la recepción de datos a través de Serial, en los pines 18 y 19

  ETout.begin(details(txdata), &Serial1);   // Comienza el envío de datos a través de Serial, en los pines 18 y 19

  28/03/2020 Se incluyen el envió de todas las instrucciones del mando, para tener todos los botones operativos (no funciona)

  03/04/2020 Se incluye la parte nueva del Giroscopio MPU6050, que muestra los 3 ejes de inclinación, más la temperatura del Giroscopio.
  Se incluye el segundo sensor de presión

  05/04/2020 se cambia el código del sensor infrarrojo E18D80NK, por uno mejor

  11/04/2020 Corrijo el código según las instrucciones de mi amigo Atilano Belinchón

  13/04/2020 Corrijo las lecturas y envió de datos del sensor de infrarrojos E18D80NK

  15/04/2020 Se incluye el servo de dirección para accionarlo con los botones R1 y R2 del mando
  según información obtenida de la pagina

  https://arduparatodos.blogspot.com/2017/02/controlar-servomotor-con-arduino-varios.html

  18/04/2020 Se cambian algunos " if ", por " else if ", para darle agilidad al código, siguiendo las instrucciones de DEA de www.cambatronics.com

  Entre el día 24/03/2020 y el día 28/04/2020, se hacen varios cambios en el código para mejorarlo y conseguir que el mando funcione,
  Siguiendo las instrucciones de bigbadbob en las publicaciones del foro

  http://www.homebuiltrovs.com/rovforum/viewtopic.php?f=18&t=1908

  A partir de la página 4

  28/04/2020 Se corrige la ortografía de todo le texto que no son órdenes

  03/05/2020 Se cambian las asignaciones de los pines, según el código de Github

  Las nuevas asignaciones de pines son:

  Salida de 3.3V a PIN rojo PS2
  Pin 24 a PIN amarillo PS2 + resistencia 1k
  Pin 23 a PIN naranja PS2
  Pin 25 a PIN marrón PS2 + resistencia 1k
  Pin 22 a PIN azul PS2

  Se arregla el código para que me salga en el Maestro el estado de los focos, encendidos / apagados

  04/05/2020 Se depura el código según los consejos de Bigbadbob de http://www.homebuiltrov.com

  05/05/2020 Se incluye la Macro F, en todos los Serial.print, para reducir el consumo de memoria dinámica
  Según los consejos de Bigbadbob de http://www.homebuiltrov.com, pero me da problemas

  06/05/2020 Se depura el código para un mejor funcionamiento, según los consejos de Bigbadbob de http://www.homebuiltrov.com
  y siguen los problemas con la Macro F

  07/05/2020 Se depura el código para un mejor funcionamiento, según los consejos de Bigbadbob de http://www.homebuiltrov.com
  y siguen los problemas con la Macro F

  08/05/2020 Se corrigen los problemas de la Macro F, en todos los Serial.print de texto fijo
  No se puede poner la Macro F, a los Serial.print de datos de los sensores
  Y se consigue reducir el consumo de memoria dinámica considerablemente

  09/05/2020 Se siguen corrigiendo líneas para la depuración del código, según los consejos de Bigbadbob de http://www.homebuiltrov.com
  Pero siguen los problemas con el mando de la PS2

  10/05/2020 Me doy cuenta de un error en la orden de encender los focos y lo corrijo
  Pero el mando sigue sin funcionar como es debido

  11/05/2020 Se modifican varias órdenes del control de los botones, pero el mando sigue sin funcionar correctamente

  16/05/2020 Se hacen diversos cambios, segun los consejos de Tsanshon de www.foromodelismonaval.es







  La versión original tomada como punto de partida es la siguiente

  ROVPS2Control_Slavev8.ino
  Hamish Trolove - 30 de marzo de 2016
  www.techmonkeybusiness.com

  Este boceto toma los comandos que se le envían desde la unidad maestra con el controlador PS2 conectado y lo convierte en comandos de motor,
  Servo comandos, controles de luz, etc. Los datos se envían desde el Arduino (maestro) al ROV (esclavo) utilizando la biblioteca EasyTransfer de Bill Porter a través de un enlace en serie de 9600 baudios (anclaje de 100 m). La biblioteca MS5803_14 es de Luke Miller http://github.com/millerlp

  Los datos enviados desde el maestro son configuraciones sin formato para el control ESC.

  Este boceto está diseñado para un Arduino Nano con un solo puerto serie.

  Yo lo estoy usando en un Mega 2560, y funcionba, hasta que empecé a introducir sensores


  Para la transmisión del video asesorplaza1 utilizara una Raspberry Pi 3 plus, una cámara USB, y el programa VCL Media Player

  Se cambian estos sensores por obsoletos, se usan los sensores DHT22 y el giroscopio MPU6050

  Conexión serial de comunicaciones: modificado por Asesorplaza1, el 26/03/2020, para separar los datos mandados entre Arduinos, de los datos a mandar al Monitor serie
  19 superior (TX) a ROV 18 (RX) Conexión serial: 18 superior (RX) a ROV 19 (TX)
  Conecte el GND en ambos

  Tenga en cuenta que los ESC ya se habrán programado en este punto del proyecto.

  Los datos de voltaje interno, rumbo, profundidad y temperatura interna se envían a través del enlace serie de regreso al maestro
  Para su visualización en una pantalla LCD de 16x2.
  La pantalla LCD de 16x2, se cambiara por una pantalla Nextion básica de 5"

  Se cambia este sensor por obsoleto, se usa el giroscopio MPU 6050

  Ver también como se desarrolla el proyecto original con los siguientes códigos:
  HoryzonTrigger.ino, ROVPS2Control_Masterv0.ino,
  ROVDoNothing.ino, ROVSubBv0.ino, DigitalCompassv2.ino,
  PTLoggerv4.ino y TMP36_Temperature_Sensor.ino.
  En la página www.techmonkeybusiness.com

*/

/*
Modified byplaza advisor1 on the different dates indicated
The first tests and code changes were initiated in 2,016, due to the number of modifications
As of now 30/01/2020, dates and changes are made to the project description
To make it easier to find errors in different code changes

30/01/2020 all camera and LCD control lines have already been commented on
I add 2 DHT22 and so will be the 3 I need
I've erased several control lines from the camera that won't be used

01/02/2020 I add the gyroscope controls provided by Dea de [www.cambatronics.com](https://ssl.microsofttranslator.com/bv.aspx?ref=TAns&from=&to=en&a=www.cambatronics.com)

02/02/2020 I add the order to read only 1 time X second the DHT22, trick by José Luis de
[www.cambatronics.com](https://ssl.microsofttranslator.com/bv.aspx?ref=TAns&from=&to=en&a=www.cambatronics.com)
and the lines corresponding to the control of the video camera are deleted
Not used byplaza advisor1, in this modification of the original project

04/02/2020 I modify the reading lines of the sensors, because so far I only print in Monitor Series the text, not the data

06/02/2020 debugging the code a bit, and modifying the code header

08/02/2020 corrects the reading error in the sensors, and corrects the writing of the Series Monitor

12/02/2020 to be able to add any code you have to follow specific programming rules
The structure of the code is modified according to those programming orders, based on the information obtained and stored
In the 01_UNIR_2_CODIGOS folder
Several blocks are created in the void loop, for the operation of each of the sensors, eliminating the delay()

13/02/2020 temperature sensor DS18B20 is included, assisted by DEA of [www.cambatronics.com](https://ssl.microsofttranslator.com/bv.aspx?ref=TAns&from=&to=en&a=www.cambatronics.com)

16/02/2020 E18-D80NK infrared distance sensor added, no errors
and I get to adapt a code to read the pressure sensor SKU237545

08/03/2020 a relay is connected on pin 12 of the Arduino Slave, to turn on the external light bulbs, there is no need to change the code

26/03/2020 The MPU6050 library is included to control the gyroscope
Fixed data sending, separating the data from the Serial Monitor, and the data to be sent to the Arduino Maestro,
initiating two serial ports with orders

Serial.begin(57600); USB Series Port

Serial1.begin(57600); Serial port on pins 18 and 19

ETin.begin(details(rxdata), &Serial1); Data reception begins through Serial, at pins 18 and 19

ETout.begin(details(txdata), &Serial1); Start sending data through Serial, at pins 18 and 19

28/03/2020 All control instructions are included, to have all buttons operational (not working)

03/04/2020 The new part of the MPU6050 Gyroscope is included, showing the 3 tilt axes, plus the temperature of the Gyroscope.
Included is the second pressure sensor

05/04/2020 the code of the infrared sensor E18D80NK is changed, to a better one

11/04/2020 I correct the code according to the instructions of my friend Atilano Belinchón

13/04/2020 I correct the readings and send data from the E18D80NK infrared sensor

15/04/2020 Steering servo is included to operate it with the R1 and R2 buttons on the controller
based on information obtained from the website

[https://arduparatodos.blogspot.com/2017/02/controlar-servomotor-con-arduino-varios.html](https://ssl.microsofttranslator.com/bv.aspx?ref=TAns&from=&to=en&a=https%3A%2F%2Farduparatodos.blogspot.com%2F2017%2F02%2Fcontrolar-servomotor-con-arduino-varios.html)

18/04/2020 Some "if" are changed to "else if" to give the code agility, following the DEA instructions in [www.cambatronics.com](https://ssl.microsofttranslator.com/bv.aspx?ref=TAns&from=&to=en&a=www.cambatronics.com)

Between 24/03/2020 and 28/04/2020, several code changes are made to improve it and make the controller work,
Following the instructions of bigbadbob in the forum posts

[http://www.homebuiltrovs.com/rovforum/viewtopic.php?f=18&t=1908](https://ssl.microsofttranslator.com/bv.aspx?ref=TAns&from=&to=en&a=http%3A%2F%2Fwww.homebuiltrovs.com%2Frovforum%2Fviewtopic.php%3Ff%3D18%26t%3D1908)

From page 4

28/04/2020 Corrects the spelling of all text that are not orders

03/05/2020 Pin assignments are changed, according to Github code

The new pin assignments are:

3.3V output to red PS2 PIN
Pin 24 to PS2 yellow PIN + 1k resistance
Pin 23 to PIN Orange PS2
Pin 25 to PIN brown PS2 + 1k resistance
Pin 22 to PS2 Blue PIN

Fixed the code to get me out in the Master the state of the spotlights, on/off

04/05/2020 Code is debugged according to Bigbadbob's advice from [http://www.homebuiltrov.com](https://ssl.microsofttranslator.com/bv.aspx?ref=TAns&from=&to=en&a=http%3A%2F%2Fwww.homebuiltrov.com)

05/05/2020 Macro F is included, in all Serial.print, to reduce dynamic memory consumption
According to Bigbadbob's advice from http://www.homebuiltrov.com, but it gives me trouble

06/05/2020 Code is debugged for better performance, according to Bigbadbob's advice from [http://www.homebuiltrov.com](https://ssl.microsofttranslator.com/bv.aspx?ref=TAns&from=&to=en&a=http%3A%2F%2Fwww.homebuiltrov.com)
and the problems with Macro F follow

07/05/2020 Code is debugged for better performance, according to Bigbadbob's advice from [http://www.homebuiltrov.com](https://ssl.microsofttranslator.com/bv.aspx?ref=TAns&from=&to=en&a=http%3A%2F%2Fwww.homebuiltrov.com)
and the problems with Macro F follow

08/05/2020 Fixed Macro F issues in all fixed-text [Serial.prints](https://ssl.microsofttranslator.com/bv.aspx?ref=TAns&from=&to=en&a=Serial.prints)
You can't put Macro F, to [Serial.print](https://ssl.microsofttranslator.com/bv.aspx?ref=TAns&from=&to=en&a=Serial.print) sensor data
And it reduces dynamic memory consumption considerably

09/05/2020 Lines are still corrected for code debugging, according to Bigbadbob's advice from [http://www.homebuiltrov.com](https://ssl.microsofttranslator.com/bv.aspx?ref=TAns&from=&to=en&a=http%3A%2F%2Fwww.homebuiltrov.com)
But the problems with PS2 command continue

10/05/2020 I notice an error in the order to turn on the spotlights and correct it
But the controller still doesn't work properly

11/05/2020 Several button control commands are modified, but the controller still does not work properly

16/05/2020 Various changes are made, according to Tsanshon's advice from [www.foromodelismonaval.es](https://ssl.microsofttranslator.com/bv.aspx?ref=TAns&from=&to=en&a=www.foromodelismonaval.es)

The original version taken as a starting point is as follows

ROVPS2Control_Slavev8.ino
Hamish Trolove - 30 March 2016
[www.techmonkeybusiness.com](https://ssl.microsofttranslator.com/bv.aspx?ref=TAns&from=&to=en&a=www.techmonkeybusiness.com)

This sketch takes the commands that are sent to you from the master drive with the PS2 controller connected and converts it to engine commands,
Servo commands, light controls, etc. The data is sent from the Arduino (master) to the ROV (slave) using Bill Porter's EasyTransfer library via a 9600 baud (100 m anchor) serial link. The MS5803_14 library is by Luke Miller [http://github.com/millerlp](https://ssl.microsofttranslator.com/bv.aspx?ref=TAns&from=&to=en&a=http%3A%2F%2Fgithub.com%2Fmillerlp)

Data sent from the master are raw configurations for the ESC control.

This sketch is designed for an Arduino Nano with a single serial port.

I'm using it on a Mega 2560, and it worked, until I started introducing sensors

For the transmission of the video advisorplaza1 will use a Raspberry Pi 3 plus, a USB camera, and the program VCL Media Player

These sensors are changed to obsolete, dhT22 sensors and the MPU6050 gyroscope are used

Serial communications connection: modified by Adviserplaza1, 26/03/2020, to separate the data sent between Arduinos, from the data to be sent to the Serial Monitor
19 top (TX) to ROV 18 (RX) Serial connection: 18 top (RX) to ROV 19 (TX)
Connect the GND on both

Note that THE ESCs have already been scheduled at this point in the project.

Internal voltage, heading, depth, and internal temperature data are sent via the series link back to the master
For viewing on a 16x2 LCD screen.
The 16x2 LCD display will be replaced by a basic Nextion display of 5"

This sensor is changed to obsolete, the MPU 6050 gyroscope is used

See also how the original project develops with the following codes:
HoryzonTrigger.ino, ROVPS2Control_Masterv0.ino,
ROVDoNothing.ino, ROVSubBv0.ino, DigitalCompassv2.ino,
[PTLoggerv4.ino](https://ssl.microsofttranslator.com/bv.aspx?ref=TAns&from=&to=en&a=PTLoggerv4.ino) and TMP36_Temperature_Sensor.ino.
On the [www.techmonkeybusiness.com](https://ssl.microsofttranslator.com/bv.aspx?ref=TAns&from=&to=en&a=www.techmonkeybusiness.com) page

*/

[asesorplaza1]

// Se ponen todas las librerías juntas
#include <Servo.h>              // librería para gestionar los servos y los ESC
#include <EasyTransfer.h>       // librería Easy Transfer de Bill Porter
#include <Adafruit_Sensor.h>    // librería para gestionar el sensor de temperatura DHT22
#include <DHT.h>                // librería para el sensor DHT 22
#include <OneWire.h>            // librería para el sensor de temperatura DS18B20
#include <DallasTemperature.h>  // Librería para el sensor de temperatura DS18B20
#include <MPU6050.h>            // librería i2c para el Giroscopio ***
#include <PS2X_lib.h>           // Librería para el mando PS2
#include <ESC.h>                // Librería para los ESC

PS2X ps2x;                          // Genera un objeto llamado ps2x
EasyTransfer ETin, ETout;           // Genera los dos objetos de transferencia fácil para Comunicación bidireccional

const int pinDatosDQ = 28;                       // Pin donde se conecta el bus 1-Wire para los sensores de temperatura
OneWire oneWireObjeto(pinDatosDQ);               // Instancia a las clases OneWire y DallasTemperature
DallasTemperature sensorDS18B20(&oneWireObjeto); // Instancia a las clases OneWire y DallasTemperature

// #define F(string_literal) (reinterpret_cast<const __FlashStringHelper *>(PSTR(string_literal)))

// Se pone toda la identificación de los DHT22 junta

DHT dht(22, DHT22);    // Seleccionamos el pin y tipo de sensor del casco
DHT dht1(24, DHT22);   // Seleccionamos el pin y tipo de sensor del motor derecho
DHT dht2(26, DHT22);   // Seleccionamos el pin y tipo de sensor del motor izquierdo

// Se pone toda la identificación de los ESC y los Servos junta

ESC ESCVL(8, 1000, 2000, 500);           // Genera objeto ESC vertical izquierdo en el pin 8, con el minimo en 1000, maximo en 2000, y armado en 500
ESC ESCVR(7, 1000, 2000, 500);           // Genera objeto ESC vertical derecho en el pin 7, con el minimo en 1000, maximo en 2000, y armado en 500
ESC ESCHL(6, 1000, 2000, 500);           // Genera Objeto ESC Horizontal Izquierdo en el pin 6, con el minimo en 1000, maximo en 2000, y armado en 500
ESC ESCHR(5, 1000, 2000, 500);           // Genera objeto ESC Horizontal Derecho, en el pin 5, con el minimo en 1000, maximo en 2000, y armado en 500
Servo ServoInmersion;           // Genera un objeto llamado ServoDireccion
int angulo = 90;                // Variable para el ángulo, inicia en 90º

// Se pone toda la identificación de los LED indicadores de batería junta

const int RedLEDpin = 13;  // El pin del indicador LED es 13.
const int HeadLts = 34;    // El control de los faros está en el pin 34
const int Voltpin = A7;    // pin analógico utilizado para leer el voltaje de la batería
const int yelLEDpin = 38;  // Pin utilizado como chivato de recibir datos del mando

// Se pone toda la identificación del sistema de refrigeración junta

const int Refrigeracion = 34; // el pin utilizado para encender la bomba de refrigeración es el 34
const int TwarnLEDpin = 36;   // El pin utilizado para el LED de alarma de temperatura es el 36

// Se pone toda la identificación del MPU6050 junta

const int MPU6050_addr = 0x68; // Direction I2C del MPU6050
int16_t AccX, AccY, AccZ, Temp, GyroX, GyroY, GyroZ;

// Se pone toda la parte de lectura de la batería junta

int volts;                          // variable para leer el voltaje del pin analógico
const float RefVolts = 5.0;         // Voltaje de referencia de la placa de 5 voltios en Nano
const float ResistFactor = 319.68;  // Calculado a partir de 1023.0 * (R2 / (R1 + R2)
// Donde R1 = 2200 ohmios y R2 = 1000 ohmios para un voltaje máximo de 15 V.

// Se pone toda la parte del sensor E18D80NK

int pinSensorE18D80NK = 30;   // Se genera el sensor E18D80NK en el pin 30
int pinLedColision = 31;      // Se genera el LED de aviso de peligro colisión en el pin 31
boolean objectDetect = false; // Marca para mostrar si se ha detectado un objeto

// Se generan todos los botones del mando

boolean PSB_PAD_UPstate = false;     // Genera el botón Izquierda arriba al Esclavo
boolean PSB_PAD_DOWNstate = false;   // Genera el botón Izquierda abajo al Esclavo
boolean PSB_PAD_LEFTstate = false;   // El botón Izquierda izquierdo ya esta usado para encender los focos
boolean PSB_PAD_RIGHTstate = false;  // Genera el botón Izquierda derecho al Esclavo
boolean PSB_BLUEstate = false;       // Genera el botón Cruz azul al Esclavo
boolean PSB_GREENstate = false;      // Genera el botón Triangulo verde al Esclavo
boolean PSB_PINKstate = false;       // Genera el botón Cuadrado rosa al Esclavo
boolean PSB_REDstate = false;        // Genera el botón Circulo rojo al Esclavo
boolean PSB_L1state = false;         // Genera el botón Izquierda delante arriba al Esclavo
boolean PSB_L2state = false;         // Genera el botón Izquierda delante abajo al Esclavo
boolean PSB_L3state = false;         // Genera el botón Palo izquierdo abajo al Esclavo
boolean PSB_R1state = false;         // Genera el botón Derecha delante arriba al Esclavo
boolean PSB_R2state = false;         // Genera el botón Derecha delante abajo al Esclavo
boolean PSB_R3state = false;         // Genera el botón Palo derecho abajo al Esclavo

// Se genera un pin de entrada de datos para el sensor de presión SKU237545

int SensorSKU237545_I = 32;  // Sensor de presión Interno
int SensorSKU237545_E = 33;  // Sensor de presión Externo

int intervalodatos = 1000;  // Hace que solo se envíen los valores 1 vez por segundo
// int auxMillis = 0;          // Indica el valor del intervalo de tiempo

// Se pone toda la estructura de recepción de datos junta

struct RECEIVE_DATA_STRUCTURE {
  int upLraw = 0;   // Variables para transportar los datos sin procesar reales de los ESC
  int upRraw = 0;
  int HLraw = 0;
  int HRraw = 0;
  volatile boolean PSB_PAD_UPstate;     // Recibe lectura del botón Izquierda arriba del Maestro
  volatile boolean PSB_PAD_DOWNstate;   // Recibe lectura del botón Izquierda abajo del Maestro
  volatile boolean PSB_PAD_RIGHTstate;  // Recibe lectura del botón Izquierda derecha del Maestro
  volatile boolean PSB_PAD_LEFTstate;   // Recibe lectura del botón Izquierda Izquierda del Maestro
  volatile boolean PSB_BLUEstate;       // Recibe lectura del botón Cruz azul del Maestro
  volatile boolean PSB_GREENstate;      // Recibe lectura del botón Triangulo verde del Maestro
  volatile boolean PSB_PINKstate;       // Recibe lectura del botón Cuadrado rosa del Maestro
  volatile boolean PSB_REDstate;        // Recibe lectura del botón Circulo rojo del Maestro
  volatile boolean PSB_L1state;         // Recibe lectura del botón Delante izquierda arriba del Maestro
  volatile boolean PSB_L2state;         // Recibe lectura del botón Delante izquierda abajo del Maestro
  volatile boolean PSB_L3state;         // Recibe lectura de presión Palo izquierda del Maestro
  volatile boolean PSB_R1state;         // Recibe lectura del botón Delante derecha arriba del Maestro
  volatile boolean PSB_R2state;         // Recibe lectura del botón Delante derecha abajo del Maestro
  volatile boolean PSB_R3state;         // Recibe lectura de presión Palo izquierdo del Maestro
  volatile boolean LEDHdlts;            // Luces LED encendidas / apagadas
};

// Se pone toda la identificación del envío de datos junta

struct  SEND_DATA_STRUCTURE {
  int BattVolt;             // Manda mensaje de datos de voltaje de batería al maestro.
  int t;                    // Manda mensaje de datos de temperatura interior del ROV al Maestro
  int t1;                   // Manda mensaje de datos de temperatura del motor derecho al Maestro
  int t2;                   // Manda mensaje de datos de temperatura del motor izquierdo al Maestro
  int ROVDepth;             // Manda mensaje de datos de lectura de profundidad de ROV (m)
  int ROVHDG;               // Manda mensaje de Dirección del ROV (grados)
  int h;                    // Manda mensaje de humedad al Maestro
  int h1;                   // Manda mensaje de humedad al Maestro del motor derecho
  int h2;                   // Manda mensaje de humedad al Maestro del motor izquierdo
  int AccX;                 // Manda mensaje de datos de inclinación del eje X al Maestro
  int AccY;                 // Manda mensaje de datos de inclinación del eje Y al Maestro
  int AccZ;                 // Manda mensaje de datos de de inclinación del eje Z al Maestro
  int Temp;                 // Manda mensaje de datos de temperatura del giroscopio al Maestro
  int GyroX;                // Manda mensaje de datos de aceleración en el eje X al Maestro
  int GyroY;                // Manda mensaje de datos de aceleración en el eje Y al Maestro
  int GyroZ;                // Manda mensaje de datos de aceleración en el eje Z al Maestro
  int E18D80NK;             // Manda mensaje de lectura del sensor infrarrojo E18-D80NK
  int pinLedColision;       // Manda mensaje de encender alarma de colisión
  int sensorDS18B20;        // Manda mensaje de lectura del sensor de temperatura DS18B20
  int pressure_bar;         // Manda mensaje de lectura del sensor de presión SKU237545 Interno en Bares
  int pressure_psi;         // Manda mensaje de lectura del sensor de presión SKU237545 Interno en PSI
  int pressure_bar1;        // Manda mensaje de lectura del sensor de presión SKU237545 Interno en Bares
  int pressure_psi1;        // Manda mensaje de lectura del sensor de presión SKU237545 Interno en PSI
};

RECEIVE_DATA_STRUCTURE rxdata; // Dar un nombre al grupo de datos recibidos
SEND_DATA_STRUCTURE txdata;    // Dar un nombre al grupo de datos enviados

void setup()
{

  // Se pone todo lo referente a la comunicación junta

  Wire.begin ();                           // Comienza la comunicación i2c

  Serial.begin(9600);                       // Comienza la Comunicación Serie para hablar con el ordenador a 9600 baudios
  Serial1.begin(9600);                     // Comienza la Comunicación Serie en el puerto 1, pines 18 y 19, para hablar con el Arduino Maestro
  Serial1.flush();                         // Depura la información del Puerto Serie
  ETin.begin(details(rxdata), & Serial1);  // Comienza la recepción de datos a través de Serial, en los pines 18 y 19
  ETout.begin(details(txdata), & Serial1); // Comienza el envío de datos a través de Serial, en los pines 18 y 19
  sensorDS18B20.begin();                   // Comienza el trabajo del sensor DS18B20

  // Se define el inicio del LED y de los Focos

  pinMode(RedLEDpin, OUTPUT);
  pinMode(HeadLts, OUTPUT);
  digitalWrite(HeadLts, LOW);  // Establezca los faros en Off
  digitalWrite(RedLEDpin, LOW);

  // Se inician los ESC y se define en que pin actúa cada uno
  ESCVL.arm();         // Inicia el ESCVL
  ESCVR.arm();         // Inicia el ESCVR
  ESCHL.arm();         // Inicia el ESCHL
  ESCHR.arm();         // Inicia el ESCHR

  // Esto hay que comprobarlo
  // Debido a problemas con el ESC que reconoce el máximo posición en la configuración predeterminada, las cifras después de
  // El número de pin son las señales de microsegundos para el mínimo y máximo que el ESC reconocerá, 600 y 2250 trabajo.

  ServoInmersion.attach(4); // Adjunte el servo de dirección al pin 4
  ServoInmersion.write(90); // Posiciona el servo inicialmente en la mitad (90°)

  // Se inician y se manda a imprimir la prueba de funcionamiento de los sensores DHT22
  dht.begin();  // Inicia el trabajo del sensor DHT22 del casco
  Serial.println (F(" \n Probando sensor DHT22 casco!"));
  dht1.begin(); // Inicia el trabajo del sensor DHT22 del motor derecho
  Serial.println (F(" \n Probando sensor DHT22 motor DR!"));
  dht2.begin(); // Inicia el trabajo del sensor DHT22 del motor izquierdo
  Serial.println (F(" \n Probando sensor DHT22 motor IZ!"));

  // Se inician los pines del sensor y de la alarma
  pinMode(pinSensorE18D80NK, INPUT_PULLUP); // Definir pin como sensor de entrada
  pinMode(pinLedColision, OUTPUT); // Definir pin como SALIDA para ACTION

  // Se inicia el pin del sensor de presión SKU237545 Interno
  pinMode (SensorSKU237545_I, INPUT);

  // Se inicia el pin del sensor de presión SKU237545 Externo
  pinMode (SensorSKU237545_E, INPUT);

  // Proceso para iniciar el giroscopio MPU6050
  Wire.begin();
  Wire.beginTransmission(MPU6050_addr);
  Wire.write(0x6B);
  Wire.write(0);
  Wire.endTransmission(true);

  delay (200);
}

void loop ()
{

  if (ETin.receiveData());    // Recibe los datos al puerto serie para el ROV
  {
    Serial.print (F("\n Datos recibidos del Meastro.."));
  }
  loop_ESC();             // Bloque de trabajo de los ESC de los motores
  loop_Luces();           // Bloque de trabajo de los focos
  loop_Voltaje();         // Bloque de trabajo para medir el voltaje de la batería
  loop_DHT22();           // Bloque de trabajo de los sensores de temperatura y humedad DHT22
  loop_MPU6050();         // Bloque de trabajo del Giroscopio
  loop_SensorE18D80NK();  // Bloque de trabajo del sensor de infrarrojos
  loop_DS18B20();         // Bloque de trabajo del sensor de temperatura DS18B20
  loop_SKU237545_I();     // Bloque de trabajo del sensor de presión interno
  loop_SKU237545_E();     // Bloque de trabajo del sensor de presión externo
  loop_ServoInmersion();  // Bloque de trabajo del servo

  PSB_PAD_UPstate = (rxdata.PSB_PAD_UPstate);         // Recibe lectura del botón Izquierda arriba al Esclavo
  PSB_PAD_DOWNstate = (rxdata.PSB_PAD_DOWNstate);     // Recibe lectura del botón Izquierda abajo al Esclavo
  PSB_PAD_LEFTstate = (rxdata.PSB_PAD_LEFTstate);     // Recibe lectura del botón Izquierda Izquierda al Esclavo
  PSB_PAD_RIGHTstate = (rxdata.PSB_PAD_RIGHTstate);   // Recibe lectura del botón Izquierda derecho al Esclavo
  PSB_BLUEstate = (rxdata.PSB_BLUEstate);             // Recibe lectura del botón Cruz azul al Esclavo
  PSB_GREENstate = (rxdata.PSB_GREENstate);           // Recibe lectura del botón Triangulo verde al Esclavo
  PSB_PINKstate = (rxdata.PSB_PINKstate);             // Recibe lectura del botón Cuadrado rosa al Esclavo
  PSB_REDstate = (rxdata.PSB_REDstate);               // Recibe lectura del botón Circulo rojo al Esclavo
  PSB_L1state = (rxdata.PSB_L1state);                 // Recibe lectura del botón Izquierda delante arriba al Esclavo
  PSB_L2state = (rxdata.PSB_L2state);                 // Recibe lectura del botón Izquierda delante abajo al Esclavo
  PSB_L3state = (rxdata.PSB_L3state);                 // Recibe lectura del botón Palo izquierdo abajo al Esclavo
  PSB_R1state = (rxdata.PSB_R1state);                 // Recibe lectura del botón Derecha delante arriba al Esclavo
  PSB_R2state = (rxdata.PSB_R2state);                 // Recibe lectura del botón Derecha delante abajo al Esclavo
  PSB_R3state = (rxdata.PSB_R3state);                 // Recibe lectura del botón Palo derecho abajo al Esclavo

  // No me deja generar un bloque de trabajo para los botones del mando
  // Por eso los pongo dentro del void loop genérico

  if (rxdata.PSB_PAD_UPstate)
    // Si presionamos el botón izquierda arriba
  {
    digitalWrite(yelLEDpin, HIGH);
    // Enciende el Led Amarillo
  }

  if (rxdata.PSB_PAD_DOWNstate)
    // Si presionamos el botón izquierda abajo
  {
    digitalWrite(yelLEDpin, HIGH);
    // Enciende el Led Amarillo
  }

  if (rxdata.PSB_PAD_RIGHTstate)
    // Si presionamos el botón izquierda derecha
  {
    digitalWrite(yelLEDpin, HIGH);
    // Enciende el Led Amarillo
  }

  if (rxdata.PSB_GREENstate)
    // Si presionamos triangulo verde
  {
    digitalWrite(yelLEDpin, HIGH);
    // Enciende el Led Amarillo
  }

  if (rxdata.PSB_REDstate)
    // Si presionamos el círculo rojo
  {
    digitalWrite(yelLEDpin, HIGH);
    // Enciende el Led Amarillo
  }

  if (rxdata.PSB_BLUEstate)
    // Si presionamos el cruz azul
  {
    digitalWrite(yelLEDpin, HIGH);
    // Enciende el Led Amarillo
  }

  if (rxdata.PSB_PINKstate)
    // Si presionamos el cuadrado rosa
  {
    digitalWrite(yelLEDpin, HIGH);
    // Enciende el Led Amarillo
  }

  if (rxdata.PSB_L1state)
    // Si presionamos el botón L1
  {
    digitalWrite(yelLEDpin, HIGH);
    // Enciende el Led Amarillo
  }

  if (rxdata.PSB_L2state)
    // Si presionamos el botón L2
  {
    digitalWrite(yelLEDpin, HIGH);
    // Enciende el Led Amarillo
  }

  if (rxdata.PSB_R1state)
    // Si presionamos el botón R1
  {
    // Enciende / apaga las luces
    digitalWrite(yelLEDpin, HIGH);
    // Enciende el Led Amarillo
  }

  if (rxdata.PSB_R2state)
    // Si presionamos el botón R2
  {
    // Enciende / apaga las luces
    digitalWrite(yelLEDpin, HIGH);
    // Enciende el Led Amarillo
  }

  if (rxdata.PSB_L3state)
    // Si presionamos el joystick izquierdo hacia abajo
  {
    digitalWrite(yelLEDpin, HIGH);
    // Enciende el Led Amarillo
  }

  if (rxdata.PSB_R3state)
    // Si presionamos el joystick derecho hacia abajo
  {
    digitalWrite(yelLEDpin, HIGH);
    // Enciende el LED Amarillo
  }

}

void loop_ESC() { // Bloque de trabajo de los ESC de los motores

  // Haremos algo correctamente con los datos devueltos en un
  ESCVL.speed(rxdata.upLraw);   // Establezca la señal ESCVL en la posición del acelerador definida.
  ESCVR.speed(rxdata.upRraw);   // Establezca la señal ESCVR en la posición del acelerador definida.
  ESCHL.speed(rxdata.HLraw);    // Establezca la señal ESCHL en la posición del acelerador definida.
  ESCHR.speed(rxdata.HRraw);    // Establezca la señal ESCHR en la posición del acelerador definida.

}

void loop_ServoInmersion() {         // Bloque de trabajo del Servo de Inmersión

  if (rxdata.PSB_R1state == LOW)
    // Aumenta el ángulo mientras se mantenga presionado
  {
    angulo++;
    if (angulo >= 180)
    {
      angulo = 180;
      // El ángulo no aumenta más allá de 180 grados
      Serial.print (F(" \n Subiendo ROV a superficie "));
    }
  }
  else if (rxdata.PSB_R2state == LOW)
    // Disminuye el ángulo mientras se mantenga presionado
  {
    angulo--;
    if (angulo <= 0)
    {
      angulo = 0;
      // El ángulo no disminuye mas allá de 0 grados
      Serial.print (F("\n Inmersion ROV a profundidad "));
    }
  }
  ServoInmersion.write(angulo);
  // Manda el ángulo al servo dependiendo del pulsador presionado
  //  delay(10);
}

void loop_Luces() { // Bloque de trabajo de los focos
  digitalWrite(HeadLts, rxdata.LEDHdlts);
  // Enciende los faros en función del retraso de los datos del mensaje
  if (rxdata.LEDHdlts > 0) {
    digitalWrite(HeadLts, LOW);
    Serial.print (F(" \n Focos apagados "));
  }
  else {
    (rxdata.LEDHdlts < 0);
    digitalWrite(HeadLts, HIGH);
    Serial.print (F(" \n Focos encendidos "));
  }
}

void loop_Voltaje() { // Bloque de trabajo de medición de voltaje de la batería

  volts = analogRead(Voltpin) / ResistFactor * RefVolts * 10; // Lee el voltaje
  // De la batería a través del divisor de voltaje. Factor de 10 utilizado
  // Para ayudar a lograr un número entero con una precisión de 0.1V.
  // Factor 10 utilizado para obtener precisión adicional del valor entero y luego se muestra con 1 decimal
  txdata.BattVolt = volts;  // Enviar de vuelta el voltaje de la batería a bordo.
  Serial.print (F(" \n Voltaje del ROV = "));
  Serial.print(volts);

}

void loop_DHT22() { // Bloque de trabajo de los sensores DHT22

  float h = dht.readHumidity();
  // Lectura de Humedad desde el sensor DHT22 del interior del ROV
  float t = dht.readTemperature();
  // Lectura de Temperatura desde el sensor DHT22 del interior del ROV
  float h1 = dht1.readHumidity();
  // Lectura de Humedad desde el sensor DHT22 del motor derecho
  float t1 = dht1.readTemperature();
  // Lectura de Temperatura desde el sensor DHT22 del motor derecho
  float h2 = dht2.readHumidity();
  // Lectura de Humedad desde el sensor DHT22 del motor izquierdo
  float t2 = dht2.readTemperature();
  // Lectura de Temperatura desde el sensor DHT22 del motor izquierdo
  int intervaloMedidas = 1000;
  // Hace que solo se lean los valores 1 vez por segundo
  unsigned long auxMillis = 0;
  // Indica el valor del intervalo de tiempo

  // Comprueba si hay fallo en todas las lecturas y sale rápido y prueba otra vez
  if (isnan(h) || isnan(t)) {
    Serial.print (F(" \n Fallo de lectura desde el sensor DHT del Casco!"));
    return;
  }
  else if (isnan(h1) || isnan(t1)) {
    Serial.print (F(" \n Fallo de lectura desde el sensor DHT del motor DR!"));
    return;
  }
  else if (isnan(h2) || isnan(t2)) {
    Serial.print (F(" \n Fallo de lectura desde el sensor DHT del motor IZ!"));
    return;
  }
  else if (( millis() - auxMillis) > intervaloMedidas) {
    txdata.t = t;   // Envía al Maestro la temperatura leída en el casco
    txdata.h = h;   // Envía al Maestro la humedad leída en el casco
    txdata.t1 = t1; // Envía al Maestro la temperatura leída en el motor derecho
    txdata.h1 = h1; // Envía al Maestro la humedad leída en el motor derecho
    txdata.t2 = t2; // Envía al Maestro la temperatura leída en el motor izquierdo
    txdata.h2 = h2; // Envía al Maestro la humedad leída en el motor izquierdo
    auxMillis = millis();
  }
  else if (t > 40 || t1 > 40 || t2 > 40)
  {
    // Si la temperatura de cualquiera de los sensores DHT22 es demasiado alta (más de 40 grados C)
    // Enciende el LED de advertencia
    digitalWrite(TwarnLEDpin, HIGH);
    // Enciende la bomba de refrigeración
    digitalWrite(Refrigeracion, HIGH);
    // Escribe el texto
    Serial.print (F(" \n TEMPERATURA ELEVADA !"));
  }
  Serial.print (F(" \n Temperatura en el casco = "));
  Serial.print (t);
  Serial.print (F(" *C "));
  Serial.print (F(" \n Temperatura en el motor DR = "));
  Serial.print (t1);
  Serial.print (F(" *C1 "));
  Serial.print (F(" \n Temperatura en el motor IZ = "));
  Serial.print (t2);
  Serial.print (F(" *C2 "));
  Serial.print (F(" \n Humedad en el Casco = "));
  Serial.print (h);
  Serial.print (F(" %\t"));
  Serial.print (F(" \n Humedad en el motor DR = "));
  Serial.print (h1);
  Serial.print (F(" %\t"));
  Serial.print (F(" \n Humedad en el motor IZ = "));
  Serial.print (h2);
  Serial.print (F(" %\t"));

}

void loop_MPU6050() {  // Bloque de trabajo del giroscopio

  Wire.beginTransmission(MPU6050_addr);
  Wire.write(0x3B);
  Wire.endTransmission(false);
  Wire.requestFrom(MPU6050_addr, 14, true);
  AccX = Wire.read() << 8 | Wire.read();
  AccY = Wire.read() << 8 | Wire.read();
  AccZ = Wire.read() << 8 | Wire.read();
  Temp = Wire.read() << 8 | Wire.read();
  GyroX = Wire.read() << 8 | Wire.read();
  GyroY = Wire.read() << 8 | Wire.read();
  GyroZ = Wire.read() << 8 | Wire.read();

  txdata.AccX = AccX;
  txdata.AccY = AccY;
  txdata.AccZ = AccZ;
  txdata.Temp = Temp;
  txdata.GyroX = GyroX;
  txdata.GyroY = GyroY;
  txdata.GyroZ = GyroZ;

  Serial.print (F(" \n Inclinación del eje X del ROV = "));
  Serial.print (AccX);
  Serial.print (F(" \n Inclinación del eje Y del ROV = "));
  Serial.print (AccY);
  Serial.print (F(" \n Inclinación del eje Z del ROV = "));
  Serial.print (AccZ);
  Serial.print (F(" \n Temperatura del Giro MPU6050 = "));
  Serial.print (Temp / 340.00 + 36.53);
  Serial.print (F(" \n Aceleración del Giro MPU6050 = "));
  Serial.print (GyroX);
  Serial.print (F(" \n Aceleración del Giro MPU6050 = "));
  Serial.print (GyroY);
  Serial.print (F(" \n Aceleración del Giro MPU6050 = "));
  Serial.print(GyroZ);

  // Serial.print(" \n Dirección del ROV = ");
  //  Serial.print(rxdata.ROVHDG);  // muestra la dirección del ROV en una brújula

  Wire.endTransmission(MPU6050_addr); //

}

void loop_SensorE18D80NK() { // Bloque de trabajo del sensor infrarrojo

  int E18D80NK = digitalRead(pinSensorE18D80NK); // leer el Sensor

  if (E18D80NK > 0) {
    Serial.println (F(" \n Todo despejado"));
    digitalWrite(pinLedColision, LOW); // encender el LED de peligro
  }
  else {
    Serial.println (F(" \n Peligro Objeto detectado"));
    digitalWrite(pinLedColision, HIGH); // Apagar el LED de peligro
  }
  txdata.E18D80NK = E18D80NK;
}

void loop_DS18B20() {  // Bloque de trabajo del sensor de temperatura DS18B20

  sensorDS18B20.requestTemperatures();
  Serial.print (F("\n Temperatura sensor DS18B20 = "));
  Serial.print (sensorDS18B20.getTempCByIndex(0));
  Serial.print (F(" ºC"));
  txdata.sensorDS18B20 = sensorDS18B20.getTempCByIndex(0);
}

void loop_SKU237545_I() { // Bloque de trabajo del sensor de presión interno

  SensorSKU237545_I = analogRead(32);
  float voltage = (SensorSKU237545_I * 5.0) / 1024.0;
  float pressure_pascal = (3.0 * ((float)voltage - 0.475)) * 1000000.0;  //calibrar aquí
  float pressure_bar = pressure_pascal / 10e5;
  float pressure_psi = pressure_bar * 14.5038;
  Serial.print (F(" \n Valor del Sensor de Presión Interno =  "));
  Serial.print (SensorSKU237545_I);
  Serial.print (F(" \n Presión en Bar = "));
  Serial.print (pressure_bar);
  Serial.print (F("    bars"));
  Serial.print (F(" \n Presión en PSI = "));
  Serial.print (pressure_psi);
  Serial.print (F("   psi"));
  txdata.pressure_bar = pressure_bar;
  txdata.pressure_psi = pressure_psi;
}

void loop_SKU237545_E() {  // bloque de trabajo del sensor de presión externo

  SensorSKU237545_E = analogRead(32);
  float voltage1 = (SensorSKU237545_E * 5.0) / 1024.0;
  float pressure_pascal1 = (3.0 * ((float)voltage1 - 0.475)) * 1000000.0;  //calibrar aquí
  float pressure_bar1 = pressure_pascal1 / 10e5;
  float pressure_psi1 = pressure_bar1 * 14.5038;
  Serial.print (F(" \n Valor del Sensor de Presión Externo = "));
  Serial.print (SensorSKU237545_E);
  Serial.print (F(" Presión en Bar = "));
  Serial.print (pressure_bar1);
  Serial.print (F("    bars"));
  Serial.print (F(" \n Presión en PSI = "));
  Serial.print (pressure_psi1);
  Serial.print (F("   psi"));
  Serial.print (F(" \n Profundidad = "));
  txdata.pressure_bar1 = pressure_bar1;
  txdata.pressure_psi1 = pressure_psi1;

  // Serial.print(rxdata.ROVDepth);
  // Muestra en el Display la profundidad del ROV en metros


  ETout.sendData ();     // Envía los datos al puerto serie para el ROV Arduino

}

[asesorplaza1]

Y hasta aquí mis explicaciones de hoy, mañana os pondré mas cosas que ya es muy tarde.
El principal problema que tengo es que no consigo que el Arduino reaccione a las instrucciones del mando de PS2, y que no se como depurar el código con PIO.
Un saludo a todos.

And so far my explanations today, tomorrow I will put you more things that is too late.

The main problem I have is that I can’t get the Arduino to react to the PS2 command instructions, and I don’t know how to debug the code with PIO.

Greetings to all.

[maxgerhardt]

With all due respect, the comment / header files you’ve posted are totalling 31,474 characters in total for your explanations. I doubt someone will fully read that to try and reproduce the problem, along with the sketches which have circa 1000 lines of code. That’s the wrong approach. Let’s try and get to the bottom of the problem more easily.

@asesorplaza1

I have managed to make two programs with Arduino, which do not finish working as well as they should, and consulting in other forums dedicated to the construction of models, have indicated to me, that the best way to get to debug the codes, is by using the Platform-IO environment.

Indeed PlatformIO has easy debugging capabilities – for certain platforms. PlatformIO does currently not support live-debugging of a real AVR target CPU, which your Arduino Mega 2560 has. Live-debugging is available for other core types like ARM cores (STM32, nRF51, nRF52, Atmel SAM, NXP, …), XTensa cores (ESP32) or RISC-V cores.

However, PlatformIO has recently added support for using an AVR simulator (refer Atmel AVR dev/platform v2.1.0: new boards, AVR simulator, updated Arduino cores). But again with this simulator you would have to also simulate the PSX input, which isn’t really feasable in your specific case.

@asesorplaza1

the Atom program, as an editor

The Atom PlatformIO plugin is not recommended anymore, VSCode should be used instead – refer PlatformIO IDE — PlatformIO latest documentation.

Anyway, let’s focus on the real problem here.

@asesorplaza1

But I don’t know why I can’t send PS2 command orders from one Arduino to another.

Instead of pushing more code in a complicated 500 line sketch, start with the absolute minimal example of what you want to achieve.

It seems to me that you’re tyring to use the EasyTransfer library in order to send and receive messages (bidirectionally) between your two Arduinos via their Serial1 interfaces.

So you should first test the library’s minimal sketch for a transmitter and receiver. These are located in Arduino-EasyTransfer/EasyTransfer/examples at master · madsci1016/Arduino-EasyTransfer · GitHub in the folders EasyTransfer_RX_Example and EasyTransfer_TX_Example.

These examples make the transmitter (TX) choose a new random value every 5 seconds which describes the number of times (and delay) the onboard LED (13) should be blinked. The receivers should receive that message and do the same.

You can take that code and change all Serial occurences to Serial1 so that you have your target hardware layout. Double check that the Serial TX of one board goes to the RX of the other board and vice-versa, and that common GND is established (TX->RX, RX->TX, GND->GND). See the pinout. Then see if the sketch works or add additional debugging (Serial.println(...)) at some interesting places or for certain variables. Work on the code or ask questions until the first minimal example works succesfully.

Also you should think about modularizing your code. Your first sketch has two functions – setup() and loop(), and in those you do at least 5 different tasks (reading gamepad, preparing transmission data, reading sensors, reacting on sensor data, receing data, …). That is considered bad code practice. Not only can you use different functions to split the work but also use different files or C++ classes. Both Arduino IDE and PlatformIO support splitting code over multiple files.

[asesorplaza1]

Buenas tardes.

Lo primero que tengo que hacer es darle las gracias por su tiempo y por sus indicaciones, que sin duda, son de gran valor para mí.

Resulta muy difícil pedir ayuda sobre un proyecto, si no se explica de alguna manera, y también resulta muy difícil explicar un proyecto de más de 4 años de investigación, en muy pocas líneas. Por lo que le pido disculpas por la extensión de mis comentarios. Pero si necesito su ayuda, también necesito explicarle todos mis problemas desde el principio.

Le cuento un poco mi historia, para ponerle en antecedentes, y aclararle varias cosas sobre mí, y sobre mi proyecto.

Estoy metido en este proyecto desde el 2.016, que me surgió la idea después de leer varias páginas de Internet, donde explicaban cómo hacer proyectos de vehículos con Arduino, donde explicaban más o menos, tanto el proceso de construcción de la parte exterior del vehículo, como el programa de control con Arduino, pero a todas las paginas les falta algo por explicar, quizás esa última y definitiva, actualización del proyecto.

Pero yo no sabía, que a todas las paginas les faltaba la última actualización para que el proyecto funcionase como es debido, a esa conclusión he llegado a base de iniciar proyectos y no poder terminarlos, por falta de un ultimo empujón, aclarando los pormenores de los “errores”, o problemas de programación.

Lo primero que he hecho siempre, es informarme como funciona cualquier sensor, o parte del proyecto utilizado, por separado, y después de tener éxito en el funcionamiento de ese código solo para el funcionamiento de ese componente en concreto, lo he juntado al código de control del ROV, con el resto de instrucciones que funcionaban juntas.

Le cuento todo esto, para explicarle, que no he iniciado un código de 700 líneas, de inicio, si no que he llegado a esas 700 líneas poco a poco, sumando códigos que funcionaban.

Hasta que he llegado al punto, en que no entiendo, porque si el código solo funciona, y he adjuntado todas las líneas al código de control, este código de control, no funciona tan bien como funciona solo. He llegado a la conclusión de que estaba forzando las posibilidades del Arduino Mega 2560, pero esta conclusión se queda sin consistencia, cuando descubrí los códigos de las impresoras 3D, con más de 5.000 líneas de código, eso sí es llegar al límite de las posibilidades de Arduino, y no lo que yo estoy haciendo.

Otro de los problemas más importantes que he tenido, es que me he registrado en varios foros de construcción de modelos similares a mi proyecto, en los que hay verdaderos artistas y “manitas”, en la construcción de modelos, pero no he encontrado a ningún programador experimentado que de verdad, que supiera realmente lo que estaba aconsejándome, y en vez de ayudarme a arreglar el código, lo hemos terminado de estropear.

Por ejemplo hay una línea que me han dicho de quitar varias veces, porque estaba leyendo la estructura del programa 5 veces, y estorbaba en el código, es esta:

for (int i = 0; i < 5; i++) {}

Cuando de verdad lo que hace esta línea, es ayudar a la librería EasyTransfer, en la comunicación de los dos Arduinos, alternando cada 5 segundos, el estado de Arduino, entre la Lectura de datos, y el envió de datos.

Hasta ahora la explicación que tiene más sentido, es la suya, no la que me han dado otros con la intención de ayudar. Y posiblemente ese sea unos de los errores de programación, que impiden que el programa funcione bien.

En cuanto a los problemas de PIO con Atom, ya he leído en este foro, que casi nadie utiliza Atom, todos utilizan otro entorno, lo que me ha llevado a pensar en cambiar de plataforma en este momento, antes de aprender a utilizar algo que no me va a ser de utilidad, por lo tanto voy a cambiar inmediatamente Atom, por VSCode.

Y en cuanto a los problemas de Arduino con PIO, también he leído en este foro que causa bastantes quebraderos de cabeza solucionar algunos problemas de programación, y hay que utilizar parches o comandos de compatibilidad, que no entiendo, y no soy capaz de adoptar.

Ya he comprado y estoy esperando que me lleguen próximamente, unas placas ESP32, con las que será más fácil depurar los programas, sin perder la compatibilidad con Arduino.

Algo que verdaderamente me preocupa, es su comentario sobre el mando de PS2, que no sé cómo debo interpretar esto

“también tendría que simular la entrada de PSX, lo cual no es realmente factible en su caso específico.”

Usted me quiere decir que no voy a poder usar el mando de PS2 con PIO, de ninguna manera, aunque use otro tipo de placa.

O me quiere decir que no puedo usar el mando con Arduino en PIO, con la configuración que tengo ahora mismo.

De no poder usar este tipo de mando PSX, ¿Qué otro tipo de mando para control puedo utilizar para sustituirlo?

Por supuesto que tengo cruzados los pines TX y RX de un Arduino con el otro, es uno de los primeros errores que se cometen, y que ya solucione hace tiempo, pero gracias por su observación al respecto.

En su último párrafo no sé lo que me quiere decir, entiendo que me está diciendo que se realizan demasiadas tareas en el programa, y que tendría que dividirlo en varias funciones o archivos.

¿Cómo?

Mientras usted me contesta, voy a intentar averiguar algo sobre esto en Internet, pero dado mi experiencia en otras dudas, creo que solo voy a conseguir confundirme más de lo que ya estoy, pero aun así, voy a intentarlo, aunque solo voy a adoptar los consejos que usted me diga.

Muchas gracias por sus consejos y observaciones.

Espero que no se desanime con mis comentarios tan extensos, y siga ayudándome, muchas gracias.

Un saludo

Good afternoon.

The first thing I have to do is thank you for your time and for your directions, which are undoubtedly of great value to me.

It is very difficult to ask for help on a project, if not explained in any way, and it is also very difficult to explain a project of more than 4 years of research, in very few lines. So I apologize for the extension of my comments. But if I need your help, I also need to explain all my problems from the beginning.

I tell you a little bit about my story, to put you in the background, and clarify several things about me, and about my project.

I have been involved in this project since 2.016, which came up with the idea after reading several pages of the Internet, where they explained how to do vehicle projects with Arduino, where they explained more or less, both the process of construction of the outside of the vehicle, and the control program with Arduino, but all the pages are missing something to explain , perhaps that last and definitive, project update.

But I did not know, that all the pages lacked the last update for the project to work as it should, that conclusion I have come to start projects and not be able to finish them, for lack of a last push, clarifying the details of the “errors”, or programming problems.

The first thing I have always done is to inform myself how any sensor, or part of the project used, works, separately, and after succeeding in the operation of that code just for the operation of that particular component, I have put it together to the ROV control code, with the rest of instructions that worked together.

I tell you all this, to explain, that I have not started a code of 700 lines, starting, but that I have reached those 700 lines gradually, adding codes that worked.

Until I’ve reached the point, where I don’t understand, because if the code only works, and I’ve attached all the lines to the control code, this control code, doesn’t work as well as it works alone. I have come to the conclusion that I was forcing the possibilities of the Arduino Mega 2560, but this conclusion runs out of consistency, when I discovered the codes of 3D printers, with more than 5,000 lines of code, that is to reach the limit of Arduino’s possibilities, and not what I am doing.

Another of the most important problems that I have had, is that I have registered in several forums of construction of models similar to my project, in which there are real artists and “handymen”, in the construction of models, but I have not found any experienced programmers who really, who really knew what was advising me, and instead of helping me fix the code, we have finished spoiling it.

For example there is a line that I have been told to remove several times, because I was reading the structure of the program 5 times, and I was in the way in the code, it is this:

for (int i = 0; i < 5; i++) {}

When what this line really does, is to help the EasyTransfer library, in the communication of the two Arduinos, alternating every 5 seconds, the state of Arduino, between Data Reading, and data sending.

So far the explanation that makes the most sense is yours, not the one given to me by others with the intention of helping. And possibly that’s some of the programming errors, which prevent the program from working well.

As for the problems of PIO with Atom, I have already read in this forum, that almost no one uses Atom, everyone uses another environment, which has led me to think about changing platforms at this time, before learning to use something that will not be useful to me, therefore I will immediately change Atom, by VSCode.

And as for the problems of Arduino with PIO, I have also read in this forum that causes quite a few headaches to fix some programming problems, and you have to use patches or compatibility commands, which I do not understand, and I am not able to adopt.

I have already purchased and am waiting for to arrive soon, ESP32 boards, with which it will be easier to debug the programs, without losing compatibility with Arduino.

One thing that really worries me is your comment on the PS2 command, which I don’t know how I should interpret this

“you would also have to simulate PSX input, which is not really feasible in your specific case.”

You want to tell me that I won’t be able to use the PS2 controller with PIO, in any way, even if I use another type of board.

Or it means that I can’t use the controller with Arduino in PIO, with the settings I have right now.

If I can’t use this type of PSX controller, what other type of control controller can I use to replace it?

Of course I have crossed the TX and RX pins of one Arduino with the other, it is one of the first mistakes that are made, and that already solved a long time ago, but thank you for your observation about it.

In your last paragraph I don’t know what you mean, I understand that you’re telling me that too many tasks are done in the program, and that I would have to divide it into various functions or files.

How?

While you answer me, I’m going to try to find out something about this on the Internet, but given my experience in other doubts, I think I’m only going to get more confused than I already am, but I’m still going to try, even though I’m just going to adopt the advice you tell me.

Thank you very much for your advice and observations.

I hope you will not be discouraged by my very extensive comments, and continue to help me, thank you very much.

A greeting

[asesorplaza1]

Buenas noches.

Ya he desinstalado todo el paquete de Atom, y he instalado todo el entorno Visual Studio Code.

Me resulta mucho más difícil trabajar con este entorno, que con Atom.

Con Atom, no me daba problemas de la placa, y con VSC, no me deja compilar los programas, me da el siguiente error, cuando pulso Run > Start debugging

Could not find the specified task

Y las opciones son estas

Configure task, Open launch.json, Cancel

Con Arduino, los programas compilan

Good night.

I’ve already uninstalled the entire Atom package, and I’ve installed the entire Visual Studio Code environment.

I find it much harder to work with this environment than with Atom.

With Atom, it gave me no board problems, and with VSC, it won’t let me compile the programs, it gives me the following error, when I hit Run > Start debugging

Could not find the specified task

And the options are these

Configure task, Open launch.json, Cancel

With Arduino, programs compile

Arreglado con esta publicación
Fixed with this post.

Can't start Unified debugger in VS Code

Hi, I have set up the PIO Unified debugger, using an ESP-PROG, to debug ESP32 projects, according to Andreas Spiess’ great Youtube video. When I do “Start debugging” in Visual Studio Code I get the following error message window (I could not attach a screen shot): Visual Studio Code Could not find the specified task. The options are: “Configure task”, “Open launch.json” and “Cancel”. I have an PlatformIO account and I have added these lines to the platformio.ini file: debug_tool = esp-prog …

[asesorplaza1]

Aunque en las opciones he podido poner en alguna parte, que utilice las Librerías de Arduino, me ha tocado instalarlas de nuevo, y no encuentro la librería Easy Transfer.

Hay una opción, que es instalar una extensión, que es un paquete compatible con Arduino, entonces cuando le doy a Run > Start debugging, si hace algo, pero me sale este otro mensaje de error

Conflicted extensions with IntelliSense service were detected (Arduino). Code-completion, linting and navigation will not work properly. Please disable or uninstall them (Menu > View > Extensions).

Por lo tanto estoy en las mismas, no puedo comprobar el funcionamiento del programa, por lo menos con Atom, me confirmaba que los programas compilaban, con VSC, no puedo saber si compilan o no.

Although in the options I have been able to put somewhere, that I use the Arduino Libraries, I have had to install them again, and I can’t find the Easy Transfer library. .
There is an option, which is to install an extension, which is a package compatible with Arduino, then when I hit Run > Start debugging, if you do something, but I get this other error message

Conflicted extensions with IntelliSense service were detected (Arduino). Code-completion, linting and navigation will not work properly. Please disable or uninstall them (Menu > View > Extensions).

Therefore I am in them, I can not check the operation of the program, at least with Atom, confirmed to me that the programs compiled, with VSC, I can not know if they compile or not.

[asesorplaza1]

Buenas noches.

Ya puedo ver el funcionamiento del programa en VSC, pero me da el siguiente error de biblioteca.

Good night.

I can already see how the program works in VSC, but it gives me the following library error.

DEBUG: Current (simavr) On-board (simavr)
PACKAGES:
 - framework-arduino-avr 5.0.0
 - toolchain-atmelavr 1.50400.190710 (5.4.0)
LDF: Library Dependency Finder -> http://bit.ly/configure-pio-ldf
LDF Modes: Finder ~ chain, Compatibility ~ soft
Found 14 compatible libraries
Scanning dependencies...
No dependencies
Building in debug mode
Compiling .pio\build\megaatmega2560\src\main.cpp.o
Compiling .pio\build\megaatmega2560\FrameworkArduino\abi.cpp.o
src\main.cpp:154:54: fatal error: PS2X_lib.h: No such file or directory

******************************************************************
* Looking for PS2X_lib.h dependency? Check our library registry!
*
* CLI  > platformio lib search "header:PS2X_lib.h"
* Web  > https://platformio.org/lib/search?query=header:PS2X_lib.h
*
******************************************************************

compilation terminated.
*** [.pio\build\megaatmega2560\src\main.cpp.o] Error 1
===================================================== [FAILED] Took 6.84 seconds =====================================================
The terminal process terminated with exit code: 1

Terminal will be reused by tasks, press any key to close it.

[maxgerhardt]

@asesorplaza1

src\main.cpp:154:54: fatal error: PS2X_lib.h: No such file or directory

The PS2X library is not yet registered with PlatformIO – I suggest you go to GitHub - simondlevy/PS2X_lib: Arduino Playstation2 library with compiler warnings fixed, download the ZIP file (https://github.com/simondlevy/PS2X_lib/archive/master.zip), then create a new folder in lib/ called PS2X_lib where you put in the files from the ZIP file so that the structure is …

lib/
   PS2X_lib/ 
      PS2X_lib.cpp
      PS2X_lib.h
      ...

then add the line

lib_deps = 
   PS2X_lib

into the platformio.ini so that the library is looked for by PlatformIO.

[maxgerhardt]

@asesorplaza1

Conflicted extensions with IntelliSense service were detected (Arduino). Code-completion, linting and navigation will not work properly. Please disable or uninstall them (Menu > View > Extensions).

The PlatformIO and Arduino extension are not compatible with each other – remove one of them.

[maxgerhardt]

@asesorplaza1

Although in the options I have been able to put somewhere, that I use the Arduino Libraries, I have had to install them again, and I can’t find the Easy Transfer library. .

Same procedure as above – this is not registered in the PIO library registry (PlatformIO Registry) so you’d need to manually add it in the lib/ folder – downloads are available at the library’s github page which I linked above: GitHub - madsci1016/Arduino-EasyTransfer: An Easy way to Transfer data between Arduinos.

[asesorplaza1]

Todas mis preguntas y problemas se han solucionado con estas 3 respuestas de Maxgerhardt, muchas gracias.

All my questions and problems have been solved with these 3 maxgerhardt answers, thank you very much.

[asesorplaza1]

Buenas noches.
Lo primero que yo tengo que hacer es darle a usted las gracias por su tiempo y sus comentarios, y por haberse leído las 50.000 líneas de mis explicaciones del proyecto y mis problemas.
Sus respuestas me están siendo de gran ayuda, muchas gracias, de verdad.
Ahora mis preguntas como puede ver, son mucho más cortas y concretas. Espero que no se canse de contestarme, realmente usted me está siendo de gran ayuda.

Un saludo, y muchas gracias

Good night.
The first thing I have to do is thank you for your time and feedback, and for reading the 50,000 lines of my explanations of the project and my problems.
Your answers are being of great help to me, thank you very much, really.
Now my questions as you can see, are much shorter and more concrete. I hope you don’t get tired of answering me, you’re really being very helpful to me.

Greetings, and thank you very much.

[asesorplaza1]

Creo que sería buena idea, decirles a los administradores, que deberían dejar subir los códigos como ficheros adjuntos comprimidos, para que se pudieran ver al otro lado de mi pantalla, y ustedes pudieran ver los errores de código como los veo yo.

I think it would be a good idea to tell the administrators, that they should let the codes go up as compressed attachments, so that they could be seen on the other side of my screen, and you could see the code errors as I see them.

[asesorplaza1]

Bueno, ahora que los programas ya no me dan errores de compilación, gracias a las respuestas de Maxgerhardt, debería de pasar al siguiente paso, que el VSC, me dijese de alguna manera, como se comporta el programa, que hay que mejorar, cuánto tiempo se tarda en ejecutar el programa, que instrucciones están retrasando la ejecución del programa, por que otras órdenes las debería de cambiar, etc.
No sé cómo explicarlo, que VSC, me diga algo mas a cerca de los códigos. Para que me diga VSC, algo más que el programa compila, que eso ya lo sabía antes con el IDE de Arduino.
Pero no veo que otros botones de opciones ni de ejecución hay, el botón más interesante que he visto es el de RUN, con el que se construye y se compila el programa, pero en mi caso, eso ya lo traía hecho desde el IDE de Arduino.
Un saludo.

Well, now that the programs no longer give me compilation errors, thanks to Maxgerhardt’s responses, I should move on to the next step, that the VSC, I would say somehow, how the program behaves, that it has to improve, how long it takes to run the program, that instructions are delaying the execution of the program, because other commands should change them Etc.
I don’t know how to explain it, that VSC, tell me something else about the codes. To tell me VSC, more than just the program compiles, that I already knew that before with the Arduino IDE.
But I do not see that other options or execution buttons there, the most interesting button I have seen is that of RUN, with which the program is built and compiled, but in my case, that already brought it done from the Arduino IDE.
Greetings.