基于FPGA的红外遥控

于 2024-08-14 14:19:38 发布
阅读量353 收藏 9
点赞数 5
分类专栏： FPGA 文章标签： fpga开发
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_52438147/article/details/140824702
版权

1 基础只是

1.1红外遥控简介

        红外遥控是利用近红外光传送遥控指令的，波长为0.76um ~ 1.5um。红外发射器件（红外发光管）与红外接收器件（光敏二极管、三极管及光电池）的发光与受光峰值波长一般为0.8um~0.94um，在近红外光波段内，二者的光谱正好重合，能够很好的匹配，可以获得较高的传输效率及较高的可靠性。

        红外遥控发射部分由遥控按键，编码与调制电路、红外发光二极管等构成；红外遥控接收部分由光敏二极管，光电放大电路，解调电路等组成；最后将解调的信号输入 FPGA内部及逆行解码输出。

 

1.2 红外遥控编码协议

        NEC协议采用的是PPM（Pulse Position Modulation，脉冲位置调制）进行编码。当我们按下遥控器的一个按键时，会发送一帧的数据。这一帧的数据由引导码、地址码、地址反码、数据码、数据反码以及一位结束位（可忽略）组成。注：都是低位在前。

发送波形图

        逻辑0和1的表示方法：

        当按键一直按着不放：会发送重复码

重复码编码格式

        接收波形：（与发送波形图相对应）

接收波形图

2 实际工程

        将按键按下的数字显示在数码管上，检测到重复码的话就闪烁LED灯；

2.1 模块框图

2.1.1 总体框图

2.1.2 解码模块

2.1.3 LED灯模块

2.1.4 动态数码管模块 

2.1.5 内部接线框图

2.2 状态机转换

空闲、引导码、仲裁、数据、重复

2.3 波形图

2.4 代码部分 

2.4.1 inf_rcv.v

module inf_rcv
(
    input   wire            sys_clk     ,
    input   wire            sys_rst_n   ,
    input   wire            inf_in      ,
    
    output  reg     [19:0]  data        ,
    output  reg             reapeat_en   
);
parameter   IDLE      = 5'b0_0001,
            TIME_9MS  = 5'b0_0010,
            ARBIT     = 5'b0_0100,
            DATA      = 5'b0_1000,
            REAPEAT   = 5'b1_0000;

//just like:560us = 560_000ns and sys_clk = 20ns, so 0~27999            
parameter   CNT_560US_MIN  = 19'd20_000  ,
            CNT_560US_MAX  = 19'd35_000  ,
            CNT_1_69MS_MIN = 19'd80_000  ,
            CNT_1_69MS_MAX = 19'd90_000  ,
            CNT_2_25MS_MIN = 19'd100_000 ,
            CNT_2_25MS_MAX = 19'd125_000 ,
            CNT_4_5MS_MIN  = 19'd175_000 ,
            CNT_4_5MS_MAX  = 19'd275_000 ,
            CNT_9MS_MIN    = 19'd400_000 ,
            CNT_9MS_MAX    = 19'd490_000 ;

reg     [4:0]   state       ;
reg             inf_in_dly1 ;
reg             inf_in_dly2 ;
wire            inf_in_fall ;
wire            inf_in_rise ;
reg     [18:0]  cnt         ;
reg             flag_9ms    ;
reg             flag_4_5ms  ;
reg     [5:0]   cnt_data    ;
reg             flag_560us  ;
reg             flag_1_69ms ;
reg     [31:0]  data_reg    ;
reg             flag_2_25ms ;

