一个CORDIC算法在圆周系统下的向量模式下获取角度的Verilog 程序

下面给出一个CORDIC算法在圆周系统下的向量模式下获取角度的Verilog 程序:

/*==============================================================================*\
        Filename : Cordic.v
        Discription : 坐标旋转数字计算方法。通过该算法,对输入的向量坐标进行9次迭代
     计算,得到该向量的模值和相角。
        
\*==============================================================================*/

module CORDIC
 (
  Clk_20m,
  _Rst,
  Cordic_start,
  Ug_d,  
  Ug_q,
  Ug,
  Delta

);

input Clk_20m,
   _Rst,
   Cordic_start;  //CORDIC变换启动标志
 
 input[15:0] Ug_d,  //输出电压的d轴分量
    Ug_q;  //输出电压的q轴分量
 output[15:0] Ug;  //输出电压向量的模值
 output[13:0] Delta;  //输出电压向量的相角
 
 wire[31:0] Ug_tmp;
 reg[3:0] Times;  //迭代次数累加器
 reg[15:0] Ug_d_tmp,  //输出电压d轴分量的中间迭代结果
    Ug_q_tmp;  //输出电压q轴分量的中间迭代结果
    
 reg[13:0] //Delta,
    Delta_tmp;  //相位角旋转累加寄存器
 
 
// assign Ug = ( Ug_d_tmp>>1 ) + ( Ug_d_tmp>>3 ) - ( Ug_d_tmp>>6 ) - ( Ug_d_tmp>>9 );
 
 //对电压模值进行比例系数调整,得到实际模值的32倍
// assign Ug_tmp[31:0] = Ug_d_tmp[15:0] * 16‘d48224;//d39797;
 assign Ug_tmp[31:0] = Ug_d_tmp[15:0] * 16‘d45208;
 assign Ug[15:0] = Ug_tmp[31:16];

//输出电压向量的相角即为CORDIC算法输出的旋转角
 assign Delta = Delta_tmp;
/* 
 always @( posedge Clk_20m or negedge _Rst )
 begin
  if ( !_Rst )
   Delta <= 14‘h0;
  else if ( Delta_tmp <= 14‘h6 )
    Delta <= Delta_tmp;
   else if ( Delta_tmp <= 14‘h1fff )
     Delta <= 14‘h6;
    else if ( Delta_tmp <= 14‘h3ffa )
      Delta <= 14‘h3ffa;
     else
      Delta <= Delta_tmp;

else
   Delta <= 14‘h6;
      
 end

*/

always @( posedge Clk_20m or negedge _Rst ) 
 begin
  if ( !_Rst )
   begin
   Times[3:0] <= 4‘hf;
   Ug_d_tmp[15:0] <= 16‘h0;
   Ug_q_tmp[15:0] <= 16‘h0;
   Delta_tmp[13:0] <= 14‘h0;
   end
  else if ( Cordic_start )  //启动CORDIC变换
    begin
    Times[3:0] <= 4‘h0;
    Ug_d_tmp <= Ug_d;
    Ug_q_tmp <= Ug_q;
    Delta_tmp <= 14‘h0;
    end
    else if ( Times <= 4‘d9 )  //开始迭代计算
     begin
     Times[3:0] <= Times[3:0] + 4‘h1;  //迭代次数加1
     case ( Times )
     4‘h0:

