Física dos Veículos: Parte 1 Aceleração

Estou estudando a física dos veículos aplicada a jogos, e achei diversos trabalhos interessantes na área é um assunto bem vasto e nesta parte vamos tratar apenas da aceleração longitudinal e o tutorial de base que eu estou seguindo é este

Então vamos lá, temos diversas forças atuando no veiculo e agora vamos tratar da força aplicada pelo motor até as rodas (estou desconsiderando a transmissão) isso ficará para o futuro, vamos chamar essa força Fengine. Depois vamos considerar a resistência do vento ela é definida por algumas constantes mágicas e a resistência do ar definida na Dinâmica dos fluidos, então temos:

 Fdrag = 0.5 * Cd * S * rho * (v*v)

Onde Cd = 0.30

S é a área frontal do veiculo aqui definimos como 2.2

rho é a Resistência do ar que é de 1.29

v é a velocidade do veiculo,

Fdrag é aplicada aposta a direção do veiculo então temos

Fdrag = -u * Fdrag

Onde u é a direção do veiculo

Temos também a Frr que é a resistência do solo (fricção das rodas) que é definida por:

Frr = -u * Crr * v * |v|

Cdrag = 0.5 * Cd * S * rho

 

Crr = 30 * Cdrag

Frr = -u * Crr

Considerando essas forças atuando no veículo fica desta maneira

Flong = Fengine + Fdrag + Frr

Lembrando que segundo Newton

 v = v + dt * a

a = F / M

Fiz a integração deste calculo no FreeMat  (Equivalente Open Source do MatLab) o resultado de v é:

Perceba que em determinado ponto como as forças estão interrelacionadas, elas se mantén constantes, segue o código:

l = 100

t = [1:l]; %Array de Tempo

v = [1:l]; %Array de Velocidade

u = 1; %Direção do veiculo

rho = 1.29; %resistencia do veloar (Dinamica dos Fluidos)

a = 1; %Aceleração

Cd = 0.30; %Constante de Resistencia do Ar

S = 2.2; % Constante de Largurado Veiculo

Fengine = 450; % Força do Motor

tAmount =1; %Posição do Acelerador em porcentagem

M = 1000 % Massa do Veiculo

Fd = [1:l];

Fr = [1:l];

for (i=2:l);

dt = (t(i) - t(i-1));

vt = v(i-1) + (dt * a); %integração da Velocidade

Fdrag = (0.5 * Cd * S * rho * (vt*vt)); % Resistencia do Vento

Cdrag = 0.5 * Cd * S * rho; %Constante de Resistencia da Solo

Crr = 30*Cdrag; %Resistencia do Vento

Fdrag = -u * Fdrag; %Forca da Resistencia do Vento

Frr = -u * Crr * vt * sqrt(vt); % Forca da Resistencia do Solo

Fe = u*tAmount*Fengine; %Forca do Motor

F = Fe + Fdrag+ Frr; %Calculo das forças do Veiculo

a = F / M; %Calculo da Aceleracao

v(i) = vt;

Fd(i) = Fdrag*-1;

Fr(i) = Frr*-1;

end

plot(t,v)

xlabel('Velocidade');

ylabel('Tempo');

title('Aceleração Longitudional');

 Na próxima parte vamos estudar as transmissões (Marchas) o RPM e as Rodas, e vamos integrar a Simulação na Open Dynamics Engine, espero que tenha gostado e seu Feed Back vai ajudar nas próximas partes

Rotação com a classe de Matrizes C++

Boa tarde pessoal  a um bom tempo trabalho em uma classe de manipulação de matrizes, até o momento só implemente a cópia de matrizes e o operador Igual (=) e a multiplicação (*),

Na classe a métodos que cria matrizes em torno do eixo X, Y  e Z, na Engine o Z aponta para cima no caso para setar a posição da câmera fica desta maneira

glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
Matrix rz,ry,rx,mm;
rz.RotZ(90);
ry.RotY(90);
rx.RotY(-68); 

mm.setIdentity();
mm = ry * rz *rx;
glMultMatrixf(mm.m);

glTranslatef(6.78,18.78,-5);

O Resultado é este:

 

Segue abaixo as classes de Matrizes

//Matrix.h

# include "vec3d.h"

class Matrix

{

 public:

   float m[16];

   Matrix();

   void setIdentity();

   void RotX(float a);

   void RotY(float a);

   void RotZ(float a);

   Matrix& operator*(const Matrix& mat);

   Matrix& operator=(const Matrix& mat);

   //Matrix operator+(Matrix& mat);

   //Matrix operator-(Matrix& mat);

};

//Matrix.cpp

#include

#define M(x,y) (y*4+x)

/**

 * Classe para Manipulação de matrizes

 */

Matrix::Matrix()

{

 setIdentity();

}

