Question 2dof, arduino+ ibt2, wiper motors

Hello, I present my platform for movement, I have already purchased it but it is not a commercial version, I am having problems with the configuration, it moves but when I try the test the roll moves up and down, the pitch moves left and right, I have Tested dirt rally and obviously it's not going well.
Take Arduino One, bridge ibt-2, wiper motors of seat León Mk2
How can I make it move correctly?
Thanks in advance
The code is this:

Hola, os presento mi plataforma de movimiento, la he comprado ya montada pero no es una versión comercial, estoy teniendo problemas con la configuración, se mueve pero cuando pruebo el test el roll mueve arriba y abajo, el pitch mueve izquierda y derecha, he probado dirt rally y evidentemente no va bien.
Lleva arduino One, puente ibt-2, las pruebas en vacio parece que van bien, a pesar de estar las funciones invertidas pero cuando me subo es como si no pudiese conmigo, ( se ve lo que hace en el segundo video ), se que será problema de configuración pero no doy con la solución, a ver si me pueden echar una mano.
Gracias de antemano

Code:

/*
  Arduino code for dynamic playseat 2DOF
  Created 24 May 2011 by Jim Lindblom   SparkFun Electronics https://www.sparkfun.com/products/10182 "Example Code"
  Created 24 Apr 2012 by Jean David SEDRUE Version betatest26 - 24042012 http://www.gamoover.net/Forums/index.php?topic=25907
  Updated 20 May 2013 by RacingMat in english http://www.xsimulator.net/2dof-wiper-motor-playseat/ in french : http://www.gamoover.net/Forums/index.php?topic=27617
  Updated 30 April 2014 by RacingMat (bug for value below 16 corrected)
*/

/*
   /*
   PROGRAMA ARDUINO SIMULADOR 2DOF AMB SOFTWARE SimTools sense soroll motors

//////////Connexions dels Motors / Arduino Uno / Plaques IBT-2 i Potenciòmetres Motors////////////////////

  Placa IBT-2 Motor Left                                             Placa IBT-2 Motor Right

1. R PWM..........Pin 4 Arduino                                   1. R PWM..........Pin 7 Arduino 
2. L PWM..........Pin 5 Arduino                                   2. L PWM..........Pin 8 Arduino
3. R_EN...........Pin 9 Arduino                                   3. R_EN...........Pin 10 Arduino
4. L_EN...........Pin 9 Arduino                                   4. l_EN...........Pin 10 Arduino
5. R_IS........... (No es conecta)                                5. R_IS........... (No es conecta)
6. L_IS........... (No es conecta)                                6. L_IS........... (No es conecta)
7. VCC............ + 5 Vcc                                        7. VCC............ + 5 Vcc
8. GND............ - 0 Vcc                                        8. GND............ - 0 Vcc

  M + ............ + Motor Left                                    M + ............ + Motor Left
  M - ............ - Motor Left                                    M - ............ - Motor Left
  B + ............ + 12 Vcc                                        B + ............ + 12 Vcc
  B - ............ - 0 Vcc                                         B - ............ - 0 Vcc
 
 
Potenciòmetre Motor Left                                          Potenciòmetre Motor Right

 Pin 1................. + 5 Vcc                                    Pin 1................. + 5 Vcc
 Pin 2 (central)....... Pin A0 Arduino                             Pin 2 (central)....... Pin A1 Arduino
 Pin 3................. - 0 Vcc                                    Pin 3................. - 0 Vcc
 
*/



#define BRAKEVCC 0
#define RV  2 //beware it's depending on your hardware wiring
#define FW  1 //1 //beware it's depending on your hardware wiring
#define STOP 0
#define BRAKEGND 3

////////////////////////////////////////////////////////////////////////////////
///////AJUSTOS//////////////////////////////////////////////////////////////////

// Ajustar la velocitat i potència dels motors (Valor màxim 255)
#define pwmMax 200 //(Màxim 255)

// Ajustos Minim i Màxim Potenciometre (Valors entre 0 i 1023)
const int potMini = 208;  //Mínim Potenciómetre (Mínim 20)
const int potMaxi = 815;  //Màxim Potenciòmetre (Màxim 1003)

