MMOS controller with cheap servo drive and motor

Hi all - I've been working on this project for a long time now, and thought it might be useful to others.

It's basically a STM32F4Discovery board running the MMOS controller, with an Arduino to help it communicate with a cheap Chinese servo driver and motor. The full instructions can be found in the attached PDF.

Here's a video, just to show that it actually works:

Here's the sketch for the Arduino:

Code:

// Interface for using the MMOS controller software with a cheap driver+motor.
// Connects between the STM32F4Discovery and the servo driver.
// More information on the MMOS FFB software on https://forum.virtualracing.org/showthread.php/92420-DIY-USB-Force-Feedback-Controller
// The torque hex commands in this sketch work with the Leadshine HBS86H driver and possibly ES-D1008 (they should be similar).


// Disco pin PA0 to driver EA+,
// Disco pin PA1 to driver EB+
// Disco GND to driver EGND
// Disco GND to Arduino GND
// Arduino pin 3 to Disco pin PE9
// Arduino pin 4 to Disco pin PE11
// Arduino pin 9 to servo driver PUL+
// Arduino pin 13 to servo driver DIR+
// Arduino GND to servo driver PUL- and DIR-

// micro step resolution must be set to 200

byte PWM_OUT_PIN = 3;
int pwm_value;
int pwm_valueSum;
int pwm_value1;
int pwm_value2;
int pwm_value3;
int pwm_value4;
int pwm_value5;
int pwm_value6;
int pwm_value7;
int pwm_value8;
int pwm_value9;
int pwm_value0;

int delayshort = 1;
int delaylong = 8;

byte DIR_IN_PIN = 4;
int Dir1 = 0;
int Dir2 = 0;
byte STEP_OUT_PIN = 9; 
byte DIR_OUT_PIN = 13; 


