2DOF simulator servo model

Hi
Just wanted to try building a simulator with servos before getting in to the real deal.
Had a rc car just laying around that i could salvage servos and some other stuff from.

2x Hitec HS-311 servo
1x Traxxas u-joint
1x Arduino nano
Some cardboard



I've followed this guide when setting up simtools http://www.xsimulator.net/installing-simtools/
I've used eaorobie's arduino code and have set up my servos like he's done. http://www.xsimulator.net/community/threads/rc-model-for-motion-simulation.4600/

Now to the problem. When testing the output to the servos, the servo that is connected to pin 5 to the arduino, only moves between 0-90 degrees. When it at 90 degrees it moves back to 0 again. The other servo connected to pin 4 only moves to 90 and stays there. See video for more detail

i have managed to make rc servo move with @eaorobbie code this way
connection diagram http://www.xsimulator.net/community/threads/rc-model-for-motion-simulation.4600/
arduino code http://www.xsimulator.net/community/marketplace/rc-model-code-for-arduino-uno-2dof-expandable.89/
interface setup - IMPORTANT - Assuming a 2DOF for SimTools 2 the Interface Output should be set like this R<Axis1a>~L<Axis2a>~ https://www.xsimulator.net/community/attachments/rcsettings-jpg.48565/

and for expanding code to use more servo http://www.xsimulator.net/community/threads/my-project-guide-me.5682/#post-59262

and here it is moving with game



thnx to @eaorobbie i made my first project here and i am keep going

nice video

I see. I will tweak around with the settings to see if I solve the problem. Thanks

Hey Guys,

Cant find a wiring diagram for 3dof using Arduino and monster moto, plenty of 2d0f... can someone help. I have found a few 2d0f and 1 3dof but that is not using arduinos and mottos (see attached) I can't find the links anymore...sorry

I am creating a scale model myself using ardunio and monster moto boards before I go full scale. I want to make sure the model is working properly, i have created this board (just waiting on the pots)

and making the 3 motors pitch roll and yaw.

any help would be very much appreciated

Cheers

Dave

hi, where can i refer to set the axis assignment for 2 DOF?

currently i am using this setting.

It's not pitch and roll that you should have ??

Why there is a delay

Hi There, Hope you are well !

Any idea how to optimize the code?

I try to rework it, but still have some glich. The input seems to not be correctly manage and send thru other servo (I've extended to 3do, 4 dof but testing unde 2dof)


The first symptoms where when I was on -1 that trow the servo way out of range...
Then I see the servo totally out of mind... you change R and it move the number 2...


I have reworked multiple time, but as I'm not an expert, it start to be quite difficult...
- Added an LCD to get some message
- try to add a Stop code '*' in Simultool. R<Axis1a>~L<Axis2a>~F<Axis3a>~V<Axis4a>~*
- Try change the plug
- Try to optimize the Scaling

Noting really work...

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 = 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
// R<Axis1a>~L<Axis2a>~F<Axis3a>~V<Axis4a>~*
const char kActuatorName[kActuatorCount] = { 'R','L' };   ////'L', 'F', 'V'
const int kPins[kActuatorCount] = {4,7};                        // pins to which the Actuators are attached 4,5, 6, 7
const int kActuatorScale[kActuatorCount][2] = { { 1, 179 },         // R Actuator scaling ,
                                               { 1, 179 }          // L side Actuator scaling
                                              //{ 1, 179 } ,         // F
                                               //{ 1, 179 }           // V
                                               };     
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};     // 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;

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);         
    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() {
    
    // 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);
                          // Send to LCD for debug ----------
                           if (currentActuator == 0){
                           lcd.setCursor(0,0);
                           lcd.print('R');
                           lcd.print(tmpValue);
                           }
                          
                           if (currentActuator == 1){
                           lcd.setCursor(4,0);
                           lcd.print('L');
                           lcd.print(tmpValue);
                           }
                          
                           if (currentActuator == 2){
                           lcd.setCursor(8,0);
                           lcd.print('F');
                           lcd.print(tmpValue);
                           }
                          
                           if (currentActuator == 3){
                           lcd.setCursor(12,0);
                           lcd.print('V');
                           lcd.print(tmpValue);
                           }
                           // Send to LCD for debug ----------
                          
                              // Hysterisis Dead band kill
                              //if ((tmpValue < 0) || (tmpValue > 230)) tmpValue = 0;
                            
                            // if ((int(tmpValue) < 130) && (int(tmpValue) > 120)) {
                           //  tmpValue = 123;
                            // }
                          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
                          if (tmpValue == kEOL || valueCharCount == kMaxCharCount) {
                                      
                                // 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) {

                // Sent to LCD to debug
                 if (thisActuator == 0){
                 lcd.setCursor(0,1);
                 lcd.print('R');
                 lcd.print(actuatorPosition[thisActuator]);
                }
                
                if (thisActuator == 1){
                lcd.setCursor(4,1);
                lcd.print('L');
                lcd.print(actuatorPosition[thisActuator]);
                }

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


}

I try with these:
R<Axis1a>~L<Axis2a>~F<Axis3a>~V<Axis4a>~*

and these one where I double the info seems to work better:
R<Axis1a>~R<Axis1a>~L<Axis2a>~L<Axis2a>~F<Axis3a>~F<Axis3a>~V<Axis4a>~V<Axis4a>~*

I also try different Output type, Parity, or the 50ms... even the BitsPerSec...



My current code is here:

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] = { { 1, 179 },         // R Actuator scaling ,
                                                { 1, 179 },         // L side Actuator scaling
                                                { 1, 179 },         // F
                                                { 1, 179 },         // V
                                                { 1, 179 },         // M
                                                { 1, 179 }          // 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(9600); // 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]);
      


}

And in this kind of status it goes out of mind totally...
Moving another axis... really strange..

I have these settings fortesting now :




and forLFS:


Does it really matter ? As I'm testing within Simtool, with axes screen:



Seems, I'm two finger to have it correctly setup.... But can find the solution

for me the problem remain in the arduino to read the serial messages without skip, jump or incomplete message

Have you tried setting your baud rate differently?
That’s what helped me with interruption issues.

hi!
Thank you forthe reply.

Yes, try multiple one without success. The only parameter that seems to have an impact is this one in red:
When I put 50 the error seems to reduce. Note that if I put less than 30, the model jiggle around