[BR] Grupo brasileiro de construção de simuladores solved with post #23295

[alexandrelopes]

^ Adriano,
Fico na torcida para que o projeto dê certo de primeira, assim que instalar a eletrônica na estrutura.

Se os motores não aguentarem, estolar ou perder passo, poderia instalar molas nos quatro cantos da estrutura igual a um projeto daqui. Ou modificar o projeto e deixar só o banco com movimento.

Seu projeto está bem adiantado, falta pouco para terminar.

Deixa eu te fazer uma pergunta,você tem um vídeo que chama SImulador Lateral nd Longitudinal Force2.

Neste vídeo você está usando somente o arduino + servos, correto? É muito difícil fazer esta configuração?

Comprei uma placa arduino uno e chega amanhã, já tenho 2 servos 9g, gostaria muito de configurar o X-sim para já ter os primeiros contatos com o software e hardware.

[adrianovrm]

Sim Alexandre, Fui eu quem fez este protótipo também, foi o meu primeiro, a aproximadamente 10 meses atrás, em novembro de 2012. Usei um arduino duemilnove, uma versão anterior ao uno, mas funciona igual no UNO, com 4 servos, dois para o canudo de Bob's dianteiro e dois para canudo traseiro, mas a programação arduino para os servos é duferente da programação para transformar os motores DC em servos, totalmente, fazer a programação para os servos me foii muito simples por conta da biblioteca do arduino. Ainda tenho o código deste protótipo guardado, meu legado ehehehe, vou procurar em meu email, mas com aprendizado é válido e prazeroso ver o negócio funcionar.
a parte do display deve ser apagada, qualquer problema, me deixe saber, e eles apareceram, para quem está começando, apanha muito

/*
Blink
Turns on an LED on for one second, then off for one second, repeatedly.

This example code is in the public domain.

4.294.967.294 bilhoes de possicoes
deve ficar num range de 19 posicoes - divisor igual a = 226050910.2105263 que ficaram no intervalo de
X~a01~Y~a02~
*/

#include <LiquidCrystal.h>
#include <Servo.h>


const int numRows = 2;
const int numCols = 16;

int A = 2;
int B = 3;
int C = 4;
int P = 5;
int D = 6;
int E = 7;
int F = 8;
int G = 9;
int inByte;
LiquidCrystal lcd(12, 11, A0, A1, A2, A3);
int rowsel;
int buffer[14];
int counteri;
char tempstr[10];
int gearsmap = 0;
unsigned int carspeed;
unsigned int rpm;
int pspeed;
byte d1;
byte d2;
byte gaugerpm;
//Servo servo1;
//Servo servo2;
Servo servoFR; //defenir os nomes dos servos
Servo servoFL;
Servo servoRR; //defenir os nomes dos servos
Servo servoRL;
int FG_longintudinal;
int FG_lateral;

void setup() {
// initialize the digital pin as an output.
// Pin 13 has an LED connected on most Arduino boards:
//Serial.begin(9600);
Serial.begin(9600);
lcd.begin(numCols,numRows);
pinMode(A, OUTPUT);
pinMode(B, OUTPUT);
pinMode(C, OUTPUT);
pinMode(P, OUTPUT);
pinMode(D, OUTPUT);
pinMode(E, OUTPUT);
pinMode(F, OUTPUT);
pinMode(G, OUTPUT);

pinMode(A0, OUTPUT);
pinMode(A1, OUTPUT);
pinMode(A2, OUTPUT);
pinMode(A3, OUTPUT);
pinMode(A4, OUTPUT);
pinMode(A5, OUTPUT);

pinMode(5,OUTPUT);
pinMode(6,OUTPUT);
pinMode(9,OUTPUT);
pinMode(10,OUTPUT);

//escrevadigito(-8);
//digitalWrite(A0, LOW);
//delay(2000);
//rowsel = 0 ;
//servo1.attach(A4);
//servo1.write(0);
servoRR.attach(5);
servoFR.attach(6);
servoFL.attach(9);
servoRL.attach(10);

//servoFR.write(180); // servos iniciao na posição 0
//servoFL.write(0);
//servoRR.write(180); // servos iniciao na posição 0
//servoRL.write(0);

servoFR.write(90); // servos iniciao na posição 0
servoFL.write(90);
servoRR.write(90); // servos iniciao na posição 0
servoRL.write(90);


}