void setup()
{   Serial.begin(9600);
  pinMode(PWM_OUT_PIN, INPUT);
  pinMode(DIR_IN_PIN, INPUT);
  pinMode(STEP_OUT_PIN, OUTPUT);
    pinMode(DIR_OUT_PIN, OUTPUT);

// initialization   
      
delay (7000);  // wait seven seconds while the user turns on the driver
byte Kp000 [] = {0x01, 0x06, 0x00, 0x06, 0x00, 0x00, 0x69, 0xCB}; // set the wheel force to zero
    Serial.write(Kp000, 8);

    
    Serial.println("");

     
      // set the wheel 1000 steps offcenter
for(int i=0; i < 1000; i++){     
   digitalWrite(STEP_OUT_PIN, HIGH);
   delayMicroseconds(6);    
  digitalWrite(STEP_OUT_PIN, LOW);
   delayMicroseconds(6);
  }
   
}
void loop() {

Dir2=Dir1;
Dir1=digitalRead(DIR_IN_PIN);


  // take 10 samples of the length of the PWM signal comming from the Disco
pwm_value0 = pulseIn(PWM_OUT_PIN, HIGH);
  delay (delayshort); 
pwm_value1 = pulseIn(PWM_OUT_PIN, HIGH);
  delay (delayshort); 
pwm_value2 = pulseIn(PWM_OUT_PIN, HIGH);
  delay (delayshort);   
pwm_value3 = pulseIn(PWM_OUT_PIN, HIGH);
  delay (delayshort);   
pwm_value4 = pulseIn(PWM_OUT_PIN, HIGH);
  delay (delayshort);   
pwm_value5 = pulseIn(PWM_OUT_PIN, HIGH);
  delay (delayshort);   
pwm_value6 = pulseIn(PWM_OUT_PIN, HIGH);
  delay (delayshort);   
pwm_value7 = pulseIn(PWM_OUT_PIN, HIGH);
  delay (delayshort);   
pwm_value8 = pulseIn(PWM_OUT_PIN, HIGH);
  delay (delayshort);   
pwm_value9 = pulseIn(PWM_OUT_PIN, HIGH);
  delay (delayshort); 

//make an average of the 10 values
pwm_valueSum = pwm_value0 + pwm_value1 + pwm_value2 + pwm_value3 + pwm_value4 + pwm_value5 + pwm_value6 + pwm_value7 + pwm_value8 + pwm_value9 ;
pwm_value = pwm_valueSum / 10;

// determine if the directional signal from the Disco has changed, if it has, then set torque to zero and tell driver to turn 2000 steps in the new direction.
if (Dir2!=Dir1) {
  byte Kp000 [] = {0x01, 0x06, 0x00, 0x06, 0x00, 0x00, 0x69, 0xCB};
   byte CloLoop00 [] = {0x01, 0x06, 0x00, 0x52, 0x00, 0x00, 0x28, 0x1B};

Serial.write(Kp000, 8);
  Serial.println("");
delay (delaylong);
  Serial.write(CloLoop00, 8);
  Serial.println("");
   
  digitalWrite(DIR_OUT_PIN, Dir1);  
 
for(int i=0; i < 2000; i++){
 
digitalWrite(STEP_OUT_PIN, HIGH);
   delayMicroseconds(6);    
  digitalWrite(STEP_OUT_PIN, LOW);
   delayMicroseconds(6);
  }
  }

// Define the level of torque for a given length of the pwm signal.
int Level00=0;
int Level01=2;
int Level02=5;
int Level03=7;
int Level04=10;
int Level05=12;
int Level06=14;
int Level07=17;
int Level08=19;
int Level09=22;
int Level10=24;
int Level11=26;
int Level12=29;
int Level13=31;
int Level14=33;
int Level15=36;
int Level16=38;
int Level17=41;
int Level18=43;
int Level19=45;
int Level20=48;
int Level21=50;
int Level22=53;


// define the hex commands that will be sent to the driver via serial to control the torque

byte CloLoop00 [] = {0x01, 0x06, 0x00, 0x52, 0x00, 0x00, 0x28, 0x1B};
byte CloLoop10 [] = {0x01, 0x06, 0x00, 0x52, 0x00, 0x0A, 0xA8, 0x1C};
byte CloLoop20 [] = {0x01, 0x06, 0x00, 0x52, 0x00, 0x14, 0x28, 0x14};
byte CloLoop30 [] = {0x01, 0x06, 0x00, 0x52, 0x00, 0x1E, 0xA8, 0x13}; 
byte CloLoop35 [] = {0x01, 0x06, 0x00, 0x52, 0x00, 0x23, 0x69, 0xC2};
byte CloLoop40 [] = {0x01, 0x06, 0x00, 0x52, 0x00, 0x28, 0x28, 0x05};
byte CloLoop45 [] = {0x01, 0x06, 0x00, 0x52, 0x00, 0x2D, 0xE8, 0x06};
byte CloLoop50 [] = {0x01, 0x06, 0x00, 0x52, 0x00, 0x32, 0xA9, 0xCE}; 
byte CloLoop55 [] = {0x01, 0x06, 0x00, 0x52, 0x00, 0x37, 0x69, 0xCD};
byte CloLoop60 [] = {0x01, 0x06, 0x00, 0x52, 0x00, 0x3C, 0x28, 0x0A};
byte CloLoop70 [] = {0x01, 0x06, 0x00, 0x52, 0x00, 0x46, 0xA9, 0xE9};
byte CloLoop80 [] = {0x01, 0x06, 0x00, 0x52, 0x00, 0x50, 0x28, 0x27};
byte Kp0000 [] = {0x01, 0x06, 0x00, 0x06, 0x00, 0x00, 0x69, 0xCB};
byte Kp0100 [] = {0x01, 0x06, 0x00, 0x06, 0x00, 0x64, 0x68, 0x20};
byte Kp0200 [] = {0x01, 0x06, 0x00, 0x06, 0x00, 0xC8, 0x68, 0x5D}; 
byte Kp0300 [] = {0x01, 0x06, 0x00, 0x06, 0x01, 0x2C, 0x69, 0x86};
byte Kp0400 [] = {0x01, 0x06, 0x00, 0x06, 0x01, 0x90, 0x68, 0x37};
byte Kp0450 [] = {0x01, 0x06, 0x00, 0x06, 0x01, 0xC2, 0xE9, 0xCA};
byte Kp0500 [] = {0x01, 0x06, 0x00, 0x06, 0x01, 0xF4, 0x69, 0xDC};
byte Kp0550 [] = {0x01, 0x06, 0x00, 0x06, 0x02, 0x26, 0xE9, 0x71};
byte Kp0600 [] = {0x01, 0x06, 0x00, 0x06, 0x02, 0x58, 0x69, 0x51};
byte Kp0650 [] = {0x01, 0x06, 0x00, 0x06, 0x02, 0x8A, 0xE9, 0x0C};
byte Kp0700 [] = {0x01, 0x06, 0x00, 0x06, 0x02, 0xBC, 0x69, 0x1A};
byte Kp0800 [] = {0x01, 0x06, 0x00, 0x06, 0x03, 0x20, 0x68, 0xE3};
byte Kp0900 [] = {0x01, 0x06, 0x00, 0x06, 0x03, 0x84, 0x69, 0x58};
byte Kp1000 [] = {0x01, 0x06, 0x00, 0x06, 0x03, 0xE8, 0x69, 0x75};
byte Kp1200 [] = {0x01, 0x06, 0x00, 0x06, 0x04, 0xB0, 0x6A, 0xBF};
byte Kp1500 [] = {0x01, 0x06, 0x00, 0x06, 0x05, 0xDC, 0x6B, 0x02};
byte Kp1600 [] = {0x01, 0x06, 0x00, 0x06, 0x06, 0x40, 0x6B, 0x9B}; 
byte Kp3200 [] = {0x01, 0x06, 0x00, 0x06, 0x0C, 0x80, 0x6D, 0x6B};


// send the torque commands that correspond to the length of the pwm signal.

if ( pwm_value <= Level00) {

    Serial.write(Kp0000, 8);
    Serial.println("");
    delay (delaylong);
    Serial.write(CloLoop00, 8);
    Serial.println("");

}


if (pwm_value > Level00  && pwm_value <= Level01) {    
 

    Serial.write(Kp0100, 8);
    Serial.println("");
    delay (delaylong);  // The drive can only accept about 50 commands per second. This delay ensures that both commands are applied.
    Serial.write(CloLoop10, 8);
    Serial.println("");

}

if (pwm_value > Level01  && pwm_value <= Level02) {    
 

    Serial.write(Kp0200, 8);
    Serial.println("");
    delay (delaylong);
    Serial.write(CloLoop10, 8);
    Serial.println("");

}
if (pwm_value > Level02  && pwm_value <= Level03) {    

    Serial.write(Kp0200, 8);
    Serial.println("");
    delay (delaylong);
    Serial.write(CloLoop20, 8);
    Serial.println("");

}
if (pwm_value > Level03  && pwm_value <= Level04) {    
    Serial.write(Kp0300, 8);
    Serial.println("");
    delay (delaylong);
    Serial.write(CloLoop20, 8);
    Serial.println("");
 
}
if (pwm_value > Level04  && pwm_value <= Level05) {
    
    Serial.write(Kp0300, 8);
    Serial.println("");
    delay (delaylong);
    Serial.write(CloLoop30, 8);
    Serial.println("");
}
if (pwm_value > Level05  && pwm_value <= Level06) {
     Serial.write(Kp0400, 8);
    Serial.println("");
    delay (delaylong);
    Serial.write(CloLoop30, 8);
    Serial.println("");
}


if (pwm_value > Level06  && pwm_value <= Level07) {
     Serial.write(Kp0400, 8);
    Serial.println("");
   delay (delaylong);
    Serial.write(CloLoop35, 8);
    Serial.println("");
   
}

if (pwm_value > Level07  && pwm_value <= Level08) {
     Serial.write(Kp0450, 8);
    Serial.println("");
    delay (delaylong);
    Serial.write(CloLoop35, 8);
    Serial.println("");
}
if (pwm_value > Level08  && pwm_value <= Level09) {
     Serial.write(Kp0450, 8);
    Serial.println("");
    delay (delaylong);
    Serial.write(CloLoop40, 8);
    Serial.println("");
}
if (pwm_value > Level09  && pwm_value <= Level10) {
     Serial.write(Kp0500, 8);
    Serial.println("");
    delay (delaylong);
    Serial.write(CloLoop40, 8);
    Serial.println("");

}

if (pwm_value > Level10  && pwm_value <= Level11) {
     Serial.write(Kp0500, 8);
    Serial.println("");
    delay (delaylong);
    Serial.write(CloLoop45, 8);
    Serial.println("");

}




if (pwm_value > Level11  && pwm_value <= Level12) {    

    Serial.write(Kp0600, 8);
    Serial.println("");
    delay (delaylong);
    Serial.write(CloLoop45, 8);
    Serial.println("");

}
if (pwm_value > Level12  && pwm_value <= Level13) {    
    Serial.write(Kp0600, 8);
    Serial.println("");
    delay (delaylong);
    Serial.write(CloLoop50, 8);
    Serial.println("");
 
}
if (pwm_value > Level13  && pwm_value <= Level14) {
    
    Serial.write(Kp0700, 8);
    Serial.println("");
    delay (delaylong);
    Serial.write(CloLoop50, 8);
    Serial.println("");
}
if (pwm_value > Level14  && pwm_value <= Level15) {
     Serial.write(Kp0700, 8);
    Serial.println("");
    delay (delaylong);
    Serial.write(CloLoop55, 8);
    Serial.println("");
}


if (pwm_value > Level15  && pwm_value <= Level16) {
     Serial.write(Kp0800, 8);
    Serial.println("");
    delay (delaylong);
    Serial.write(CloLoop55, 8);
    Serial.println("");
   
}

if (pwm_value > Level16  && pwm_value <= Level17) {
     Serial.write(Kp0800, 8);
    Serial.println("");
    delay (delaylong);
    Serial.write(CloLoop60, 8);
    Serial.println("");
}

if (pwm_value > Level17  && pwm_value <= Level18) {
     Serial.write(Kp0900, 8);
    Serial.println("");
    delay (delaylong);
    Serial.write(CloLoop60, 8);
    Serial.println("");
}
if (pwm_value > Level18  && pwm_value <= Level19) {
     Serial.write(Kp0900, 8);
    Serial.println("");
    delay (delaylong);
    Serial.write(CloLoop70, 8);
    Serial.println("");

}

if (pwm_value > Level19  && pwm_value <= Level20) {
     Serial.write(Kp1000, 8);
    Serial.println("");
    delay (delaylong);
    Serial.write(CloLoop70, 8);
    Serial.println("");

}



if (pwm_value > Level20  && pwm_value <= Level21) {
     Serial.write(Kp1000, 8);
    Serial.println("");
    delay (delaylong);
    Serial.write(CloLoop80, 8);
    Serial.println("");

}

if (pwm_value > Level21  && pwm_value <= Level22) {
     Serial.write(Kp1200, 8);
    Serial.println("");
    delay (delaylong);
    Serial.write(CloLoop80, 8);
    Serial.println("");

}



if (pwm_value > Level22 ) {

    Serial.write(Kp1600, 8);
    Serial.println("");
    delay (delaylong);
    Serial.write(CloLoop80, 8);
    Serial.println("");
         

}
}

