㈠ 如何用fpga做一个串口

你的意思是不是模拟串口通信的时序？
这里有代码，供你参考吧。
1. 顶层程序与仿真
（1）顶层程序
--文件名：top.vhd。
--功能：顶层映射。
--最后修改日期：2004.3.24。
library IEEE;
use IEEE.STD_LOGIC_1164.ALL;
use IEEE.STD_LOGIC_ARITH.ALL;
use IEEE.STD_LOGIC_UNSIGNED.ALL;
entity top is
Port (clk32mhz,reset,rxd,xmit_cmd_p_in:in std_logic; --总的输入输出信号的定义
rec_ready,txd_out,txd_done_out:out std_logic;
txdbuf_in:in std_logic_vector(7 downto 0); --待发送数据输入
rec_buf:out std_logic_vector(7 downto 0)); --接收数据缓冲
end top;
architecture Behavioral of top is

component reciever
Port (bclkr,resetr,rxdr:in std_logic;
r_ready:out std_logic;
rbuf:out std_logic_vector(7 downto 0));
end component;

component transfer
Port (bclkt,resett,xmit_cmd_p:in std_logic;
txdbuf:in std_logic_vector(7 downto 0);
txd:out std_logic;
txd_done:out std_logic);
end component;

component baud
Port (clk,resetb:in std_logic;
bclk:out std_logic);
end component;

signal b:std_logic;
begin
u1:baud port map(clk=>clk32mhz,resetb=>reset,bclk=>b); --顶层映射
u2:reciever port map(bclkr=>b,resetr=>reset,rxdr=>rxd,r_ready=>rec_ready,
rbuf=>rec_buf);
u3:transfer port map(bclkt=>b,resett=>reset,xmit_cmd_p=>xmit_cmd_p_in,
txdbuf=>txdbuf_in,txd=>txd_out,txd_done=>txd_done_out);
end Behavioral;
（2）程序仿真
仿真波形图如图8.8.5所示。

图8.8.5 仿真波形
2. 波特率发生器程序与仿真
（1）波特率发生器VHDL程序
--文件名：baud.vhd.
--功能：将外部输入的32MHz的信号分成频率为153600Hz的信号。
--最后修改日期：2004.3.24。
library IEEE;
use IEEE.STD_LOGIC_1164.ALL;
use IEEE.STD_LOGIC_ARITH.ALL;
use IEEE.STD_LOGIC_UNSIGNED.ALL;
entity baud is
Port (clk,resetb:in std_logic;
bclk:out std_logic);
end baud;
architecture Behavioral of baud is
begin
process(clk,resetb)
variable cnt:integer;
begin
if resetb='1' then cnt:=0; bclk<='0'; --复位
elsif rising_edge(clk) then
if cnt>=208 then cnt:=0; bclk<='1'; --设置分频系数
else cnt:=cnt+1; bclk<='0';
end if;
end if;
end process;
end Behavioral;
（2）程序仿真
仿真波形如图8.8.6所示。