//Ug_q_tmp[15] 符号位
      if ( Ug_q_tmp[15] )  //旋转的目标是使Ug_q_tmp趋近于0,
            //根据对Ug_q_tmp符号的判断,决定正向旋转还是反向旋转
       begin
       Ug_d_tmp <= Ug_d_tmp - Ug_q_tmp;  //重新计算新的d轴分量
       Ug_q_tmp <= Ug_q_tmp + Ug_d_tmp;  //重新计算新的q轴分量
       Delta_tmp <= Delta_tmp - 14‘hB40;  //对相位角进行累加计算
       end
      else
       begin
       Ug_d_tmp <= Ug_d_tmp + Ug_q_tmp;
       Ug_q_tmp <= Ug_q_tmp - Ug_d_tmp;
       Delta_tmp <= Delta_tmp + 14‘hB40;    //(2880/64)=45
       end
     4‘h1:
      if ( Ug_q_tmp[15] )
       begin
       Ug_d_tmp <= Ug_d_tmp - { Ug_q_tmp[15], Ug_q_tmp[15:1] };
       Ug_q_tmp <= Ug_q_tmp + { Ug_d_tmp[15], Ug_d_tmp[15:1] };
       Delta_tmp <= Delta_tmp - 14‘h6A4;  // (1700/64)=26.5625
       end
      else
       begin
       Ug_d_tmp <= Ug_d_tmp + { Ug_q_tmp[15], Ug_q_tmp[15:1] };
       Ug_q_tmp <= Ug_q_tmp - { Ug_d_tmp[15], Ug_d_tmp[15:1] };
       Delta_tmp <= Delta_tmp + 14‘h6A4; // 
       end
     4‘h2:
      if ( Ug_q_tmp[15] )
       begin
       Ug_d_tmp <= Ug_d_tmp - { {2{Ug_q_tmp[15]}}, Ug_q_tmp[15:2] };
       Ug_q_tmp <= Ug_q_tmp + { {2{Ug_d_tmp[15]}}, Ug_d_tmp[15:2] };
       Delta_tmp <= Delta_tmp - 14‘h382; // (382/64=14.03125)
       end
      else
       begin
       Ug_d_tmp <= Ug_d_tmp + { {2{Ug_q_tmp[15]}}, Ug_q_tmp[15:2] };
       Ug_q_tmp <= Ug_q_tmp - { {2{Ug_d_tmp[15]}}, Ug_d_tmp[15:2] };
       Delta_tmp <= Delta_tmp + 14‘h382;
       end
     4‘h3:
      if ( Ug_q_tmp[15] )
       begin
       Ug_d_tmp <= Ug_d_tmp - { {3{Ug_q_tmp[15]}}, Ug_q_tmp[15:3] };
       Ug_q_tmp <= Ug_q_tmp + { {3{Ug_d_tmp[15]}}, Ug_d_tmp[15:3] };
       Delta_tmp <= Delta_tmp - 14‘h1c8; // (382/64=14.03125)
       end
      else
       begin
       Ug_d_tmp <= Ug_d_tmp + { {3{Ug_q_tmp[15]}}, Ug_q_tmp[15:3] };
       Ug_q_tmp <= Ug_q_tmp - { {3{Ug_d_tmp[15]}}, Ug_d_tmp[15:3] };
       Delta_tmp <= Delta_tmp + 14‘h1c8; // (456/64=7.125)
       end
     4‘h4:
      if ( Ug_q_tmp[15] )
       begin
       Ug_d_tmp <= Ug_d_tmp - { {4{Ug_q_tmp[15]}}, Ug_q_tmp[15:4] };
       Ug_q_tmp <= Ug_q_tmp + { {4{Ug_d_tmp[15]}}, Ug_d_tmp[15:4] };
       Delta_tmp <= Delta_tmp - 14‘hE5; //(229/64=3.578125)
       end
      else
       begin
       Ug_d_tmp <= Ug_d_tmp + { {4{Ug_q_tmp[15]}}, Ug_q_tmp[15:4] };
       Ug_q_tmp <= Ug_q_tmp - { {4{Ug_d_tmp[15]}}, Ug_d_tmp[15:4] };
       Delta_tmp <= Delta_tmp + 14‘hE5;
       end
     4‘h5:
      if ( Ug_q_tmp[15] )
       begin
       Ug_d_tmp <= Ug_d_tmp - { {5{Ug_q_tmp[15]}}, Ug_q_tmp[15:5] };
       Ug_q_tmp <= Ug_q_tmp + { {5{Ug_d_tmp[15]}}, Ug_d_tmp[15:5] };
       Delta_tmp <= Delta_tmp - 14‘h72; //(114/64=1.78125)
       end
      else
       begin
       Ug_d_tmp <= Ug_d_tmp + { {5{Ug_q_tmp[15]}}, Ug_q_tmp[15:5] };
       Ug_q_tmp <= Ug_q_tmp - { {5{Ug_d_tmp[15]}}, Ug_d_tmp[15:5] };
       Delta_tmp <= Delta_tmp + 14‘h72;
       end
     4‘h6:
      if ( Ug_q_tmp[15] )
       begin
       Ug_d_tmp <= Ug_d_tmp - { {6{Ug_q_tmp[15]}}, Ug_q_tmp[15:6] };
       Ug_q_tmp <= Ug_q_tmp + { {6{Ug_d_tmp[15]}}, Ug_d_tmp[15:6] };
       Delta_tmp <= Delta_tmp - 14‘h39;//(57/64=0.890625)
       end
      else
       begin
       Ug_d_tmp <= Ug_d_tmp + { {6{Ug_q_tmp[15]}}, Ug_q_tmp[15:6] };
       Ug_q_tmp <= Ug_q_tmp - { {6{Ug_d_tmp[15]}}, Ug_d_tmp[15:6] };
       Delta_tmp <= Delta_tmp + 14‘h39;
       end
     4‘h7:
      if ( Ug_q_tmp[15] )
       begin
       Ug_d_tmp <= Ug_d_tmp - { {7{Ug_q_tmp[15]}}, Ug_q_tmp[15:7] };
       Ug_q_tmp <= Ug_q_tmp + { {7{Ug_d_tmp[15]}}, Ug_d_tmp[15:7] };
       Delta_tmp <= Delta_tmp - 14‘h1C;//(28/64=0.4375)
       end
      else
       begin
       Ug_d_tmp <= Ug_d_tmp + { {7{Ug_q_tmp[15]}}, Ug_q_tmp[15:7] };
       Ug_q_tmp <= Ug_q_tmp - { {7{Ug_d_tmp[15]}}, Ug_d_tmp[15:7] };
       Delta_tmp <= Delta_tmp + 14‘h1C;
       end
     4‘h8:
      if ( Ug_q_tmp[15] )
       begin
       Ug_d_tmp <= Ug_d_tmp - { {8{Ug_q_tmp[15]}}, Ug_q_tmp[15:8] };
       Ug_q_tmp <= Ug_q_tmp + { {8{Ug_d_tmp[15]}}, Ug_d_tmp[15:8] };
       Delta_tmp <= Delta_tmp - 14‘hE;//(14/64=0.21875)
       end
      else
       begin
       Ug_d_tmp <= Ug_d_tmp + { {8{Ug_q_tmp[15]}}, Ug_q_tmp[15:8] };
       Ug_q_tmp <= Ug_q_tmp - { {8{Ug_d_tmp[15]}}, Ug_d_tmp[15:8] };
       Delta_tmp <= Delta_tmp + 14‘hE;
       end
     4‘h9:
      if ( Ug_q_tmp[15] )
       begin
       Ug_d_tmp <= Ug_d_tmp - { {9{Ug_q_tmp[15]}}, Ug_q_tmp[15:9] };
       Ug_q_tmp <= Ug_q_tmp + { {9{Ug_d_tmp[15]}}, Ug_d_tmp[15:9] };
       Delta_tmp <= Delta_tmp - 14‘h7;
       end
      else
       begin
       Ug_d_tmp <= Ug_d_tmp + { {9{Ug_q_tmp[15]}}, Ug_q_tmp[15:9] };
       Ug_q_tmp <= Ug_q_tmp - { {9{Ug_d_tmp[15]}}, Ug_d_tmp[15:9] };
       Delta_tmp <= Delta_tmp + 14‘h7; //(7/64=0.109375)
       end
     default:  //缺省情况下所有寄存器清零
      begin
      Ug_d_tmp <= 16‘h0;
      Ug_q_tmp <= 16‘h0;
      Delta_tmp <= 14‘h0;
      end