void loop() {

if (Serial.available() > 10)
{
counteri = 0;
for (counteri = 0; counteri < 10; counteri++)
{
buffer[counteri] = Serial.read();
}
if (buffer[0] == 88)
{
lcd.setCursor(0,0);
lcd.print(" ");
lcd.setCursor(0,1);
lcd.print(" ");
lcd.setCursor(0,0);
//escrevadigito(1);
//lcd.println(buffer[3]);
lcd.print('X');
lcd.setCursor(1,0);
lcd.print(buffer[1]);
lcd.setCursor(5,0);
lcd.print('Y');
lcd.setCursor(6,0);
lcd.print(buffer[2]);
lcd.setCursor(10,0);
lcd.print('G');
lcd.setCursor(11,0);
gearsmap = map(buffer[3],111,255,-1,8);
lcd.print(gearsmap);
lcd.setCursor(12,0);
lcd.print('S');
lcd.setCursor(13,0);
d1 = buffer[4]; // store high byte of speed
d2 = buffer[5]; // store low byte of speed
carspeed = d1 * 256 + d2;
carspeed = map(carspeed,32639, 65536,0,400);
//lcd.print(map(carspeed,224,255,0,450)); // carspeed
lcd.print(carspeed);
// carspeed(value,127,577,0,450);
lcd.setCursor(0,1);
lcd.print('R');
lcd.setCursor(1,1);
d1 = buffer[6]; // store high byte of speed
d2 = buffer[7]; // store low byte of speed
rpm = d1 * 256 + d2;
rpm = map(rpm,33127, 65536,0,10000);
lcd.print(rpm);
gaugerpm =0;
lcd.setCursor(7,1);
lcd.print('O');
lcd.setCursor(8,1);
d2 = buffer[8]; // valor aceleracao longitudinal
FG_longintudinal = 0;
//FG_longintudinal = map (d2,117,137,-10,10);
FG_longintudinal = map(d2,0,255,-10,10);
lcd.print(FG_longintudinal);
// mesmas variaveis - forca lateral
d2 = buffer[9]; // valor aceleracao lateral
FG_lateral = 0;
FG_lateral = map(d2,0,255,-10,10);
lcd.setCursor(11,1);
lcd.print('A');
lcd.setCursor(12,1);
lcd.print(FG_lateral);
atualiza_servo(FG_longintudinal,FG_lateral);
}
}
}

float mapfloat(float val, float i1, float i2, float o1, float o2)
{
return o1+(o2-o1)*((val-i1)/(i2-i1));
}

void atualiza_servo(int f_longitudinal, int f_lateral)
{
int angulo_servoRL;
int angulo_servoRR;
int angulo_servoFL;
int angulo_servoFR;

// servo RL diminuir angulos
// servo RR aumenta angulo
// servo1.write(0); // servo1 vai para 180 graus
// servo2.write(180);
//angulo_servo1 = map(f_longitudinal,-4, 4,0,179);
// map(f_longitudinal,-10, 10,0,179);
angulo_servoRR = f_longitudinal*15 + 90;
angulo_servoRL = 180 - angulo_servoRR;

angulo_servoFR = -f_longitudinal*15 + 90;
angulo_servoFL = 180 - angulo_servoFR;

if (f_lateral > 0) //dobrando a esquerda
{
angulo_servoFR = angulo_servoFR + f_lateral*15;
angulo_servoRR = angulo_servoRR + f_lateral*15;
}
else if (f_lateral <0) //dobrando a direita
{
angulo_servoFL = angulo_servoFL + f_lateral*15;
angulo_servoRL = angulo_servoRL + f_lateral*15;
}

// se algum angulo passar de 180. voltar para 180
angulo_servoRL = map(angulo_servoRL,0,180,0,180);
angulo_servoRR = map(angulo_servoRR,0,180,0,180);
angulo_servoFR = map(angulo_servoFR,0,180,0,180);
angulo_servoFL = map(angulo_servoFL,0,180,0,180);

servoFR.write(angulo_servoFR); // servos iniciao na posição 0
servoFL.write(angulo_servoFL);
servoRR.write(angulo_servoRR); // servos iniciao na posição 0
servoRL.write(angulo_servoRL);
}


