Problems when lowering power on ERG Mode

[Mario-uy]

Hello.
I have problems in ERG mode when the application requests to lower the power. The SmartSpin2k begins to rotate counterclockwise and does not stop until it reaches the maximum limit of the bicycle (hard braking limit). It does not stop even when the power read is lower than that requested by the app. I was able to improve the situation by lowering the engine speed, but even then the engine stopping point is at a much lower power than the requested one.

This mainly happens when the SmartSpin2k is restarted and the power drops are drastic, for example at the end of a sprint.
I am using a bicycle with a felt brake, therefore, with a few turns (1 to 3) the resistance changes a lot.
Looking at the logfile I see that in many situations: "Min Position Set: -32768". Under normal conditions, this parameter has a larger value: -100, 0, 100, -500, etc. There is no problem when the required power increase fast.

In previous software versions (May) I believe this did not happen. I tried installing an older version but had problems and went back to the latest one.

Is it possible to change the behavior in order to avoid reaching the hardware limits? Is there any change suggestion for configuration to improve?

[doudar]

Hmm... -32768 should be getting rejected - it's supposed to be an invalid number (int16_min).

There are a couple people looking at improving our current power table (lookup table) which is what is generating those invalid numbers. I'll reference them here so that they have it for their information. @ddtomic @benv12

