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

迭代七次的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 就可以得到顺滑的常规正弦函数波形
在这里插入图片描述

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

如若内容造成侵权/违法违规/事实不符,请联系我们进行投诉反馈qq邮箱809451989@qq.com,一经查实,立即删除!

相关文章

vivado 关于时钟

关于时钟 在数字设计中&#xff0c;时钟代表了从寄存器可靠传输数据的时间基准注册。AMD Vivado™集成设计环境&#xff08;IDE&#xff09;计时引擎使用时钟计算时序路径要求并通过以下方式报告设计时序裕度的特性松弛计算的方法有关更多信息&#xff0c;请参阅Vivado Design…

什么是数据仪表板?数据可视化仪表盘怎么制作?

在数据经济时代&#xff0c;分析数据是每个企业做出最佳决策的关键。但是&#xff0c;手动分析和解释大量数据是不可行的。数据可视化对于分析数据中存在的各种有价值信息至关重要&#xff0c;包括可见趋势和隐藏趋势等。仪表盘显示可视化趋势和信息&#xff0c;例如 KPI、趋势…

Everything 搜索

正则表达式Regex 首先需要开启 Everything 工具在&#xff08;字符串&#xff09;查找时&#xff0c;对正则表达式功能的支持&#xff1a; 需要在【菜单栏】⇒ 【Search】⇒ 勾选【Enable Regex】 查看Everything 支持的语法:

c语言:求算数平均数|练习题

一、题目 输入3个数&#xff0c;求这三个数的算术平均数 二、代码图片【带注释】 三、源代码【带注释】 #include <stdio.h> #include<math.h> //输入正整数a、b、c的值&#xff0c; //求其算术平均值,并保留两个小数位输出 int pass0;//定义一个开关&#xff0c;…

solidity 重入漏洞

目录 1. 重入漏洞的原理 2. 重入漏洞的场景 2.1 msg.sender.call 转账 2.2 修饰器中调用地址可控的函数 1. 重入漏洞的原理 重入漏洞产生的条件&#xff1a; 合约之间可以进行相互间的外部调用 恶意合约 B 调用了合约 A 中的 public funcA 函数&#xff0c;在函数 funcA…

关于“Python”的核心知识点整理大全32

目录 12.6.4 调整飞船的速度 settings.py ship.py alien_invasion.py 12.6.5 限制飞船的活动范围 ship.py 12.6.6 重构 check_events() game_functions.py 12.7 简单回顾 12.7.1 alien_invasion.py 12.7.2 settings.py 12.7.3 game_functions.py 12.7.4 ship.py …

数据分析基础之《numpy(6)—合并与分割》

了解即可&#xff0c;用panads 一、作用 实现数据的切分和合并&#xff0c;将数据进行切分合并处理 二、合并 1、numpy.hstack 水平拼接 # hstack 水平拼接 a np.array((1,2,3)) b np.array((2,3,4)) np.hstack((a, b))a np.array([[1], [2], [3]]) b np.array([[2], […

maven限制内存使用峰值/最大内存

前言 通过设置虚拟机的内存大小&#xff0c;达到限制maven内存使用峰值的效果 方法1&#xff1a;修改mvn脚本 找到mvn脚本在MAVEN_OPTS参数值添加-Xms、-Xmx参数&#xff1a;MAVEN_OPTS"$MAVEN_OPTS -Xms512m -Xmx512m"效果图 windows系统下修改MAVEN_OPTS参数 …

java8实战 lambda表达式、函数式接口、方法引用双冒号(中)

前言 书接上文&#xff0c;上一篇博客讲到了lambda表达式的应用场景&#xff0c;本篇接着将java8实战第三章的总结。建议读者先看第一篇博客 其他函数式接口例子 上一篇有讲到Java API也有其他的函数式接口&#xff0c;书里也举了2个例子&#xff0c;一个是java.util.functi…

重温经典struts1之自定义转换器及注册的两种方式(Servlet,PlugIn)

提示&#xff1a;文章写完后&#xff0c;目录可以自动生成&#xff0c;如何生成可参考右边的帮助文档 前言 Struts的ActionServlet接收用户在浏览器发送的请求&#xff0c;并将用户输入的数据&#xff0c;按照FormBean中定义的数据类型&#xff0c;赋值给FormBean中每个变量&a…