void escrevadigito(int digito)
{
switch (digito)
{
case 0:
{
digitalWrite(A, LOW);
digitalWrite(B, LOW);
digitalWrite(C, LOW);
digitalWrite(P, HIGH);
digitalWrite(D, LOW);
digitalWrite(E, LOW);
digitalWrite(F, LOW);
digitalWrite(G, HIGH);
break;
}
case 1:
{
digitalWrite(A, HIGH);
digitalWrite(B, LOW);
digitalWrite(C, LOW);
digitalWrite(P, HIGH);
digitalWrite(D, HIGH);
digitalWrite(E, HIGH);
digitalWrite(F, HIGH);
digitalWrite(G, HIGH);
break;
}
case 2:
{
digitalWrite(A, LOW);
digitalWrite(B, LOW);
digitalWrite(C, HIGH);
digitalWrite(P, HIGH);
digitalWrite(D, LOW);
digitalWrite(E, LOW);
digitalWrite(F, HIGH);
digitalWrite(G, LOW);
break;
}
case 3:
{
digitalWrite(A, LOW);
digitalWrite(B, LOW);
digitalWrite(C, LOW);
digitalWrite(P, HIGH);
digitalWrite(D, LOW);
digitalWrite(E, HIGH);
digitalWrite(F, HIGH);
digitalWrite(G, LOW);
break;
}
case 4:
{
digitalWrite(A, HIGH);
digitalWrite(B, LOW);
digitalWrite(C, LOW);
digitalWrite(P, HIGH);
digitalWrite(D, HIGH);
digitalWrite(E, HIGH);
digitalWrite(F, LOW);
digitalWrite(G, LOW);
break;
}
case 5:
{
digitalWrite(A, LOW);
digitalWrite(B, HIGH);
digitalWrite(C, LOW);
digitalWrite(P, HIGH);
digitalWrite(D, LOW);
digitalWrite(E, HIGH);
digitalWrite(F, LOW);
digitalWrite(G, LOW);
break;
}
case 6:
{
digitalWrite(A, LOW);
digitalWrite(B, HIGH);
digitalWrite(C, LOW);
digitalWrite(P, HIGH);
digitalWrite(D, LOW);
digitalWrite(E, LOW);
digitalWrite(F, LOW);
digitalWrite(G, LOW);
break;
}
case 7:
{
digitalWrite(A, LOW);
digitalWrite(B, LOW);
digitalWrite(C, LOW);
digitalWrite(P, HIGH);
digitalWrite(D, HIGH);
digitalWrite(E, HIGH);
digitalWrite(F, HIGH);
digitalWrite(G, HIGH);
break;
}
case 8:
{
digitalWrite(A, LOW);
digitalWrite(B, LOW);
digitalWrite(C, LOW);
digitalWrite(P, HIGH);
digitalWrite(D, LOW);
digitalWrite(E, LOW);
digitalWrite(F, LOW);
digitalWrite(G, LOW);
break;
}
case 9:
{
digitalWrite(A, LOW);
digitalWrite(B, LOW);
digitalWrite(C, LOW);
digitalWrite(P, HIGH);
digitalWrite(D, LOW);
digitalWrite(E, HIGH);
digitalWrite(F, LOW);
digitalWrite(G, LOW);
break;
}
case -1:
{
digitalWrite(A, HIGH);
digitalWrite(B, LOW);
digitalWrite(C, LOW);
digitalWrite(P, LOW);
digitalWrite(D, HIGH);
digitalWrite(E, HIGH);
digitalWrite(F, HIGH);
digitalWrite(G, HIGH);
break;
}
case -2:
{
digitalWrite(A, LOW);
digitalWrite(B, LOW);
digitalWrite(C, HIGH);
digitalWrite(P, LOW);
digitalWrite(D, LOW);
digitalWrite(E, LOW);
digitalWrite(F, HIGH);
digitalWrite(G, LOW);
break;
}
case -3:
{
digitalWrite(A, LOW);
digitalWrite(B, LOW);
digitalWrite(C, LOW);
digitalWrite(P, LOW);
digitalWrite(D, LOW);
digitalWrite(E, HIGH);
digitalWrite(F, HIGH);
digitalWrite(G, LOW);
break;
}
case -4:
{
digitalWrite(A, HIGH);
digitalWrite(B, LOW);
digitalWrite(C, LOW);
digitalWrite(P, LOW);
digitalWrite(D, HIGH);
digitalWrite(E, HIGH);
digitalWrite(F, LOW);
digitalWrite(G, LOW);
break;
}
case -5:
{
digitalWrite(A, LOW);
digitalWrite(B, HIGH);
digitalWrite(C, LOW);
digitalWrite(P, LOW);
digitalWrite(D, LOW);
digitalWrite(E, HIGH);
digitalWrite(F, LOW);
digitalWrite(G, LOW);
break;
}
case -6:
{
digitalWrite(A, LOW);
digitalWrite(B, HIGH);
digitalWrite(C, LOW);
digitalWrite(P, LOW);
digitalWrite(D, LOW);
digitalWrite(E, LOW);
digitalWrite(F, LOW);
digitalWrite(G, LOW);
break;
}
case -7:
{
digitalWrite(A, LOW);
digitalWrite(B, LOW);
digitalWrite(C, LOW);
digitalWrite(P, LOW);
digitalWrite(D, HIGH);
digitalWrite(E, HIGH);
digitalWrite(F, HIGH);
digitalWrite(G, HIGH);
break;
}
case -8:
{
digitalWrite(A, LOW);
digitalWrite(B, LOW);
digitalWrite(C, LOW);
digitalWrite(P, LOW);
digitalWrite(D, LOW);
digitalWrite(E, LOW);
digitalWrite(F, LOW);
digitalWrite(G, LOW);
break;
}
case -9:
{
digitalWrite(A, LOW);
digitalWrite(B, LOW);
digitalWrite(C, LOW);
digitalWrite(P, LOW);
digitalWrite(D, LOW);
digitalWrite(E, HIGH);
digitalWrite(F, LOW);
digitalWrite(G, LOW);
break;
}
case -10:
{
digitalWrite(A, HIGH);
digitalWrite(B, HIGH);
digitalWrite(C, HIGH);
digitalWrite(P, HIGH);
digitalWrite(D, HIGH);
digitalWrite(E, HIGH);
digitalWrite(F, HIGH);
digitalWrite(G, HIGH);
break;
}
}
};

