Make an acceleration/deceleration ramp : any ideas?

[J. Mark Wolf]

My approach would be to generate the "points" you need for the line equation, given your slope and time parameters, in Excel. Then print a CSV file of the results, then copy the CSV file into your program as a table. It'll take some minor editing to generate your table but no big deal, and get the values from the table with Lookup or Lookup2. You can even change the slope of your ramp easily by adjusting the dwell time at each point, etc.

I do this sort of thing a lot for thermistor temperature tables, etc. Saves the time of executing the extensive formula for thermistor values.

[mark_s]

Can you give more info?

What is the motor being used for?

How does the user change the speed?

Typical servo systems use a PID routine.

Henrik Olsson posted a great PID program example on the forum. As I recall the thread mentioned motors and DT interupts.

[pxidr84]

I don't want to use a PID routine or a lookup table (because a lookup table is hungry of program memory space). It's a open-loop inverter.

The user changes the frequency reference by turning a potentiometer connected to a ADCIN port.

Exemple :

Note the acceleration and deceleration ramp of the output frequency, that changes the speed of the AC motor.

I like to have a routine (in a low-priority interrupt for exemple, to have the most accurate timings) that increments a value from the actual output frequency (for exemple 20Hz) to the frequency reference (for exemple 60Hz, defined by the user) in x seconds (for exemple 10 seconds, can be modified in real-time), and that without using any "pause" command (because my PIC has a lot things to do during this time).

[Jerson]

You can delegate the timekeeping and ramping to the ISR. What you need to pass to it is the 'target' value and 'step size' Step Size could be +ve or -ve depending on which way you want it to move.

the ISR could tick every millisec or maybe more depending on how fast you want to change the output.

[Charles Linquis]

I don't know how fast your ramp needs to be - but..

I would use a timer interrupt - say 1 millisecond

Multiply ramp time (in seconds) X 1000 to get the number of steps
Take

(endvalue - startvalue)/numberofsteps to get step size
Initialize a counter with the start value and increment the step size in each interrupt.

Depending on your needs, you may have to add some extra increments, because the step size will be an integer, and when multiplied by the number of steps may not exactly equal the
end value.

[pxidr84]

I don't know how fast your ramp needs to be - but..

I would use a timer interrupt - say 1 millisecond

Multiply ramp time (in seconds) X 1000 to get the number of steps
Take

(endvalue - startvalue)/numberofsteps to get step size
Initialize a counter with the start value and increment the step size in each interrupt.

Depending on your needs, you may have to add some extra increments, because the step size will be an integer, and when multiplied by the number of steps may not exactly equal the
end value.

My maximum acceleration slope is incrementing a variable from 0 to 1200 in one second with a resolution of 1 (steps of 1).

I've tried to "translate" your algorithm into this :


'Variable init
freq var word
maxfreq var word
minfreq var word
stepnum var word
stepsize var word
time var word

'Variables def
minfreq=10
maxfreq=1200
time=10

'Calculate steps
stepnum=time*1000
stepsize=(maxfreq-minfreq)/stepnum

'Init counter
freq=minfreq

main:

' Counter
freq=freq+stepsize

'Update LCD
lcdout $fe,$2,"Frequency: ",dec5 freq

' 1ms time base (simulates an interrupt)
pause 1

goto main


It is correct? Because the result of "stepsize" is a float in this case (0.119)...

[Charles Linquis]

According to my calculations -

endval = 1200
startval = 20


endval - startval = 1180
ramp time in milliseconds = 1000

1180/1000 = 1.18 (so 1180/1000 = 1 = increment)
1180//1000 = 180 (=remainder = fractional)



fractional = 0
oldfractional = 0

frequency = 20 ; start value

ISR:

Frequency = frequency + increment ; increment the main part

fractional = fractional + remainder ; Deal with the fractional part
If fractional dig3 != oldfractional ; keep adding up the partial until we reach 1000
oldfractional = fractional ; update so we can see the next change
frequency = frequency + 1 ; add a count - since we broke 1000
Endif


This will increment by one every program loop and then add an extra count every 5 (or so) loops. I haven't tested the algorithm, but I believe it should deal properly with the 'wrap' when "fractional" overflows.