2DOF simulator servo model

Thnk you for the reply will have a look in more depth to the documentation.
I can understand the 100% per axis in the game and testing with Roll, pitch, heave... But when I'mdirectly using the axis it shouldn't have any impact.

Anyway I test it ... no change... , I've also reduce the Axis limiting.


A testI have already done in the past, but nothing change...


all it change is sending the code to the Arduino from 13 to 242 instead of 0 to 255
90 of 256 is 229-230 so the 90% of the total range242-13=229




Reading the pdf and tips toseeif I can find something...

Thank you!

Well, I'm using the

R<Axis1qa>~ based on the code:

now this one, as it seem towork berter:
R<Axis1a>R<Axis1a>L<Axis2a>L<Axis2a>F<Axis3a>F<Axis3a>V<Axis4a>V<Axis4a>~*

Let me do a video to show the jiggle at "-1"

Regarding the Code, I've edited to:
- extend to 6dof (but even in 2 dof I've the issue)
- add a lcd to display some info
- rework the code to move the motor all in one on '*'

Code:

//************************************************************************************************
// RC Model Servo
// Original code By EAOROBBIE (Robert Lindsay)
// Completely mangled by aarondc
// Reworked by Andy Strappazzon
// For free use for Sim Tool Motion Software
//***********************************************************************************************

// LibrairieLCD
// Ecran LCD
#include "LiquidCrystal.h"
LiquidCrystal lcd(3,2,11,10,9,8);


#include <Servo.h>
//#define DEBUG 1                                    // comment out this line to remove debuggin Serial.print lines
const int kActuatorCount = 6;                       // 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
// R<Axis1a>~L<Axis2a>~F<Axis3a>~V<Axis4a>~*
const char kActuatorName[kActuatorCount] = { 'R', 'L', 'F', 'V', 'M', 'N' };   ////'L', 'F', 'V','M','N'
const int kPins[kActuatorCount] = {4,5,6,7,12,13};                        // pins to which the Actuators are attached 4,5, 6, 7
const int kActuatorScale[kActuatorCount][2] = { { 179, 0 },         // R Actuator scaling ,
                                                { 179, 0 },         // L side Actuator scaling
                                                { 179, 0 },         // F
                                                { 179, 0 },         // V
                                                { 179, 0 },         // M
                                                { 179, 0 }          // N
                                               };     
const char kEOL = '~';                                    // End of Line - the delimiter for our acutator values
const char kESP = '*';                                    // end of Order - Execute positioning
const int kMaxCharCount = 3;                              // some insurance...
Servo actuatorSet[kActuatorCount];                        // our array of Actuators
int actuatorPosition[kActuatorCount] = {90,90,90,90,90,90};     // current Actuator positions, initialised to 90 , 90, 90, 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!!
int dataFromSimtools[kActuatorCount];                     // Data From Simtools live


// 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
// psEndOfLine
enum TPortState { psReadActuator, psReadValue, psEndOfLine };   
TPortState currentState = psReadActuator;


// Setup of the system
void setup()
{
    // attach the Actuators to the pins
    for (int i = 0; i < kActuatorCount; i++)
        actuatorSet[i].attach(kPins[i]);
    
    // initialise actuator position
    //for (int i = 0; i < kActuatorCount; i++)
        updateActuator(1);

    lcd.begin(16,2);    // Initialize the LCD Screen     
    Serial.begin(115200); // opens serial port at a baud rate of 9600
}



// Main loop not used
void loop()
{

}





// this code only runs when we have serial data available. ie (Serial.available() > 0).
// ------------------------------------------------------------------------------------
void serialEvent() {
    
    // Initialisation of variables
    //-----------------------------------------------
    char tmpChar;         // Character * or ~  RLVF
    int tmpValue;         // Value
    int oneAtTime;    // avoid multiple instance

    
    // Main While on Serial.available
    // -----------------------------
    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
                           for (int i = 0; i < kActuatorCount; i++) {
                                                if (tmpChar == kActuatorName[i]) {
                                          
                                                            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;
                                                }
                          }
                          // look for our actuator in the array of actuator names we set up
        }
        // if we're waiting for a Actuator name, grab it here
        //---------------------------------------------------



        
        // if we're ready to read in the current Actuator's position data
        // --------------------------------------------------------------
        if (currentState == psReadValue) {
            while ((valueCharCount < kMaxCharCount) && Serial.available()) {


                // Step One grab the Serial Message
                tmpValue = Serial.read();   // read Serial input
                
                
                // If differnet from the  end of line charachter  '~' or end of message '*'
                // -------------------------------------------------------------------------
                          if ((tmpValue != kEOL)||(tmpValue != kEOL)) {
                          tmpValue = int(tmpValue);
                          dataFromSimtools[currentActuator] = tmpValue;
                          actuatorPosition[currentActuator] = tmpValue;
                          valueCharCount++;                                           
                    
                          }
              // -----------------------------------------------
                        
                         else break;
            }
            
                          // if we've read the value delimiter, update the Actuator and start looking for the next Actuator name|| valueCharCount == kMaxCharCount
                          if (tmpValue == kEOL ) {
                                      
                                // Adjust the TempValue to avoid division per Zero
                                // scale the new position so the value is between 0 and 179   0 255
                                actuatorPosition[currentActuator] = map(actuatorPosition[currentActuator] -24, 1, 255, kActuatorScale[currentActuator][0], kActuatorScale[currentActuator][1]);
                                dataFromSimtools[currentActuator] = actuatorPosition[currentActuator];
                          
                          }

                          // if we'read the end of Order execute the update of the servo
                          //------------------------------------------------------------
                          if (tmpValue == kESP || valueCharCount == kMaxCharCount) {
            
                            updateActuator(currentActuator);
                            currentState = psReadActuator;
                          }

            
        }
    }


}
// ------------------------------------------------------------------------------------
// ------------------------------------------------------------------------------------


