【【迭代七次的CORDIC算法-Verilog实现】】

news2024/9/22 13:37:13

迭代七次的CORDIC算法-Verilog实现求解正弦余弦函数

COEDIC.v

module CORDIC #(
    parameter         DATA_WIDTH    =      4'd8  ,     // we set data width
    parameter         PIPELINE      =      4'd8
  )(
    input                              clk       ,
    input                              rst_n     ,
    input       [DATA_WIDTH - 1 : 0]   phase     ,
    input                              ena       ,
    output  reg [DATA_WIDTH - 1 : 0]   sin_out   ,
    output  reg [DATA_WIDTH - 1 : 0]   cos_out
  );

  //  ------------------------------------------------  \\
  //         next is define and parameter               \\
  //  -------------------------------------------------\\

  reg      [DATA_WIDTH - 1 : 0]    phase_reg     ;
  reg      [DATA_WIDTH - 1 : 0]    X0            ;
  reg      [DATA_WIDTH - 1 : 0]    Y0            ;
  reg      [DATA_WIDTH - 1 : 0]    Z0            ;
  wire     [DATA_WIDTH - 1 : 0]    X1 , Y1 , Z1  ;
  wire     [DATA_WIDTH - 1 : 0]    X2 , Y2 , Z2  ;
  wire     [DATA_WIDTH - 1 : 0]    X3 , Y3 , Z3  ;
  wire     [DATA_WIDTH - 1 : 0]    X4 , Y4 , Z4  ;
  wire     [DATA_WIDTH - 1 : 0]    X5 , Y5 , Z5  ;
  wire     [DATA_WIDTH - 1 : 0]    X6 , Y6 , Z6  ;
  wire     [DATA_WIDTH - 1 : 0]    X7 , Y7 , Z7  ;

  reg [1:0] quadrant[PIPELINE : 0] ;
  integer i ;

  always@(posedge clk or negedge rst_n)
  begin
    if(rst_n == 0)
      for(i = 0 ; i <= PIPELINE ; i=i+1)
        quadrant[i] <= 0 ;
    else
      if(ena == 1)
      begin
        for(i = 0 ; i <= PIPELINE ; i=i+1)
          quadrant[i+1] <= quadrant[i] ;
        quadrant[0] <= phase[DATA_WIDTH - 1 : DATA_WIDTH - 2] ;
      end
  end














  //  we set a new phase to Unify the phase in the first quadrant
  //  we set 8'h      0010 0000 =>  45度     and  1000 0000 => 180度

  always@(posedge clk or negedge rst_n)
  begin
    if(rst_n == 0)
    begin
      phase_reg <= 0 ;
    end
    else if(ena == 1)
    begin
      case(phase[DATA_WIDTH -1 : DATA_WIDTH -2])
        2'b00 :
          phase_reg <= phase          ;
        2'b01 :
          phase_reg <= phase - 8'h40  ; // subtract 90
        2'b10 :
          phase_reg <= phase - 8'h80  ; // subtract 180
        2'b11 :
          phase_reg <= phase - 8'hC0  ; // subtract 270
        default :
          ;
      endcase
    end
  end




  //  start to calculate
  // we should set x0= 0.607252935    y0= 0  z0
  always@(posedge clk or negedge rst_n )
  begin
    if( rst_n == 0)
    begin
      X0 <= 0     ;
      Y0 <= 0     ;
      Z0 <= 0     ;
    end
    else if(ena == 1 )
    begin
      X0 <= 8'h4D      ;
      Y0 <= 0          ;
      Z0 <= phase_reg  ;
    end
  end



  // next is iteration

  INTERATION#(
              .DATA_WIDTH ( 4'd8 ),
              .shift      ( 4'd0 ),
              .ANGLE      ( 8'h20 )
            )u_INTERATION0(
              .clk        ( clk        ),
              .rst_n      ( rst_n      ),
              .ena        ( ena        ),
              .X0         ( X0         ),
              .Y0         ( Y0         ),
              .Z0         ( Z0         ),
              .X1         ( X1         ),
              .Y1         ( Y1         ),
              .Z1         ( Z1         )
            );




  INTERATION#(
              .DATA_WIDTH ( 4'd8 ),
              .shift      ( 4'd1 ),
              .ANGLE      ( 8'h12 )
            )u_INTERATION1(
              .clk        ( clk        ),
              .rst_n      ( rst_n      ),
              .ena        ( ena        ),
              .X0         ( X1         ),
              .Y0         ( Y1         ),
              .Z0         ( Z1         ),
              .X1         ( X2         ),
              .Y1         ( Y2         ),
              .Z1         ( Z2         )
            );





  INTERATION#(
              .DATA_WIDTH ( 4'd8 ),
              .shift      ( 4'd2 ),
              .ANGLE      ( 8'h09 )
            )u_INTERATION2(
              .clk        ( clk        ),
              .rst_n      ( rst_n      ),
              .ena        ( ena        ),
              .X0         ( X2         ),
              .Y0         ( Y2         ),
              .Z0         ( Z2         ),
              .X1         ( X3         ),
              .Y1         ( Y3         ),
              .Z1         ( Z3         )
            );




  INTERATION#(
              .DATA_WIDTH ( 4'd8 ),
              .shift      ( 4'd3 ),
              .ANGLE      ( 8'h04 )
            )u_INTERATION3(
              .clk        ( clk        ),
              .rst_n      ( rst_n      ),
              .ena        ( ena        ),
              .X0         ( X3         ),
              .Y0         ( Y3         ),
              .Z0         ( Z3         ),
              .X1         ( X4         ),
              .Y1         ( Y4         ),
              .Z1         ( Z4         )
            );



  INTERATION#(
              .DATA_WIDTH ( 4'd8 ),
              .shift      ( 4'd4 ),
              .ANGLE      ( 8'h02 )
            )u_INTERATION4(
              .clk        ( clk        ),
              .rst_n      ( rst_n      ),
              .ena        ( ena        ),
              .X0         ( X4         ),
              .Y0         ( Y4         ),
              .Z0         ( Z4         ),
              .X1         ( X5         ),
              .Y1         ( Y5         ),
              .Z1         ( Z5         )
            );



  INTERATION#(
              .DATA_WIDTH ( 4'd8 ),
              .shift      ( 4'd5 ),
              .ANGLE      ( 8'h01 )
            )u_INTERATION5(
              .clk        ( clk        ),
              .rst_n      ( rst_n      ),
              .ena        ( ena        ),
              .X0         ( X5         ),
              .Y0         ( Y5         ),
              .Z0         ( Z5         ),
              .X1         ( X6         ),
              .Y1         ( Y6         ),
              .Z1         ( Z6         )
            );



  INTERATION#(
              .DATA_WIDTH ( 4'd8 ),
              .shift      ( 4'd6 ),
              .ANGLE      ( 8'h00 )
            )u_INTERATION6(
              .clk        ( clk        ),
              .rst_n      ( rst_n      ),
              .ena        ( ena        ),
              .X0         ( X6         ),
              .Y0         ( Y6         ),
              .Z0         ( Z6         ),
              .X1         ( X7         ),
              .Y1         ( Y7         ),
              .Z1         ( Z7         )
            );

  //   The results of different phases are also different
  //   phase[DATA_WIDTH -1 : DATA_WIDTH -2]
  //  00 first  quadrant
  //  01 second quadrant
  //  10 third  quadrant
  //  11 Fourth Quadrant


  always@(posedge clk or negedge rst_n)
  begin
    if(rst_n == 0)
    begin
      cos_out <= 0 ;
      sin_out <= 0 ;
    end
    else if( ena == 1)
    begin
      case(quadrant[7])
        2'b00 :
        begin
          cos_out <= X6 ;
          sin_out <= Y6 ;
        end
        2'b01 :
        begin
          cos_out <= ~(Y6) + 1 ;
          sin_out <= X6        ;
        end
        2'b10 :
        begin
          cos_out <= ~(X6) + 1 ;
          sin_out <= ~(Y6) + 1 ;
        end
        2'b11 :
        begin
          cos_out <= Y6        ;
          sin_out <= ~(X6) + 1 ;
        end
        default:
          ;
      endcase
    end
  end
endmodule

Interation.v

module INTERATION #(
    parameter   DATA_WIDTH       =    4'd8      ,
    parameter   shift            =    4'd0      ,
    parameter   ANGLE            =    8'h20
  )(
    input                                  clk     ,
    input                                  rst_n   ,
    input                                  ena     ,
    input        [DATA_WIDTH - 1 : 0]      X0      ,
    input        [DATA_WIDTH - 1 : 0]      Y0      ,
    input        [DATA_WIDTH - 1 : 0]      Z0      ,
    output  reg  [DATA_WIDTH - 1 : 0]      X1      ,
    output  reg  [DATA_WIDTH - 1 : 0]      Y1      ,
    output  reg  [DATA_WIDTH - 1 : 0]      Z1
  );

  always@(posedge clk or negedge rst_n)
  begin
    if( rst_n == 0)
    begin
      X1 <= 0 ;
      Y1 <= 0 ;
      Z1 <= 0 ;
    end
    else if( ena == 1)
    begin
      if(Z0[DATA_WIDTH - 1] == 0 )
      begin
        X1 <= X0 - {{shift{ Y0[DATA_WIDTH - 1] }} ,Y0[DATA_WIDTH - 1 : shift] } ;
        Y1 <= Y0 + {{shift{ X0[DATA_WIDTH - 1] }} ,X0[DATA_WIDTH - 1 : shift] } ;
        Z1 <= Z0 - ANGLE                                                    ;
      end
      else if(Z0[DATA_WIDTH - 1] == 1 )
      begin
        X1 <= X0 + {{shift{ Y0[DATA_WIDTH - 1 ] }} ,Y0[DATA_WIDTH - 1 : shift] } ;
        Y1 <= Y0 - {{shift{ X0[DATA_WIDTH - 1 ] }} ,X0[DATA_WIDTH - 1 : shift] } ;
        Z1 <= Z0 + ANGLE                                                    ;
      end
    end
  end

endmodule

cordic_tb.v

module cordic_tb #(
       parameter       DATA_WIDTH   =    4'd8      
);
reg                                 clk       ;
reg                                 rst_n     ;
reg          [DATA_WIDTH - 1 : 0]   phase     ;
reg                                 ena       ;
wire         [DATA_WIDTH - 1 : 0]   sin_out   ;
wire         [DATA_WIDTH - 1 : 0]   cos_out   ;

CORDIC#(
    .DATA_WIDTH    ( DATA_WIDTH )
)u_CORDIC(
    .clk           ( clk           ),
    .rst_n         ( rst_n         ),
    .phase         ( phase         ),
    .ena           ( ena           ),
    .sin_out       ( sin_out       ),
    .cos_out       ( cos_out       )
);

always #5 clk = ~clk ;

initial 
begin 
    clk      = 0     ;
    rst_n    = 0     ; 
    ena      = 1     ;
    phase    = 8'h00 ;
    #10
    rst_n   = 1      ;
end
always #10
phase = phase + 1    ; 

endmodule 

README.md

# 本文参考自 西电的verilog 课程实验 还有网上的 CORDIC算法详解
对于CORDIC的算法 关键是学会迭代和 掌握自 不同象限角度的换算
我在参阅网上资料的时候 发现有些角度的换算存在了错误这里我再写入一下 
| 第一象限 | 第二象限 | 第三象限 | 第四象限 |
| --------| --------| --------| --------|
| (x,y)   | (x,y)   | (x,y)    |  (x,y)   |
| (x,y)   | (-y,x)  | (-x ,-y) | (y , -x) |

最关键的是在于理清如何计算的 实际操作起来的  圆周旋转求旋转模式下的正余弦
并不用考虑太多的 角度旋转 选取初始值之后 直接迭代开干 

在这里插入图片描述

## 波形很奇怪 我也不懂为什么做不到像其他人的这么顺滑 但是应该没错吧

纠正一下 把进制改成 Signed Decimal 就可以得到顺滑的常规正弦函数波形
在这里插入图片描述

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处:http://www.coloradmin.cn/o/1325315.html

如若内容造成侵权/违法违规/事实不符,请联系多彩编程网进行投诉反馈,一经查实,立即删除!

相关文章

命令执行 [SWPUCTF 2021 新生赛]babyrce

打开题目 我们看到题目说cookie值admin等于1时&#xff0c;才能包含文件 bp修改一下得到 访问rasalghul.php&#xff0c;得到 题目说如果我们get传入一个url且不为空值&#xff0c;就将我们get姿势传入的url的值赋值给ip 然后用正则过滤了 / /&#xff0c;如果ip的值没有 / …

Android 13 - Media框架(24)- OMXNodeInstance(一)

为了了解 ACodec 是如何与 OpenMAX 组件进行 buffer 流转的&#xff0c;我们有必要先来学习 OMXNodeInstance&#xff0c;在前面的章节中&#xff0c;我们已经了解了 media.codec 进程包含的内容&#xff0c;以及 OpenMAX 框架中的一些内容。这一节我们将来学习 OMXNode 与 med…

X 进制减法问题

思路如下&#xff1a; 代码如下&#xff1a; #include<iostream> using namespace std; const int N 1e5 5; const long long MOD 1000000007; //定义了常量 N 和 MOD。N 是数组的最大长度&#xff0c;MOD 是取模运算的模数。int numsA[N], numsB[N]; //声明了两个数…

IDEA创建springboot工程

选择spring boot的版本和依赖 finish创建完成 删除无用的文件

Android 自动化测试——Monkey测试

Android自带了很多方便的测试工具和方法&#xff0c;包括我们常用的单元测试、Robotium测试、Monkey测试、MonkeyRunner测试、senevent模拟等。这些方法对于我们编写高质量的APP十分有用。也可以提前暴露我们程序的隐藏问题。今天给大家讲一下Monkey测试&#xff0c;Monkey测试…

页面菜单,通过get请求一个url后,跳转另外一个页面,+丢失问题

业务场景描述&#xff1a; 在A系统&#xff0c;菜单点击跳B系统这个操作。 A系统菜单是get请求到B系统的一个缓冲页面&#xff0c;然后这个缓冲页面获取到url中的accessToken后&#xff0c;在这个页面中通过post请求后端接口。 问题描述&#xff1a; 当accessToken中包含了…

Stable Diffusion Windows 部署简单认知

写在前面 偶然看到&#xff0c;简单了解博文为 SD 部署&#xff0c;以及简单使用&#xff0c;部署过程遇到问题解决理解不足小伙伴帮忙指正 对每个人而言&#xff0c;真正的职责只有一个&#xff1a;找到自我。然后在心中坚守其一生&#xff0c;全心全意&#xff0c;永不停息。…

adam优化器和动量

原始的SGD 加上动量&#xff08;惯性&#xff0c;每一次更新根据前面所有结果&#xff0c;使结果更快收敛&#xff09; AdaGrad 与SGD的核心区别在于计算更新步长时&#xff0c;增加了分母&#xff1a;梯度平方累积和的平方根。此项能够累积各个参数 的历史梯度平方&#xf…

Vue 2.5 入门学习记录

Vue 2.5 入门学习记录 1. 基础知识Vue 是什么Vue引入方式Vue特点Vue实例中的数据事件方法Vue中的属性绑定和双向绑定Vue中的v-if、v-show、v-fortoDoList制作局部组件&全局组件 2. vue-cli工程3. 工程案例实践使用vue-cli实现todoList及删除某个元素全局样式与局部样式 4. …

2024年camtasia怎么导出mp4

Camtasia 2024是一款屏幕录制和视频剪辑软件&#xff0c;教授课程&#xff0c;培训他人&#xff0c;以更快的速度和更吸引人的方式进行沟通和屏幕分享。使您在Windows和Mac上进行录屏和剪辑创作专业外观的视频变得更为简单。 Camtasia Studio 2023 win-安装包&#xff1a;https…

智能优化算法应用:基于蜜獾算法3D无线传感器网络(WSN)覆盖优化 - 附代码

智能优化算法应用&#xff1a;基于蜜獾算法3D无线传感器网络(WSN)覆盖优化 - 附代码 文章目录 智能优化算法应用&#xff1a;基于蜜獾算法3D无线传感器网络(WSN)覆盖优化 - 附代码1.无线传感网络节点模型2.覆盖数学模型及分析3.蜜獾算法4.实验参数设定5.算法结果6.参考文献7.MA…

机器视觉工程师,我存多少钱可以躺平

钱钱钱&#xff01;还是钱&#xff01;除了钱还能聊点别的吗&#xff1f;钱可以让你生活的更好&#xff0c;也可以让你​在生活中的选择很无奈。 如果想要知道拥有多少存款才能躺平不上班&#xff0c;那么首先要明确躺平的定义。所谓的躺平&#xff0c;其实并不代表不能工作&a…

车载V2X方案的选型分享

ACX200T面向 5G车联网C-V2X 应用的安全芯片&#xff0c;满足V2X场景下消息认证的专用安全芯片&#xff0c;该款芯片采用公司自主的 高速硬件加密引擎 &#xff0c;支 持国家标准SM1、SM2、SM3、SM4密码算法&#xff0c;同时支持国际ECDSA、AES、SHA-1密码算法。可实现网联汽车云…

SWUST-跳绳比赛

由于这里只算前60s的&#xff0c;又有每秒跳一个&#xff0c;假设60秒抽象为数组&#xff0c;每个值为1。根据输入来更新数组&#xff0c;若停下则更新为0。最后对数组求和即可。 代码如下 #include<stdio.h> #include<stdlib.h> int main() {int n;scanf("…

Qt前端技术:2.QSS

border-style&#xff1a;后边是两个参数的话第一个参数改变上下的style 第二个参数改变左右的style 如果后边是三个参数的话第一个参数改变上边的style第二个参数改变左右的style&#xff0c;第三个参数改变的下边的style 如果后边是四个参数的话对应的顺序为上&#xff0c;右…

【蓝桥杯】专题练习

前缀和 3956. 截断数组 - AcWing题库 一看到题目很容易想到的思路是对数组求前缀和&#xff0c;然后枚举两个分段点就好&#xff0c;时间复杂度是On^2&#xff0c;n是1e5会t&#xff0c;需要优化。 朴素的代码&#xff0c;会超时&#xff1a; #include <bits/stdc.h> u…

Floating point exception

参考:https://blog.csdn.net/yyangzhenjie/article/details/87859506?spm1001.2101.3001.6661.1&utm_mediumdistribute.pc_relevant_t0.none-task-blog-2%7Edefault%7ECTRLIST%7ERate-1-87859506-blog-126091159.235%5Ev39%5Epc_relevant_3m_sort_dl_base2&depth_1-ut…

使用包、Crate 和模块管理项目(下)

1、使用 use 关键字将路径引入作用域 在之前的示例中我们引用模块中的函数或者结构体之类的&#xff0c;都是需要用到相对路径或者绝对路径去引用&#xff0c;然尔在这里&#xff0c;有一种方法可以简化这个过程。我们可以使用 use 关键字创建一个短路径&#xff0c;然后就可以…

Spring Boot3通过GraalVM生成exe执行文件

一、安装GraalVM 1、官网&#xff1a;https://www.graalvm.org/downloads/ 2、配置环境变量 2.1、环境变量必须使用JAVA_HOME&#xff0c;否则会出现问题 2.2、在系统变量配置Path,%JAVA_HOME%\bin&#xff0c;注意必须放在顶部第一位 2.3、配置jdk的环境变量&#xff0c;在P…

IDEA中如何创建各种类型的java工程

如果你的工程下面的module没有互相依赖&#xff0c;就相当于是一个小的项目&#xff0c;idea版本不同&#xff0c;细节可能不同 1、普通的Java 工程 在工程上&#xff0c;右键- New - Module&#xff0c;如下&#xff1a; 指明Java工程的名称及使用的JDK版本&#xff1a; 创建…