//      ;
     endcase
     end
    else
     Times[3:0] <= 4‘hf;  //迭代计算完毕,结束CORDIC算法,迭代次数置复位值
 
 
 end

endmodule

时间: 2024-10-05 07:40:59

一个CORDIC算法在圆周系统下的向量模式下获取角度的Verilog 程序的相关文章

新闻发布系统,B/S模式下的三层应用

三层的学习已接触四五个月了,最早是在学习VB.NET视频中开始接触的,那时候跟着视频敲了两个例子.再后来,个人机房重构的时候,从三层进步到了七层,此后就觉得我们不能仅仅局限于三层之上. 不过,那些都是C/S模式之下的编程.到现在,接触了B/S模式也一个多月了,第一个牛腩新闻发布系统觉得很是有趣,还是从最基本的开始,下面就一起看看B/S模式下,三层是怎样应用的.这篇博客就以添加新闻的实例来总结. 对于三层的整个过程大家都是很熟悉的了,那么在这里就不再赘述了,直接一层一层来分析. 一.思路整理. U

华为服务器通过mgmt口挂载光盘装系统及Linux系统rescue模式下修复内核

Linux系统rescue模式下修复内核和grub 故障现象 处理思路,内核报错,因此重新安装内核,通过光盘启动,进入救援模式.1.进入救援模式(1)华为服务器没有光驱,通过mgmt管理口登录,挂载iso镜像来引导.连接服务器mgmt口至数据中心网络,浏览器登录,默认IP地址192.168.2.100,默认账号root,默认密码Huawei12#$.登录如下图 单击远程控制链接,进入远程控制管理页面,选择独占模式,如下图 打开远程管理控制台,java信息提示,点击继续这里要求远控操作电脑安装好j

微博feed系统的推(push)模式和拉(pull)模式和时间分区拉模式架构探讨