Nice work! The sound of the motor working makes it seem like maybe there is cogging/torque ripple/low fidelity. Have you driven a typical direct drive wheel to compare at all?

how much did you invest in your project?

I haven't had a chance to compare it with any other direct drive wheel, but I'm pretty sure that this one is not nearly as good as any of the more expensive direct drive wheels. There is a bit of a feeling that it is cogging or 'rubbing'. Tuning the drive has taken away some of it, and it doesn't bother me too much.
As a side note, I've measured that the drive can receive about 50 torque change command via serial every second. So the update rate is roughly 50 Hz, which is not very impressive. But again, it works OK for me, I've used the wheel for many hours of driving, and it feels better than the Momo wheel I had some years ago.

The drive + motor is a noname clone of a Leadshine HBS86H system, and
cost less that 100 USD, you can find it here: https://item.taobao.com/item.htm?sp...=e0efb180-9d8e-4695-8dae-0f7f6bbea7d9&idnum=0

I don't think it's availavable outside China, though, so perhaps you'd have to dish out a bit more for a real
Leadshine HBS86H.

Add an Arduino and a STM32F4Discovery board plus some wiring and a power supply, and I guess the whole thing cost me about 170 USD.
The wheel itself is a broken SimRaceway srw-s1, so it was worthless to begin with

