4 * Copyright 2004, 2008 Develer S.r.l. (http://www.develer.com/)
8 * \brief Test for compute, save and load ramps for stepper motors (implementation)
11 * \author Simone Zinanni <s.zinanni@develer.com>
12 * \author Bernie Innocenti <bernie@codewiz.org>
13 * \author Giovanni Bajo <rasky@develer.com>
14 * \author Daniele Basile <asterix@develer.com>
17 * The formula used by the ramp is the following:
21 * f(t) = -------------
25 * Where <code>a</code> and <code>b</code> are the maximum and minimum speed
26 * respectively (minimum and maximum wavelength respectively), and <code>lerp</code>
27 * is a linear interpolation with a factor:
30 * lerp(a,b,t) = a + t * (b - a) = (a * (1 - t)) + (b * t)
33 * <code>t</code> must be in the [0,1] interval. It is easy to see that the
34 * following holds true:
40 * And that the function is monotonic. So, the function effectively interpolates
41 * between the maximum and minimum speed through its domain ([0,1] -> [b,a]).
43 * The curve drawn by this function is similar to 1 / (sqrt(n)), so it is slower
44 * than a linear acceleration (which would be 1/n).
46 * The floating point version uses a slightly modified function which accepts
47 * the parameter in the domain [0, MT] (where MT is maxTime, the length of the
48 * ramp, which is a setup parameter for the ramp). This is done to reduce the
49 * number of operations per step. The formula looks like this:
53 * g(t) = ----------------------------
54 * (a * MT) + t * (b - a)
57 * It can be shown that this <code>g(t) = f(t * MT)</code>. The denominator
58 * is a linear interpolation in the range [b*MT, a*MT], as t moves in the
59 * interval [0, MT]. So the interpolation interval of the function is again
60 * [b, a]. The implementation caches the value of the numerator and parts
61 * of the denominator, so that the formula becomes:
69 * g(t) = ----------------------
73 * and <code>t</code> is exactly the parameter that ramp_evaluate() gets,
74 * that is the current time (in range [0, MT]). The operations performed
75 * for each step are just an addition, a multiplication and a division.
77 * The fixed point version of the formula instead transforms the original
78 * function as follows:
82 * f(t) = ------------------------- = --------------------
84 * b * ( - * (1 - t) + t ) - * (1 - t) + t
88 * <code>t</code> must be computed by dividing the current time (24 bit integer)
89 * by the maximum time (24 bit integer). This is done by precomputing the
90 * reciprocal of the maximum time as a 0.32 fixed point number, and multiplying
91 * it to the current time. Multiplication is performed 8-bits a time by
92 * FIX_MULT32(), so that we end up with a 0.16 fixed point number for
93 * <code>t</code> (and <code>1-t</code> is just its twos-complement negation).
94 * <code>a/b</code> is in the range [0,1] (because a is always less than b,
95 * being the minimum wavelength), so it is precomputed as a 0.16 fixed point.
96 * The final step is then computing the denominator and executing the division
97 * (32 cycles using the 1-step division instruction in the DSP).
99 * The assembly implementation is needed for efficiency, but a C version of it
100 * can be easily written, in case it is needed in the future.
105 #include <cfg/debug.h>
106 #include <cfg/test.h>
109 static bool ramp_test_single(uint32_t minFreq, uint32_t maxFreq, uint32_t length)
116 ramp_setup(&r, length, minFreq, maxFreq);
118 cur = old = r.clocksMaxWL;
122 kprintf("testing ramp: (length=%lu, min=%lu, max=%lu)\n", (unsigned long)length, (unsigned long)minFreq, (unsigned long)maxFreq);
123 kprintf(" [length=%lu, max=%04x, min=%04x]\n", (unsigned long)r.clocksRamp, r.clocksMaxWL, r.clocksMinWL);
128 while (clock + cur < r.clocksRamp)
134 cur = ramp_evaluate(&r, clock);
138 uint16_t t1 = FIX_MULT32(oldclock >> RAMP_CLOCK_SHIFT_PRECISION, r.precalc.inv_total_time);
139 uint16_t t2 = FIX_MULT32(clock >> RAMP_CLOCK_SHIFT_PRECISION, r.precalc.inv_total_time);
140 uint16_t denom1 = FIX_MULT32((uint16_t)((~t1) + 1), r.precalc.max_div_min) + t1;
141 uint16_t denom2 = FIX_MULT32((uint16_t)((~t2) + 1), r.precalc.max_div_min) + t2;
143 kprintf(" Failed: %04x @ %lu --> %04x @ %lu\n", old, (unsigned long)oldclock, cur, (unsigned long)clock);
144 kprintf(" T: %04x -> %04x\n", t1, t2);
145 kprintf(" DENOM: %04x -> %04x\n", denom1, denom2);
147 cur = ramp_evaluate(&r, clock);
151 if ((old-cur) >= 256)
157 kprintf("Test finished: %04x @ %lu [min=%04x, totlen=%lu, numsteps:%d, nonbyte:%d]\n", cur, (unsigned long)clock, r.clocksMinWL, (unsigned long)r.clocksRamp, i, nonbyte);
162 int ramp_testSetup(void)
168 int ramp_testTearDown(void)
173 int ramp_testRun(void)
175 #define TEST_RAMP(min, max, len) do { \
176 if (!ramp_test_single(min, max, len)) \
180 TEST_RAMP(200, 5000, 3000000);
181 TEST_RAMP(1000, 2000, 1000000);