[adrianovrm]

Deu trabalho sim, existe que se saiba programar em c. Para não programadores a coisa fica mais dificil, tem que ter um mínimo de noção de programação, e aprender as funções básicas de controle de portas de entrada /saída digitais e analógicas do arduino.... Só não é algo para ET, pessoas normais com algumas horas de leitura, podem fazer ...

[alexandrelopes]

Olá Adriano, carreguei o seu código no arduino, mas não quis funcionar. Compilou tudo certinho, mas no x-sim nem sinal de vida, fiz testes nos canais 5,6,9,10 (attach) ... Não tenho ideia do que posso estar fazendo de errado.

Hoje tive o primeiro contato com o X-Sim Extractor & Converter, consegui colocar na tela do segundo pc (converter) a leitura de rpm e velocidade, através da ferramenta nativa de gauges do X-sim.

Andei pesquisando muito esses códigos 2dof rc servo para arduino, fiz testes com alguns agora pouco, mas não consegui colocar o servo para interagir com o programa.

A única resposta que tive do arduino/x-sim, foi uma resposta de led, através do firmware feito pelo Sirnoname (Arduino Open Source X-PID firmware).

[zecaEU01]

Bom dia a Todos
Um abraço aos novos malucos aqui no x-sim então vamos a alguns endereços de alguns produtos que serão úteis.

1- Perfil em alumínio
perfilart.terra.com.br Carlos Alberto
estruturalbr.com.br/ Leandro
drygalla.com.br Bruno