/**

 * seta a matrix como identidade

 * |1 0 0 0|

 * |0 1 0 0|

 * |0 0 1 0|

 * |0 0 0 1|

 */

void Matrix::setIdentity()

{

 m[0]  = 1.0f;  m[1]  = 0.0f; m[2]  = 0.0f; m[3]  = 0.0f;

 m[4]  = 0.0f;  m[5]  = 1.0f; m[6]  = 0.0f; m[7]  = 0.0f;

 m[8]  = 0.0f;  m[9]  = 0.0f; m[10] = 1.0f; m[11] = 0.0f;

 m[12] = 0.0f; m[13]  = 0.0f; m[14] = 0.0f; m[15] = 1.0f;

}

/**

 * Multiplica a Matrix por um vetor 3x1

 */

vec3d vecbymat(vec3d vec, Matrix mat)

{

   vec3d r;

   r.x = mat.m[0] * vec.x + mat.m[1]  * vec.y + mat.m[2]    * vec.z + mat.m[3];

   r.y = mat.m[4] * vec.x + mat.m[5]  * vec.y + mat.m[6]    * vec.z + mat.m[7];

   r.z = mat.m[8] * vec.x + mat.m[9]  * vec.y + mat.m[10]   * vec.z + mat.m[11];

   return r;

}

Matrix& Matrix::operator*(const Matrix& mat)

{

                float _m[16];

                for(int i = 0; i <4;i++)

                               for(int j = 0; j<4; j++)

                               {

                                               float sum = 0.0f;

                                               for(int k=0;k<4;k++)

                                                               sum += this->m[i*4+k] * mat.m[k*4+j];

                                               _m[i*4+j] = sum;

                               }

   memcpy(this->m,_m,sizeof(float)*16);

                return *this;

}

Matrix& Matrix::operator=(const Matrix& mat)

{

                memcpy(this->m,mat.m,sizeof(float)*16);

                return *this;

}

void Matrix::RotX(float a)

{

                float c = cosf(DEG2RAD(a));

                float s = sinf(DEG2RAD(a));

                m[0]  = 1.0f;  m[1]  =  0.0f; m[2]  = 0.0f; m[3]  = 0.0f;

                m[4]  = 0.0f;  m[5]  =  c;    m[6]  = s;    m[7]  = 0.0f;

                m[8]  = 0.0f;  m[9]  =  -s;   m[10] = c;    m[11] = 0.0f;

                m[12] = 0.0f; m[13]  =  0.0f; m[14] = 0.0f; m[15] = 1.0f;

}

void Matrix::RotY(float a)

{

                 float c = cosf(DEG2RAD(a));

                 float s = sinf(DEG2RAD(a));

                 m[0]  = c;     m[1]   = 0.0f; m[2]  =  -s; m[3]  = 0.0f;

                 m[4]  = 0.0f;  m[5]   = 1.0f; m[6]  =  0.0f; m[7]  = 0.0f;

                 m[8]  = s;     m[9]   = 0.0f; m[10] =  c; m[11] = 0.0f;

                 m[12] = 0.0f;  m[13]  = 0.0f; m[14] =  0.0f; m[15] = 1.0f;

}

void Matrix::RotZ(float a)

{

                 float c = cosf(DEG2RAD(a));

                  float s = sinf(DEG2RAD(a));

                  m[0]  = c;     m[1]   = s;    m[2]  = 0.0f; m[3]  = 0.0f;

                  m[4]  = -s;    m[5]   = c;    m[6]  = 0.0f; m[7]  = 0.0f;

                  m[8]  = 0.0f;  m[9]   = 0.0f; m[10] = 1.0f; m[11] = 0.0f;

                  m[12] = 0.0f;  m[13]  = 0.0f; m[14] = 0.0f; m[15] = 1.0f;

}

Só para refrescar a memória as matrizes de rotação seguem abaixo:

Ánalise numérica ON-LINE

Galera achei uma interface web para o programa GNU Octave (equivalente ao Matlab), os gentis senhores do Department of Mathematics, Warsaw University. (Polonia), emprestão seus processadores para fazermos os nossos calculos on-line.

 

me divertindo um pouco criei esta plot:

x = y = -10:0.1:10;
[X,Y] = meshgrid(x,y);
mesh(X,Y,(1./X).*sin(X).*(1./Y).*sin(Y));

não há limites quanto ao tempo de computação mais esses generosos senhores pedem:

"Please do not submit codes that will run for a long time or take up a lot of memory. This service is intended for occasional, quick computations. Use "Files -> Remove all files" button to clear your workspace after you are done. All your activities are being logged. If you don't like this policy, don't use this service. "




agora quando tiver perdido em algum lugar em posse de um computador e tiver que fazer um calulo já sabe onde deve ir: http://hara.mimuw.edu.pl/weboctave/web/index.php

a interface Web é um projeto Open Source  está no Source Forge
http://sourceforge.net/projects/weboctave/