图8.8.6 波特率发生器的仿真波形
3. UART发送器程序与仿真
（1）UART发送器VHDL程序
--文件名：transfer.vhd。
--功能：UART发送器。
--说明：系统由五个状态（x_idle,x_start,x_wait,x_shift,x_stop）和一个进程构成。
--最后修改日期：2004.3.24。
library IEEE;
use IEEE.STD_LOGIC_1164.ALL;
use IEEE.STD_LOGIC_ARITH.ALL;
use IEEE.STD_LOGIC_UNSIGNED.ALL;
entity transfer is
generic(framlent:integer:=8);
Port (bclkt,resett,xmit_cmd_p:in std_logic; --定义输入输出信号
txdbuf:in std_logic_vector(7 downto 0):="11001010";
txd:out std_logic;
txd_done:out std_logic);
end transfer;
architecture Behavioral of transfer is
type states is (x_idle,x_start,x_wait,x_shift,x_stop); --定义个子状态
signal state:states:=x_idle;
signal tcnt:integer:=0;
begin
process(bclkt,resett,xmit_cmd_p,txdbuf) --主控时序、组合进程
variable xcnt16:std_logic_vector(4 downto 0):="00000"; --定义中间变量
variable xbitcnt:integer:=0;
variable txds:std_logic;
begin
if resett='1' then state<=x_idle; txd_done<='0'; txds:='1'; --复位
elsif rising_edge(bclkt) then
case state is
when x_idle=> --状态1，等待数据帧发送命令
if xmit_cmd_p='1' then state<=x_start; txd_done<='0';
else state<=x_idle;
end if;
when x_start=> --状态2，发送信号至起始位
if xcnt16>="01111" then state<=x_wait; xcnt16:="00000";
else xcnt16:=xcnt16+1; txds:='0'; state<=x_start;
end if;
when x_wait=> --状态3，等待状态
if xcnt16>="01110" then
if xbitcnt=framlent then state<=x_stop; xbitcnt:=0;
else state<=x_shift;
end if;
xcnt16:="00000";
else xcnt16:=xcnt16+1; state<=x_wait;
end if;
when x_shift=>txds:=txdbuf(xbitcnt); xbitcnt:=xbitcnt+1; state<=x_wait; --状态4，将待发数据进行并串转换
when x_stop=> --状态5，停止位发送状态
if xcnt16>="01111" then
if xmit_cmd_p='0' then state<=x_idle; xcnt16:="00000";
else xcnt16:=xcnt16; state<=x_stop;
end if; txd_done<='1';
else xcnt16:=xcnt16+1; txds:='1'; state<=x_stop;
end if;
when others=>state<=x_idle;
end case;
end if;
txd<=txds;
end process;
end Behavioral;
UART发送器的仿真波形如图8.8.7所示。

图8.8.7 UART发送器的仿真波形
4. UART接收器程序与仿真
（1）UART接收器VHDL程序
--文件名：reciever.vhd。
--功能：UART接受器。
--说明：系统由五个状态（r_start,r_center,r_wait,r_sample,r_stop）和两个进程构成
--最后修改日期：2004.3.24。
library IEEE;
use IEEE.STD_LOGIC_1164.ALL;
use IEEE.STD_LOGIC_ARITH.ALL;
use IEEE.STD_LOGIC_UNSIGNED.ALL;
entity reciever is
generic(framlenr:integer:=8);
Port (bclkr,resetr,rxdr:in std_logic; --定义输入输出信号
r_ready:out std_logic;
rbuf:out std_logic_vector(7 downto 0));
end reciever;
architecture Behavioral of reciever is
type states is (r_start,r_center,r_wait,r_sample,r_stop); --定义各子状态
signal state:states:=r_start;
signal rxd_sync:std_logic;
begin
pro1:process(rxdr)
begin
if rxdr='0' then rxd_sync<='0';
else rxd_sync<='1';
end if;
end process;

pro2:process(bclkr,resetr,rxd_sync) --主控时序、组合进程
variable count:std_logic_vector(3 downto 0); --定义中间变量
variable rcnt:integer:=0;
variable rbufs:std_logic_vector(7 downto 0);
begin
if resetr='1' then state<=r_start; count:="0000"; --复位
elsif rising_edge(bclkr) then
case state is
when r_start=> --状态1，等待起始位
if rxd_sync='0' then state<=r_center; r_ready<='0'; rcnt:=0;
else state<=r_start; r_ready<='0';
end if;
when r_center=> --状态2，求出每位的中点
if rxd_sync='0' then
if count="0100" then state<=r_wait; count:="0000";
else count:=count+1; state<=r_center;
end if;
else state<=r_start;
end if;
when r_wait=> --状态3，等待状态
if count>="1110" then
if rcnt=framlenr then state<=r_stop;
else state<=r_sample;
end if;
count:="0000";
else count:=count+1; state<=r_wait;
end if;
when r_sample=>rbufs(rcnt):=rxd_sync; rcnt:=rcnt+1;state<=r_wait;
--状态4，数据位采样检测
when r_stop=>r_ready<='1'; rbuf<=rbufs; state<=r_start; --状态4，输出帧接收完毕信号
when others=>state<=r_start;
end case;
end if;
end process;
end Behavioral;