2- Rotulas
josecteixeira@ terra.com.br ZECA

3- Ponte H
robotpower.com Chris Baron

4- Placa Thanos
bruno.martins@fatec.sp.gov.br Bruno

5- Motores
kalatec.com.br Eduardo

6- Fontes 24V
casaseg.com
impnetbr@gmail.com Fábio

Estes são alguns fornecedores dos quais comprei e fui muito bem atendido, caso alguem tenha mais fornecedores favor me mande um email que vou atualizando a lista.
Abraços
zeca

[alexandrelopes]

Olá Zeca,

Obrigado por postar os links, para a nova leva de brazucas aqui no x-sim.de

Você sabe se o Bruno monta ponte H também, ou somente a placa controladora Thanos?

A ponte H é a única coisa que falta para encontramos todo o hardware necessário, para um simulador de movimento com peças encontrada no brasil.

Abraço.

[alexandrelopes]

Olá pessoal, boa noite.

Depois de duas noites mal dormidas e três dias na frente do PC, agora de tarde, consegui colocar para funcionar o arduino + x-sim. Fiquei muito feliz!

Deu para conhecer os recursos de física/feedback, e ter uma noção do que é este incrível software.

Segue o meu primeiro avanço.

[zecaEU01]

Bom dia a todos.

Bom Alexandre quanto a controladora eu sei que ele monta por sinal fez uma para mim e para outros malucos aqui do forum, quanto a ponte H acho que logo ele responderá sua duvida.
Ficou muito legal sua maquete parabéns.
Caso vc necessitar de unibol ou alguma dúvida para o seu simulador me consulte, já vendi para alguns aqui no forum.
zeca

[alexandrelopes]

Olá Zeca,

Enviei Mensagem particular e, e-mail para o Bruno perguntando da controladora e ponte H.

Em breve, certamente precisarei de unibol. Primeiro vou comprar as pontes e motores para fazer a eletrônica funcionar em bancada, e depois parto para a cruzeta, unibol e ferragens.

Dúvidas certamente virão, e ficarei muito feliz se você e os outros companheiros de fórum puder ajudar.

Alexandre

[adrianovrm]

Parabéns alexandre, sei com estás se sentindo, desculpe a demora, o trabalho me deixa pouco tempo.. Imagino que os seu problema era , ou a falta do plugin do x-sim na pasta do rfactor ou problemas na progamação da leitura da serial, que sempre dá algum trabalho. Segue o código atual que usei em meu ultimo video , ja com os motores de 24volts da bosch fm wm0.
Retire do código a biblioteca virtualwire e lcd, pois vc não deve ter estes instrumentos instalados em tua maquina. Posto também uma foto do meu uso. eu estou usando os efeito 25 e 27 (Aceleração longitudinal e lateral) com resolução binária de 16 bits para cada efeito, siginficando que recebo pacotes de informação do x-sim formatados da seguinte forma: O caracter "X" iniciando e seguido por 4 bytes, 2 para o efeito 27 e dois para o efeito 25, segue-se uma pequena conta para montar o valore correto dentro do arduino e o resto é o algoritmo que se segue. Parecido com o do sirnoname pois a lógica é semelhante, mas escrito do zero por mim, demorou dois meses para botar pra funcionar por que meu tempo de trabalho no x-SIm é bem limitado e quase sempre estou cansado quando trbalaho nele, paciëncia, cada um com seu abacaxi. Espero que minhas informações ajude e boa sorte quando meter a cara o simulador de tamanho real... estamos aqui, só demoramos um pouco para responder devido as obrigasçõs da vida moderna

A propósito qquia efeitos estás a usar ?
Não estranhe os pinos 32 e 41, estou usando um arduino mega, ele tem bem mais pinos de I/O.

Ooops, já ia me esquecendo, para este código funcionar legal , tem que inverter a saída dos efeitos da tela de math, posto minhas telas de math , para ajudar


#include <VirtualWire.h>
#include <LiquidCrystal.h>

// initialize the library with the numbers of the interface pins
LiquidCrystal lcd(32, 31, 38, 39, 40, 41);

