2DOF Motion SIM Model - Arduino Uno

Hey guys,

Haven't posted for a while. Not sure if you remember but a few months back I was having some troubles getting the SIM of the ground but thanks to @eaorobbie , the idea of using servos rather than dc motors certainly made our vision feasible and we are now at the early stages of building our first SIM.

My colleague (metal fabricator) has been constructing the SIM whilst I have been assisting with the software related areas (i.e. Arduino sketch and SimTools etc).

Anyway, my colleague wanted me to upload this video and would welcome any comments. We have been playing around with the Tuning Center and various profile settings in Game Engine but we still feel that correlation between in-game-motion and simulator motion is not where we would like it to be.

I will post back later with the Game Engine settings we have been using. Just thought I would present the video first.

I should also point out that this video is few weeks old and my colleague has already made some additions to the SIM. One major addition has been the attaching of an accelerometer to the SIM. We were hoping the data outputted by the accelerometer might build on the information derived from the Simtools Tuning Centre. Unfortunately, the data derived at this stage has been rather inconclusive.

Looking forward to your comments.

Mark

hi @marky000 IMO there may be something wrong with any settings.

Thanks heaps @yobuddy. I will take some time to try the things you suggested. In the meantime, here is the profile settings that I think were used at the time of the video being created:




Interesting that you mentioned surge and sway because most of the write-ups I have seen have been using roll and pitch.

Pitch and surge as well as roll and sway often behave likewise. The hood of the car goes up when accelerating → pitch up, the car rolls in a curve, where you also experience sway. [Just to mention: yaw and heave are not in sync.] Therefore sway/roll, surge/pitch are somewhat similar.

As far as i can see you @marky000 are using the Arduino code of RacingMat, please have a look to the linked screenshot below and correct your settings (BitsPerSec, Outputtype...) http://www.xsimulator.net/community/attachments/com-output-simtools-jpg.9478/

PS!!! Interface output is wrong, you have mistyped using "P" instead of "L"

Just my friendly advice: @Guys, if you have any issues we will help ASAP but first read thoughtfully the manuals or instructions. Thank you.

i used @eaorobbie 's code
http://www.xsimulator.net/community/threads/rc-model-for-motion-simulation.4600/
and some more explanation
http://www.xsimulator.net/community/threads/my-project-guide-me.5682/#post-59229
http://www.xsimulator.net/community/threads/my-project-guide-me.5682/#post-59262

@Pit Not true. Using @eaorobbie arduino code. As you can see in the code, Actuator Name = R, P

Code:

//********************************************************************************************
// RC Model Servo
// Original code By EAOROBBIE (Robert Lindsay)
// Completely mangled by aarondc
// For free use for Sim Tool Motion Software
//********************************************************************************************
#include <Servo.h>
//#define DEBUG 1                                    // comment out this line to remove debuggin Serial.print lines
const int kActuatorCount = 2;                       // how many Actuators we are handling

// the letters ("names") sent from Sim Tools to identify each actuator
// NB: the order of the letters here determines the order of the remaining constants kPins and kActuatorScale
const char kActuatorName[kActuatorCount] = { 'R', 'P'};
const int kPins[kActuatorCount] = {4, 5};                       // pins to which the Actuators are attached
const int kActuatorScale[kActuatorCount][2] = { { 0, 179 } ,    // Right Actuator scaling
                                                { 179, 0 }      // Left side Actuator scaling
                                               };    
const char kEOL = '~';                              // End of Line - the delimiter for our acutator values
const int kMaxCharCount = 3;                        // some insurance...
Servo actuatorSet[kActuatorCount];                  // our array of Actuators
int actuatorPosition[kActuatorCount] = {90, 90};    // current Actuator positions, initialised to 90
int currentActuator;                                // keep track of the current Actuator being read in from serial port
int valueCharCount = 0;                             // how many value characters have we read (must be less than kMaxCharCount!!

// set up some states for our state machine
// psReadActuator = next character from serial port tells us the Actuator
// psReadValue = next 3 characters from serial port tells us the value
enum TPortState { psReadActuator, psReadValue };
TPortState currentState = psReadActuator;

void setup()
{
    // attach the Actuators to the pins
    for (int i = 0; i < kActuatorCount; i++)
        actuatorSet.attach(kPins);
 
    // initialise actuator position
    for (int i = 0; i < kActuatorCount; i++)
        updateActuator(i);
 
    Serial.begin(9600); // opens serial port at a baud rate of 9600
}

void loop()
{

}

// this code only runs when we have serial data available. ie (Serial.available() > 0).
void serialEvent() {
    char tmpChar;
    int tmpValue;

    while (Serial.available()) {
        // if we're waiting for a Actuator name, grab it here
        if (currentState == psReadActuator) {
            tmpChar = Serial.read();
            // look for our actuator in the array of actuator names we set up
#ifdef DEBUG          
Serial.print("read in ");          
Serial.println(tmpChar);          
#endif
            for (int i = 0; i < kActuatorCount; i++) {
                if (tmpChar == kActuatorName) {
#ifdef DEBUG          
Serial.print("which is actuator ");          
Serial.println(i);          
#endif
                    currentActuator = i;                        // remember which actuator we found
                    currentState = psReadValue;                 // start looking for the Actuator position
                    actuatorPosition[currentActuator] = 0;      // initialise the new position
                    valueCharCount = 0;                         // initialise number of value chars read in
                    break;
                }
            }
        }
     
        // if we're ready to read in the current Actuator's position data
        if (currentState == psReadValue) {
            while ((valueCharCount < kMaxCharCount) && Serial.available()) {
                tmpValue = Serial.read();
                if (tmpValue != kEOL) {
                    tmpValue = tmpValue - 48;
                    if ((tmpValue < 0) || (tmpValue > 9)) tmpValue = 0;
                    actuatorPosition[currentActuator] = actuatorPosition[currentActuator] * 10 + tmpValue;
                    valueCharCount++;
                }
                else break;
            }
         
            // if we've read the value delimiter, update the Actuator and start looking for the next Actuator name
            if (tmpValue == kEOL || valueCharCount == kMaxCharCount) {
#ifdef DEBUG          
Serial.print("read in ");          
Serial.println(actuatorPosition[currentActuator]);          
#endif
                // scale the new position so the value is between 0 and 179
                actuatorPosition[currentActuator] = map(actuatorPosition[currentActuator], 0, 255, kActuatorScale[currentActuator][0], kActuatorScale[currentActuator][1]);
#ifdef DEBUG          
Serial.print("scaled to ");          
Serial.println(actuatorPosition[currentActuator]);          
#endif
                updateActuator(currentActuator);
                currentState = psReadActuator;
            }
        }
    }
}

// write the current Actuator position to the passed in Actuator
void updateActuator(int thisActuator) {
    actuatorSet[thisActuator].write(actuatorPosition[thisActuator]);
}

mea culpa, this code was not known to me. Sorry for the false information. Anyway I suggest you to try out the proven SMC3 code.