Topic XC886/888CLM Cordic & MDU Module

May 2006

n

o Department

e

n

i

f

n XC886/888CLM

May 2006 I Page 1 Agenda

XC888/886CLM – Cordic Coprocessor

XC886/888CLM – MDU Coprocessor

XC886/888CLM May 2006 Page 2 XC886/888CLM – New Peripherals

„ T21 „ UART1 „ MultiCan „ Cordic „ MDU

XC886/888CLM May 2006 Page 3 XC886/888CLM – Cordic Basics

„ Cordic (COordinate Rotation DIgital Computer) – Mathematical co-processor for 16bit trigonometric, hyperbolic and linear functions (e.g. to solve SIN, COS, LOG, EXP, SQRT...) – Hardcoded - Look Up Table based on iterative approximation algorithm (16 iterations, max 41 cycles) „ 8 SFRs in the mapped area „ one interrupt vector on a shared node @0x0043

XC886/888CLM May 2006 Page 4 XC886/888CLM – Cordic History

„ CORDIC algorithms belong to the class of shift-add algorithms. (introduced by Jack E. Volder in 1951 for trigonometric functions, generalized and extended with linear and hyperbolic functions by J.S. Walther 1971 ) „ The idea behind the CORDIC is, to have all mathematic functions in a microcontroller available with most less costs, since shift and add hardware can be easy implemented. „ Mainly the CORDIC is used to perform a rotation in a plane using a series of specific incremental rotation angles selected so that each is performed by a shift and add operation. There is also a mechanism for computing the magnitude and phase angle of an input vector. „ One CORDIC iteration involves 2 shifts, 1 table lookup, 3 additions

XC886/888CLM May 2006 Page 5 XC886/888CLM – Some Math Basics

„ Some basic functions „ Taylor series expansion – sine (x), cosine (x)

x3 x5 x7 sin x = x − + − ±...; 3! 5! 7!

–arctan(x)

x3 x5 x7 arctan x = x − + − ±... 3 5 7

„ Factorial – e.g. 5! = 5*4*3*2*1 = 120

XC886/888CLM May 2006 Page 6 XC886/888CLM – Some Math Basics cont.

„ The Unite Circle

„ Radian π – deg to rad angle []rad = angle deg [• ] 180

„ e.g. 45 (deg) Æ 45/180*PI = 0.7854 (rad)

„ e.g. 1 (rad) = PI Æ 180 (deg) XC886/888CLM May 2006 Page 7 XC886/888CLM – Cordic Coordinate Systems

„ CORDIC equations m Coordinate Domain of System Convergence (i+1) (i) (i) –i x = x – m di y 2 (i+1) (i) (i) –i y = y + di x 2 1 circular 1.74 radian (i+1) (i) (i) z = z – di e 0 linear 2

-1 hyperbolic 1.11 radian

XC886/888CLM May 2006 Page 8 XC886/888CLM – Cordic Iterations

„ Starting with a phase of 45 degrees, the phase of each successive R multiplier is a little over half of the phase of the previous „ “Binary search" on phase by adding or subtracting successively smaller phases to reach the "target" phase –––––––––––––––––––––––––––––––– i e(i) in degrees e(i) in radians ––––––––––––––––––––––––––––––– 0 45.0 0.785 398 163 1 26.6 0.463 647 609 2 14.0 0.244 978 663 3 7.1 0.124 354 994 4 3.6 0.062 418 810 5 1.8 0.031 239 833 6 0.9 0.015 623 728 7 0.4 0.007 812 341 8 0.2 0.003 906 230 9 0.1 0.001 953 123 ––––––––––––––––––––––––––––––––

„ Example: 30° angle

XC886/888CLM 30.0 ≅ 45.0 – 26.6 + 14.0 – 7.1 + 3.6 + 1.8 – 0.9 + 0.4 – 0.2 + 0.1 May 2006 Page 9 = 30.1 XC886/888CLM – Cordic Math Functions

CORDIC Rotation Vectoring

Linear IN xn,zn,yn xn,yn,zn MUL/DIV/MAC OUT y =x * z + y z =y / x + z K = 1 n+1 n n n n+1 n n n

Circular IN zn=angle, xn=K,yn=0 xn,yn, zn=0 SINE/COSINE angle/ OUT xn+1 = cos(angle) zn+1 = arctan(yn/xn ) magnitude 2 + 2 1/2 yn+1 = sin(angle) xn+1 = 1/K*(xn yn ) K = 1.64676