byte xPosEixo = 1; //0 para motores posicionados atrás do banco; 1 - para motores posicionados a frente do banco
int xPosEsq;
int xPosDir;
int xEnaEsq = 13; int xSentEsq = 8; int xPwmEsq = 6; int xReadEsq = 1;
int xEnaDir = 12; int xSentDir = 7; int xPwmDir = 5; int xReadDir = 0;
int xDeadZone = 12;
int xCentPos = 511;
double kPotUnGraus = 2.844433;
double xkp = 1;
double xki = 0.05;
double xkd = 0.25;
// xSent[Esq ou Dir] em HIGH : Sentido Horário com 0 sendo a maior velocidade
// xSent[Esq ou Dir] em LOW : Sentido AntiHorário com 255 sendo a maior velocidade
double lastTime[2] = {millis() - 20,millis() - 20};
double lastErr[2] = {0,0};
double errSum[2] = {0,0};

byte xXSIMData[4];
unsigned int xXSIMDatLong;
unsigned int xXSIMDatLat;

int xSetpEsq = 0;
int xSetpDir = 0;
//int xPidDir;
//int xPidEsq;
int xPidGlobal[2] = {0,0};
byte xBoolStop = 1;

void setup()
{
Serial.begin(1200);
lcd.begin(16,2);
lcd.setCursor(0,0);
lcd.print("hello world");
delay(3000);
lcd.clear();
//Serial3.begin(9600);
pinMode(xEnaEsq,OUTPUT); pinMode(xEnaDir,OUTPUT);
pinMode(xSentEsq,OUTPUT); pinMode(xSentDir,OUTPUT);
pinMode(xPwmEsq,OUTPUT); pinMode(xPwmDir,OUTPUT);
pinMode(A1, INPUT);
pinMode(A0, INPUT);
digitalWrite(xEnaEsq,LOW);
digitalWrite(xEnaDir,LOW);
// Centralizar Motores Aqui
MotorPosicionar(xCentPos, xReadEsq, 1, 0, 0);
MotorPosicionar(xCentPos, xReadDir, 1, 0, 0);

Serial.print("Motores Ok...");
//Serial3.println("STR");

// Configurar transmissao RFID
pinMode(3,OUTPUT);
pinMode(2,INPUT);
// Initialise the IO and ISR
vw_set_ptt_inverted(true); // Required for DR3100
vw_set_tx_pin(3); // pino transmissor
vw_setup(2000); // Bits per sec
Serial.println(digitalRead(2));
}

void loop()
{
while (1==1)
{



// Bloco Leitura Serial; Zera pid em caso de recepcao de novos dados seriais
LerXSIM();
// Bloco Calculo do Angulo Target (Motores)
CalcularSetpoint();
// Bloco de Leitura da Posicao Atual dos Motores
LerSensorMotor(xReadEsq);
LerSensorMotor(xReadDir);

lcd.clear();
lcd.print(xXSIMDatLong);
lcd.setCursor(8,0);
lcd.print(xPosEsq);
lcd.setCursor(0,1);
lcd.print(xXSIMDatLat);
lcd.setCursor(8,1);
lcd.print(xPosDir);

xBoolStop = digitalRead(2); // pino da chave fisica
if (xBoolStop == 0)
{
xSetpEsq = xCentPos;
xSetpDir = xCentPos;
}
// Bloco Calcular PID
fPID(xReadEsq, xkp, xki, xkd, xPosEsq, xSetpEsq, 0);
fPID(xReadDir, xkp, xki, xkd, xPosDir, xSetpDir, 0);

// Bloco de Execucao de Movimento de Motor de acordo com calculo do PID e Posicao Atual
// Usar Funcao Adaptada MotorPosicionar e implementar limitacao de curso com deadzone
MotorPosicionar(abs(xSetpEsq), xReadEsq, 0, xPidGlobal[xReadEsq], xPosEsq);
MotorPosicionar(abs(xSetpDir), xReadDir, 0, xPidGlobal[xReadDir], xPosDir);



}
}