////////////////////////////////////////////////////////////////////////////////


#define motLeft 0
#define motRight 1
#define potL A0
#define potR A1

////////////////////////////////////////////////////////////////////////////////
//  DECLARATIONS
////////////////////////////////////////////////////////////////////////////////
/*  VNH2SP30 pin definitions*/
int inApin[2] = {
  4, 7       
};  // INA: Clockwise input
int inBpin[2] = {
  5, 8    //9  Modificacions Conexions
}; // INB: Counter-clockwise input
int pwmpin[2] = {
  9, 10   //5, 6  Modificacions Conexions
}; // PWM input
int cspin[2] = {
  2, 3
}; // CS: Current sense ANALOG input
int enpin[2] = {
  0, 1
}; // EN: Status of switches output (Analog pin)
int statpin = 13;  //not explained by Sparkfun
/* init position value*/
int DataValueL = 512; //middle position 0-1024
int DataValueR = 512; //middle position 0-1024

////////////////////////////////////////////////////////////////////////////////
// INITIALIZATION
////////////////////////////////////////////////////////////////////////////////
void setup()
{
  // serial initialization
  Serial.begin(115200);

  // initialization of Arduino's pins
  pinMode(statpin, OUTPUT); //not explained by Sparkfun
  digitalWrite(statpin, LOW);

  for (int i = 0; i < 2; i++)
  {
    pinMode(inApin[i], OUTPUT);
    pinMode(inBpin[i], OUTPUT);
    pinMode(pwmpin[i], OUTPUT);
  }
  // Initialize braked for motor
  for (int i = 0; i < 2; i++)
  {
    digitalWrite(inApin[i], LOW);
    digitalWrite(inBpin[i], LOW);
  }
 
   ///////////////////////////////////////////////////
    // Augmenta la frequència dels pins PWM  9, 10
    // per eliminar el soroll dels motors
    setPwmFrequency(9, 1);
    setPwmFrequency(10, 1);
   ///////////////////////////////////////////////////
 
}
////////////////////////////////////////////////////////////////////////////////
///////////////////////////////// Main Loop ////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
void loop()
{
  int sensorL, sensorR;

  //setup();
  //while(Serial.available() == 0){}
 
  readSerialData();   // DataValueR & L contain the last order received (if there is no newer received, the last is kept)
  // the previous order will still be used by the PID regulation MotorMotion Function

  sensorR = analogRead(potR);  // range 0-1024
  sensorL = analogRead(potL);  // range 0-1024

  motorMotion(motRight,sensorR,DataValueR);
  motorMotion(motLeft,sensorL,DataValueL);

  //Serial.flush();

  //delay(2500);

//testPot();
  //testpulse();
}
////////////////////////////////////////////////////////////////////////////////
// Procedure: wait for complete trame
////////////////////////////////////////////////////////////////////////////////
void readSerialData()
{
  byte Data[3] = {
    '0', '0', '0'
  };
  // keep this function short, because the loop has to be short to keep the control over the motors

  if (Serial.available() > 2) {
    //parse the buffer : test if the byte is the first of the order "R"
    Data[0] = Serial.read();
    if (Data[0] == 'L') {
      Data[1] = Serial.read();
      Data[2] = Serial.read();
      //  call the function that converts the hexa in decimal and that maps the range
      DataValueR = NormalizeData(Data);
    }
    if (Data[0] == 'R') {
      Data[1] = Serial.read();
      Data[2] = Serial.read();
      //  call the function that converts the hexa in decimal and maps the range
      DataValueL = NormalizeData(Data);

    }
  }
  if (Serial.available() > 16) Serial.flush();
}
////////////////////////////////////////////////////////
void motorMotion(int numMot, int actualPos, int targetPos)
////////////////////////////////////////////////////////
{
  int Tol = 20; // no order to move will be sent to the motor if the target is close to the actual position
  // this prevents short jittering moves
  //could be a parameter read from a pot on an analogic pin
  // the highest value, the calmest the simulator would be (less moves)

  int gap;
  int pwm;
  int brakingDistance = 30;

  /*Serial.print("\nMotor numMot:");
  Serial.print(numMot);
  Serial.print("\nMotor actualPos:");
  Serial.print(actualPos);
  Serial.print("\nMotor targetPos:");
  Serial.print(targetPos);*/

  // security concern : targetPos has to be within the mechanically authorized range
  targetPos = constrain(targetPos, potMini + brakingDistance, potMaxi - brakingDistance);

  gap = abs(targetPos - actualPos);

  if (gap <= Tol) {
    motorOff(numMot); //too near to move
   // Serial.print("\ntoo near to move");
  }
  else {
    // PID : calculates speed according to distance
    pwm = 195;
    if (gap > 50)   pwm = 215;//pwm = 130;//pwm = 215;
    if (gap > 75)   pwm = 235;//pwm = 150;//pwm = 235;
    if (gap > 100)  pwm = 255;//pwm = 200;//pwm = 255;
    pwm = map(pwm, 0, 255, 0, pwmMax); //adjust the value according to pwmMax for mechanical debugging purpose !

    // if motor is outside from the range, send motor back to the limit !
    // go forward (up)
    if ((actualPos < potMini) || (actualPos < targetPos)) motorGo(numMot, FW, pwm);
    // go reverse (down)
    if ((actualPos > potMaxi) || (actualPos > targetPos)) motorGo(numMot, RV, pwm);

  }
}