IN z1=angle, x1=K´,y1=0 y1

K = 0.828 OUT xn+1 = cosh(angle) zn+1 = arctanh(y1/x1) XC886/888CLM 2 - 2 1/2 May 2006 yn+1 = sinh(angle) xn+1 = 1/K´*(x1 y1 ) Page 10 XC886/888CLM – Cordic Data Format

„ S15 Example S15 – S15 or e.g. S5.10 or S10.5. 25 x -25 = -625 – signed integer 0x0019 x 0xFFE7 = 0xFD8F „ one sign bit | 15 number bits 2.5 x -2.5 = -6.25 – rational number (fractional) 0x0028 x 0xFFD8 = 0xF9C0 „ one sign | n . (15-n) bit fractional 0.25 x -0.25= 0.0625 „ decimal point can be freely chosen „ fraction means S | 21 + 20. 2-1 + 2-2 + 2-3 +.... – negative numbers in Twos Complement „ e.g. -25dec = 1|111 1111 1110 0110 +1 = 1|111 1111 1110 0111 „ 4Q16 (S4.11) – decimal point is fixed Example S4.11 S| 4.11 2.5 = 0|001‘0.100‘0000‘0000 = 0x1400 XC886/888CLM (-5.625 = 0|010‘1.101‘0000‘0000 = 0x2D00 May 2006 Page 11 twos compl)= 1|101‘0.010‘1111‘1111 + 1 = 0xD300 XC886/888CLM – Cordic Data Format cont.

„ Input: „ Results: – X, Y can be integer (S15) or rational – X, Y can be integer (S15) or rational number (fraction) in all operating number (fraction) in all operating modes. They must have the same modes. Must be same format as form and in case of fraction the same input format. number of bits for the decimal place. –X in circular vectoring mode can be interpreted „ as twos complement or „ as 16-bit unsigned depending on bit X_USIGN

X, Y Result Data = CD_Result / MPS MPS = magnitude prescaler (1, 2, 4)

– Z for linear functions it is always in – Z for linear functions is signed 4Q16 signed 4Q16 (S4.11) format ( S4.11 ) – Z for circular and hyperbolic functions – Z for circular and hyperbolic it is always handled functions is a scaled normalized as scaled normalized integer. integer XC886/888CLM May 2006 Page 12 input Z = real Z (in rad) * 32768/PI real result Z (in rad) = Z* PI/32768 XC886/888CLM – Cordic Accuracy & Deviation

„ Input inaccuracy: representation of a value is limited by the number of bits „ The CORDICs accuracy is also limited by the number of iterations. Therefore an absolute deviation can be calculated. This is the difference between the expected and the real value. „ The normalized deviation refers to the magnitude of the result, i.e. the absolute error for small numbers is big, but if this is put into relationship to the magnitude it is still small. „ Properly scaled values will produce small errors. The max. error can be calculated and is depending on the chosen mode. „ Some examples for Linear and Circular mode

XC886/888CLM May 2006 Page 13 XC886/888CLM – Cordic Accuracy & Deviation cont

„ Some example calculation in LINEAR mode – y = z * x „ |z| ≤ 2 Æ z in S1.11 „ with x = 3000, 6000, ....30000 in S15 „ and z = 1, 0.1, 0.01, 0.001 in S4.11

// result magnitude in S15 = 32768 // calculate 0*0.01, 3000*0.01, 6000*0.01 ... 30000*0.01