always@(posedge sys_clk or negedge sys_rst_n)
    if(sys_rst_n == 1'b0)
        state <= IDLE;
    else    case(state)
        IDLE: if(inf_in_fall == 1'b1)
                state <= TIME_9MS;
              else
                state <= IDLE;
        //if over 9ms，just wait the inf_rise
        TIME_9MS: if((inf_in_rise == 1'b1) && (flag_9ms == 1'b1))
                    state <= ARBIT;
                  else if((inf_in_rise == 1'b1) && (flag_9ms == 1'b0))
                    state <= IDLE;
                  else
                    state <= TIME_9MS;
        ARBIT: if((inf_in_fall == 1'b1) && (flag_2_25ms == 1'b1))
                    state <= REAPEAT;
               else if((inf_in_fall == 1'b1) && (flag_4_5ms == 1'b1))
                    state <= DATA;
               else if((inf_in_fall == 1'b1) && (flag_2_25ms == 1'b0) && (flag_4_5ms == 1'b0))
                    state <= IDLE;
               else
                    state <= ARBIT;
        DATA: if((inf_in_rise == 1'b1) && (flag_560us == 1'b0))
                state <= IDLE;
              else if((inf_in_fall == 1'b1) && (flag_560us == 1'b0) && (flag_1_69ms == 1'b0))
                state <= IDLE;
              else if((inf_in_rise == 1'b1) && (cnt_data == 6'd32))
                state <= IDLE;
        REAPEAT: if(inf_in_rise == 1'b1)
                    state <= IDLE;
                 else
                    state <= REAPEAT;
        default: state <= IDLE;
    endcase 

always@(posedge sys_clk or negedge sys_rst_n)
    if(sys_rst_n == 1'b0)
        begin
            inf_in_dly1 <= 1'b0;
            inf_in_dly2 <= 1'b0;
        end
    else
        begin
            inf_in_dly1 <= inf_in;
            inf_in_dly2 <= inf_in_dly1;
        end
        
assign inf_in_fall = (inf_in_dly1 == 1'b0) && (inf_in_dly2 == 1'b1);
assign inf_in_rise = (inf_in_dly1 == 1'b1) && (inf_in_dly2 == 1'b0);

always@(posedge sys_clk or negedge sys_rst_n)
    if(sys_rst_n == 1'b0)
        cnt <= 19'd0;
    else
        case(state)
            IDLE: cnt <= 19'd0;
            TIME_9MS:   if((inf_in_rise == 1'b1) && (flag_9ms == 1'b1))
                            cnt <= 19'd0;
                        else
                            cnt <= cnt + 1'b1;
            ARBIT:      if((inf_in_fall == 1'b1) && ((flag_4_5ms == 1'b1) || (flag_2_25ms == 1'b1)))
                            cnt <= 19'd0;
                        else
                            cnt <= cnt + 1'b1;
            DATA:   if((inf_in_rise == 1'b1) && (flag_560us == 1'b1))
                        cnt <= 19'd0;
                    else if((inf_in_fall == 1'b1) && ((flag_560us == 1'b0) || (flag_1_69ms == 1'b0)))
                        cnt <= 19'd0;
                    else
                        cnt <= cnt + 1'b1;
            default: cnt <= 19'd0;
        endcase

always@(posedge sys_clk or negedge sys_rst_n)
    if(sys_rst_n == 1'b0)
        flag_9ms <= 1'b0;
    else if((state == TIME_9MS) && (cnt >= CNT_9MS_MIN) && (cnt <= CNT_9MS_MAX))
        flag_9ms <= 1'b1;
    else
        flag_9ms <= 1'b0;
    
always@(posedge sys_clk or negedge sys_rst_n)
    if(sys_rst_n == 1'b0)
        flag_4_5ms <= 1'b0;
    else if((state == ARBIT) && (cnt >= CNT_4_5MS_MIN) && (cnt <= CNT_4_5MS_MAX))
        flag_4_5ms <= 1'b1;
    else
        flag_4_5ms <= 1'b0;

always@(posedge sys_clk or negedge sys_rst_n)
    if(sys_rst_n == 1'b0)
        flag_560us <= 1'b0;
    else if((state == DATA) && (cnt >= CNT_560US_MIN) && (cnt <= CNT_560US_MAX)) 
        flag_560us <= 1'b1;
    else
        flag_560us <= 1'b0;

always@(posedge sys_clk or negedge sys_rst_n)
    if(sys_rst_n == 1'b0)
        flag_1_69ms <= 1'b0;
    else if((state == DATA) && (cnt >= CNT_1_69MS_MIN) && (cnt <= CNT_1_69MS_MAX)) 
        flag_1_69ms <= 1'b1;
    else
        flag_1_69ms <= 1'b0;

always@(posedge sys_clk or negedge sys_rst_n)
    if(sys_rst_n == 1'b0)
        flag_2_25ms <= 1'b0;
    else if((state == ARBIT) && (cnt >= CNT_2_25MS_MIN) && (cnt <= CNT_2_25MS_MAX)) 
        flag_2_25ms <= 1'b1;
    else
        flag_2_25ms <= 1'b0;

always@(posedge sys_clk or negedge sys_rst_n)
    if(sys_rst_n == 1'b0)  
        cnt_data <= 6'd0;
    else if((inf_in_rise == 1'b1) && (cnt_data == 6'd32))
        cnt_data <= 6'd0;
    else if((state == DATA) && (inf_in_fall == 1'b1))
        cnt_data <= cnt_data + 1'b1;
    else 
        cnt_data <= cnt_data;
        
always@(posedge sys_clk or negedge sys_rst_n)
    if(sys_rst_n == 1'b0) 
        data_reg <= 32'b0;
    else if((state == DATA) && (inf_in_fall == 1'b1) && (flag_560us == 1'b1))
        data_reg[cnt_data] <= 1'b0;
    else if((state == DATA) && (inf_in_fall == 1'b1) && (flag_1_69ms == 1'b1))
        data_reg[cnt_data] <= 1'b0;
    else
        data_reg <= data_reg;
        
always@(posedge sys_clk or negedge sys_rst_n)
    if(sys_rst_n == 1'b0)
        data <= 20'd0;
    else if((cnt_data == 6'd32) && (~data_reg[23:16] == data_reg[31:24]) && (~data_reg[15:8] == data_reg[7:0]))
        data <= {12'b0,data_reg[23:16]};
    else
        data <= data;

always@(posedge sys_clk or negedge sys_rst_n)
    if(sys_rst_n == 1'b0)
        reapeat_en <= 1'b0;
    else if((state == REAPEAT) && (~data_reg[23:16] == data_reg[31:24]))
        reapeat_en <= 1'b1;
    else
        reapeat_en <= 1'b0;
        
endmodule

2.4.2 tb_inf_rcv.v

`timescale 1ns/1ns
module tb_inf_rcv();

reg     sys_clk;
reg     sys_rst_n;
reg     inf_in;

wire    [19:0]  data;
wire            reapeat_en;

initial
    begin
        sys_clk = 1'b1;
        sys_rst_n <= 1'b0;
        inf_in <= 1'b1;
        #30
        sys_rst_n <= 1'b1;
        #1000
        //引导码
        inf_in <= 1'b0;
        #9000_000
        inf_in <= 1'b1;
        #4500_000
        //地址码（8'h57 0101_0111   因为低位在前：1110_1010）
        inf_in <= 1'b0;
        #560_000
        inf_in <= 1'b1;
        #1690_000          //至此实现了逻辑1
        inf_in <= 1'b0;
        #560_000
        inf_in <= 1'b1;
        #1690_000          //至此实现了逻辑1
        inf_in <= 1'b0;
        #560_000
        inf_in <= 1'b1;
        #1690_000          //至此实现了逻辑1
        inf_in <= 1'b0;
        #560_000
        inf_in <= 1'b1;
        #560_000            //至此实现了逻辑0
        inf_in <= 1'b0;
        #560_000
        inf_in <= 1'b1;
        #1690_000          //至此实现了逻辑1
        inf_in <= 1'b0;
        #560_000
        inf_in <= 1'b1;
        #560_000            //至此实现了逻辑0
        inf_in <= 1'b0;
        #560_000
        inf_in <= 1'b1;
        #1690_000          //至此实现了逻辑1
        inf_in <= 1'b0;
        #560_000
        inf_in <= 1'b1;
        #560_000            //至此实现了逻辑0
        //地址反码（0001_0101）
        inf_in <= 1'b0;
        #560_000
        inf_in <= 1'b1;
        #560_000            //至此实现了逻辑0
        inf_in <= 1'b0;
        #560_000
        inf_in <= 1'b1;
        #560_000            //至此实现了逻辑0
        inf_in <= 1'b0;
        #560_000
        inf_in <= 1'b1;
        #560_000            //至此实现了逻辑0
        inf_in <= 1'b0;
        #560_000
        inf_in <= 1'b1;
        #1690_000          //至此实现了逻辑1
        inf_in <= 1'b0;
        #560_000
        inf_in <= 1'b1;
        #560_000            //至此实现了逻辑0
        inf_in <= 1'b0;
        #560_000
        inf_in <= 1'b1;
        #1690_000          //至此实现了逻辑1
        inf_in <= 1'b0;
        #560_000
        inf_in <= 1'b1;
        #560_000            //至此实现了逻辑0
        inf_in <= 1'b0;
        #560_000
        inf_in <= 1'b1;
        #1690_000          //至此实现了逻辑1
        //数据码:(8'h22    0010_0010   低位在前：0100_0100)
        inf_in <= 1'b0;
        #560_000
        inf_in <= 1'b1;
        #560_000            //至此实现了逻辑0
        inf_in <= 1'b0;
        #560_000
        inf_in <= 1'b1;
        #1690_000          //至此实现了逻辑1
        inf_in <= 1'b0;
        #560_000
        inf_in <= 1'b1;
        #560_000            //至此实现了逻辑0
        inf_in <= 1'b0;
        #560_000
        inf_in <= 1'b1;
        #560_000            //至此实现了逻辑0
        inf_in <= 1'b0;
        #560_000
        inf_in <= 1'b1;
        #560_000            //至此实现了逻辑0
        inf_in <= 1'b0;
        #560_000
        inf_in <= 1'b1;
        #1690_000          //至此实现了逻辑1
        inf_in <= 1'b0;
        #560_000
        inf_in <= 1'b1;
        #560_000            //至此实现了逻辑0
        inf_in <= 1'b0;
        #560_000
        inf_in <= 1'b1;
        #560_000            //至此实现了逻辑0
        //数据反码（1011_1011）
        inf_in <= 1'b0;
        #560_000
        inf_in <= 1'b1;
        #1690_000          //至此实现了逻辑1
        inf_in <= 1'b0;
        #560_000
        inf_in <= 1'b1;
        #560_000            //至此实现了逻辑0
        inf_in <= 1'b0;
        #560_000
        inf_in <= 1'b1;
        #1690_000          //至此实现了逻辑1
        inf_in <= 1'b0;
        #560_000
        inf_in <= 1'b1;
        #1690_000          //至此实现了逻辑1
        inf_in <= 1'b0;
        #560_000
        inf_in <= 1'b1;
        #1690_000          //至此实现了逻辑1
        inf_in <= 1'b0;
        #560_000
        inf_in <= 1'b1;
        #560_000            //至此实现了逻辑0
        inf_in <= 1'b0;
        #560_000
        inf_in <= 1'b1;
        #1690_000          //至此实现了逻辑1
        inf_in <= 1'b0;
        #560_000
        inf_in <= 1'b1;
        #1690_000          //至此实现了逻辑1
        //结束位
        inf_in <= 1'b0;
        #560_0000
        //高电平保持
        inf_in <= 1'b1;
        #4200_0000
        //重复码
        inf_in <= 1'b0;
        #9000_000
        inf_in <= 1'b1;
        #2250_000
        //结束位
        inf_in <= 1'b0;
        #560_0000
        inf_in <= 1'b1;
        inf_in <= 1'b1;        
    end

always #10 sys_clk = ~sys_clk;

inf_rcv inf_rcv_inst
(
    .sys_clk     (sys_clk),
    .sys_rst_n   (sys_rst_n),
    .inf_in      (inf_in),
             
    .data        (data),
    .reapeat_en  (reapeat_en) 
);


endmodule

 2.5 仿真波形

注：其他模块可根据具体开发板书写

Super_WY_
关注
专栏目录
学习型红外遥控器的FPGA设计与实现
FPGA/MATLAB学习教程/源码/项目合作开发
05-21 2278
1.问题描述： 振荡电路提供系统工作时钟和常用的38K站空比为1:3的载波，键扫描输入输出电路与SEL输入口形成用户码与键码，并由码产生电路形成待发射数据，在输出控制电路控制下，通过REMO输出口由红外线输出。在遥控器发射的每帧数据中，包括引导码，用户码，和键码三个部分。并采用脉冲位置调制方式（PPM）区分“1”和“0”，脉冲的宽度，脉冲间的时间间隔的大小，每帧数据所包含的位数以及引导码高低电平的时间宽度的不同，为不同的发码格式，常用的如NEC6122格式。 NEC6122格式如下所示： .
FPGA的学习：红外遥控
weixin_44297949的博客
06-09 2481
使用 FPGA 开发板配套的红外遥控器发送红外信号， FPGA 开发板上的一 体化接收头接收到红外信号后传入 FPGA 芯片内， FPGA 芯片接收到信号后进行解码，将解码后的按键码显示在数码管上。若检测到发送了重复码，则让 led 闪烁显示，一个重复码闪烁一次。 来看红外接收模块： `timescale 1ns/1ns module infrared_rcv ( input wire sys_clk , //系统时钟，频率50MHz in
FPGA- 红外遥控（附代码）
m0_72885897的博客
03-20 2655
1. 实验核心部分在于红外接收模块，要理解何时进行状态跳转以及判断其跳转的条件。*2. 代码编写上有些新的知识点，注意学习。说明：本人使用的是野火家Xilinx Spartan6系列开发板及配套教程，以下内容如有疑惑或错误欢迎评论区指出。开发软件：ise14.7 仿真：modelsim 10.5如需上述资料私信或留下邮箱！
FPGA红外遥控器
06-05
基于FPGA开发的红外遥控器，可以实现对空调电视的遥控
FPGA之红外遥控
qq_52450571的博客
07-21 2211
红外遥控系统由红外发射部分和红外接收部分组成。发射部分由遥控案件、编码以及调制电路、红外发光二极管等组成。接收部分由光敏二极管、解调电路等组成，最后将解调的信号输入FPGA内进行解码输出。使用的红外接收头要购买一体化红外接收头...
基于FPGA的红外遥控解码与PC串口通信
热门推荐
zouxy09的专栏
06-20 1万+
基于FPGA的红外遥控解码与PC串口通信zouxy09@qq.comhttp://blog.csdn.net/zouxy09        这是我的《电子设计EDA》的课程设计作业（呵呵，这个月都拿来做大作业了，各种大作业，能发上来和大家分享的我会发上来，否则博客太冷清了）。之前没有学过FPGA，但要掌握基础的Verilog编程也不是很困难。不过altium公司的NanoBoard2开发板的确也不
基于FPGA红外遥控乐曲播放器设计.pdf
07-13
本文介绍了一种基于现场可编程门阵列（FPGA）的红外遥控乐曲播放器设计方法。在详细分析了FPGA在乐曲播放器系统中的应用后，本文阐述了红外遥控器的工作原理和红外遥控接收解码器的设计方法，以及按键消抖的有限状态...
基于FPGA的红外遥控密码锁的设计
08-31
《基于FPGA的红外遥控密码锁的设计》这篇文章探讨了一种创新的电子密码锁设计，它利用可编程逻辑器件FPGA，具有高可靠性、便捷性和良好的灵活性及可扩展性。文章着重介绍了红外遥控解码、密码解锁及修改等功能的实现...
基于FPGA的红外遥控信号解码设计.pdf
07-13
本文通过设计基于FPGA的红外遥控解码电路，证实了使用Verilog HDL实现的红外解码电路功能是可行的，并且具有高效率和高精度。未来，随着FPGA技术的进步和红外遥控应用领域的发展，该技术有望进一步提升性能，并拓展...
基于FPGA的红外遥控的应用
01-27
在本文中，我们将深入探讨基于FPGA（Field-Programmable Gate Array，现场可编程门阵列）的红外遥控系统的设计与实现，重点包括红外信号的编码、解码以及系统的构建和测试。 红外遥控信号的编码是系统设计的基础。...
FPGA 红外遥控解码
09-19
FPGA红外遥控接收代码，使用红外遥控接收头输入到FPGA，串口打印收到的按键值，Altera EP1C
基于FPGA的红外线接收
09-09
红外遥控器按下数字键，FPGA接收红外信号并在数码管上面显示相应的数字
源码系列：基于FPGA的红外线遥控系统设计（附源工程）
04-23 927
今天给大侠带来基于FPGA的红外线遥控系统设计，附源码，获取源码，请在“FPGA技术江湖”公众号内回复“红外线遥控系统设计源码”，可获取源码文件。话不多说，上货。 前言 红外线(Infrared)是波长介乎微波与可见光之间的电磁波，波长在760纳米(nm)至1毫米(mm)之间，比红光长的非可见光。红外线遥控是目前使用最广泛的一种通信和遥控手段。由于红外线遥控装置具有体积小、功...
FPGA之旅设计99例之第十四例-----接收红外遥控数据
weixin_44678052的博客
09-12 870
本例是FPGA之旅设计的第十四例，本例将红外遥控的使用，并将红外接收器接收到红外遥控的数据显示在数码管上。红外遥控接收器模块，非常简单，也是由GND，VCC和数据三个引脚组成，通过杜邦线可以直接连接在FPGA的IO口上，产品细节如下。
[FPGA][红外遥控]驱动程序
永恒盛夏
11-19 776
目录一、开发环境二、准备工作2.1、需要具备的知识2.2、红外线基础三、代码部分 一、开发环境 Verilog Quartus 13.1 Modelsim 基于NEC协议 二、准备工作 2.1、需要具备的知识 Verilog的基本语法包括但不限于 case always 时钟分频 状态机 红外线通讯时序 2.2、红外线基础 NEC协议的特征 8位地址和8位指令长度 地址用来区分不同的红外遥控器，指令是我们主要关注的部分。 地址和指令都将传输两次 传输顺序由先到后（地址码-地址反码
【FPGA基础】红外遥控学习笔记
迦南的博客
05-10 735
1、红外遥控基础知识 （1）波长 0.76μm～1.5μm 之间的近红外线，不干扰其他电器设备工作，也不会影响周边环境； 2、红外遥控协议（NEC） （1）数据帧格式 一帧数据由帧头、地址码、数据码、数据反码以及 1bit 结束位（可忽略）组成。 引导码由 9ms 高电平的头码和 4.5ms 低电平的间隙组成，其代表一个数据帧的帧头；地址码共 16 位，低位在前，高位在后；8 位数据码及其反码低位在前，高位在后； （2）数据编码发送波形 （3）接收波形 2、红外解码模块设计 （1）接口框图 （2）关
【红外遥控器】基于FPGA的红外遥控verilog附代码及解析
最新发布
qianzui136的博客
02-24 2740
红外遥控：红外遥控是一种无线、非接触控制技术。特点：抗干扰能力强，信息传输可靠，功耗低，成本低，易实现等；由于它不能穿过障碍物去控制被控对象的能力，可以有相同的遥控频率或编码，而不会出现遥控信号“串门”的情况。红外光波长为760nm到1mm，人眼可见波长为400nm到760nm。输入的由系统时钟、复位、红外信号，输出的repeat_en重复码标志信号，数据有效信号data_en,及红外控制码。input sys_clk , //系统时钟。
FPGA-红外
muyidian的博客
09-06 1307
发射器为普通的红外遥控器，接收器为1838T（VCC/GND/OUT）； 软件协议：NEC（还有一种常用协议，SONY）； 协议介绍：     引导码：9ms低电平+4.5ms高电平；     客户代码：C0-C7,C0-C7（反码）；     用户码：D0-D7,D0-D7（反码）；     停止位：低脉冲（560us）；     重复码：若按键时间过长，会在发送完一帧正常数据之后...
fpga红外遥控代码
05-26
FPGA 红外遥控代码主要涉及到两个方面：红外信号的发送和接收。下面分别介绍这两个方面的代码实现。 ## 红外信号发送 红外信号发送需要用到一个红外发射二极管，它能够将FPGA输出的数字信号转换为红外信号并发射出去。以下是一个基于Verilog HDL的红外信号发送代码示例： ``` module ir_transmitter ( input clk, // 时钟信号 input rst, // 复位信号 output reg ir_out, // 红外发射信号 input btn // 按钮信号 ); reg [15:0] cnt; // 计数器，用于控制红外信号的发送 reg [3:0] state; // 状态机状态变量，用于控制红外信号发送的不同阶段 always @(posedge clk) begin if(rst) begin cnt <= 0; ir_out <= 0; state <= 0; end else begin case(state) 0: begin // 空闲状态 cnt <= 0; ir_out <= 0; if(btn == 1) begin state <= 1; end end 1: begin // 发送起始信号 ir_out <= 1; if(cnt >= 5000) begin cnt <= 0; state <= 2; end else begin cnt <= cnt + 1; end end 2: begin // 发送数据信号 if(cnt <= 100) begin ir_out <= 1; end else if(cnt <= 200) begin ir_out <= 0; end else begin cnt <= 0; state <= 3; end cnt <= cnt + 1; end 3: begin // 发送结束信号 ir_out <= 1; if(cnt >= 5000) begin cnt <= 0; state <= 0; end else begin cnt <= cnt + 1; end end default: begin cnt <= 0; ir_out <= 0; state <= 0; end endcase end end endmodule ``` 上述代码实现了一个红外信号发送器。当 FPGA 开发板上的按钮被按下时，会触发红外信号的发送。信号发送分为三个阶段：发送起始信号、发送数据信号和发送结束信号。在发送数据信号阶段，根据实际需求可以修改数据信号的发送逻辑。 ## 红外信号接收 红外信号接收需要用到一个红外接收头，它能够将接收到的红外信号转换为数字信号并输入到FPGA中。以下是一个基于Verilog HDL的红外信号接收代码示例： ``` module ir_receiver ( input clk, // 时钟信号 input rst, // 复位信号 input ir_in, // 红外接收信号 output reg [3:0] data_out // 接收到的数据 ); reg [3:0] state; // 状态机状态变量，用于控制红外信号接收的不同阶段 reg [15:0] cnt; // 计数器，用于控制红外信号的接收 always @(posedge clk) begin if(rst) begin state <= 0; cnt <= 0; data_out <= 0; end else begin case(state) 0: begin // 空闲状态 cnt <= 0; if(ir_in == 0) begin state <= 1; end end 1: begin // 接收起始信号 if(cnt >= 6000 && ir_in == 1) begin cnt <= 0; state <= 2; end else if(cnt >= 10000) begin cnt <= 0; state <= 0; end else begin cnt <= cnt + 1; end end 2: begin // 接收数据信号 if(cnt <= 100) begin data_out <= {data_out[2:0], ir_in}; end else if(cnt >= 10000) begin cnt <= 0; state <= 0; end cnt <= cnt + 1; end default: begin cnt <= 0; state <= 0; data_out <= 0; end endcase end end endmodule ``` 上述代码实现了一个红外信号接收器。当红外接收头接收到红外信号时，会触发红外信号的接收。信号接收分为三个阶段：接收起始信号、接收数据信号和接收结束信号。在接收数据信号阶段，根据实际需求可以修改数据信号的接收逻辑。接收到的数据存储在 `data_out` 变量中，可以根据实际需求处理这些数据。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Super_WY_

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值