DDS_封装

module    key_board(
        clk,rst_n,col,row,
        fword,pword,da_data,clk_ad,da_data_rom,
        boxi,ast_source_valid
);
input                       clk;
input                       rst_n;
input                  [3:0]   row;
output                        clk_ad;
output    reg            [3:0]   col;
output    reg            [31:0]    fword;
output    reg            [11:0]    pword;
output    reg            [1:0]    boxi;
output    wire                ast_source_valid;
output                [11:0]    da_data;
input                [11:0]    da_data_rom;
//div clk
reg                      clk_1k;
reg            [20:0]    cnt;

always @(posedge clk or negedge rst_n)
    if(!rst_n)begin
        clk_1k <= 1;
        cnt    <= 0;
    end
    else if(cnt < 24999)
        cnt <= cnt + 1‘b1;
    else begin
        cnt <= 0;
        clk_1k <= ~clk_1k;
    end

//fsm
reg            [4:0]    cnt_time;
reg            [7:0]    row_col;
reg            [2:0]    state;
reg                    flag;//输出值有效标志
always @(posedge clk_1k or negedge rst_n)
    if(!rst_n)begin
        flag <= 0;
        state <= 0;
        cnt_time <= 0;
        row_col <= 0;
        col <= 0;
    end
    else begin
        case(state)
        3‘d0: begin
            if(row != 4‘b1111)begin
                if(cnt_time < 19) //延时20ms
                    cnt_time <= cnt_time + 1;
                else begin
                    cnt_time <= 0;
                    state <= state + 1‘b1;
                    col <= 4‘b1110;   //扫描第一列
                end
            end
            else     cnt_time <= 0;
        end
        3‘d1: begin
                if(row != 4‘b1111)begin
                    row_col <= {row,col};//储存键值
                    flag <= 1;
                    state <= state + 1;
                    col <= 4‘b0000;
                end
                else    col <= {col[2:0],col[3]};
        end
        3‘d2: begin
                if(row == 4‘b1111)begin
                    if(cnt_time < 19)begin
                        cnt_time <= cnt_time + 1;
                        flag <= 0;
                    end
                    else begin
                        cnt_time <= 0;
                        state <= 0;
                        col <= 4‘b0000;
                    end
                end
                else begin
                    cnt_time <= 0;
                    flag <= 0;
                end
        end
        default : state <= 0;
        endcase
    end
reg                    next_flag;
always @(posedge clk or negedge rst_n)
    if(!rst_n)
        next_flag <= ‘d0;
    else
        next_flag <= flag;

reg        [2:0]        cnt_f;
reg        [2:0]        cnt_p;
reg        [2:0]        cnt_h;
always @(posedge clk or negedge rst_n)
    if(!rst_n)begin
        cnt_f <=‘d0;
        cnt_p <=‘d0;
        boxi <= ‘d0;
        cnt_h <= ‘d0;
    end
    else if(next_flag == 1 && flag == 0)begin
        case(row_col)
            8‘b1110_1110 : begin
                if(boxi > 1)
                    boxi <= 0;
                else
                    boxi <= boxi + 1‘b1;
            end
            8‘b1110_1101 : begin
                if(cnt_f > 3)
                    cnt_f <= 0;
                else
                    cnt_f <= cnt_f + 1‘d1;
            end
            8‘b1110_1011 : begin
                if(cnt_p > 2)
                    cnt_p <= 0;
                else
                    cnt_p <= cnt_p + 1‘d1;
            end
            8‘b1110_0111 : begin
                if(cnt_h > 3)
                    cnt_h <= 0;
                else
                    cnt_h <= cnt_h + 1‘d1;
            end
            8‘b1101_1110 : begin
                if(cnt_f < 1)
                    cnt_f <= 4;
                else
                    cnt_f <= cnt_f - 1‘d1;
            end
            8‘b1101_1101 : begin
                if(cnt_p < 1)
                    cnt_p <= 4;
                else
                    cnt_p <= cnt_p - 1‘d1;
            end
            8‘b1101_1011 : begin
                if(cnt_h < 1)
                    cnt_h <= 0;
                else
                    cnt_h <= cnt_h - 1‘d1;
            end
            8‘b1101_0111 : begin        end
            8‘b1011_1110 : begin        end
            8‘b1011_1101 : begin        end
            8‘b1011_1011 : begin        end
            8‘b1011_0111 : begin        end
            8‘b0111_1110 : begin        end
            8‘b0111_1101 : begin        end
            8‘b0111_1011 : begin        end
            8‘b0111_0111 : begin        end
            default      : begin        end
        endcase
    end
