1dof Project from a chair with a stepper servo drive

Concept:

To create an inexpensive project for a deeper immersion into sim racing without cluttering up the space with a large cockpit.

We have a regular office chair with a rocking chair option. Our task is to remove the spring and replace it with a servo drive. We are not changing the rest of the functionality.

Calculations showed that a 2 Nm motor would be sufficient to generate a lifting force of 100 kg. However, we decided to play it safe and go for an 8.5 Nm motor.
Stepper servo drive with encoder (feedback) 86EBP145ALC-TK0 + HBS86H, 8.5 Nm
We will also need a SHV1605 screw and a 10-14 mm D32L45 rigid coupling.

We take apart the chair, remove the spring, drill a hole to put the axle in, cut the axle to size, and screw it on.

Code:

// Pins for connecting to HBS86H driver
#define PUL_PIN 9  // STEP — to PUL+
#define DIR_PIN 8  // DIR+
#define ENA_PIN 7  // ENABLE
#define MICROSTEP_PER_REV 1000     // Microsteps per revolution, set according to driver configuration
#define MAX_REVOLUTIONS    2       // Number of revolutions corresponding to SimTools maximum (adjust for your actuator)
long targetPosition = 0;           // Desired position (in steps)
long currentPosition = 0;          // Current position (in steps)
void setup() {
  Serial.begin(115200);
  pinMode(PUL_PIN, OUTPUT);
  pinMode(DIR_PIN, OUTPUT);
  pinMode(ENA_PIN, OUTPUT);
  digitalWrite(ENA_PIN, LOW); // LOW — enable driver (for HBS86H, usually LOW = ON)
}
void loop() {
  static String inputString = "";
  static bool inputStarted = false;
  // ==== Read command character-by-character for reliability ====
  while (Serial.available()) {
    char inChar = (char)Serial.read();
    if (inChar == '[') {
      inputStarted = true;
      inputString = "";    // start collecting the string
    } else if (inChar == ']') {
      inputStarted = false;
      inputString.trim();
      processCommand(inputString);
      inputString = "";
    } else {
      if (inputStarted) inputString += inChar;
    }
  }
}
// ==== COMMAND PROCESSING ====
void processCommand(String cmd) {
  // Example: "A512"
  if (cmd.length() < 2) return;
  if (cmd.charAt(0) == 'A') {
    int rawValue = cmd.substring(1).toInt();      // numeric value after 'A'
    long mapped = mapPosition(rawValue);
    if (mapped != targetPosition) {
      targetPosition = mapped;
      moveToPosition(targetPosition);
    }
  }
}
// ==== MAPPING SimTools values (0-1023) => step count (e.g., 0 ... 8000) ====
long mapPosition(int val) {
  long minStep = 0;
  long maxStep = long(MAX_REVOLUTIONS) * long(MICROSTEP_PER_REV); // e.g., 2 × 1000 = 2000 steps
  if(val < 0) val = 0;
  if(val > 1023) val = 1023;
  return map(val, 0, 1023, minStep, maxStep);
}
// ==== MOVE to the desired position ====
void moveToPosition(long target) {
  long stepsToGo = target - currentPosition;
  if (stepsToGo == 0) return;     // already in place
  int dir = (stepsToGo >= 0) ? HIGH : LOW;
  digitalWrite(DIR_PIN, dir);
  stepsToGo = abs(stepsToGo);
  for (long i = 0; i < stepsToGo; ++i) {
    digitalWrite(PUL_PIN, HIGH);
    delayMicroseconds(250);      // step speed — adjust for your motor!
    digitalWrite(PUL_PIN, LOW);
    delayMicroseconds(250);
    currentPosition += (dir == HIGH) ? 1 : -1;
  }
}

We received a chair that can be used as a regular chair, but can also be used as a single-axis sim racing chair.

I would like to say a few more words in support of such single-axis cockpits.
Three types of input data can be used:
heave
surge
pitch
This is sufficient for normal driving. Probably the most sought-after axis is heave, which is responsible for shaking.
The pitch axis is also good when driving up or down a hill, as the car tilts.
Surge gives the effect of tilting the car when pressing the accelerator or brake pedal.
Side tilt is not usually present when driving a car in reality.

Perhaps it would be worth limiting the heave axis in this project, because at large amplitudes it will cause an unexpected tilt, but at small amplitudes it works perfectly and transmits the jolting when driving over bumps.