////////////////////////////////////////////////////////////////////////////////
void motorOff(int motor) { //Brake Ground : free wheel actually
  ////////////////////////////////////////////////////////////////////////////////
  digitalWrite(inApin[motor], LOW);
  digitalWrite(inBpin[motor], LOW);
  analogWrite(pwmpin[motor], 0);
}
////////////////////////////////////////////////////////////////////////////////
void motorOffBraked(int motor) { // "brake VCC" : short-circuit inducing electromagnetic brake
  ////////////////////////////////////////////////////////////////////////////////
  digitalWrite(inApin[motor], HIGH);
  digitalWrite(inBpin[motor], HIGH);
  analogWrite(pwmpin[motor], 0);
}

////////////////////////////////////////////////////////////////////////////////
void motorGo(uint8_t motor, uint8_t direct, uint8_t pwm)
////////////////////////////////////////////////////////////////////////////////
{
  if (motor <= 1)
  {
    if (direct <= 4)
    {
      // Set inA[motor]
      if (direct <= 1)
        digitalWrite(inApin[motor], HIGH);
      else
        digitalWrite(inApin[motor], LOW);

      // Set inB[motor]
      if ((direct == 0) || (direct == 2))
        digitalWrite(inBpin[motor], HIGH);
      else
        digitalWrite(inBpin[motor], LOW);

      analogWrite(pwmpin[motor], pwm);

    }
  }
}