sns系统,微博系统都应用到了feed(每条微博或者sns里的新鲜事等我们称作feed)系统,不管是twitter.com或者国内的新浪微博,人人网等,在各种技术社区,技术大会上都在分享自己的feed架构,也就是推拉模式(timyang上次也分享了新浪微薄的模式).下面我们就微博的feed推拉(push,pull)模式做一下探讨,并提出新的时间分区拉模式. 众所周知,在微博中,当你发表一篇微博,那么所有关注你的followers(粉丝)都会在一定的时间内收到你的微薄,这有点像群发一封邮件,所有的

SQL Server SQL性能优化之--数据库在“简单”参数化模式下,自动参数化SQL带来的问题

数据库参数化的模式 数据库的参数化有两种方式,简单(simple)和强制(forced),默认的参数化默认是“简单”,简单模式下,如果每次发过来的SQL,除非完全一样,否则就重编译它(特殊情况会自动参数化,正是本文想说的重点)强制模式就是将adhoc SQL强制参数化,避免每次运行的时候因为参数值的不同而重编译,这里不详细说明. 这首先要感谢“潇湘隐者”大神的提示, 当时也是遇到一个实际问题, 发现执行计划对数据行的预估,怎么都不对,有观察到无论怎么改变参数,SQL语句执行前都没有重编译,疑惑了

Cordic 算法入门

三角函数计算,Cordic 算法入门 三角函数的计算是个复杂的主题,有计算机之前,人们通常通过查找三角函数表来计算任意角度的三角函数的值.这种表格在人们刚刚产生三角函数的概念的时候就已经有了,它们通常是通过从已知值(比如sin(π/2)=1)开始并重复应用半角和和差公式而生成. 现在有了计算机,三角函数表便推出了历史的舞台.但是像我这样的喜欢刨根问底的人,不禁要问计算机又是如何计算三角函数值的呢.最容易想到的办法就是利用级数展开,比如泰勒级数来逼近三角函数,只要项数取得足够多就能以任意的精度来逼

一个简单的情感识别系统的实现

情感识别,主要就是正和负的识别,偶尔也有中性.类别比较少,所以相对于广义的文本分类来说,看起来要简单很多,特别是很多词汇都有很强的倾向性.当然这是针对某一特定的领域.一般的话,情感识别主要用于商品评论,因为不同的商品会有不同的术语之类的专门的某一词汇,所以如果将某一领域的数据集上学到的模型应用在另一个领域的话,可能效果会不很理想. Stephan Raaijmakers等的这篇文章[1]提出的是一种基于阀值投票的方法,即使用独立的分类器去分各个类别的数据,最后使用新领域的数据对分类结果进行投票校

(转)三角函数计算,Cordic 算法入门

由于最近要使用atan2函数,但是时间上消耗比较多,因而网上搜了一下简化的算法. 原帖地址:http://blog.csdn.net/liyuanbhu/article/details/8458769 三角函数计算,Cordic 算法入门 三角函数的计算是个复杂的主题,有计算机之前,人们通常通过查找三角函数表来计算任意角度的三角函数的值.这种表格在人们刚刚产生三角函数的概念的时候就已经有了,它们通常是通过从已知值(比如sin(π/2)=1)开始并重复应用半角和和差公式而生成. 现在有了计算机,三

三角函数计算,Cordic 算法入门

三角函数的计算是个复杂的主题,有计算机之前,人们通常通过查找三角函数表来计算任意角度的三角函数的值.这种表格在人们刚刚产生三角函数的概念的时候就已经有了,它们通常是通过从已知值(比如sin(π/2)=1)开始并重复应用半角和和差公式而生成.现在有了计算机,三角函数表便推出了历史的舞台.但是像我这样的喜欢刨根问底的人,不禁要问计算机又是如何计算三角函数值的呢.最容易想到的办法就是利用级数展开,比如泰勒级数来逼近三角函数,只要项数取得足够多就能以任意的精度来逼近函数值.除了泰勒级数逼近之外,还有其他

一个日期算法的原理分析

1.问题描述 在 OSC 问答频道有一个问题:时间算法:帮忙解答下 简单的复述一遍就是能够通过如下式子来计算month月day日是一年的第几天. 闰年是 day_of_year=(275*month)/9 - (month+9)/12 + day - 30 非闰年比这个少1天.可以简单的验证,这个式子中每个部分计算后都取整,整个结果总是对的. 我们知道1.3.5.7.8.10.12都是31天,2月的天数有点诡异,其他都是30天,正常情况下我们写程序会写很多if来判断月份,进而计算累积的天数.但是