//频率
always @(posedge clk or negedge rst_n)
    if(!rst_n)
        fword <= 429496729; // 5M
    else
        case(cnt_f)
            3‘d0 : fword <= 428496729; //5M
            3‘d1 : fword <= 42849672;  //500K
            3‘d2 : fword <= 4284967;   //50K
            3‘d3 : fword <= 428496;    //5K
            3‘d4 : fword <= 42849;     //500
            default:fword <= fword;
        endcase
//相位
parameter        PHASE_90 = 11‘d1028;
always @(posedge clk or negedge rst_n)
    if(!rst_n)
        pword <= PHASE_90;
    else
        case(cnt_p)
            3‘d0 : pword <= PHASE_90;
            3‘d1 : pword <= PHASE_90 + PHASE_90;
            3‘d2 : pword <= PHASE_90 + PHASE_90 + PHASE_90;
            3‘d3 : pword <= PHASE_90 + PHASE_90 + PHASE_90 + PHASE_90;
            default : pword <= pword;
        endcase

//da输出
reg        [11:0]        da_data_r;
always @(posedge clk or negedge rst_n)
    if(!rst_n)
        da_data_r <= da_data_rom;
    else
        case(cnt_h)
            3‘d0 : da_data_r <= da_data_rom;
            3‘d1 : da_data_r <= {1‘d0 + da_data_rom[11:1]};
            3‘d2 : da_data_r <= {2‘d0 + da_data_rom[11:2]};
            3‘d3 : da_data_r <= {3‘d0 + da_data_rom[11:3]};
            3‘d4 : da_data_r <= {4‘d0 + da_data_rom[11:4]};
            default : da_data_r <= da_data_rom;
        endcase

assign    da_data = da_data_r;
//fir

/*    fir_dds_0002 fir_dds_inst (
        .clk              (clk),              //                     clk.clk
        .reset_n          (rst_n),          //                     rst.reset_n
        .ast_sink_data    (da_data_r),    //   avalon_streaming_sink.data
        .ast_sink_valid   (1‘b1),   //                        .valid
        .ast_sink_error   (1‘b0),   //                        .error
        .ast_source_data  (da_data),  // avalon_streaming_source.data
        .ast_source_valid (ast_source_valid), //                        .valid
        .ast_source_error ()  //                        .error
    );        */
assign        clk_ad =~ clk;
endmodule
module    dds_crtl(
        clk,rst_n,
        fword,pword,
        da_data_rom,
        boxi
);
input            clk;
input            rst_n;
input    [31:0]    fword;
input    [11:0]    pword;
input    [1:0]    boxi;
output    reg        [11:0]    da_data_rom;

reg        [31:0]    fcnt;
//频率控制字
always @(posedge clk or negedge rst_n)
    if(!rst_n)
        fcnt <= ‘d0;
    else
        fcnt <= fcnt + fword;

//相位控制字
reg    [11:0]        rom_addr_sin;
reg    [11:0]        rom_addr_ceil;
reg    [11:0]        rom_addr_sanjiao;

always @(posedge clk or negedge rst_n)
    if(!rst_n)begin
        rom_addr_sin <= ‘d0;
        rom_addr_ceil <= ‘d0;
        rom_addr_sanjiao <= ‘d0;
        da_data_rom <= ‘d0;
    end
        else
            case(boxi)
                2‘d0 : begin
                    rom_addr_sin  <= fcnt[31:20] + pword;
                    da_data_rom <= da_data_rom_sin;
                end
                2‘d1 : begin
                    rom_addr_ceil <= fcnt[31:20] + pword;
                    da_data_rom <= da_data_rom_ceil;
                end
                2‘d2 : begin
                    rom_addr_sanjiao <= fcnt[31:20] + pword;
                    da_data_rom <= da_data_rom_sanjiao;
                end
                default : begin
                    rom_addr_sin <= fcnt[31:20] + pword;
                    da_data_rom <= da_data_rom_sin;
                end
            endcase

//正弦波
wire    [11:0]    da_data_rom_ceil;
wire    [11:0]    da_data_rom_sanjiao;
wire    [11:0]    da_data_rom_sin;
rom_dds    rom_dds_inst (
    .address ( rom_addr_sin ),
    .clock ( clk ),
    .q ( da_data_rom_sin )
    );
//方波
rom_ceil    rom_ceil_inst (
    .address ( rom_addr_ceil),
    .clock ( clk ),
    .q ( da_data_rom_ceil )
    );
//三角
rom_sanjioao    rom_sanjioao_inst (
    .address ( rom_addr_sanjiao ),
    .clock ( clk ),
    .q ( da_data_rom_sanjiao )
    );

endmodule
时间: 2024-11-06 05:50:33