㈡ FPGA与电脑串口通信verilog程序

//本模块的功能是验证实现和PC机进行基本的串口通信的功能。需要在
//PC机上安装一个串口调试工具来验证程序的功能。
//程序实现了一个收发一帧10个bit（即无奇偶校验位）的串口控
//制器，10个bit是1位起始位，8个数据位，1个结束
//位。串口的波特律由程序中定义的div_par参数决定，更改该参数可以实
//现相应的波特率。程序当前设定的div_par 的值是0x145，对应的波特率是
//9600。用一个8倍波特率的时钟将发送或接受每一位bit的周期时间
//划分为8个时隙以使通信同步.
//程序的工作过程是：串口处于全双工工作状态，按动key1，FPGA向PC发送“21 EDA"
//字符串（串口调试工具设成按ASCII码接受方式）；PC可随时向FPGA发送0-F的十六进制
//数据，FPGA接受后显示在7段数码管上。
//视频教程适合我们21EDA电子的所有学习板
mole serial(clk,rst,rxd,txd,en,seg_data,key_input,lowbit);

input clk,rst;
input rxd;//串行数据接收端
input key_input;//按键输入

output[7:0] en;
output[7:0] seg_data;
reg[7:0] seg_data;
output txd;//串行数据发送端
output lowbit;

////////////////////inner reg////////////////////
reg[15:0] div_reg;//分频计数器，分频值由波特率决定。分频后得到频率8倍波特率的时钟
reg[2:0] div8_tras_reg;//该寄存器的计数值对应发送时当前位于的时隙数
reg[2:0] div8_rec_reg;//该寄存器的计数值对应接收时当前位于的时隙数
reg[3:0] state_tras;//发送状态寄存器
reg[3:0] state_rec;//接受状态寄存器
reg clkbaud_tras;//以波特率为频率的发送使能信号
reg clkbaud_rec;//以波特率为频率的接受使能信号
reg clkbaud8x;//以8倍波特率为频率的时钟，它的作用是将发送或接受一个bit的时钟周期分为8个时隙

reg recstart;//开始发送标志
reg recstart_tmp;

reg trasstart;//开始接受标志

reg rxd_reg1;//接收寄存器1
reg rxd_reg2;//接收寄存器2，因为接收数据为异步信号，故用两级缓存
reg txd_reg;//发送寄存器
reg[7:0] rxd_buf;//接受数据缓存
reg[7:0] txd_buf;//发送数据缓存

reg[2:0] send_state;//每次按键给PC发送"Welcome"字符串，这是发送状态寄存器
reg[19:0] cnt_delay;//延时去抖计数器
reg start_delaycnt;//开始延时计数标志
reg key_entry1,key_entry2;//确定有键按下标志

////////////////////////////////////////////////
parameter div_par=16'h145;//分频参数，其值由对应的波特率计算而得，按此参数分频的时钟频率是波倍特率的8
//倍，此处值对应9600的波特率，即分频出的时钟频率是9600*8 (CLK 50M)

////////////////////////////////////////////////
assign txd=txd_reg;
assign lowbit=0;

assign en=0;//7段数码管使能信号赋值

