半双工串口

最新推荐文章于 2025-03-26 21:57:59 发布
最新推荐文章于 2025-03-26 21:57:59 发布
阅读量1.8k 收藏 4
点赞数 1
分类专栏： Verilog 文章标签： verilog串口通信
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qinyaray/article/details/73826567
版权

半双工是用一根信号线双向传输，不可同时发送接收。

主要代码：

状态机定义

    localparam  IDLE    =   3'b001,
                RECEIVE =   3'b010,
                SEND    =   3'b100;

状态机

always @ ( * )  begin
        case ( state_now )
            IDLE:   begin
                if( IDLE2RECEIVE )  begin
                    state_next = RECEIVE;
                end
                else    if ( IDLE2SEND )    begin
                    state_next = SEND;
                end
                else    begin
                    state_next = IDLE;
                end

            end
            RECEIVE:    begin
                if( RECEIVE2IDLE )  begin
                    state_next = IDLE;
                end
                else begin
                    state_next = RECEIVE;
                end
            end
            SEND:   begin
                if( SEND2IDLE ) begin
                    state_next = IDLE;
                end
                else begin
                    state_next = SEND;
                end
            end
            default:    begin
                state_next = IDLE;
            end
        endcase

    end


    always @ ( posedge clk_uart )   begin
        state_now <= state_next;    
    end

    always @ ( posedge clk_uart )   begin
        case ( state_now )  
        IDLE:   begin
            txd  <= 1;
            if( IDLE2SEND ) begin
                data_send   <=  { 1'b1,data_send_reg_1[counter_send_1],1'b0 };
                counter_send_1  <=  counter_send_1 + 1 ;
                counter_send    <=  0;
            end
            else    if ( bh_flag == 3'b101 )    begin
                counter_send_1  <=  0;
                data_send   <= 0;               
                counter_send    <=  0;
            end
            else    begin
                data_send   <= 0;               
                counter_send    <=  0;          
            end

            if( data_receive[0] == 0 && data_receive[9] == 1 )  begin
                {  data_receive_reg [6] , data_receive_reg [5] , data_receive_reg [4] , data_receive_reg [3] , data_receive_reg [2] , data_receive_reg [1] , data_receive_reg [0]  }    
                <= { data_receive_reg [5] , data_receive_reg [4] , data_receive_reg [3] , data_receive_reg [2] , data_receive_reg [1] , data_receive_reg [0] , data_receive [8:1] };
                data_receive        <= 0;
                counter_receive     <= 0;
            end
            else    begin
                data_receive        <= 0;
                counter_receive     <= 0;
            end
        end
        RECEIVE:    begin
            rxd_1   <= rxd;
            rxd_2   <= rxd_1;
            rxd_3   <= rxd_2;
            rxd_4   <= rxd_3;
            rxd_5   <= rxd_4;
            rxd_6   <= rxd_5;
            rxd_7   <= rxd_6;
            rxd_8   <= rxd_7;
            counter_receive <=  counter_receive + 1 ;
            data_receive[counter_receive[7:4]]  <=  rxd_8 ;
        end
        SEND:   begin
            counter_send    <=  counter_send + 1 ;
            txd     <= data_send [ counter_send [7:4] ] ;
        end
        default:    begin
            data_send   <= 0;
            counter_send    <=  0;
            data_receive        <= 0;
            counter_receive     <= 0;
            txd      <= 1;
        end
        endcase
    end

状态转换条件

assign  IDLE2RECEIVE    = state_now == IDLE  &&  rxd == 0;
assign  IDLE2SEND       = state_now == IDLE  &&  counter_send_1 <= 8'd6  ;
assign  RECEIVE2IDLE    = state_now == RECEIVE  &&  counter_receive >= 8'd155;
assign  SEND2IDLE       = state_now == SEND  &&  counter_send >= 8'd159;

输出

assign  xd = state_now == SEND ? txd : 1'bz;
assign  rxd = state_now == SEND ? 1'bz : xd;

内部指令系统，随便写的

    always @ ( posedge clk_uart )  begin
        if ( data_receive_reg[0] == 8'h7f ) begin
            data_send_reg[0]   <=   8'h0f;
            data_send_reg[1]   <=   8'h0e;
            data_send_reg[2]   <=   8'h0d;
            data_send_reg[3]   <=   8'h0c;
            data_send_reg[4]   <=   8'h0b;
            data_send_reg[5]   <=   8'h0a;
            data_send_reg[6]   <=   8'h09;
        end
        else ;

    end

意思是收到一个 7f 字节时就返回7个字节 0f 0e 0d 0c 0b 0a 09 仿真正常 如下
这里写图片描述

增加2017.7.24：

应同事要求做了相应更改，隐藏部分代码：

`timescale 1ns / 1ps
//-------------------------------------------------------------------
//      一次发送一个字节，从低字节开始发送
//      如果发送的数据为 56'h 07060504030201
//          另一端就收的数据为 56'h 01020304050607
//-------------------------------------------------------------------
module uart
    (
    inout            xd,         //数据线
    input            clk,        //20m时钟    
    input  [55:0]    data_in,    //上层模块发送数据，比发送开始信号提前一个周期就绪 
    input            send_start, //发送开始信号，send_flag = 1 时才能发送
    output  reg      send_flag,  //发送就绪状态   
    output [55:0]    data_out,   //收到的数据，data_out_en = 1 时有效    
    output  reg      data_out_en //输出数据有效位
    );
//--------------变量定义------------------------------------------------------    
       省略
//---------------------clk_uart=波特率*16------------------------  
//---------------------默认115200--------------------------------
//------------------  UART_B = 20M / 115200 * 16 / 2 = 1389 -----     
    localparam UART_B = 16'd1389;

    reg clk_uart = 0;
    reg [15:0]  clk_counter = 0 ;
    wire clk_end;
    assign clk_end = clk_counter >= UART_B;
    always @ ( posedge clk )    begin
        if ( clk_end )  begin
            clk_uart <= ~clk_uart;
            clk_counter <= 0 ;
        end
        else    begin
            clk_counter <= clk_counter + 1 ;
        end
    end
//-----------------------inout口xd配置---------------------------------
    assign    xd  = state_now == SEND ? txd : 1'bz;
    assign    rxd = state_now == SEND ? 1'bz : xd;
//-----------------------状态跳转标志位--------------------------------
    隐藏   
//---------------未用----------------输入变化触发输出--------------    
    ...
//-----------------------数据输出------------------------------------   
    省略
//----------------------数据输入转存--------------------------------  
    省略
//------------------------状态机下一状态-------------------------- 
    always @ ( * )  begin
        case ( state_now )
            IDLE:   begin
                if( IDLE2RECEIVE )  begin
                    state_next = RECEIVE;
                end
                else    if ( IDLE2SEND )    begin
                    state_next = SEND;
                end
                else    begin
                    state_next = IDLE;
                end             
            end
            RECEIVE:    begin
                if( RECEIVE2IDLE )  begin
                    state_next = IDLE;
                end
                else begin
                    state_next = RECEIVE;
                end
            end
            SEND:   begin
                if( SEND2IDLE ) begin
                    state_next = IDLE;
                end
                else begin
                    state_next = SEND;
                end
            end
            default:    begin
                state_next = IDLE;
            end
        endcase 
    end 
//--------------------状态机转换-------------------------------  
    always @ ( posedge clk_uart )   begin
        state_now <= state_next;    
    end
//---------------------状态机输出部分-------------------------------   
    always @ ( posedge clk_uart )   begin
        case ( state_now )  
        IDLE:   begin
            txd  <= 1;
            send_flag <= counter_send_1 >= 8'd7 && counter_receive_1 == 0 && counter_receive == 0;
            if( IDLE2SEND ) begin
                data_send   <=  { 1'b1,data_send_reg_1[counter_send_1],1'b0 };
                counter_send_1  <=  counter_send_1 + 1 ;
                counter_send    <=  0;
            end
            else    if ( send_start )   begin
                counter_send_1  <=  0;
                data_send   <= 0;               
                counter_send    <=  0;
            end
            else    begin
                data_send   <= 0;               
                counter_send    <=  0;          
            end         
            if( data_receive[0] == 0 && data_receive[9] == 1 )  begin
                {  data_receive_reg [6] , data_receive_reg [5] , data_receive_reg [4] , data_receive_reg [3] , data_receive_reg [2] , data_receive_reg [1] , data_receive_reg [0]  }    
                <= { data_receive_reg [5] , data_receive_reg [4] , data_receive_reg [3] , data_receive_reg [2] , data_receive_reg [1] , data_receive_reg [0] , data_receive [8:1] };
                data_receive        <= 0;
                counter_receive     <= 0;
                if ( counter_receive_1 >= 4'd6 ) begin
                    counter_receive_1 <= 0;
                    data_out_en         <= 1'b1;
                end
                else begin
                    counter_receive_1 <= counter_receive_1 + 1'b1;
                end                             
            end
            else    begin
                data_receive        <= 0;
                counter_receive     <= 0;
            end
        end
        RECEIVE:    begin
            rxd_1   <= rxd;
            rxd_2   <= rxd_1;
            rxd_3   <= rxd_2;
            rxd_4   <= rxd_3;
            rxd_5   <= rxd_4;
            rxd_6   <= rxd_5;
            rxd_7   <= rxd_6;
            rxd_8   <= rxd_7;
            data_out_en         <= 0;
            send_flag <= 0;
            counter_receive <=  counter_receive + 1 ;
            data_receive[counter_receive[7:4]]  <=  rxd_8 ;
        end
        SEND:   begin
            counter_send    <=  counter_send + 1 ;
            txd     <= data_send [ counter_send [7:4] ] ;
            send_flag <= 0;         
        end
        default:    begin
            data_send   <= 0;
            send_flag <= 0;
            counter_send    <=  0;
            data_receive        <= 0;
            counter_receive     <= 0;
            txd      <= 1;
            data_out_en         <= 0;
        end
        endcase
    end     
endmodule

仿真结果：
这里写图片描述

【串口通信】-01-单工、半双工、全双工详解
随意的风的专栏
07-04 1412
串口通信是一种点对点的数据传输方式，数据以串行的形式在发送端和接收端之间传输。这种通信方式广泛应用于计算机与外部设备之间的数据交换，如打印机、调制解调器等。
Usart的单线半双工模式（stm32F10x系列）
weixin_30650039的博客
10-28 3158
　　这两天折腾CTS/RTS硬件流控，看到说232协议的CTS/RTS只是用来做半双工换向使用的。正好手头上有块stm32的板子，看了看stm32的Usart，竟然发现支持的是单线半双工。232里面毕竟4根线，支持半双工也是各自独立地物理信道（大胆猜测，回头回顾一下以前草草使用的双线485，看看它的半双工）。第一次注意到。之所以引起我的兴趣，是因为，我好奇stm32的单线半双工有2点。 　　第一...
串口通讯—全双工和半双工方式
07-06
串口通讯—全双工和半双工方式 串口通讯—全双工和半双工方式 串口通讯—全双工和半双工方式
全双工串口、半双工串口总线及其转换
Light&Electricity的博客
11-16 5536
介绍全双工串口和半双工串口总线，并介绍两者的转换方法
串口USART
最新发布
weixin_51931174的博客
03-26 807
在绝大多数场合下，发送端和接收端，采用的都是同一个时钟，所以在传送数据的同时还要 发送时钟信号，以便接收端可以使用时钟信号来确定每一个信息位。同步是指在约定的通信速率下，发送端和接收端的时钟信号和相位始终保持一致，保证通信 双方在发送和接收数据时具有完全一致的定时关系。字符帧也叫做数据帧，由起始位，数据位，奇偶校验位，停止位等部分组成，是异步通信的 一个重要指标。在嵌入式中，有众多的通信协议，往往从性能，成本，稳定性，易用性等角度考虑选择合。
STM32 基础系列教程 10 - 单线串口（半双工）
热门推荐
张十三的博客
04-03 1万+
前言 在工程应用中，很多时间为了方便走线会采用单线串口方案，本节将学习stm32 usart单线串口的使用，学会用使用单线串口收发数据。 示例详解 基于硬件平台： STM32F10C8T6最小系统板， MCU 的型号是STM32F103c8t6, 使用stm32cubemx 工具自动产生的配置工程，使用KEIL5编译代码。 本示例所用的最小系统板原理图： ...
stc8单片机 -使用Timer2模拟一个半双工串口-C和汇编.zip
02-25
半双工串口通信是指数据在同一时间内只能沿一个方向传输，例如RS-485或UART接口。在这种模式下，设备既可以发送数据也可以接收数据，但不能同时进行。模拟串口通常涉及到定时器的配置、中断处理以及数据的发送与接收...
stm32使用1个IO口模拟串口半双工通讯.rar
06-08
使用proteus8.9仿真实现两个stm32通过GPIO PA9实现单个GPIO实现串口的半双工收发，重新编译两个工程代码，仿真里面如果有连接PA10的话把PA10去掉。一个stm32发送按键再另一个stm32上面显示按键次数，另一个发送rtc...
MFC与PLC半双工串口通讯 项目实例 可直接使用 上下位机都有
08-08
总结来说，MFC与PLC的半双工串口通讯是一个涉及硬件接口、通信协议、软件编程等多个层面的综合技术问题。通过理解串口通信的基本原理，熟悉MFC的CAsyncSocket类，以及掌握PLC的编程，开发者能够构建出高效稳定的上下...
STM32F103单线半双工串口通信配置与测试
综上所述，通过精确配置STM32F103单片机的串口参数并实现严格的软件控制逻辑，可以成功地实现单线半双工串口通信。在实际应用中，工程师需要根据具体需求选择合适的通信模式，并通过测试来确保其可靠性。在现代电子...
软件模拟串口全双工 UART，可实现单线双向半双工通信，带按键处理
07-28
用51单片机写的一个单线半双工的模拟串口通信程序，同时支持两线全双工，目前只做了1位起始位，1、1.5、2位起始位，没做校验。上一个版本的代码已经用在产品上了，这个版本的还没怎么用过，就拿了块板子验证了一下，...
STM8 UART 半双工串口通信
09-06
STM8 串口通信模板 要实现的功能需要自己添加
STM32F103串口单线半双工通信_可用于Dynamixel舵机
07-24
基于STM32F103串口2的单线半双工收发，内嵌Dynamixel新版通信协议(protoco 2.0)，代码简单好用。
nrf24l01半双工通信代码
04-16
这段代码是一个基于基于51单片机的nrf24l01无线模块的简单通信程序。主函数的功能是初始化无线模块，设置接收模式，然后进入一个无限循环。在循环中，首先检测按键输入，如果按下了KEY1或KEY2，就发送相应的数据包。接着检测是否接收到数据包，如果接收到数据包，根据数据包的内容控制LED3和LED4的状态。 无线遥控系统：使用两个按键作为控制信号的发送端，通过SI24R1模块传输数据到接收端，从而控制LED灯或其他设备。 简单通信协议的实现：利用代码中定义的两个不同的数据包头（0x55和0xAA），可以在一对设备之间建立简单的指令或消息传递机制。 低功耗传感器网络：如果所用的单片机具备低功耗特性，该代码可以应用于需要长时间运行且电池供电的传感器网络中，用于控制设备的唤醒和休眠。 小型机器人或智能玩具：在这类应用中，代码可以用于处理无线遥控器的信号输入，并根据接收到的命令执行相应的动作。 工业控制系统：在工业环境中，可以用该代码作为无线控制节点的一部分，用来远程控制或监控设备状态。
【正点原子STM32】串口（数据通信、串行/并行，单工/半双工/全双工，同步/异步、ST MCU选型手册、串口数据发送接收过程、设置USART波特率、UART异步通信配置步骤、IO引脚复用功能）
咖喱年糕的博客
01-30 4348
数据通信 通信方式：串行/并行通信 传输方向：单工/半双工/全双工通信 同步方式：同步/异步通信 RS-232，CMOS，TTL，USB电平、CH340C ST MCU选型手册 时钟域和时钟源 串口数据发送接收过程 相关寄存器作用 设置USART波特率 USART/UART异步通信配置步骤 IO引脚复用功能 通过串口接收或者发送一个字符 串口源码接收或者发送一段字符串数据
UART，通信基础（并行串行，单工，全双工，半双工）
m0_72065741的博客
06-26 2408
Universal Asynchronous Receiver Transmitter 即通用异步收发器，是一种通用的串行、异步通信总线，该总线有两条数据线，可以实现全双工的发送和接收，在嵌入式系统中常用于主机与辅助设备之间的通信。
串口的同步和异步，全双工和半双工
congjiaoyan3682的博客
09-24 5898
同步：发送数据块给到另一端称之为同步，要求发送和接收方的时钟必须一致。 异步：不发送数据块，而是一个一个字符发送。 全双工：两端都能同时接收和发送。例如打电话。 半双工：两端只能接收或者发送，例如对讲机。 RS232串口为全双工模式。可在代码中设置同步或者异步。 RS485串口为半双工模式。干扰较大，需要接一个终端电阻。（最近端和最远端都要接）， RS485可以接成全双工模式，类似于RS422。 IO卡的输出为继电器类型，则一端接PLC的输入点，一端接一个PLC的地线，(0v),即导通就有信号， 开关量信号
串口单线半双工转换电路
刻[苦] 的 blog
05-02 3077
用来把单线半双工模式的串口转换成双线，然后才能连接到普通的双线USB 串口模块，比如CH340 之类的。。他在Arduino 上用软件模拟串口功能，利用这个电路，可以进一步减少串口占用的引脚，ARM 单片机一般都有硬件单线半双工模式，就不用折腾软件时序了，不过软件串口可以在所有IO 引脚上实现通信，某些情况下还是方便的。
ARM内核的USART单线半双工通信
m0_46429777的博客
07-14 727
开发过程中遇到一个问题，需要单线的串口协议。平时使用串口一直都是基本的全双工模式。查看手册才知道原来USART还支持单线的半双工通信方式，做个记录查漏补缺。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值