Hi,
I didn't know if this was the correct place to post this issue, but as it involves controlling DC motors I hope it is close enough.
My setup is a go-cart for my kids, I use an Arduino Uno R3 to read a Hall-sensor throttle pedal on A0 and a toggle switch for selection of direction on D11.
The motor is a 200W worm-gear driven DC setup with 20Nm of torque.
The DC controller I chose for this setup is the SyRen 25 by DimentionEngineering.
Expensive, but awesome!
https://www.dimensionengineering.com/products/syren25
The basic control of the motor is quite straight forward due to the library made for the SyRen controller.
-126 equals 100% speed in negative direction
0 equals standstill
126 equals full speed forward.
As you can see in the code I've limited the reverse to 100 because kids 
The issue that I am having is that when the kids is smashing the throttle, or lifting the throttle, or most importantly when direction is switched while pedal is at 100% the SyRen does what it is told, giving full acceleration/retardation depending on mentioned scenario. This not only causes major wear on the worm gear, but also causes the bolts that connect the output shaft to the driveshaft to snap on a weekly basis.
Ive tried to utilise the Smoothing example in Arduino IDE to smooth out the output sent to the DC controller in hope of having some sort of ramping, but with the numReadings set to 255 (code fails if more) I can only see a marginally improvement where the DC controller ramps slightly.
I am out of ideas and since I'm quite the noob when it comes to programming I kindly ask for your assistance on programming the following:
-Ramping function that can be tuned with a parameter so that acceleration and retardation is smooth, and so that when switching direction while having the throttle at 100% the output it ramped down to 0 and then up to the desired output.
Thanks in advance.
// constants won't change. They're used here to set pin numbers:
const int DirectionPin = 11; // the number of the Direction pin
// variables will change:
int DirectionState = 0; // variable for reading the Driection status
int ThrottleOutput = 0;
// Variables for Smoothing output
const int numReadings = 255;
int readings[numReadings]; // the readings from the analog input
int readIndex = 0; // the index of the current reading
int total = 0; // the running total
int AvgSpeedCmd = 0; // the average
#include <SyRenSimplified.h>
SyRenSimplified SR; // We'll name the SyRen object SR.
// For how to configure the SyRen, see the DIP Switch Wizard for
// http://www.dimensionengineering.com/datasheets/SyrenDIPWizard/start.htm
// Be sure to select Simplified Serial Mode for use with this library.
// This sample uses a baud rate of 9600.
//
// Connections to make:
// Arduino TX->1 -> SyRen S1
// Arduino GND -> SyRen 0V
// Arduino VIN -> SyRen 5V (OPTIONAL, if you want the SyRen to power the Arduino)
//
// If you want to use a pin other than TX->1, see the SoftwareSerial example.
void setup() {
// initialize the pushbutton pin as an input:
pinMode(DirectionPin, INPUT);
// Initialize communication with DC controller
SyRenTXPinSerial.begin(9600); // This is the baud rate you chose with the DIP switches.
// Serial.begin(9600);
// init Smoothing logic
for (int thisReading = 0; thisReading < numReadings; thisReading++) {
readings[thisReading] = 0;}
}
void loop() {
// Read Value of Pedal:
// read the input on analog pin 0:
int PedalValue = analogRead(A0);
// Read the state of the pushbutton value:
DirectionState = digitalRead(DirectionPin);
// check if the DirectionState is HIGH or LOW. map correct gains to output:
if (DirectionState == LOW) {
ThrottleOutput = map(PedalValue, 200, 800, 0, 126);
ThrottleOutput = constrain(ThrottleOutput, 0, 126);
}
else {
ThrottleOutput = map(PedalValue, 200, 800, 0, -100);
ThrottleOutput = constrain(ThrottleOutput, -100, 0);
}
//Logic for smoothing of output
// subtract the last reading:
total = total - readings[readIndex];
// read from the sensor:
readings[readIndex] = ThrottleOutput;
// add the reading to the total:
total = total + readings[readIndex];
// advance to the next position in the array:
readIndex = readIndex + 1;
// if we're at the end of the array...
if (readIndex >= numReadings) {
// ...wrap around to the beginning:
readIndex = 0;
}
// calculate the averaged/smoother ouput:
AvgSpeedCmd = total / numReadings;
//send smoothed and constrained value to DC controller
SR.motor(1, AvgSpeedCmd);
}