// write the current Actuator position to the passed in Actuator
//--------------------------------------------------------------
void updateActuator(int thisActuator) {





                lcd.setCursor(0,1);
                lcd.print('R');
                lcd.print(actuatorPosition[0]);
                lcd.setCursor(0,0);
                lcd.print('R');
                lcd.print(dataFromSimtools[0]);



                lcd.setCursor(4,1);
                lcd.print('L');
                lcd.print(actuatorPosition[1]);
                lcd.setCursor(4,0);
                lcd.print('L');
                lcd.print(dataFromSimtools[1]);

                lcd.setCursor(8,1);
                lcd.print('F');
                lcd.print(actuatorPosition[2]);
                lcd.setCursor(8,0);
                lcd.print('F');
                lcd.print(dataFromSimtools[2]);
                

                lcd.setCursor(12,1);
                lcd.print('V');
                lcd.print(actuatorPosition[3]);
                lcd.setCursor(12,0);
                lcd.print('V');
                lcd.print(dataFromSimtools[3]);
                
                
    //actuatorSet[thisActuator].write(actuatorPosition[thisActuator]);
    for (int i = 0; i < kActuatorCount; i++)
        actuatorSet[i].write(actuatorPosition[i]);
      


}

I can't believe it!

An update from my test...

Ok after multiple investigation, I change arduino for a Mega that I have in my bags...

And with the original code. I mange to make it work perfectly...

So I've upgrade to 6dof and try some test...

Thankx for the massages and help...

Hello everyone, for the first time, thank you for all this information. I wanted to recreate such a small simulator for myself.
Unfortunately I don't get any further. I am desperate. Hopefully someone can tell me where my mistake is.

Did everything according to these instructions. The test software worked and the motors moved as I set it up.

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', 'L' };
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[i].attach(kPins[i]);
    
    // 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[i]) {
#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]);
}

at "turn on" the Arduino goes on (LED is ON). but nothing moves ??

What information is still missing to isolate the problem.

Or did you already know it. Everyone (YouTube) sets the parameters and the motors move, just not with me.

Thanks for the help.

First, I want to congratulate you for the excellent work.
I am master (Mini Project 3DOF with 3 Micro Servo Motors S9 SG90).
My goal is to better understand the SIMTOOLS SOFTWARE, so that later I can build a 3DOF Simulator Platform with larger 12Volts or 24Volts Motors.
I'm a beginner, I need your help for my project.
I am very grateful for all the help and collaboration.

Helloo guys, this information has been working for me, my servos works very nice. But i have a question about live for speed. I installed simtools and everything is working, but when i want to get information from de LFS game, it apears simtools is'nt getting information. I patched the game using GameManager, there are a way to make me sure if i already installed de LFS plugging, even when it is supposed to install when simtools install.

Thanks sir, but now, how could i know if required files has been generated_

Thank youuuuuu! Its working, Im gratefull, where can i get some tips to fit the axis assigments? What would you recommend?

beautiful project congratulations! I think it would be very nice to modify an rc car and make sure that the tires stay still and the bodywork moves.