FPGA project ： inf_rcv

已于 2023-09-19 16:43:02 修改
阅读量296 收藏
点赞数
分类专栏： 野火征途pro 文章标签： fpga开发
于 2023-09-19 16:15:36 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Meng_long2022/article/details/133033846
版权 

module top (
    input       wire            sys_clk     ,
    input       wire            sys_rst_n   ,
    input       wire            inf_in      ,

    output      wire            led         ,
    output      wire            ds          ,
    output      wire            oe          ,
    output      wire            shcp        ,
    output      wire            stcp     
);


// 例化连线
    wire    [7:0]   data        ;
    wire            sign        ;
    wire    [19:00] data_w      ;
    assign          data_w = {12'd0,data} ;
    wire    [05:00] point_w     ;
    assign          point_w = 6'b000000 ;
    wire            sign_w      ;
    assign          sign_w = 1'b0 ;
    wire            seg_en_w    ;
    assign          seg_en_w = 1'b1 ;
inf_rcv inf_rcv_insert(
    .sys_clk                ( sys_clk   ) ,
    .sys_rst_n              ( sys_rst_n ) ,
    .inf_in                 ( inf_in    ) ,

    .data                   ( data      ) ,
    .sign                   ( sign      )        
);

led led_insert(
    .sys_clk                ( sys_clk   ) ,
    .sys_rst_n              ( sys_rst_n ) ,
    .key_in                 ( sign ) ,

    .led_out                ( led  )     
);

seg_595_dynamic seg_595_dynamic_insert(
    .sys_clk                ( sys_clk    ) ,
    .sys_rst_n              ( sys_rst_n  ) ,
    .data                   ( data_w     ) ,
    .point                  ( point_w    ) ,
    .sign                   ( sign_w     ) ,
    .seg_en                 ( seg_en_w   ) ,

    .ds                     ( ds         ) ,
    .oe                     ( oe         ) ,
    .shcp                   ( shcp       ) ,
    .stcp                   ( stcp       )    
);

endmodule
module inf_rcv (
    input       wire            sys_clk     ,
    input       wire            sys_rst_n   ,
    input       wire            inf_in      ,

    output      reg     [7:0]   data        ,
    output      reg             sign        
);
    // parameter degine
    parameter       T_9MS    = 19'd450_000 ,
                    T_4_5MS  = 18'd225_000 ,
                    T_2_225MS= 17'd112_500 ,
                    T_560US  = 15'd28_000  ,
                    T_1_69MS = 17'd84_500  ;

    // parameter degine
    localparam      IDLE     = 5'b0_0001 ,
                    TIME_9MS = 5'b0_0010 ,
                    ARBITE   = 5'b0_0100 ,
                    DATA     = 5'b0_1000 ,
                    REPEAT   = 5'b1_0000 ;

    // wire signal define 
    wire            nege        ;
    wire            pose        ;


    // reg signal define
    reg             inf_in_reg0 ;
    reg             inf_in_reg1 ;
    reg             inf_in_reg2 ;
    reg     [ 4:0]  state       ;
    reg     [19:0]  cnt         ; // 虽然最大计数9ms只需19位宽，但还是定义20位宽。
    reg             flag_9ms    ; // 由于设备制造精度与环境因素影响，这个标志信号在指定目标附近拉高即可。
    reg             flag_4_5ms  ;
    reg             flag_2_25ms ;
    reg             flag_560us  ;
    reg             flag_1_69ms ;
    reg     [ 5:0]  cnt_bit     ; // 32 bit 数据
    reg     [31:0]  data_reg    ;


    // // reg signal define
    // reg             inf_in_reg0 ;
    // reg             inf_in_reg1 ;
    // reg             inf_in_reg2 ;
    always @(posedge sys_clk or negedge sys_rst_n) begin
        if(~sys_rst_n) begin
            inf_in_reg0 <= 1'b1 ;
            inf_in_reg1 <= 1'b1 ;
            inf_in_reg2 <= 1'b1 ;
        end else begin
            inf_in_reg0 <= inf_in      ;
            inf_in_reg1 <= inf_in_reg0 ;
            inf_in_reg2 <= inf_in_reg1 ;
        end
    end
    // // wire signal define 
    // wire            nege        ;
    // wire            pose        ;
    assign  nege = ~inf_in_reg1 &&  inf_in_reg2 ;
    assign  pose =  inf_in_reg1 && ~inf_in_reg2 ;
    // reg     [ 4:0]  state       ;
    always @(posedge sys_clk or negedge sys_rst_n)
        if(~sys_rst_n) 
            state <= IDLE ;
        else case (state)
        IDLE    :if (nege == 1'b1) 
                    state <= TIME_9MS ;
                 else 
                    state <= IDLE ;
        TIME_9MS:if(pose == 1'b1 && flag_9ms == 1'b1) //T_9MS - 19'd100
                    state <= ARBITE ;
                 else if(pose == 1'b1 && flag_9ms == 1'b0)
                    state <= IDLE ;
                 else 
                    state <= TIME_9MS ;
        ARBITE  :if(nege == 1'b1 && flag_4_5ms == 1'b1) // 说明是引导码
                    state <= DATA ;
                 else if(nege == 1'b1 && flag_2_25ms == 1'b1) // 说明是重复码
                    state <= REPEAT ;
                 else if(nege == 1'b1 && flag_4_5ms == 1'b0 && flag_2_25ms == 1'b0)
                    state <= IDLE ;
                 else 
                    state <= ARBITE ;
        DATA    :if((pose == 1'b1 && flag_560us == 1'b1 && cnt_bit == 6'd32) 
                    || (pose == 1'b1 && flag_560us == 1'b0) 
                    || (nege == 1'b1 && ( flag_560us == 1'b0 && flag_1_69ms == 1'b0)))
                    state <= IDLE ;
                 else
                    state <= DATA ;
        REPEAT  :if(pose == 1'b1 )
                    state <= IDLE ;
                 else
                    state <= REPEAT ;
        default : state <= IDLE ;
        endcase
    // reg     [19:0]  cnt         ; // 虽然最大计数9ms只需19位宽，但还是定义20位宽。
    // reg             flag_9ms    ; // 由于设备制造精度与环境因素影响，这个标志信号在指定目标附近拉高即可。
    // reg             flag_4_5ms  ;
    // reg             flag_2_25ms ;
    // reg             flag_560us  ;
    // reg             flag_1_69ms ;
    // reg     [ 5:0]  cnt_bit     ; // 32 bit 数据
    always @(posedge sys_clk or negedge sys_rst_n) begin
        if(~sys_rst_n) begin
            cnt         <= 20'd0 ;
            flag_9ms    <= 1'b0  ;
            flag_4_5ms  <= 1'b0  ;
            flag_2_25ms <= 1'b0  ;
            flag_560us  <= 1'b0  ;
            flag_1_69ms <= 1'b0  ;
            cnt_bit     <= 6'd0  ;
        end else begin
            case (state)
            IDLE    :begin
                        cnt         <= 20'd0 ;
                        flag_9ms    <= 1'b0  ;
                        flag_4_5ms  <= 1'b0  ;
                        flag_2_25ms <= 1'b0  ;
                        flag_560us  <= 1'b0  ;
                        flag_1_69ms <= 1'b0  ;
                        cnt_bit     <= 6'd0  ;
                     end
            TIME_9MS:begin
                        if(pose == 1'b1) begin
                            cnt <= 20'd0 ;
                        end else begin
                            cnt <= cnt + 1'b1 ;
                        end

                        if(cnt >= T_9MS - 19'd8000 && cnt <= T_9MS + 19'd8000) // 9ms附近拉高。不能太“离谱”。
                            flag_9ms <= 1'b1 ;
                        else 
                            flag_9ms <= 1'b0 ;

                        flag_4_5ms  <= 1'b0  ;
                        flag_2_25ms <= 1'b0  ;
                        flag_560us  <= 1'b0  ;
                        flag_1_69ms <= 1'b0  ;
                        cnt_bit     <= 6'd0  ;
                     end
            ARBITE  :begin
                        if(nege == 1'b1)
                            cnt <= 20'd0 ;
                        else 
                            cnt <= cnt + 1'b1 ;
                        
                        if(cnt >= T_4_5MS - 18'd8000 && cnt <= T_4_5MS + 18'd8000)
                            flag_4_5ms <= 1'b1 ;
                        else 
                            flag_4_5ms <= 1'b0 ;

                        if(cnt >= T_2_225MS - 17'd8000 && cnt <= T_2_225MS + 17'd8000)
                            flag_2_25ms <= 1'b1 ;
                        else 
                            flag_2_25ms <= 1'b0 ;

                        flag_9ms    <= 1'b0  ;
                        flag_560us  <= 1'b0  ;
                        flag_1_69ms <= 1'b0  ;
                        cnt_bit     <= 6'd0  ;
                        end
            DATA    :begin
                        if(nege == 1'b1 || pose == 1'b1)
                            cnt <= 20'd0 ;
                        else 
                            cnt <= cnt + 1'b1 ;
                        
                        if(cnt >= T_560US - 15'd8000 && cnt <= T_560US + 15'd8000)
                            flag_560us <= 1'b1 ;
                        else 
                            flag_560us <= 1'b0 ;
                        
                        if(cnt >= T_1_69MS - 15'd8000 && cnt <= T_1_69MS + 15'd8000)
                            flag_1_69ms <= 1'b1 ;
                        else 
                            flag_1_69ms <= 1'b0 ;

                        flag_9ms    <= 1'b0  ;
                        flag_4_5ms  <= 1'b0  ;
                        flag_2_25ms <= 1'b0  ;

                        if(pose == 1'b1 && flag_560us == 1'b1 && cnt_bit == 6'd32)
                            cnt_bit <= 'd0 ;
                        else if(nege == 1'b1)
                            cnt_bit     <= cnt_bit + 1'b1 ;
                        else 
                            cnt_bit     <= cnt_bit ;
                     end
            REPEAT  :begin
                        cnt         <= 20'd0 ;
                        flag_9ms    <= 1'b0  ;
                        flag_4_5ms  <= 1'b0  ;
                        flag_2_25ms <= 1'b0  ;
                        flag_560us  <= 1'b0  ;
                        flag_1_69ms <= 1'b0  ;
                        cnt_bit     <= 6'd0  ;
                        end
            default:begin
                        cnt         <= 20'd0 ;
                        flag_9ms    <= 1'b0  ;
                        flag_4_5ms  <= 1'b0  ;
                        flag_2_25ms <= 1'b0  ;
                        flag_560us  <= 1'b0  ;
                        flag_1_69ms <= 1'b0  ;
                        cnt_bit     <= 6'd0  ;
                    end
            endcase
        end
    end

    // reg [31:0]       data_reg    ;
    always @(posedge sys_clk or negedge sys_rst_n)
        if(~sys_rst_n)
            data_reg <= 31'd0 ;
        else if(state == DATA && nege == 1'b1 && cnt_bit <= 6'd31 && flag_1_69ms == 1'b1)
            data_reg[cnt_bit] <= 1'b1 ;
        else if(state == DATA && nege == 1'b1 && cnt_bit <= 6'd31 && flag_560us == 1'b1)
            data_reg[cnt_bit] <= 1'b0 ;
        else 
            data_reg <= data_reg ;

    // output signal 
    // reg     [7:0]   data        ,
    always @(posedge sys_clk or negedge sys_rst_n)
        if(~sys_rst_n)
            data <= 8'd0 ;
        else if((data_reg[23:16] == ~data_reg[31:24]) && (data_reg[7:0] == ~data_reg[15:8]))
            data <= data_reg[23:16] ;
        else 
            data <= data ;
    // reg             sign   
    always @(posedge sys_clk or negedge sys_rst_n)
        if(~sys_rst_n) 
            sign <= 1'b0 ;
        else if(state == REPEAT)
            sign <= 1'b1 ; 
        else 
            sign <= 1'b0 ;
endmodule
module led(
    input           sys_clk ,
    input           sys_rst_n ,
    input           key_in      ,

    output    wire   led_out     
);
    reg   key_in_reg1 ;
    reg   key_in_reg2 ;
    wire  pose        ;
    reg   [24:0]    cnt_500ms   ; // 24_999_999
    always @(posedge sys_clk or negedge sys_rst_n) begin
        if(~sys_rst_n) begin
            key_in_reg1 <= 1'b0 ;
            key_in_reg2 <= 1'b0 ;
        end else begin
            key_in_reg1 <= key_in ;
            key_in_reg2 <= key_in_reg1 ;
        end
    end
    assign pose = ~key_in_reg2 && key_in_reg1 ;
    always @(posedge sys_clk or negedge sys_rst_n) begin
        if(~sys_rst_n) begin
            cnt_500ms <= 25'd0 ;
        end else begin
            if(cnt_500ms == 25'd0 && pose == 1'b1) begin
                cnt_500ms <= 25'd24_999_999 ;
            end else begin
                if(cnt_500ms == 25'd0) begin
                    cnt_500ms <= cnt_500ms ;
                end else begin
                    cnt_500ms <= cnt_500ms - 1'b1 ;
                end
            end
        end
    end
    assign led_out = (cnt_500ms == 0) ? 1'b1 : 1'b0 ;  // 低电平亮。
    
endmodule

 

`timescale 1ns/1ns
module test_inf_rcv();
    reg             sys_clk     ;
    reg             sys_rst_n   ;
    reg             inf_in      ;

    wire    [7:0]   data        ;
    wire            sign        ;

// Instantiation
inf_rcv inf_rcv_insert(
    .sys_clk        ( sys_clk    ) ,
    .sys_rst_n      ( sys_rst_n  ) ,
    .inf_in         ( inf_in     ) ,

    .data           ( data       ) ,
    .sign           ( sign       )        
);
    parameter CYCLE = 20 ;
    initial begin
        sys_clk    = 1'b1 ;
        sys_rst_n <= 1'b0 ;
        inf_in    <= 1'b1 ;
        #( CYCLE * 10 )   ;
        sys_rst_n <= 1'b1 ;
        #( CYCLE * 500  ) ;

// 引导码
        inf_in <= 1'b0 ;
        #(9_000_000)   ;
        inf_in <= 1'b1 ;
        #(4_500_000)   ;
// 地址码 8'h57 0101_0111 1110_1010
        inf_in <= 1'b0 ; // 1
        #(560_000)     ;
        inf_in <= 1'b1 ;
        #(1690_000)    ;
        inf_in <= 1'b0 ; // 1
        #(560_000)     ;
        inf_in <= 1'b1 ;
        #(1690_000)    ;
        inf_in <= 1'b0 ; // 1
        #(560_000)     ;
        inf_in <= 1'b1 ;
        #(1690_000)    ;
        inf_in <= 1'b0 ; // 0
        #(560_000)     ;
        inf_in <= 1'b1 ;
        #(560_000)     ;
        inf_in <= 1'b0 ; // 1
        #(560_000)     ;
        inf_in <= 1'b1 ;
        #(1690_000)    ;
        inf_in <= 1'b0 ; // 0
        #(560_000)     ;
        inf_in <= 1'b1 ;
        #(560_000)     ;
        inf_in <= 1'b0 ; // 1
        #(560_000)     ;
        inf_in <= 1'b1 ;
        #(1690_000)    ;
        inf_in <= 1'b0 ; // 0
        #(560_000)     ;
        inf_in <= 1'b1 ;
        #(560_000)     ;
// 地址反码 8'hA8 1010_1000 0001_0101
        inf_in <= 1'b0 ; // 0
        #(560_000)     ;
        inf_in <= 1'b1 ;
        #(560_000)     ;
        inf_in <= 1'b0 ; // 0
        #(560_000)     ;
        inf_in <= 1'b1 ;
        #(560_000)     ;
        inf_in <= 1'b0 ; // 0
        #(560_000)     ;
        inf_in <= 1'b1 ;
        #(560_000)     ;
        inf_in <= 1'b0 ; // 1
        #(560_000)     ;
        inf_in <= 1'b1 ;
        #(1690_000)    ;
        inf_in <= 1'b0 ; // 0
        #(560_000)     ;
        inf_in <= 1'b1 ;
        #(560_000)     ;
        inf_in <= 1'b0 ; // 1
        #(560_000)     ;
        inf_in <= 1'b1 ;
        #(1690_000)    ;
        inf_in <= 1'b0 ; // 0
        #(560_000)     ;
        inf_in <= 1'b1 ;
        #(560_000)     ;
        inf_in <= 1'b0 ; // 1
        #(560_000)     ;
        inf_in <= 1'b1 ;
        #(1690_000)    ;
// 数据码 8'h22 0010_0010 0100_0100
        inf_in <= 1'b0 ; // 0
        #(560_000)     ;
        inf_in <= 1'b1 ;
        #(560_000)     ;
        inf_in <= 1'b0 ; // 1
        #(560_000)     ;
        inf_in <= 1'b1 ;
        #(1690_000)    ;
        inf_in <= 1'b0 ; // 0
        #(560_000)     ;
        inf_in <= 1'b1 ;
        #(560_000)     ;
        inf_in <= 1'b0 ; // 0
        #(560_000)     ;
        inf_in <= 1'b1 ;
        #(560_000)     ;
        inf_in <= 1'b0 ; // 0
        #(560_000)     ;
        inf_in <= 1'b1 ;
        #(560_000)     ;
        inf_in <= 1'b0 ; // 1
        #(560_000)     ;
        inf_in <= 1'b1 ;
        #(1690_000)    ;
        inf_in <= 1'b0 ; // 0
        #(560_000)     ;
        inf_in <= 1'b1 ;
        #(560_000)     ;
        inf_in <= 1'b0 ; // 0
        #(560_000)     ;
        inf_in <= 1'b1 ;
        #(560_000)     ;
// 数据反码 8'hDD 1101_1101 1011_1011
        inf_in <= 1'b0 ; // 1
        #(560_000)     ;
        inf_in <= 1'b1 ;
        #(1690_000)    ;
        inf_in <= 1'b0 ; // 0
        #(560_000)     ;
        inf_in <= 1'b1 ;
        #(560_000)     ;
        inf_in <= 1'b0 ; // 1
        #(560_000)     ;
        inf_in <= 1'b1 ;
        #(1690_000)    ;
        inf_in <= 1'b0 ; // 1
        #(560_000)     ;
        inf_in <= 1'b1 ;
        #(1690_000)    ;
        inf_in <= 1'b0 ; // 1
        #(560_000)     ;
        inf_in <= 1'b1 ;
        #(1690_000)    ;
        inf_in <= 1'b0 ; // 0
        #(560_000)     ;
        inf_in <= 1'b1 ;
        #(560_000)     ;
        inf_in <= 1'b0 ; // 1
        #(560_000)     ;
        inf_in <= 1'b1 ;
        #(1690_000)    ;
        inf_in <= 1'b0 ; // 1
        #(560_000)     ;
        inf_in <= 1'b1 ;
        #(1690_000)    ;
// 结束码 
        inf_in <= 1'b0 ;
        #(560_000)     ;
        inf_in <= 1'b1 ;
        #(1_000_000)   ;
// 重复码 
        inf_in <= 1'b0 ;
        #(9_000_000)   ;
        inf_in <= 1'b1 ;
        #(2_250_000)   ;
// 结束码 
        inf_in <= 1'b0 ;
        #(560_000)     ;
        inf_in <= 1'b1 ;
        #(1_000_000)   ;
        $stop             ;
    end
    always #( CYCLE / 2 ) sys_clk = ~sys_clk ;


endmodule

 

 

其他模块是之前的。

已上板验证成功。

核桃_warrior
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
linux网络协议栈ip_rcv
徐维溢的博客
03-12 773
int ip_rcv(struct sk_buff *skb, struct net_device *dev, struct packet_type *pt, struct net_device *orig_dev) { const struct iphdr *iph; struct net *net; u32 len; //丢弃PACKET_OTHERHOST类型的包 /* When the interface is in promisc. mode, drop all the.
UDP protocol--udp_rcv
RT的博客
03-19 3833
网络层对数据包处理完成后，会调用传输层的handler进行后续处理，UDP层的handler是在inet初始化注册的。 inet_init inet_add_protocol(&udp_protocol, IPPROTO_UDP) udp_protocol定义如下： static struct net_protocol udp_protocol = { .early_demux = udp_v4_early_demux, .early_demux_handler = udp_v4_early
ip_rcv_finish
City_of_skey的博客
11-15 1010
上一章我们分析了ip_rcv，这个函数主要是对数据包做各种正确性验证，然后调用掉网络过滤子系统的在PRE_ROUTEING链上的回调函数，经过网络子系统的处理在调用ip_rec_finish，ip_rcv_finish主要的工作： 1）、确定数据包是前送还是在本机协议栈上传，如果是前送要确保输出网络设备和下一个接受栈的地址。 2)、解析和处理部分IP选项。   1、获取路由信息 skb-...
Android UI布局之区分 android:gravity 和 android:layout_gravity
热门推荐
手把手教你学安卓
07-30 1万+
Android 布局UI知识点记录 本文链接 http://blog.csdn.net/never_cxb/article/details/47156935 转载请注明出处 一言以蔽之 普遍的说法是这样的 android:gravity 组件的子组件在组件中的位置 android:layout_gravity 组件自身在父组件中的位置 但是《第一行代码里》是这么说
【linux网络】ip_rcv()函数
图像、视频、算法、Linux
04-26 3469
ip_rcv()函数存在于linux内核net/ipv4/ip_input.c文件中。 linux-3.10.36中ip_rcv()函数源码如下（夹带中文注释）： /* * Main IP Receive routine. * 对IP头部合法性进行严格检查，然后把具体功能交给ip_rcv_finish */ int ip_rcv(struct sk_buff *skb, struct ne
网络收包流程-网络层处理流程ip_rcv（五）
hzj_001的博客
03-18 2971
报文提交给内核协议栈处理后，最终会调用到__netif_receive_skb_core函数，如果报文没有被网桥处理函数rx_handler消费掉，最终会交给ptype_base中注册的协议处理，包括内核注册的协议，也包括raw socket等创建的协议处理。本文将分析普通ipv4 报文的处理过程，处理入口函数为ip_rcv函数。 主要调用流程：ip_rcv-->ip_...
Linux内核packet_rcv代码分析
dean_gdp的专栏
06-26 3336
static int packet_rcv(struct sk_buff *skb, struct net_device *dev,      struct packet_type *pt, struct net_device *orig_dev) { struct sock *sk; struct sockaddr_ll *sll; struct packet_sock *po; u
【linux网络】ip_rcv_finish()函数
图像、视频、算法、Linux
04-27 3792
ip_rcv_finish()函数存在于kernel/net/ipv4/ip_input.c文件中记得在ip_rcv()函数执行最后条用了NF_HOOK，将数据发往netfilter的NF_INET_PRE_ROUTING节点，如下： NF_HOOK(NFPROTO_IPV4, NF_INET_PRE_ROUTING, skb, dev, NULL, ip_rcv_
Linux内核分析 - 网络：netif_receive_skb平台报文入口函数详解
qq_18144747的博客
11-10 8189
网络收包流程从网卡驱动开始，一直往上，涉及NAPI、GRO、RPS等特性，但是一般最后都会调用__netif_receive_skb函数： static int __netif_receive_skb(struct sk_buff *skb) {     struct packet_type *ptype, *pt_prev;     rx_handler_fu
linux内核对TCP的连接状态管理
网络安全研究
04-26 2115
TCP协议实例连接状态存放在struct sock数据结构的state数据域中。 当TCP协议实例连接处于不同状态时，对数据包的处理不一样，所以每个输入的数据包都要来查询TCP状态机，整个状态机制划分成3个阶段： 第一阶段：连接建立阶段。 第二阶段：数据传送阶段。 第三阶段：断开连接阶段。 1. TCP建立连接（tcp_v4_connect） tcp_v4_connect 函数将初始化一个对外...
fpga例子程序源代码-19_infrared_rcv.zip
05-26
fpga例子程序源代码
send_rcv.rar_visual c
09-20
是mini2440和cc2420读写串口读写的程序
ir_rcv_while.zip
07-21
红外解码的实现一般有定时器中断、外部中断+定时器、查询三种解码方案，其中查询方式解码在一些资源极少的MCU中或需要长时间关闭中断的系统中比较实用！ 资源一般均已查毒，但为安全起见，请在使用前查毒。
EBS经典流程
10-24
EBS经典流程资料，适用于EBS的初学者
xjf_stm8l_PC_UART_TIMEOUT_RCV.7z
01-26
例程实现了STM8L051F3串口接收中断超时判断数据结束.例程开发环境IAR FOR STM8 V3.10. 请用7Z软件解压.
第18篇 Intel FPGA Monitor Program的使用＜一＞
weixin_47841246的博客
06-11 271
Intel FPGA Monitor Program开发工具支持Terasic的FPGA开发板使用
RGMII接口---＞(013)FPGA实现RGMII接口(十三)
2401_84405631的博客
06-09 142
（a）FPGA（Field Programmable Gate Array）是在PAL （可编程阵列逻辑）、GAL（通用阵列逻辑）等可编程器件的基础上进一步发展的产物。它是作为专用集成电路（ASIC）领域中的一种半定制电路而出现的，既解决了定制电路的不足，又克服了原有可编程器件门电路数有限的缺点。（b）FPGA工程师就业应用于通信、航空航天、汽车电子，还是人工智能、物联网等新兴领域。
18.双线性插值缩放算法的matlab与FPGA实现（二）
q1594的博客
06-09 585
在图像算法中，可以知道算法本身不算复杂，但是在FPGA中，视频主要用视频流的方式在FPGA中，基本不可能对图像进行任意位置的索引。因此，如何根据视频流来进行插值最难的点在于如何寻找到缩放后的点对应的四个点坐标。根据视频流的特点，可以知道视频流的索引式按照左上到右下进行依次索引的。根据这个特点，可以实现只缓存几行数据即可实现图像的索引。这里缩放算法对视频流有两种，一种是主动式(act)，另一种是被动式（inact），主动式是指算法的视频流输入不受缩放模块控制，视频信息通常以视频流的方式直接进入模块。
【Quartus 13.0】EP1C3144I7 部署4*6矩阵键盘
最新发布
SHNIXU的博客
06-12 318
按键的值先打一拍(key_reg
NTSTATUS my_disk_handle_control(PDEVICE_OBJECT device, PIRP irp) { PIO_STACK_LOCATION ioc = IoGetCurrentIrpStackLocation(irp); const unsigned long code = ioc->Parameters.DeviceIoControl.IoControlCode; if (code == IOCTL_STORAGE_QUERY_PROPERTY) { if (StorageDeviceProperty == ((PSTORAGE_PROPERTY_QUERY)irp->AssociatedIrp.SystemBuffer)->PropertyId) n_util::change_ioc(ioc, irp, my_storage_query_ioc); } else if (code == IOCTL_ATA_PASS_THROUGH) n_util::change_ioc(ioc, irp, my_ata_pass_ioc); else if (code == SMART_RCV_DRIVE_DATA) n_util::change_ioc(ioc, irp, my_smart_data_ioc); return g_original_disk_control(device, irp); } NTSTATUS my_disk_handle_control(PDEVICE_OBJECT device, PIRP irp) { PIO_STACK_LOCATION ioc = IoGetCurrentIrpStackLocation(irp); const unsigned long code = ioc->Parameters.DeviceIoControl.IoControlCode; if (code == IOCTL_STORAGE_QUERY_PROPERTY) { if (StorageDeviceProperty == ((PSTORAGE_PROPERTY_QUERY)irp->AssociatedIrp.SystemBuffer)->PropertyId) n_util::change_ioc(ioc, irp, my_storage_query_ioc); } else if (code == IOCTL_ATA_PASS_THROUGH) n_util::change_ioc(ioc, irp, my_ata_pass_ioc); else if (code == SMART_RCV_DRIVE_DATA) n_util::change_ioc(ioc, irp, my_smart_data_ioc); return g_original_disk_control(device, irp); }
07-15
类似地，如果 `code` 的值等于 `IOCTL_ATA_PASS_THROUGH` 或者 `SMART_RCV_DRIVE_DATA`，则分别执行相应的逻辑操作。 最后，函数返回调用 `g_original_disk_control` 函数，并传入 `device` 和 `irp`。 整体来说，...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值