SOME/IP SubscriberEventGroup

1 SOME/IP SubscriberEventGroup SubscriberEventGroup是SOME/IP中的一种服务发现和注册的消息类型,它用于让服务使用者订阅服务提供者的事件组。 事件组是一种将服务的方法和字段分组的方式,它可以让服务使用者只接收感兴趣的数据,而不是所有的数据。 SubscriberEventGrou…

w13渗透测试实战之https账号密码捕抓

此次实验需要配合arp欺骗,不知道arp欺骗的&#xff0c;可以查看这篇w13渗透测试实战之ARP欺骗攻击&#xff08;ARP断网攻击&#xff09; 一、实验环境 攻击机&#xff1a;linux Kali 靶机&#xff1a;window 7 网络环境&#xff1a;虚拟机NAT 网关&#xff1a;192.168.89.2实…

CSS自适应分辨率 amfe-flexible 和 postcss-pxtorem:大屏高宽自适应问题

前言 继上篇《CSS自适应分辨率 amfe-flexible 和 postcss-pxtorem》。 发现一个有趣的问题&#xff0c;文件 rem.js 中按照宽度设置自适应&#xff0c;适用于大多数页面&#xff0c;但当遇到大屏就不那么合适了。 问题 使用宽度&#xff0c;注意代码第2 和 4 行&#xff1a;…

C/C++、Java、Python:主要编程语言的演进与未来趋势

导言 C/C、Java、Python作为主要的编程语言&#xff0c;在软件开发领域扮演着重要角色。本文将深入研究这三者的发展历程、遇到的问题、解决过程&#xff0c;以及未来的可用范围。同时&#xff0c;分析它们之间的联系与区别&#xff0c;探讨哪一门语言可能在未来占据主导地位&a…

OpenCV技术应用(9)— 视频的暂停播放和继续播放

前言&#xff1a;Hello大家好&#xff0c;我是小哥谈。本节课就手把手教大家如何控制视频的暂停播放和继续播放&#xff0c;希望大家学习之后能够有所收获~&#xff01;&#x1f308; 目录 &#x1f680;1.技术介绍 &#x1f680;2.实现代码 &#x1f680;1.技术介绍…

14:00面试,14:08就出来了,问的问题有点变态。。。

从小厂出来&#xff0c;没想到在另一家公司又寄了。 到这家公司开始上班&#xff0c;加班是每天必不可少的&#xff0c;看在钱给的比较多的份上&#xff0c;就不太计较了。没想到5月一纸通知&#xff0c;所有人不准加班&#xff0c;加班费不仅没有了&#xff0c;薪资还要降40%…

13. 从零用Rust编写正反向代理, HTTP中的压缩gzip,deflate,brotli算法

wmproxy wmproxy是由Rust编写&#xff0c;已实现http/https代理&#xff0c;socks5代理&#xff0c; 反向代理&#xff0c;静态文件服务器&#xff0c;内网穿透&#xff0c;配置热更新等&#xff0c; 后续将实现websocket代理等&#xff0c;同时会将实现过程分享出来&#xff…

Ansible的脚本----playbook剧本

Playbook组成部分 tasks 任务&#xff1a;包含要在目标主机上执行的操作&#xff0c;使用模块定义这些操作。每个任务都是一个模块的调用。Variables 变量&#xff1a;存储和传递数据。变量可以自定义&#xff0c;可以在playbook当中定义全局变量&#xff0c;可以外部传参。T…

MyBatis ORM映射

MyBatis只能自动维护库表”列名“与”属性名“相同时的对应关系&#xff0c;二者不同时无法自动ORM 因此需要使用到ORM映射。 共有两种解决办法&#xff1a;1.列的别名 2.结果映射 1.列的别名 在SQL中使用 as 为查询字段添加列别名&#xff0c;以匹配属性名 public List<…

Gazebo GUI模型编辑器

模型编辑器 现在我们将构建我们的简单机器人。我们将制作一个轮式车辆&#xff0c;并添加一个传感器&#xff0c;使我们能够让机器人跟随一个斑点&#xff08;人&#xff09;。 模型编辑器允许我们直接在图形用户界面 &#xff08;GUI&#xff09; 中构建简单的模型。对于更复…