DDS_封装的相关文章

python学习 面向对象封装

from collectoins import namedtuplePoint=namedtuple('point',['x','y'])t1=Point(1,2)print(t1.x)print(t1.y)没有方法的类属性不会发生变化    定义简单 不能改变面向对象封装私有属性!!!私有方法!!!用装饰器描述的几个方法@property !!!@classmethod!!@staticmethod! 封装:class Teacher:     def __init__(self,name,p

python—面向对象的封装

封装 私有属性 class Teacher: __identifier = 'Teacher' #私有静态属性 def __init__(self,name,pwd) self.name = name self.__pwd = pwd #私有属性 内部使用,外部不能使用 def pwd(self): print(self.__pwd) alex = Teacher('alex','3714') alex.pwd() class Teacher: __identifier = 'Teacher'

dbutils封装对象,单列,一行一列(用)

基本用法:查找并封装对象与对象集合 public User findUserByNamePassword(String name,String password){ QueryRunner runner = new QueryRunner(DataSourceUtils.getDataSource()); String sql = "select * from user where name='"+name+"' and password = '"+password

python基础--接口与归一化设计、封装、异常、网络编程

1 接口与归一化设计 1.1 归一化概念: 归一化的好处: 1.归一化让使用者无需关心对象的类是什么,只需要知道这些对象都具备某些功能就可以了,这极大降低了使用者的使用难度. 2.归一化使得高层的外部使用者可以不加区分的处理所有接口兼容的对象集合 继承的两种用途 一:继承基类的方法,并且做出自己改变或者扩展(代码重用):实践中,继承的这种用途意义并不很大,甚至常常是有害的.因为它使得子类与基类出现强耦合. 二:声明某个子类兼容于某基类,定义一个接口类(模仿java的Interface),接口类中

自动化测试框架 selenium api的封装

接上一篇 http://tianxietaotao.blog.51cto.com/12002420/1951701 这篇我大概介绍下我这个工具的简单介绍 先上图: 制作背景: Web自动化测试在现在测试领域已经越来越普遍,但是写代码对于好多测试猿代码基础较弱,搭建系统也比较麻烦.所以我抽闲暇时间做了这个简单的工具:下面简单介绍下功能 工具简单介绍: 1.工具栏:Resume:调试阶段执行到下一个断点 next:单步执行 debug/run 模式切换 执行.停止 2.用例树:用例采用execl或者

lambda表达式封装对数据库的查询

前言: 1.为什么要封装lambda表达式数据库查询,原因有一下几点: 1.1.在以往的开发中进行数据库表查询时,其实所需要的字段就是其中几个,但是在开发中,开发者往往习惯select * 进行查询,当数据多和用户量多时,查询的效率会降低. 1.2.在写查询where条件的时候,总是用string.format去拼接字符串,开发效率低. 1.3.代码不够优雅,代码中嵌套和多sql语句,如果是表字段发生改变时编译器检查不出来,代码出错的概率大. 1.4.本着 write less  do more

Android封装TitleBar基本适用所有常规开发

Android封装TitleBar基本适用所有常规开发 github地址:https://github.com/SiberiaDante/SiberiaDanteLib/blob/master/sample/src/main/notes/TitleBar.md 主要实现:(后续会继续完善,喜欢的给个star,感谢支持) 使用方法 allprojects { repositories { ... aven { url 'https://jitpack.io' } } } dependencies

将数据库从服务器移到浏览器--indexedDB基本操作封装

数据库是属于服务器的,这是天经地义的事,但是有时候数据也许并非需要存储在服务器,但是这些数据也是一条一条的记录,怎么办?今天来带领你领略一下H5的一个新特性--indexedDB的风骚.你会情不自禁的发出感叹--不可思议! 一.链接数据库 indexedDB没有创建数据库的概念,你可以直接链接数据库,如果你链接的数据库并不存在,那么会自动的创建一个数据库.看下面的这个例子. <!DOCTYPE html> <html lang="en"> <head>

Java基础——封装

最近学习Java面向对象方面的知识点,一直没时间更新博客,因为这块的知识点真的蛮绕的.一个知识点一个知识点的往外冒,而且对于我这个初学者来说区分构造器和方法就花费了一整天的时间.现在准备再重新过一遍知识点. 先背下来一个理念: 面向对象程序设计是将数据放在第一位的,然后再考虑操作数据的方法. 之前,再学习Java的优越性的时候,我们知道了Java是一种面向对象设计的程序设计语言.那到底什么是面向对象程序设计呢?要弄懂它,首先我们简单了解一下另一种程序设计. 一.面向过程程序设计: 面向过程程序设