Question Need 6dof configuration for simtools

Hi, I'm building a mini model of a 6dof rig using servo motors to sync with LFS. I've assembled the platform and connected to Arduinos, yet a few questions :
1. Do I need motor controller and what type ?
2. Can't figure out the simtools configuration for axis, interface and such ( I have the free/demo version ).
So if anyone would help me I'd be grateful.

I'm trying to replicate hooshang's rig, I have the platform set but I'm confused how to move forward.
Currently I have just the Arduinos and servo motors, unsure if I need motor controllers or SMC3 to make it work just like that.
Would appreciate if I get specific instructions as codes/software isn't exactly my forte

Quick question, how does the servo code and simtools relate ?

So first I run the code, then simtools simultaneously takes data from the game to manipulate the code and thus the motors ?

Strange, simtools isn't registering or working on 2 of my 6 motors after implementing the code and configuring
any idea why this is happening

My friend has taken it off my hands to have a look. will update you as soon as he returns it. till then, can you give an example of what a modified code should really look like for my rig ?
please and thank you

Welp, I guess I didn't configure the Interface properly. A little help with this axis assignment ?
Also, t his is the code I've been using


#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
const char kActuatorName[kActuatorCount] = { 'A', 'B' , 'C' , 'D' , 'E' , "F" };
const int kPins[kActuatorCount] = {4, 5, 6, 7, 8, 9}; // pins to which the Actuators are attached
const int kActuatorScale[kActuatorCount][6] = { { 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]);
}

I guess I'm still doing something wrong with the interface, looking at my axis assignment what should I put in the interface output box ? I'm using Serial type interface 9600 bits

So far I'm here. Fried some pins on one of my Arduinos testing the servos. Any specific power supplies/ battery recommendations for MG995/ MG996R servos ? Would appreciate if it is possible for a single Arduino to do it via simtools.

Update : I'm trying FlyPT for Assetto Corsa, using this code to upload to an ESP32 for testing purpose .
Uploaded this, tried the interfacing with the Output window but no movement in platform

#include <Servo.h>

// Define servo objects for 6 servo motors
Servo servo1, servo2, servo3, servo4, servo5, servo6;

void setup() {
// Initialize serial communication at 9600 baud rate
Serial.begin(9600);

// Attach servo objects to corresponding pins
servo1.attach(2);
servo2.attach(3);
servo3.attach(4);
servo4.attach(5);
servo5.attach(6);
servo6.attach(7);
}

void loop() {
// Check if data is available to read from serial port
if (Serial.available() >= 18) { // Assuming each set of three numbers is sent for each DOF
// Read incoming data for all 6 DOFs
int dof1 = mapValue(Serial.parseInt(), 0, 1023, 0, 180);
int dof2 = mapValue(Serial.parseInt(), 0, 1023, 0, 180);
int dof3 = mapValue(Serial.parseInt(), 0, 1023, 0, 180);
int dof4 = mapValue(Serial.parseInt(), 0, 1023, 0, 180);
int dof5 = mapValue(Serial.parseInt(), 0, 1023, 0, 180);
int dof6 = mapValue(Serial.parseInt(), 0, 1023, 0, 180);

// Control servo motors based on incoming DOF data
servo1.write(dof1);
servo2.write(dof2);
servo3.write(dof3);
servo4.write(dof4);
servo5.write(dof5);
servo6.write(dof6);
}
}

// Function to map incoming value to new range
int mapValue(int value, int fromLow, int fromHigh, int toLow, int toHigh) {
return map(value, fromLow, fromHigh, toLow, toHigh);
}

Did you set the rig for 10 bits (0 to 1024) in the rig module of Mover?
In your code you are using 9600 baud rate, in Mover you have 115200, it should be the same.
Also, serial is a stream, you have no way to know when you are receiving the data for the first axis.
You need to use a delimiter for that in your string.
For example 3 bytes with 255, that's something that never happens for 10 bits

So do I change the bits in the mover or the code ? I'm not sure I understand anything after the "serial is a stream..." Don't happen to be a coder geek . All I have is a basic understanding and made this code using bits and pieces from online and some ai. Also, is it fine if I change the range of motors 2,4,6 with 180,0 ( since it's inverted on the 2 4 6 position? )