Good job

Very great

The following video should be able to help you intuitively understand the different force feedback steering wheel performance

wow thats very nice

can you compare with g27 or t150 ?

Better than two toy wheels? I hope so.

i think FFB's detail is better

but what about force strength ?

dose it give more power than g27 or t150

I made a couple of videos to show the wheel in action:





I made a simple measurement of the force, the maximum force is 3.1 kg 10 cm from the shaft, I guess that means around 3 newtonmetre.

It's difficult for me to compare with other wheels that I haven't tried, but my impression is that this setup is reasonably powerful and reacts very quickly. I'm not so sure that it's more detailed than the g27 or t150, it seems to me that the drive is not very good at making small adjustments in the torque output. For example when you have oversteer, the wheel really forces you to counter-steer, but when you have understeer its a bit difficult to feel the subtle change in the torque level (the torque should reduce a little as the front wheels loose their grip).

In the videos you may notice a high pitched sound as I turn the wheel, and a low pitched hum when the wheel is turning on its own. Both these sounds can be felt through the wheel, it doesn't bother mee too much, but some would probably find it annoying.

Perhaps the performance in all of the above mentioned areas could be improved by tuning the drive and adjusting the Arduino script, but I haven't found the time for that yet. Any suggestions are more than welcome.

3nm is really little, that engine does not have 12nm of force? A t300 has 5-6nm.

