Subversion Repositories kvcordic

//
// Filename: cordic.nac
// Purpose : N-address code (NAC) implementation for a fixed-point universal 
//           CORDIC supporting all directions (ROTATION, VECTORING) and 
//           operation modes (CIRCULAR, LINEAR, HYPERBOLIC). 
//           The arithmetic representation used is signed fixed-point 
//           (Q2.14S). The implementation is based partly on the following 
//           sources (as references):
//           [1] The simple fixed-point CORDIC tools from:
//           http://www.dcs.gla.ac.uk/~jhw/cordic/
//           [2] Jorg Arndt, Matters Computational (free ebook): 
//           http://www.jjj.de/fxt/
//           [3] Jean-Michel Muller, Elementary Functions: Algorithms and 
//           Implementation, Second Edition, Birkhauser, 2006.
//           [4] Uwe Meyer-Baese, Digital Signal Processing with Field 
//           Programmable Gate Arrays, Third Edition, Springer, 2007.
// Author  : Nikolaos Kavvadias (C) 2010
// Date    : 01-Nov-2010
// Revision: 0.3.0 (31/10/10)
//           Initial version.
//           0.3.1 (01/11/10)
//           Some hand optimizations.
//           0.3.2 (01/11/10)
//           Interface changes, implementation of a unified CORDIC (can 
//           compute any function).
//           0.3.3 (08/11/10)
//           Replaced the three coefficient LUTs with a single one.
// 

constant s16 0, 1, 2, 4, 14, 28, 15;
globalvar s16 cordic_tab[42]={65535,8999,4184,2058,1025,512,256,128,64,32,16,8,4,2,16384,8192,4096,2048,1024,512,256,128,64,32,16,8,4,2,12867,7596,4013,2037,1022,511,255,127,63,31,15,7,3,1};

procedure cordic (in s16 direction, in s16 mode, in s16 xin, in s16 yin, in s16 zin, out s16 xout, out s16 yout, out s16 zout)
{
  localvar s16 k, d;
  localvar s16 x, y, z;
  localvar s16 xbyk, ybyk, i, tabval;
  localvar s16 t0, t1, t2, t3, t4, t5, t6, t7;
  localvar s16 zero, one, ldirection, lmode, offset;
  
S_1:
  zero <= ldc 0;
  one <= ldc 1;
  x <= mov xin;
  y <= mov yin;
  z <= mov zin;
  ldirection <= mov direction;
  lmode <= mov mode;
//  kstart = ((mode == HYPERBOLIC) ? 1 : 0);
  k <= muxeq lmode, 2, one, zero;
//  offset = ((mode == HYPERBOLIC) ? 0 : ((mode == LINEAR) ? 14 : 28)); 
  t0 <= muxeq lmode, 1, 14, 28;
  offset <= muxeq lmode, 2, 0, t0;
  i <= ldc 4;
  S_2 <= jmpun;

//  for (k = kstart; k < CORDIC_NTAB; ++k) {
S_2:
  S_3, S_EXIT <= jmplt k, 14;
  
//again:
S_3:
  // precompute invariants: y>>k, -(y>>k), x>>k, cordic_ctab[k]
  t0 <= shr y, k;
  t1 <= neg t0;
//  xbyk = (x>>k);
  xbyk <= shr x, k;
//  ybyk = ((mode == HYPERBOLIC) ? -(y>>k) : ((mode == LINEAR) ? 0 : (y>>k)));
  t5 <= muxeq lmode, 1, zero, t0;
  ybyk <= muxeq lmode, 2, t1, t5;
//  tabval = ((mode == HYPERBOLIC) ? cordic_htab[k] : ((mode == LINEAR) ? cordic_btab[k] : cordic_ctab[k]));
  t2 <= add k, offset;
  tabval <= load cordic_tab, t2;
//  if (direction == ROTATION) {
//    d = ((z>=0) ? 0 : 1);
  t7 <= shr z, 15;
  t1 <= muxeq t7, 0, zero, one; 
//  } else { // VECTORING
//    d = ((y<0) ? 0 : 1);                      
//  }
  t2 <= shr y, 15;
  t3 <= muxne t2, 0, zero, one;
  d <= muxeq ldirection, 0, t1, t3;
  S_4, S_5 <= jmpeq d, 0;

S_4:
//   x = x - ybyk;
  x <= sub x, ybyk;
//   y = y + xbyk;
  y <= add y, xbyk;
//   z = z - tabval;
  z <= sub z, tabval;
  S_6 <= jmpun;
  
S_5:
//  x = x + ybyk;
  x <= add x, ybyk;
//  y = y - xbyk;
  y <= sub y, xbyk;
//  z = z + tabval;
  z <= add z, tabval;
  S_6 <= jmpun; 
 
S_6:
//  if ((k == i) && (mode == HYPERBOLIC)) {
  t0 <= seteq k, i;
  t1 <= seteq lmode, 2;
  t2 <= and t0, t1;
  S_7, S_8 <= jmpeq t2, 1;

S_7:
//    i = ((i << 1) + i) + 1;
//    goto again;
//  }
  t3 <= shl i, 1;
  t4 <= add t3, i;
  i <= add t4, 1;
  S_3 <= jmpun;
  
S_8:
  k <= add k, 1;
  S_2 <= jmpun;
  
S_EXIT:
  xout <= mov x;
  yout <= mov y;
  zout <= mov z;
}