for (x=0;x<32000;x+=3000){ //(x, z=0.01 S4Q16) product = CD_multiply (x, 0x0014); }

– here: the deviation depends on how accurate the value z can be coded in S4.11 (Input inaccuracy) Æ max. error: 2-11 = 0,000488281 Z 1 0.1 0.01 0.001 hex 0x0800 0x00CD 0x0014 0x0002 XC886/888CLM Zcoded May 2006 dec 1.000000 0.100098 0.009766 0.000977 Page 14 XC886/888CLM – Cordic Accuracy & Deviation cont

X 3000 6000 9000 12000 15000 18000 21000 24000 27000 30000 Z 1 3000 6000 9000 12000 15000 18000 21000 24000 27000 30000 0x0800 0.1 300 600 901 1201 1501 1802 2102 2403 2701 3003 0x00CD 0.01 0x0014 29 58 88 117 146 176 205 235 264 293

0.001 3 6 9 12 15 18 21 24 27 30 0x0002

– Input format of X: integer (S15) or fraction – It is necessary to reserve as many bits as possible after the decimal point to minimize the output truncation error of the result. „ i.e. 18.5 Æ possible: 0|000 0001 0010.1000 = 0x0128 better: 0|001 0010.1000 0000 = 0x1280 XC886/888CLM May 2006 Page 15 XC886/888CLM – Cordic Scaling the Amplitude

„ Example for circular rotation mode – sine calculation

–YFINAL = K*X*sin(Z) K = 1,64676 – For scaling the amplitude A = K*X, set X = A/K note: choose the amplitude as high as possible to increase the resolution of the range of sin(Z) and to decrease the result error

note: Amax = 32768

X A YFINAL 1 1.64676 {-1.64676…+1.64676} 100 164.676 {-164.676…+164.676} 12145 19999.9 {-19999.9…+19999.9} 19898 32767.3 {-32767.3…+32676.3}

– Angle Z in normalized scaled integer ° 180 = ° XC886/888CLM „ Min. adjusting angle: 0.00549 May 2006 32768 Page 16 XC886/888CLM – Cordic Example SINE() z0=angle, x0=K,y0=0 „ How to calculate sine(z) yn+1 = sine(angle)

SYSCON0 |= 0x01; // switch into mapped area CD_STATC = 0x00; // clear keep bits - disable CORDIC IRQ CD_CON = 0x0A; // circular rotation mode - auto start CD_CORDYL= 0x00; CD_CORDYH= 0x00; // y0=0 CD_CORDXH= 0x17; // x0hi=K CD_CORDZL= z; CD_CORDZH= (z>>8); // input angle z in integer ~1µs CD_CORDXL= 0xB9; // x0lo=K and start Cordic while(!(CD_STATC & 0x04)); // wait on CORDIC ready printf ("SIN CORDIC = %d%d\n",CD_CORDYH,CD_CORDYL ); // print result SYSCON0 &= 0xFE; // switch to non-mapped area

XC886/888CLM May 2006 Page 17 XC886/888CLM – Cordic Example ARCTAN() xn, yn, zn=0 „ How to calculate an angle zn+1 = arctan(yn/xn ) CD_S15 CORDIC_CalculateAtan (CD_S15 Xval ,CD_S15 Yval) { if(Xval == 0x0000) { g_CORDIC_atan.WORD = 0; // Avoid error at 'divide by 0' } else { ´ SYSCON0 |= 1; CD_STATC = 0; CD_CON =(MPS_1+TWOS_COMPLEMENT+START_AUTO+MODE_VECTORING+FUNC_CIRCULAR); CD_CORDZH = CD_CORDZL = 0; CD_CORDYH = (unsigned char) Yval; CD_CORDYL = (unsigned char) (Yval>>8); CD_CORDXH = (unsigned char) Xval; CD_CORDXL = (unsigned char) (Xval>>8);

while(!(CD_STATC & 0x04)); // wait on CORDIC ready

g_CORDIC_atan.BYTE.H = CD_CORDZH; ~1µs g_CORDIC_atan.BYTE.L = CD_CORDZL; SYSCON0 &= 0xFE; } XC886/888CLM May 2006 } Page 18 XC886/888CLM – Cordic Example Multiply & Accumulate xn, zn, yn „ How to do a MAC in S4Q16 (S4.11) yn+1 = xn * zn + yn

// mac (multiply & accumulate) -- input format x, y in S15, z in S4.11 // x=4096 = 0x1000, y=4096 =0x1000, z=2 =0x1000 >> yn+1 = 12288 = 0x3000 SYSCON0 |= 0x01; // set RMAP ~1µs CD_CON =(MPS_1+TWOS_COMPLEMENT+START_WITH_ST_SET+MODE_ROTATION+FUNC_LINEAR); CORDIC_LOAD_XYZ_REGISTERS(0x1000,0x1000,0x1000); // (x, y, z) CORDIC_START(); // set start bit while(!(CD_STATC & 0x04)); // Polling until CORDIC is ready – EOCflag g_CORDIC_mac.BYTE.H = CD_CORDYH; g_CORDIC_mac.BYTE.L = CD_CORDYL; // result yn+1 = 12288 = 0x3000

// additional accumulate CD_CON &= 0xEF; // Set AutoStart CD_STATC |= 0x40; // KEEP Y CD_CORDZH = 0x08; // z=1 = 0x0800 ~1µs CD_CORDZL = 0x00; CD_CORDXH = 0x10; // x=4096 = 0x1000 CD_CORDXL = 0x00; //CORDIC starts here automatically while(!(CD_STATC & 0x04)); // Polling until CORDIC is ready - EOC g_CORDIC_mac.BYTE.H = CD_CORDYH; g_CORDIC_mac.BYTE.L = CD_CORDYL; // result yn+1 = 16384 = 0x4000

XC886/888CLM SYSCON0 &= 0xFE; // clr RMAP May 2006 Page 19 Agenda

XC888/886CLM – Cordic Coprocessor

XC886/888CLM – MDU Coprocessor

XC886/888CLM May 2006 Page 20 XC886/888CLM – MDU

„ Mathematical co-processor for Multiply and Divide – Fast signed/unsigned 16x16bit multiplication – Fast signed/unsigned 32/16bit or 16/16bit division – 32bit unsigned normalization – 32bit arithmetic/logical shift operations „ CPU has to MOVE the operands and result (including waitstate for code fetching from Flash) = 8clk / 8bit – e.g. signed multiplication 16bit x 16bit: 32 (load operands) + 16 (multiplication) + 32 (fetch result) = 80clk = 3.3µs @ 24MHz „ For continues MDU operation, next operands can be loaded in parallel to current calculation – e.g. continues (interleaved) signed multiplication 16bit x 16bit: 16 (multiplication) || 32 (load operands for next multiplication) + 32 (fetch result) = 64clk = 2.7µs @ 24MHz

XC886/888CLM May 2006 Page 21 XC886/888CLM – MDU Performance

XC886/888CLM May 2006 Page 22 XC886/888CLM – MDU ROM-Library

„ MDU is very useful for some mathmetical functions such as – UIDIV, LMUL, ULDIV, LShift „ ROM contains most valuable MDU-routines which can be called by user –this saves codespace and runtime (no waitstate for ROM access) „ easy integration with KEIL compiler „ MDU Library support in ROM only available for devices marked with “M” „ ROM Library support from AB-step onwards

Routine Name Num of Bytes Num of Clock Cycle ROM Software MDU Software MDU ?C?IMUL 18 20 57 53 MDU Library ?C?UIDIV 85 24 267 61 MDU Library ?C?LMUL 139 61 213 123 / 105 MDU Library ?C?ULDIV 146 197 1148 / 886 101 / 249 MDU Library ?C?LNEG 14 X 31 X -- ?C?ULSHR 19 28 10 + (30 * n) 50 + n MDU Library ?C?SLSHR 20 28 10 + (30 * n) 50 + n MDU Library XC886/888CLM May 2006 ?C?LSHL 20 28 10 + (30 * n) 50 + n MDU Library Page 23 XC886/888CLM – Floating Point ROM-Library

„ ROM contains most valuable floating point routines which can be called by user –this saves codespace and runtime (no waitstate for ROM access) „ easy integration with KEIL compiler „ Float Library support in ROM available for all devices „ Fload Library support from AB-step onwards

Routine Name Num of Bytes Num of Clock Cycle ROM Software Software ?C?FPADD from 309 to 488 Float Library ?C?FSUB ~408 Float Library ?C?FPMUL ~385 Float Library ?C?FPDIV ~1757 Float Library ?C?FPCMP3 ~1kbyte ~87 Float Library ?C?FPCASTC from 197 to 231 Float Library ?C?FPCASTI from 271 to 305 Float Library ?C?FPCASTL from 699 to 733 Float Library ?C?FPCASTF from 630 to 980 Float Library XC886/888CLM May 2006 Page 24 XC886/888CLM May 2006 Page 25 Example PI-Control without Cordic in ASM

;******* PI-Regler 16********* pi16_3_B: pi16_8_B: _pi_regler16_B: ; Eingang_istwert (16 Bits) = Drehzahl cjne a,ymax16,pi16_4_B ; Ausgang und Integrierer mov ; sollwert,a ; Eingang_sollwert (16 Bits) = sollwert16 Begrenzung ret ; Ausgang ( 8 Bits) = sollwert pi16_4_B: pi16_neg_B: ; negative Regelabw e_L Begrenzung clr c jc pi16_5_B cjne a,#0FFh,pi16_9_B mov a,sollwert16+1 ; e = Regelabweichung = Sollwert - Iswert mov a,ymax16 mov a,r2 subb a,Drehzahl+1 mov yint16,a jz pi16_9_B ; negative Regelabweichung e_L mov r2,a ; R2 = e_L mov sollwert,a cpl a mov a,sollwert16 ret inc a subb a,Drehzahl ; A = e_H pi16_5_B: sjmp pi16_10_B jc pi16_neg_B ; Überlauftest mov yint16,a pi16_9_B: cjne a,#0,pi16_1_B ; High-teil von Regelabweichung e_H test pi16_51_B: ; positive Regelabweichung e_L mov a,#0FFh ; negative Regelabweichung e_L jmp pi16_2_B mov a,r2 ; Proportional Anteil pi16_10_B: pi16_1_B: mov b,kp16 mov r2,a ; R2 = maximale Regelabweichung e_L mov a,#0FFh ; positive Regelabweichung e_L Begrenzung mul ab ; kp * e_L mov b,ki16 ; Integrierer , yint = yint - ki*e mov r2,a ; positive Regelabweichung e_L jnb b.7,pi16_52_B ; Überlauftest vor der mul ab ; ki * e_L Multiplication pi16_2_B: mov r3,a mov b,#07FH mov a,r2 ; positive Regelabweichung e_L mov a,yint16+2 ; yint16_L = yint16_L - L pi16_52_B: ; Multiplication mal 2 mov b,ki16 ; Integrierer yint16 = yint16 + ki*e_L clr c ; C = 0 add a,ACC ; A = L * 2 mul ab ; ki * e_L subb a,r3 ; A = yint16_L - L xch a,b ; A = H / B = L * 2 add a,yint16+2 ; A = yint16_L + L mov yint16+2,a ; yint16_L = yint16_L - L addc a,ACC ; A = H * 2 mov yint16+2,a ; yint16_L = yint16_L + L mov a,yint16+1 ; A = yint16_M xch a,b ; A = L * 2 / B = H * 2 mov a,b ; A = H subb a,b ; A = yint16_M - H - C add a,yint16+1 addc a,yint16+1 ; A = yint16_M + H + C mov yint16+1,a ; yint16_M = yint16_M - H - C mov a,b mov yint16+1,a ; yint16_M = yint16_M + H + C mov a,yint16 ; A = yint16_H addc a,yint16 clr a ; A = 0 subb a,#0 ; A = yint16_H - C jc pi16_7_B ; Überlauftest addc a,yint16 ; A = yint16_H + C jnc pi16_11_B ; Überlauftest cjne a,ymax16,pi16_6_B ; Ausgang Begrenzung jnc pi16_3_B ; Überlauftest clr a pi16_6_B: mov a,ymax16 ; Ausgang und Integrierer Begrenzung pi16_11_B: jc pi16_8_B XC886/888CLMmov yint16,a mov yint16,a May 2006 pi16_7_B: mov sollwert,a pi16_101_B: ; negative Regelabweichung e_L Page 26 mov a,ymax16 ret mov a,r2 ; Proportional Anteil Example PI-Control with Cordic

int pi_control(int IST, int SOLL) { // y = Kp * e + Ki * integral(e*dt) error = SOLL-IST; // calculation of the error SYSCON0 |= 0x01; // switch into mapped area CD_STATC = 0x00; // clr keep bit - int dis CD_CON = 0x08; // LinRot - auto start MPS=1 CORDY = 0x0000; // Y = 0 CORDZ = 0x08CD; // Kp = 1.1 CORDX = error; // CORDIC start auto NOP // wait on ready – 25nops if(ERROR) result = result_max; CD_STATC = 0x40; //set keep bit for CORDY CORDZ = 0x0733; // Ki = 0.9 CORDX = error_int;//CORDIC start auto NOP // wait on ready – 25nops error_int += error;// calc error integral if(ERROR) result = result_max; printf ("PI = %04d dec \n",(int)result); SYSCON0 &= 0xFE; return (int)result; }

XC886/888CLM May 2006 Page 27