void fPID(int pxReadPin, double pxkp, double pxki, double pxkd, int pxInput, int pxSetpoint, int pzerar)
{
int result;

//How long since we last calculated
if (pzerar == 1)
{
lastTime[pxReadPin] = millis() - 1;
lastErr[pxReadPin] = 0;
errSum[pxReadPin] = 0;
result = 0;
//return 0;
}
else
{

unsigned long now = millis() - 5;
int timeChange = (double)(now - lastTime[pxReadPin]);
if (timeChange ==0)
{
timeChange = 1;
}
//Serial.println(timeChange);
//Compute all the working error variables
double error = pxSetpoint - pxInput;
errSum[pxReadPin] += (error * timeChange);
double dErr = (error - lastErr[pxReadPin]) / timeChange;
//Remember some variables for next time
lastErr[pxReadPin] = error;
lastTime[pxReadPin] = now;
//Serial.println(constrain(abs(xkp * error + xki * errSum[xReadPin] + xkd * dErr),0,255));
result = constrain(abs(pxkp * error + pxki * errSum[pxReadPin] + pxkd * dErr),0,255);
}
xPidGlobal[pxReadPin] = result;
}

void LerSensorMotor(int xReadPin)
{
if (xReadPin == xReadEsq)
{
xPosEsq = analogRead(xReadPin);
}
else if (xReadPin == xReadDir)
{
xPosDir = analogRead(xReadPin);
}
}



void CalcularSetpoint()
{

// calculos realizados para eixo traseiro por default;
xSetpEsq = 1023 - (xXSIMDatLong); // logica invertida do eixo esquerdo
xSetpDir = (xXSIMDatLong);


if (xXSIMDatLat < xCentPos) // se forca lateral < 511 entao dobrando a esquerda
{
if (xXSIMDatLong > xCentPos) // se forca frontal > 511 entao acelerando se < 511 freiando
{
xSetpDir = xSetpDir - (xCentPos - xXSIMDatLat); // Baixa o eiso direito um pouco
}
else if (xXSIMDatLong < xCentPos) //freiando
{
xSetpEsq = xSetpEsq - (xCentPos - xXSIMDatLat);
}
}
else if (xXSIMDatLat > xCentPos) // se forca lateral >511 entao dobrando a direita
{
if (xXSIMDatLong > xCentPos) // se forca frontal > 511 entao acelerando se < 511 freiando
{
xSetpEsq = xSetpEsq - (xCentPos - xXSIMDatLat);
}
else if (xXSIMDatLong < xCentPos) //freiando
{
xSetpDir = xSetpDir - (xCentPos - xXSIMDatLat);
}
}


if (xPosEixo == 1) // se for 1 então inverte para eixo dianteiro
{
// Inversao de eixos
xSetpDir = 1023 - xSetpDir;
xSetpEsq = 1023 - xSetpEsq;
}

}


void LerXSIM()
{
//xXSIMData[0] = 0; // Aceleracao Frontal
//xXSIMData[1] = 0;
byte vcontrol[1];
//vcontrol[0] = '2';
//vw_send((uint8_t *)vcontrol, 1);
//vw_wait_tx();
if (Serial.available()>=5)
{
//qt = Serial.available();
vcontrol[0] = Serial.read();
if (vcontrol[0] == 88) // Caracter "X"
{

//vw_send((uint8_t *)vcontrol, 1);
//vw_wait_tx();


//vw_send((uint8_t *)msg, strlen(msg));
xXSIMData[0] = Serial.read(); // Aceleracao Frontal
xXSIMData[1] = Serial.read(); // Aceleracao Lateral
xXSIMData[2] = Serial.read(); // Aceleracao Frontal
xXSIMData[3] = Serial.read(); // Aceleracao Lateral


xXSIMDatLong = xXSIMData[0]*256 + xXSIMData[1];
xXSIMDatLat = xXSIMData[2]*256 + xXSIMData[3];


if (xXSIMDatLong != 32767) //freiando - menor qie 32767 // acelerando - maior que 32767
{
xXSIMDatLong = (unsigned int) (xXSIMDatLong / (65355/1023));
}
else
{
xXSIMDatLong = xCentPos; // Nem Acelerando - nem freiando // idle
}

if (xXSIMDatLat > 0) //Direita - maior que 32767 // esquercda - menor que 32767
{
xXSIMDatLat = (unsigned int) (xXSIMDatLat / (65355/1023));
}
else
{
xXSIMDatLat = xCentPos; // Nem Acelerando - nem freiando // idle
}
// Resetar os PIDs
fPID(xReadEsq, 0, 0, 0, 0, 0, 1);
fPID(xReadDir, 0, 0, 0, 0, 0, 1);
}
}

}