The tests for int16_min are in this function which checks the power table for valid values. It will return int32_min if nothing is found, (but that doesn't seem to be our problem here.)

SmartSpin2k/src/ERG_Mode.cpp

Lines 181 to 242 in 04fd746

	int32_t PowerTable::lookup(int watts, int cad) {
	int cadIndex = round(((float)cad - (float)MINIMUM_TABLE_CAD) / (float)POWERTABLE_CAD_INCREMENT);
	int wattIndex = round((float)watts / (float)POWERTABLE_WATT_INCREMENT);
	// If request is outside table limits, perform linear extrapolation
	if (cad < MINIMUM_TABLE_CAD || cad > (MINIMUM_TABLE_CAD + (POWERTABLE_CAD_SIZE - 1) * POWERTABLE_CAD_INCREMENT) ||
	watts > (POWERTABLE_WATT_SIZE - 1) * POWERTABLE_WATT_INCREMENT) {
	// Perform linear extrapolation based on existing data
	int extrapolatedValue = INT16_MIN;
	// Extrapolation for cadence out of bounds
	if (cad < MINIMUM_TABLE_CAD || cad > (MINIMUM_TABLE_CAD + (POWERTABLE_CAD_SIZE - 1) * POWERTABLE_CAD_INCREMENT)) {
	int extrapRow1 = -1, extrapRow2 = -1;
	for (int i = 0; i < POWERTABLE_CAD_SIZE; ++i) {
	if (this->tableRow[i].tableEntry[wattIndex].targetPosition != INT16_MIN) {
	extrapRow1 = i;
	break;
	}
	}
	for (int i = POWERTABLE_CAD_SIZE - 1; i >= 0; --i) {
	if (this->tableRow[i].tableEntry[wattIndex].targetPosition != INT16_MIN) {
	extrapRow2 = i;
	break;
	}
	}
	if (extrapRow1 != -1 && extrapRow2 != -1) {
	int cad1 = extrapRow1 * POWERTABLE_CAD_INCREMENT + MINIMUM_TABLE_CAD;
	int cad2 = extrapRow2 * POWERTABLE_CAD_INCREMENT + MINIMUM_TABLE_CAD;
	int val1 = this->tableRow[extrapRow1].tableEntry[wattIndex].targetPosition;
	int val2 = this->tableRow[extrapRow2].tableEntry[wattIndex].targetPosition;
	extrapolatedValue = val1 + (val2 - val1) * (cad - cad1) / (cad2 - cad1);
	SS2K_LOG(ERG_MODE_LOG_TAG, "Lookup Extrapolated %d from %d, %d, for %dw %dcad", extrapolatedValue, val2, val1, watts, cad);
	return extrapolatedValue * 100;
	}
	}
	// Extrapolation for watts out of bounds
	if (watts > (POWERTABLE_WATT_SIZE - 1) * POWERTABLE_WATT_INCREMENT) {
	int extrapCol1 = -1, extrapCol2 = -1;
	for (int j = POWERTABLE_WATT_SIZE - 1; j >= 0; j--) {
	if (this->tableRow[cadIndex].tableEntry[j].targetPosition != INT16_MIN) {
	if (extrapCol2 == -1) {
	extrapCol2 = j;
	} else {
	extrapCol1 = j;
	break;
	}
	}
	}
	if (extrapCol1 != -1 && extrapCol2 != -1) {
	int watts1 = extrapCol1 * POWERTABLE_WATT_INCREMENT;
	int watts2 = extrapCol2 * POWERTABLE_WATT_INCREMENT;
	int val1 = this->tableRow[cadIndex].tableEntry[extrapCol1].targetPosition;
	int val2 = this->tableRow[cadIndex].tableEntry[extrapCol2].targetPosition;
	extrapolatedValue = val1 + (val2 - val1) * (watts - watts1) / (watts2 - watts1);
	SS2K_LOG(ERG_MODE_LOG_TAG, "Lookup Extrapolated %d from %d, %d, for %dw %dcad", extrapolatedValue, val2, val1, watts, cad);
	return extrapolatedValue * 100;
	}
	}
	// Not enough data.
	return INT32_MIN;
	}

In the meantime, with the newest code, we have more options available as preventative measures in the stepper code by testing for power less than setpoint and not driving further into the hole.

That would be at:

SmartSpin2k/src/Main.cpp

Lines 388 to 396 in 04fd746

	if (!ss2k->externalControl) {
	if ((rtConfig->getFTMSMode() == FitnessMachineControlPointProcedure::SetTargetPower) ||
	(rtConfig->getFTMSMode() == FitnessMachineControlPointProcedure::SetTargetResistanceLevel)) {
	ss2k->targetPosition = rtConfig->getTargetIncline();
	} else {
	// Simulation Mode
	ss2k->targetPosition = rtConfig->getShifterPosition() * userConfig->getShiftStep();
	ss2k->targetPosition += rtConfig->getTargetIncline() * userConfig->getInclineMultiplier();
	}

Feel free to take a look yourself and see if there's a modification you can make. Otherwise, I'll look at it and see if I can come up with a test that doesn't interfere with anything else. Felt resistance bikes are a bit of a challenge, but not insurmountable.

Thanks for the report!!!

[doudar]

I just added this to the moveStepper(). Give the binary a try and let me know if it helps you. Make sure to unzip it first.

void SS2K::moveStepper() {
  bool _stepperDir = userConfig->getStepperDir();
  if (stepper) {
    ss2k->stepperIsRunning = stepper->isRunning();
    ss2k->currentPosition  = stepper->getCurrentPosition();
    if (!ss2k->externalControl) {
      if ((rtConfig->getFTMSMode() == FitnessMachineControlPointProcedure::SetTargetPower)) {
        // don't drive lower out of bounds. This is a final test that should never happen. 
        if ((stepper->getCurrentPosition() > rtConfig->getTargetIncline()) && (rtConfig->watts.getValue() < rtConfig->watts.getTarget())) {
          rtConfig->setTargetIncline(stepper->getCurrentPosition() + 1);
        }
        // don't drive higher out of bounds. This is a final test that should never happen. 
        if ((stepper->getCurrentPosition() < rtConfig->getTargetIncline()) && (rtConfig->watts.getValue() > rtConfig->watts.getTarget())) {
          rtConfig->setTargetIncline(stepper->getCurrentPosition() - 1);
        }
        ss2k->targetPosition = rtConfig->getTargetIncline();
      } else if (rtConfig->getFTMSMode() == FitnessMachineControlPointProcedure::SetTargetResistanceLevel) {
        ss2k->targetPosition = rtConfig->getTargetIncline();
      } else {
        // Simulation Mode
        ss2k->targetPosition = rtConfig->getShifterPosition() * userConfig->getShiftStep();
        ss2k->targetPosition += rtConfig->getTargetIncline() * userConfig->getInclineMultiplier();
      }
    }

firmware.zip

I haven't tested it at all, so there's a chance it could fail spectacularly.

[Mario-uy]

Hi Anthony, thank you for the fast answer and firmware. I tested it and it worked fine to stop motor to continue when the measured power is below target but there are some strange behavior I noticed: 1) Once you stabilize cadence on new motor position, power could be higher than target and there is no adjustment to lower resistance, 2) sometimes the adjustment of resistance seems to be slower on increase. Maybe there is a desynchronization between motor position and what is expected.
I need more tests to give you better feedback.

[Mario-uy]

Hi Anthony, after some settings changes and more testing, I can tell you that the firmware works very well. No more problems with lowering the resistance. Thank you!!!
I think this modification could be incorporated into the standard versions.

Beyond this change, the algorithm for calculating the motor position when using felt resistance brakes would probably have to be revised.
In my case, between the minimum and maximum resistance, there is only one and a half full turn. Maybe this is the difficult part.

[doudar]

Awesome! Glad to hear it, Mario!

Yes, that's my experience with the felt resistance - noting, nothing, nothing, full resistance!