3.1 kg force @ 10 cm equals 0.31 Nm
you divide by 10 being the 10cm is a tenth of a metre.

My 2cents - kg is a unit of mass and Nt (or Newton) is a unit of force . My answer 3.0400615 Nm - which looking at the motor sounds about right.

That engine is 12nm? If so, I do not see normal just 3nm

Just working from the supplied real measurement - '3.1kg at 10cm' so 31kg at 1cm * 1 kg-cm is equal to 0.0980665 Nm, so = 3.0400615Nm .

Has not understood me, I mean that those engines are 12nm and that only 3nm is very little, the engines that I have watched nema34 give 12nm, it is the engine of the accuforce

It seems the power supply I have been using is too weak, that could be one reason for the lack of force. I'll try to get a stronger power source and see what result it gives me.

When you put the power supply with more current you probably have to adjust again the values of force in the arduino scketch

So now I've gone and changed the power supply from 25 VAC to 75 VDC, and added a bunch of capacitors, just to make sure it can handle the peak loads.
I've also changed the value 'max force' from 15% to 30% in the MMosForceFeedback2014 program.
This makes a really big difference, the FFB is much more powerful now, and changes in grip level can really be felt through the FFB.

But I still don't think the torque is much over 5 newtonmeter, even though the drive and motor is advertised to be capable of 12 newtonmeter. Maybe the tuning I did to reduce the cogging has also reduced the torque.

And I've now changed the serial port rate in the Arduino sketch to 38400 baud (the line Serial.begin(9600) has been changed to Serial.begin(38400), and settings in the serial redirect software have been changed correspondingly).
This seems to have made the wheel a bit more responsive. But the drive still only accepts between 50 and 75 commands per second.