void motorPara(int xEna,int xSent,int xPwm)
{
digitalWrite(xEna,HIGH); digitalWrite(xSent,HIGH); digitalWrite(xPwm,HIGH);
}

//CORRECAO LOW = antiHorario e HIGH = Horario
// xSent[Esq ou Dir] em HIGH : Sentido Horário com 0 sendo a maior velocidade
// xSent[Esq ou Dir] em LOW : Sentido AntiHorário com 255 sendo a maior velocidade
void motorGira(int xEnapin, int xPwmpin, int xMotorpin, int xSent, int xPwm)
{
// xSent = HIGH (Sentido Horario)or LOW (Sentido de rotacao AntiHorario)
digitalWrite(xEnapin,HIGH);
if (xSent == HIGH) // Sentido Horário
{
xPwm = xPwm - 255;
}
analogWrite(xPwmpin,xPwm);
digitalWrite(xMotorpin,xSent);
// Rodando motor Esquerdo Ex: motorGira(xEnaEsq, xPwmEsq, xSentEsq, HIGH(Horário) or LOW(AntiHorario), Valor[Retorno da Funcao PID]);
// Rodando motor Direito Ex: motorGira(xEnaDir, xPwmDir, xSentDir, HIGH(Horário) or LOW(AntiHorario), Valor[Retorno da Funcao PID]);
}

// xReadPin = 1 motor esquerdo
// xReadPin = 0 motor direito
void MotorPosicionar(int xPosCentral,int xReadPin, int xlock, int xPwm, int xPosMotorParam)
{
// xlock == 0 Operando - so executa do .. while uma unica vez sem travar os motores na saida
// xlock == 1 Centralizando - executa o do..while enquanto nao achar a posicao e na saida trava os motores
int xPwmInterno;
int xPosMotor;
do
{
if (xlock == 1)
{
xPosMotor = analogRead(xReadPin);
fPID(xReadPin, xkp, xki, xkd, xPosMotor, xPosCentral, 0);
xPwmInterno = xPidGlobal[xReadPin];
}
else
{
xPwmInterno = xPwm;
xPosMotor = xPosMotorParam;
}

if (xPosMotor <= xPosCentral - xDeadZone)
{
if (xReadPin == xReadEsq)
{
motorGira(xEnaEsq, xPwmEsq, xSentEsq, LOW, xPwmInterno);
//Serial.println(xPwm);
}
else if (xReadPin == xReadDir)
{
motorGira(xEnaDir, xPwmDir, xSentDir, LOW, xPwmInterno);
}
}
else if (xPosMotor >= xPosCentral + xDeadZone)
{
if (xReadPin == xReadEsq)
{
motorGira(xEnaEsq, xPwmEsq, xSentEsq, HIGH, xPwmInterno);
}
else if (xReadPin == xReadDir)
{
motorGira(xEnaDir, xPwmDir, xSentDir, HIGH, xPwmInterno);
}
}
else // Motor em questao esta posicionado entao deve ser parado
{
if (xReadPin == xReadEsq)
{
motorPara(xEnaEsq,xSentEsq,xPwmEsq);
}
else
{
motorPara(xEnaDir,xSentDir,xPwmDir);
}
}
} while (((xPosMotor <= xPosCentral - xDeadZone) || (xPosMotor >= xPosCentral + xDeadZone)) && (xlock == 1));

// se xlock ==1 entao para os motores na saida da rotina de loop quando executando centralizacao
if (xlock == 1)
{
if (xReadPin == xReadEsq)
{
motorPara(xEnaEsq,xSentEsq,xPwmEsq);
}
else
{
motorPara(xEnaDir,xSentDir,xPwmDir);
}
}
}