always@(posedge clk )
begin
if(!rst) begin
cnt_delay<=0;
start_delaycnt<=0;
end
else if(start_delaycnt) begin
if(cnt_delay!=20'd800000) begin
cnt_delay<=cnt_delay+1;
end
else begin
cnt_delay<=0;
start_delaycnt<=0;
end
end
else begin
if(!key_input&&cnt_delay==0)
start_delaycnt<=1;
end
end

always@(posedge clk)
begin
if(!rst)
key_entry1<=0;
else begin
if(key_entry2)
key_entry1<=0;
else if(cnt_delay==20'd800000) begin
if(!key_input)
key_entry1<=1;
end
end
end

always@(posedge clk )
begin
if(!rst)
div_reg<=0;
else begin
if(div_reg==div_par-1)
div_reg<=0;
else
div_reg<=div_reg+1;
end
end

always@(posedge clk)//分频得到8倍波特率的时钟
begin
if(!rst)
clkbaud8x<=0;
else if(div_reg==div_par-1)
clkbaud8x<=~clkbaud8x;
end

always@(posedge clkbaud8x or negedge rst)
begin
if(!rst)
div8_rec_reg<=0;
else if(recstart)//接收开始标志
div8_rec_reg<=div8_rec_reg+1;//接收开始后，时隙数在8倍波特率的时钟下加1循环
end

always@(posedge clkbaud8x or negedge rst)
begin
if(!rst)
div8_tras_reg<=0;
else if(trasstart)
div8_tras_reg<=div8_tras_reg+1;//发送开始后，时隙数在8倍波特率的时钟下加1循环
end

always@(div8_rec_reg)
begin
if(div8_rec_reg==7)
clkbaud_rec=1;//在第7个时隙，接收使能信号有效，将数据打入
else
clkbaud_rec=0;
end

always@(div8_tras_reg)
begin
if(div8_tras_reg==7)
clkbaud_tras=1;//在第7个时隙，发送使能信号有效，将数据发出
else
clkbaud_tras=0;
end

always@(posedge clkbaud8x or negedge rst)
begin
if(!rst) begin
txd_reg<=1;
trasstart<=0;
txd_buf<=0;
state_tras<=0;
send_state<=0;
key_entry2<=0;
end
else begin
if(!key_entry2) begin
if(key_entry1) begin
key_entry2<=1;
txd_buf<=8'd50; //"2"
end
end
else begin
case(state_tras)
4'b0000: begin //发送起始位
if(!trasstart&&send_state<7)
trasstart<=1;
else if(send_state<7) begin
if(clkbaud_tras) begin
txd_reg<=0;
state_tras<=state_tras+1;
end
end
else begin
key_entry2<=0;
state_tras<=0;
end
end
4'b0001: begin //发送第1位
if(clkbaud_tras) begin
txd_reg<=txd_buf[0];
txd_buf[6:0]<=txd_buf[7:1];
state_tras<=state_tras+1;
end
end
4'b0010: begin //发送第2位
if(clkbaud_tras) begin
txd_reg<=txd_buf[0];
txd_buf[6:0]<=txd_buf[7:1];
state_tras<=state_tras+1;
end
end
4'b0011: begin //发送第3位
if(clkbaud_tras) begin
txd_reg<=txd_buf[0];
txd_buf[6:0]<=txd_buf[7:1];
state_tras<=state_tras+1;
end
end
4'b0100: begin //发送第4位
if(clkbaud_tras) begin
txd_reg<=txd_buf[0];
txd_buf[6:0]<=txd_buf[7:1];
state_tras<=state_tras+1;
end
end
4'b0101: begin //发送第5位
if(clkbaud_tras) begin
txd_reg<=txd_buf[0];
txd_buf[6:0]<=txd_buf[7:1];
state_tras<=state_tras+1;
end
end
4'b0110: begin //发送第6位
if(clkbaud_tras) begin
txd_reg<=txd_buf[0];
txd_buf[6:0]<=txd_buf[7:1];
state_tras<=state_tras+1;
end
end
4'b0111: begin //发送第7位
if(clkbaud_tras) begin
txd_reg<=txd_buf[0];
txd_buf[6:0]<=txd_buf[7:1];
state_tras<=state_tras+1;
end
end
4'b1000: begin //发送第8位
if(clkbaud_tras) begin
txd_reg<=txd_buf[0];
txd_buf[6:0]<=txd_buf[7:1];
state_tras<=state_tras+1;
end
end
4'b1001: begin //发送停止位
if(clkbaud_tras) begin
txd_reg<=1;
txd_buf<=8'h55;
state_tras<=state_tras+1;
end
end
4'b1111:begin
if(clkbaud_tras) begin
state_tras<=state_tras+1;
send_state<=send_state+1;
trasstart<=0;
case(send_state)
3'b000:
txd_buf<=8'd49;//"1"
3'b001:
txd_buf<=8'd32;//" "
3'b010:
txd_buf<=8'd69;//"E"
3'b011:
txd_buf<=8'd68;//"D"
3'b100:
txd_buf<=8'd65;//"A"
3'b101:
txd_buf<=8'd10;//"e"
default:
txd_buf<=0;
endcase
end
end
default: begin
if(clkbaud_tras) begin
state_tras<=state_tras+1;
trasstart<=1;
end
end
endcase
end
end
end

always@(posedge clkbaud8x or negedge rst)//接受PC机的数据
begin
if(!rst) begin
rxd_reg1<=0;
rxd_reg2<=0;
rxd_buf<=0;
state_rec<=0;
recstart<=0;
recstart_tmp<=0;
end
else begin
rxd_reg1<=rxd;
rxd_reg2<=rxd_reg1;
if(state_rec==0) begin
if(recstart_tmp==1) begin
recstart<=1;
recstart_tmp<=0;
state_rec<=state_rec+1;
end
else if(!rxd_reg1&&rxd_reg2) //检测到起始位的下降沿，进入接受状态
recstart_tmp<=1;
end
else if(state_rec>=1&&state_rec<=8) begin
if(clkbaud_rec) begin
rxd_buf[7]<=rxd_reg2;
rxd_buf[6:0]<=rxd_buf[7:1];
state_rec<=state_rec+1;
end
end
else if(state_rec==9) begin
if(clkbaud_rec) begin
state_rec<=0;
recstart<=0;
end
end
end
end

always@(rxd_buf) //将接受的数据用数码管显示出来
begin
case (rxd_buf)
8'h30:
seg_data=8'b11000000;
8'h31:
seg_data=8'b11111001;
8'h32:
seg_data=8'b10100100;
8'h33:
seg_data=8'b10110000;
8'h34:
seg_data=8'b10011001;
8'h35:
seg_data=8'b10010011;
8'h36:
seg_data=8'b10000010;
8'h37:
seg_data=8'b11111000;
8'h38:
seg_data=8'b10000000;
8'h39:
seg_data=8'b10010000;
8'h41:
seg_data=8'b00010001;
8'h42:
seg_data=8'b11000001;
8'h43:
seg_data=8'b0110_0011;
8'h44:
seg_data=8'b1000_0101;
8'h45:
seg_data=8'b0110_0001;
8'h46:
seg_data=8'b0111_0001;
default:
seg_data=8'b1111_1111;
endcase
end

endmole

㈢ FPGA做串口通信，波特率自适应怎么编程

首先，从技术上的必要性上该技术可分为两类：
一、接收端工作频率固定，使用典型波特率通讯。程序员比较喜欢这种情况，无论是测量计算还是比对查表，都相对简单。
然后，从技术实现方式的方式上也可分为两类：
一、具有独立的同步字符。使用串行通讯时，要先进行同步操作，即接收端通过对比接收到的字符与同步字符的差异调整波特率，或者通过定时器测量同步字符的位宽计算波特率。
二、没有独立的同步字符。即不管波特率如何，可以直接通讯。这里面通常又有两种情况。1、通讯命令开始字符固定，比如一些短消息模块使用AT指令集，每条指令都是以AT开始的，这样虽然是命令但是有同步的作用，只不过要求必须在真实命令到来前调整波特率，判断必须快速准确。2、随机字符可以同步波特率，这种方法在周立功的文章里有描述。这种情况，其实也是有限制的：即字符最后一位必须是0，且同步字符只能是独立的字符，不能有连发字符。
没有一种方法是万能的，各种方法都有自己的使用范围。应该说字符比对比较简单，速度快但适用范围小，容易中断化处理；定时器测量比较麻烦，但适用范围差，必须主程序处理。像短消息模块那种没有独立同步字符的设计支持的波特率通常是有限的。
在此理论的指导下，我认为具体程序编制可参考以下两种：
1、 RC震荡时钟源，主程序检测IO口—RXD,使用定时器计算波特率。细分可考虑a、使用同步字符，b、使用任意ASCII码。
2、 固定频率时钟源、仅支持有限典型波特率。细分可考虑a、反复使用同步字符，扩大支持波特率范围；b、迅速比对支持无同步命令