////////////////////////////////////////////////////////////////////////////////
void motorDrive(uint8_t motor, uint8_t direct, uint8_t pwm)
////////////////////////////////////////////////////////////////////////////////
{
  // more readable function than Jim's (for educational purpose)
  // but 50 octets heavier ->  unused
  if (motor <= 1 && direct <= 4)
  {
    switch (direct) {
      case 0: //electromagnetic brake : brake VCC
        digitalWrite(inApin[motor], HIGH);
        digitalWrite(inBpin[motor], HIGH);
        break;
      case 3: //Brake Ground (free wheel)
        digitalWrite(inApin[motor], LOW);
        digitalWrite(inBpin[motor], LOW);
        break;
      case 1: // forward : beware it's depending on your hardware wiring
        digitalWrite(inApin[motor], HIGH);
        digitalWrite(inBpin[motor], LOW);
        break;
      case 2: // Reverse : beware it's depending on your hardware wiring
        digitalWrite(inApin[motor], LOW);
        digitalWrite(inBpin[motor], HIGH);
        break;
    }
    analogWrite(pwmpin[motor], pwm);
  }
}
////////////////////////////////////////////////////////////////////////////////
// testPot
////////////////////////////////////////////////////////////////////////////////
void testPot() {

  Serial.print(analogRead(potR));
  Serial.print(";");
  Serial.println(analogRead(potL));
  delay(250);

}
////////////////////////////////////////////////////////////////////////////////
void testpulse() {
  int pw = 250; //120;
  while (true) {

    motorGo(motLeft, FW, pw);
    delay(250);
    motorOff(motLeft);
    delay(250);
    motorGo(motLeft, RV, pw);
    delay(250);
    motorOff(motLeft);
    Serial.println("Motor left\n");
    delay(2000);
    testPot();
    motorGo(motRight, FW, pw);
    delay(250);
    motorOff(motRight);
    delay(250);
    motorGo(motRight, RV, pw);
    delay(250);
    motorOff(motRight);
    Serial.println("Motor right:\n");
    delay(2000);
    testPot();
  }
}
////////////////////////////////////////////////////////////////////////////////
// Function: convert Hex to Dec
////////////////////////////////////////////////////////////////////////////////
int NormalizeData(byte x[3])
////////////////////////////////////////////////////////////////////////////////
{
  int result;

  if ((x[2] == 13) || (x[2] == 'R') || (x[2] == 'L')) //only a LSB and Carrier Return or 'L' or 'R' in case of value below 16 (ie one CHAR and not 2)
  {
    x[2] = x[1]; //move MSB to LSB
    x[1] = '0';   //clear MSB
  }
  for (int i = 1; i < 3; i++)
  {
    if (x[i] > 47 && x[i] < 58 ) { //for xA to xF
      x[i] = x[i] - 48;
    }
    if (  x[i] > 64 && x[i] < 71 ) { //for x0 to x9
      x[i] = x[i] - 55;
    }
  }
  // map the range from Xsim (0 <-> 255) to the mechanically authorized range (potMini <-> potMaxi)
  result = map((x[1] * 16 + x[2]), 0, 255, potMini, potMaxi);
  return result;
}



////////////////////////////////////////////////////////////////////////
// Elimina el soroll dels motors augmentant la freqüència dels pins PWM
void setPwmFrequency(int pin, int divisor) {
  byte mode;
  if(pin == 9 || pin == 10) {
    switch(divisor) {
      case 1: mode = 0x01; break;
      case 8: mode = 0x02; break;
      case 64: mode = 0x03; break;
      case 256: mode = 0x04; break;
      case 1024: mode = 0x05; break;
      default: return;
    }
    if(pin == 5 || pin == 6) {
      TCCR0B = TCCR0B & 0b11111000 | mode;
    } else {
      TCCR1B = TCCR1B & 0b11111000 | mode;
    }
  }
}
////////////////////////////////////////////////////////////////////////

Thanks, the manuals have already been followed, the movement seems to be going well but I still have the pitching problem when I ride

one more test.......

Very thanks for the support........

I've been browsing the forum and I've seen that they were talking about lowering forces and I've been testing that same thing with the same result except if I go down to 10% that barely moves, with 15% already the problem occurs again

He estado navegando por el foro y he visto que comentaban de bajar las fuerzas y he estado probando eso mismo con el mismo resultado excepto si bajo a un 10% que apenas se mueve, con un 15% ya se da el problema de nuevo

To get a correct movement I have to keep DIR orange in Pitch, if I do it in Roll both Pitch and Roll do the same movement, anyway I do not know if this affects so that the movement is stuck as I show in the last video that is the biggest problem I see right now

Para obtener un movimiento correcto debo mantener DIR naranja en Pitch, si lo hago en Roll tanto Pitch como Roll hacen el mismo movimiento, de todos modos no se si esto afecta para que el movimiento se me quede atascado como muestro en el ultimo video que es el mayor problema que veo ahora mismo

the last test I have done, I have raised the speed of the engines and no longer makes the pitch, the movements are fine but I stopped for an engine every time, I thought it was due to excess heat in one of the ibt plates but now it seems which is well refrigerated and keeps falling

these are the values doing a round with a medium car on a medium track, I have only captured the min-max and saved, now the movement is very unreal and I am very lost, I do not know what to touch, any suggestions? @noorbeast

yesterday I changed the right engine, I was convinced that this could be the problem but no, still doing the same, it is something that happens even without playing with what I can only think is something in the code, to see if someone who understands the code can help me, thank you all.

@noorbeast I changed the wiring and the program to smc3, I have movement in smc3 but with simtools nothing moves
Because it can be?

It already moves but it does not do it well, I think that the movement of one of the engines is inverted