devbox
羊村懒王
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

FPGA与stm32实现串口通信（stm32发，FPGA收）_stm32 fpga

作者：羊村懒王 | 2024-04-20 06:27:40

赞

踩

stm32 fpga

要使用FPGA与STM32实现串口通信，以下是一般的步骤：

  1. 配置STM32的串口模块：使用STM32的库函数或者寄存器配置，选择一个可用的串口模块（例如USART1、USART2等）并设置相应的波特率、数据位、停止位等参数。确保STM32串口的引脚与FPGA连接正确。

  2. 配置FPGA与STM32之间的通信接口：确定FPGA与STM32之间的通信接口，通常使用串口通信需要至少两个信号线：一个用于发送数据（TX），一个用于接收数据（RX）。确保FPGA的引脚与STM32的串口引脚相连。

  3. 在FPGA中实现串口通信接口：使用HDL（硬件描述语言，如Verilog或VHDL）编写FPGA逻辑，实现串口通信接口。这包括发送和接收数据的逻辑，以及与STM32的串口模块进行数据交换的逻辑。

  4. 在STM32中编写串口通信代码：使用STM32的开发环境（如Keil或STM32CubeIDE）编写串口通信的代码。这包括配置STM32串口模块、发送和接收数据的代码。

  5. 在FPGA中进行数据的发送和接收：通过FPGA的串口通信接口将数据发送到STM32，或从STM32接收数据。确保数据的格式和协议在FPGA和STM32之间匹配。

  6. 在STM32中进行数据的发送和接收：使用STM32的串口通信代码，接收来自FPGA的数据或将数据发送到FPGA。确保STM32的串口配置与FPGA的串口配置匹配。

  7. 测试与调试：使用示波器或串口调试工具监视串口数据的发送和接收。检查数据的准确性和完整性，并进行必要的调试和修复。

需要注意的是，FPGA和STM32之间的串口通信需要确保数据格式、波特率等参数的一致性。另外，还需要关注引脚连接和信号电平的匹配，以确保正确的数据传输。具体的实现细节和代码编写可能因具体的FPGA型号和STM32型号而有所不同，你可以参考相关的开发文档和例程来帮助你完成串口通信的实现。

       以下为本人做无人船时使用的FPGA与stm32串口通信过程。

       首先为FPGA输出PWM波控制两个电机的过程：

  1. //FPGA 控制舵机程序（verilog）
  2. module pwm_gen(
  3.  
  4. input nreset,
  5. input clk,
  6. input en,//1
  7.  
  8. input [31:0] period,
  9. input [31:0] h_time,
  10.  
  11. output reg pwm
  12.  
  13. );
  14.  
  15. reg [31:0] CNT;
  16.  
  17. always @ (posedge clk)
  18. begin
  19. 	if(nreset)
  20. 		CNT <= 0;
  21. 	else if(CNT >= period - 1 )
  22. 		CNT <= 0;
  23. 	else
  24. 		CNT <= CNT + 1;
  25. end
  26.  
  27. always @ (posedge clk)
  28. begin
  29. 	if(nreset)
  30. 		pwm <= 0;
  31.     else    //nreset = 1
  32.     begin
  33.         if(en == 0)
  34.             pwm <= 0;
  35.         else    //en = 1
  36.         begin
  37.             if(CNT <= h_time - 1)
  38.                 pwm <= 1;
  39.             else
  40.                 pwm <= 0;
  41.         end
  42.     end
  43. end
  44.  
  45. endmodule 
  46. //125M 20M
  47. //例化可控制三个舵机
  48. module PWM1(clk,nreset,uart_rxd,pwm3,pwm4);
  49. 	input clk;
  50. 	input nreset;
  51. 	input uart_rxd;
  52. 	output pwm3;//[2:0]
  53. 	output pwm4;//[2:0]
  54. 	//reg pwm2;
  55. 	
  56. 	wire [31:0]left0;
  57. 	wire [31:0]right0;
  58. 	wire clkp0;
  59. wire uart_rx_done;		
  60. wire uart_rx_data;
  61. wire locked;
  62.  
  63.  pwm_gen a1(
  64.  .nreset(nreset),
  65.  .clk(clk),
  66.  .en(1),
  67.  .period(2500000),
  68.  .h_time(left0),
  69.  .pwm(pwm3)
  70.  );  
  71.   pwm_gen a2(
  72.  .nreset(nreset),
  73.  .clk(clk),
  74.  .en(1),
  75.  .period(2500000),
  76.  .h_time(right0),
  77.  .pwm(pwm4)
  78.  );  
  79. //  pwm_gen a2(nreset,clk,1,2500000,right0,pwm4);  //125000  250000
  80. // pwm_gen a2(clk,nreset,1,2500000,1500_000,pwm3[1]);  
  81. // pwm_gen a3(clk,nreset,1,2500000,2000_000,pwm3[2]);  
  82.  
  83.  
  84. //例化被测试的接收模块
  85. //uart_rx #(
  86. //	.BPS			(9600),		//波特率9600
  87. //	.SYS_CLK_FRE	(50_000_000)//时钟频率50M	
  88. //)
  89.  
  90. uart_rx u_uart_rx (
  91. 	.sys_clk		(clkp0),			
  92. 	.sys_rst_n		(sys_rst_n),			
  93. 	.uart_rxd		(uart_rxd),			
  94. 	.uart_rx_done	(uart_rx_done),		
  95. 	.uart_rx_data	(uart_rx_data)	,
  96. 	.left(left0),
  97. 	.right(right0)
  98. );
  99.  clk_wiz_0 uu0
  100.  (
  101.   // Clock out ports
  102. .clk_out1(clkp0),
  103.  .reset(nreset),
  104. .locked(),
  105.  // Clock in ports
  106.  .clk_in1(clk)
  107.  );
  108.  // 1000 2000
  109. //1000_000  1500_000 2000_000
  110. endmodule

      其次建立FPGA的uart模块：

  1. //`timescale 1ns / 1ps
  2. //
  3. // Company: 
  4. // Engineer: 
  5. // 
  6. // Create Date: 2023/06/16 18:08:02
  7. // Design Name: 
  8. // Module Name: uart
  9. // Project Name: 
  10. // Target Devices: 
  11. // Tool Versions: 
  12. // Description: 
  13. // 
  14. // Dependencies: 
  15. // 
  16. // Revision:
  17. // Revision 0.01 - File Created
  18. // Additional Comments:
  19. // 
  20. //
  21.  
  22.  
  23. module uart_rx(
  24. 	input 			sys_clk,			//50M系统时钟
  25. 	input 			sys_rst_n,			//系统复位
  26. 	input 			uart_rxd,			//接收数据线
  27. 	output reg 		uart_rx_done,		//数据接收完成标志
  28. 	output reg [7:0]uart_rx_data,		//接收到的数据
  29. 	output reg 	[31:0]	left,		//数据接收完成标志
  30. 	output reg 	[31:0]	right		//数据接收完成标志
  31. );
  32. //常量化波特率，可更改
  33. parameter	BPS=115200;					//波特率9600bps，可更改
  34. parameter	SYS_CLK_FRE=50_000_000;		//50M系统时钟
  35. localparam	BPS_CNT=SYS_CLK_FRE/BPS;	//传输一位数据所需要的时钟个数
  36.  
  37. reg 			uart_rx_d0;		//寄存1拍
  38. reg 			uart_rx_d1;		//寄存2拍
  39. reg [15:0]		clk_cnt;				//时钟计数器
  40. reg [3:0]		rx_cnt;					//接收计数器
  41. reg 			rx_flag;				//接收标志位
  42. reg [7:0]		uart_rx_data_reg;		//数据寄存
  43. reg [3:0] cnt_dj;//电机PWM值计数	
  44. reg [31:0] count0 = 10'd100;
  45. wire 			neg_uart_rx_data;		//数据的下降沿
  46. reg [31:0] lefft; 
  47. reg [31:0] lefft1; 
  48. assign	neg_uart_rx_data=uart_rx_d1 & (~uart_rx_d0);  //捕获数据线的下降沿，用来标志数据传输开始
  49. //将数据线打两拍，作用1：同步不同时钟域信号，防止亚稳态；作用2：用以捕获下降沿
  50. always@(posedge sys_clk or negedge sys_rst_n)begin
  51. 	if(sys_rst_n)begin
  52. 		uart_rx_d0<=1'b0;
  53. 		uart_rx_d1<=1'b0;
  54. 	end
  55. 	else begin
  56. 		uart_rx_d0<=uart_rxd;
  57. 		uart_rx_d1<=uart_rx_d0;
  58. 	end		
  59. end
  60. //捕获到数据下降沿（起始位0）后，拉高传输开始标志位，并在第9个数据（终止位）的传输过程正中（数据比较稳定）再将传输开始标志位拉低，标志传输结束
  61. always@(posedge sys_clk or negedge sys_rst_n)begin
  62. 	if(sys_rst_n)
  63. 		rx_flag<=1'b0;
  64. 	else begin 
  65. 		if(neg_uart_rx_data)
  66. 			rx_flag<=1'b1;
  67. 		else if((rx_cnt==4'd9)&&(clk_cnt==BPS_CNT/2))//在第9个数据（终止位）的传输过程正中（数据比较稳定）再将传输开始标志位拉低，标志传输结束
  68. 			rx_flag<=1'b0;
  69. 		else 
  70. 			rx_flag<=rx_flag;			
  71. 	end
  72. end
  73. //时钟每计数一个BPS_CNT（传输一位数据所需要的时钟个数），即将数据计数器加1，并清零时钟计数器
  74. always@(posedge sys_clk or negedge sys_rst_n)begin
  75. 	if(sys_rst_n)begin
  76. 		rx_cnt<=4'd0;
  77. 		clk_cnt<=16'd0;
  78. 	end
  79. 	else if(rx_flag)begin
  80. 		if(clk_cnt<BPS_CNT-1'b1)begin
  81. 			clk_cnt<=clk_cnt+1'b1;
  82. 			rx_cnt<=rx_cnt;
  83. 		end
  84. 		else begin
  85. 			clk_cnt<=16'd0;
  86. 			rx_cnt<=rx_cnt+1'b1;
  87. 		end
  88. 	end
  89. 	else begin
  90. 		rx_cnt<=4'd0;
  91. 		clk_cnt<=16'd0;
  92. 	end		
  93. end
  94. //在每个数据的传输过程正中（数据比较稳定）将数据线上的数据赋值给数据寄存器
  95. always@(posedge sys_clk or negedge sys_rst_n)begin
  96. 	if(sys_rst_n)
  97. 		uart_rx_data_reg<=8'd0;
  98. 	else if(rx_flag)
  99. 		if(clk_cnt==BPS_CNT/2) begin
  100. 			case(rx_cnt)			
  101. 				4'd1:uart_rx_data_reg[0]<=uart_rxd;
  102. 				4'd2:uart_rx_data_reg[1]<=uart_rxd;
  103. 				4'd3:uart_rx_data_reg[2]<=uart_rxd;
  104. 				4'd4:uart_rx_data_reg[3]<=uart_rxd;
  105. 				4'd5:uart_rx_data_reg[4]<=uart_rxd;
  106. 				4'd6:uart_rx_data_reg[5]<=uart_rxd;
  107. 				4'd7:uart_rx_data_reg[6]<=uart_rxd;
  108. 				4'd8:uart_rx_data_reg[7]<=uart_rxd;
  109. 				default:;
  110. 			endcase
  111. 		end
  112. 		else
  113. 			uart_rx_data_reg<=uart_rx_data_reg;
  114. 	else
  115. 		uart_rx_data_reg<=8'd0;
  116. end	
  117. //当数据传输到终止位时，拉高传输完成标志位，并将数据输出
  118. always@(posedge sys_clk or negedge sys_rst_n)begin
  119. if(sys_rst_n)
  120. begin
  121. 		uart_rx_done=1'b0;
  122. 		left=32'd125000;
  123. 		lefft=32'd0;
  124. 		lefft1=32'd0;
  125. 		right=32'd0;
  126. 		cnt_dj=4'd0;
  127. 		uart_rx_data=8'd0;
  128. end	
  129. else if(rx_cnt==4'd9)
  130. begin//接收完判断
  131. 		uart_rx_done=1'b1;
  132. 		uart_rx_data=uart_rx_data_reg;
  133. //		rx_cnt<=4'd0;
  135. 		if(uart_rx_data==16'hFF &&cnt_dj==4'd0)
  136. 		begin
  137. 		  cnt_dj=4'd1;
  138. 		  uart_rx_data=8'd0;
  139. 		  left=32'd0;
  140. 		  right=32'd0;
  141. 		end
  142.         else if(uart_rx_data!=16'hFF &&cnt_dj==4'd1)
  143.         begin
  144.               left=uart_rx_data*count0;
  145.               cnt_dj=4'd2;
  146. 		end
  147. 		else if(uart_rx_data==16'hFE &&cnt_dj==4'd2)
  148. 		begin
  149. 		  cnt_dj=4'd3;
  150. 		  uart_rx_data=8'd0;
  151. 		end
  152. 		else if(uart_rx_data!=16'hFE &&cnt_dj==4'd3)
  153.         begin
  154.               left=left+uart_rx_data;
  155.               left=left*10'd125;
  156.               cnt_dj=4'd4;
  157. 		end
  158. 		else if(uart_rx_data==16'hFD &&cnt_dj==4'd4)
  159.         begin
  160. 		  cnt_dj=4'd5;
  161. 		  uart_rx_data=8'd0;
  162. 		end
  163. 		else if(uart_rx_data!=16'hFD &&cnt_dj==4'd5)
  164.         begin
  165.               right=uart_rx_data*count0;
  166.               cnt_dj=4'd6;
  167. 		end
  168. 		else if(uart_rx_data==16'hFC &&cnt_dj==4'd6)
  169.         begin
  170. 		  cnt_dj=4'd7;
  171. 		  uart_rx_data=8'd0;
  172. 		end	
  173. 		else if(uart_rx_data!=16'hFC &&cnt_dj==4'd7)
  174.         begin
  175.               right=right+uart_rx_data;
  176.               right=right*10'd125;
  177.               cnt_dj=4'd0;
  178. 		end
  179. end		
  180. else 
  181. begin
  182. 		uart_rx_done<=1'b0;
  183. 		uart_rx_data=8'd0;
  184. end
  185. end
  186. endmodule
  188. //	if(uart_rx_data==16'hFF &&cnt_dj==4'd0)
  189. //		begin
  190. //		  cnt_dj=4'd1;
  191. //		  uart_rx_data=8'd0;
  192. //		  left=32'd0;
  193. //		  right=32'd0;
  194. //		end
  195. //        else if(uart_rx_data!=16'hFF)
  196. //        begin
  197. //            if(cnt_dj==4'd4)
  198. //            begin
  199. //              right=right+uart_rx_data;
  200. //              cnt_dj=4'd0;
  201. //            end
  202. //            if(cnt_dj==4'd3)
  203. //            begin
  204. //              right=uart_rx_data*100;
  205. //              cnt_dj=4'd4;
  206. //            end
  207. //            if(cnt_dj==4'd2)
  208. //            begin
  209. //              left=left+uart_rx_data;
  210. //              lefft1=left;
  211. //              cnt_dj=4'd3;
  212. //            end
  213. //            if(cnt_dj==4'd1)
  214. //            begin
  215. //              left=uart_rx_data*count0;
  216. //              lefft<=left;
  217. //              cnt_dj=4'd2;
  218. //            end
  219. //		end
  220.

       由于两模块间需要进行分频处理，将125MHZ分成50MHZ，我们采用vivado自带的IP核进行分频处理，具体步骤如下图所示：

       仿真模块如下所示：

  1. `timescale 1ns/1ps
  2. //module tb;
  3. //  reg sys_clk;
  4. //  reg sys_rst_n;
  5. //  wire PWMA_H, PWMA_L, PWMB_H, PWMB_L, PWMC_H, PWMC_L;
  6.  
  7. //  // Reset generation
  8. //  initial begin
  9. //    sys_rst_n = 0;
  10. //    sys_clk=0;
  11. //    #10;
  12. //    sys_rst_n = 1;
  13. //    #100;
  14. //    $finish; // End simulation after some time
  15. //  end
  16.  
  17. //  // Clock generation
  18. //  always #5 sys_clk = ~sys_clk;
  19.  
  20. //  // Testbench logic
  21. //  reg clk_counter = 0;
  22.  
  23. //  // Instantiate the PWM module
  24. //PWM1 a4(sys_clk,sys_rst_n,PWMA_H);
  25.  
  26. //  always @(posedge sys_clk) begin
  27. //    if (sys_rst_n) begin
  28. //      clk_counter <= clk_counter + 1;
  29.  
  30. //      // Read PWM output signals
  31. //      $display("Time: %t, PWMA_H: %b, PWMA_L: %b, PWMB_H: %b, PWMB_L: %b, PWMC_H: %b, PWMC_L: %b",
  32. //        $time, PWMA_H, PWMA_L, PWMB_H, PWMB_L, PWMC_H, PWMC_L);
  33.  
  34. //      // Add your testbench assertions or other test logic here
  35.  
  36. //      // Stop simulation after a certain number of clock cycles
  37. //      if (clk_counter == 1000)
  38. //        $finish;
  39. //    end
  40. //  end
  41.  
  42. //endmodule
  43.  
  44.  
  45. //模块、接口定义
  46. module uart_rx_tb();
  47. reg sys_clk;			
  48. reg sys_rst_n;			
  49. reg uart_rxd;
  50. wire locked;
  51. wire clkp0;
  52.   wire PWMA_H;
  53. wire uart_rx_done;		
  54. wire uart_rx_data;
  55. wire pwm3;		
  56. wire pwm4;
  57. wire [31:0] left0;		
  58. wire [31:0] right0;
  59.  pwm_gen a1(sys_rst_n,sys_clk,1,2000000,left0,pwm3);  
  60.   pwm_gen a2(sys_rst_n,sys_clk,1,2000000,right0,pwm4);  
  61. //例化被测试的接收模块
  62. uart_rx #(
  63. 	.BPS			(9600),		//波特率9600
  64. 	.SYS_CLK_FRE	(50_000_000)//时钟频率50M	
  65. )
  66. u_uart_rx(
  67. 	.sys_clk		(clkp0),			
  68. 	.sys_rst_n		(sys_rst_n),			
  69. 	.uart_rxd		(uart_rxd),			
  70. 	.uart_rx_done	(uart_rx_done),		
  71. 	.uart_rx_data	(uart_rx_data),
  72. 		.left(left0),
  73. 	.right(right0)
  74. );
  75.  clk_wiz_1 uu1
  76.  (
  77.   // Clock out ports
  78. .clk_out1(clkp0),
  79.  .reset(sys_rst_n),
  80. .locked(locked),
  81.  // Clock in ports
  82.  .clk_in1(sys_clk)
  83.  );
  84.  
  85. // PWM1 a4(sys_clk,sys_rst_n,PWMA_H);
  86. localparam	CNT=50_000_000/9600*20;	//计算出传输每个时钟所需要的时间
  87. initial begin	//传输8位数据	8'b01010101
  88. 	//初始时刻定义
  89. 		sys_clk	<=1'b0;	
  90. 		sys_rst_n<=1'b0;		
  91. 		uart_rxd<=1'b1;
  92. 	#20 //系统开始工作
  93. 		sys_rst_n<=1'b1;
  94. 			#20 //系统开始工作
  95. 		sys_rst_n<=1'b0;
  96. 	#(CNT/2)	
  97. 		uart_rxd<=1'b0;//开始传输起始位
  98. 	#CNT		
  99. 		uart_rxd<=1'b1;//传输最低位，第1位
  100. 	#CNT		
  101. 		uart_rxd<=1'b0;//传输第2位
  102. 	#CNT		
  103. 		uart_rxd<=1'b1;//传输第3位
  104. 	#CNT		
  105. 		uart_rxd<=1'b0;	//传输第4位
  106. 	#CNT		
  107. 		uart_rxd<=1'b1;//传输第5位
  108. 	#CNT		
  109. 		uart_rxd<=1'b0;//传输第6位
  110. 	#CNT		
  111. 		uart_rxd<=1'b1;//传输第7位
  112. 	#CNT		
  113. 		uart_rxd<=1'b0;	//传输最高位，第8位
  114. 	#CNT		
  115. 		uart_rxd<=1'b1;	//传输终止位
  116. 	//FF	
  117. 	#(CNT/2)	
  118. 		uart_rxd<=1'b1;//开始传输起始位
  119. 	#(CNT/2)	
  120. 		uart_rxd<=1'b0;//开始传输起始位
  121. 	#CNT		
  122. 		uart_rxd<=1'b1;//传输最低位，第1位
  123. 	#CNT		
  124. 		uart_rxd<=1'b1;//传输第2位
  125. 	#CNT		
  126. 		uart_rxd<=1'b1;//传输第3位
  127. 	#CNT		
  128. 		uart_rxd<=1'b1;	//传输第4位
  129. 	#CNT		
  130. 		uart_rxd<=1'b1;//传输第5位
  131. 	#CNT		
  132. 		uart_rxd<=1'b1;//传输第6位
  133. 	#CNT		
  134. 		uart_rxd<=1'b1;//传输第7位
  135. 	#CNT		
  136. 		uart_rxd<=1'b1;	//传输最高位，第8位
  137. 	#CNT		
  138. 		uart_rxd<=1'b1;	//传输终止位
  139. 		// 左右电机的数
  140. 	#(CNT/2)	
  141. 		uart_rxd<=1'b1;//开始传输起始位
  142. 	#(CNT/2)	
  143. 		uart_rxd<=1'b0;//开始传输起始位
  144. 	#CNT		
  145. 		uart_rxd<=1'b0;//传输最低位，第1位
  146. 	#CNT		
  147. 		uart_rxd<=1'b1;//传输第2位
  148. 	#CNT		
  149. 		uart_rxd<=1'b0;//传输第3位
  150. 	#CNT		
  151. 		uart_rxd<=1'b1;	//传输第4位
  152. 	#CNT		
  153. 		uart_rxd<=1'b0;//传输第5位
  154. 	#CNT		
  155. 		uart_rxd<=1'b0;//传输第6位
  156. 	#CNT		
  157. 		uart_rxd<=1'b0;//传输第7位
  158. 	#CNT		
  159. 		uart_rxd<=1'b0;	//传输最高位，第8位
  160. 	#CNT		
  161. 		uart_rxd<=1'b1;	//传输终止位
  162. 		//FE	
  163. 	#(CNT/2)	
  164. 		uart_rxd<=1'b1;//开始传输起始位
  165. 	#(CNT/2)	
  166. 		uart_rxd<=1'b0;//开始传输起始位
  167. 	#CNT		
  168. 		uart_rxd<=1'b0;//传输最低位，第1位
  169. 	#CNT		
  170. 		uart_rxd<=1'b1;//传输第2位
  171. 	#CNT		
  172. 		uart_rxd<=1'b1;//传输第3位
  173. 	#CNT		
  174. 		uart_rxd<=1'b1;	//传输第4位
  175. 	#CNT		
  176. 		uart_rxd<=1'b1;//传输第5位
  177. 	#CNT		
  178. 		uart_rxd<=1'b1;//传输第6位
  179. 	#CNT		
  180. 		uart_rxd<=1'b1;//传输第7位
  181. 	#CNT		
  182. 		uart_rxd<=1'b1;	//传输最高位，第8位
  183. 	#CNT		
  184. 		uart_rxd<=1'b1;	//传输终止位
  185. 			#(CNT)	//00
  186. 	#(CNT/2)	
  187. 		uart_rxd<=1'b1;//开始传输起始位
  188. 	#(CNT/2)	
  189. 		uart_rxd<=1'b0;//开始传输起始位
  190. 	#CNT		
  191. 		uart_rxd<=1'b0;//传输最低位，第1位
  192. 	#CNT		
  193. 		uart_rxd<=1'b0;//传输第2位
  194. 	#CNT		
  195. 		uart_rxd<=1'b0;//传输第3位
  196. 	#CNT		
  197. 		uart_rxd<=1'b0;	//传输第4位
  198. 	#CNT		
  199. 		uart_rxd<=1'b0;//传输第5位
  200. 	#CNT		
  201. 		uart_rxd<=1'b0;//传输第6位
  202. 	#CNT		
  203. 		uart_rxd<=1'b0;//传输第7位
  204. 	#CNT		
  205. 		uart_rxd<=1'b0;	//传输最高位，第8位
  206. 	#CNT		
  207. 		uart_rxd<=1'b1;	//传输终止位
  208. 	//FD	
  209. 	#(CNT/2)	
  210. 		uart_rxd<=1'b1;//开始传输起始位
  211. 	#(CNT/2)	
  212. 		uart_rxd<=1'b0;//开始传输起始位
  213. 	#CNT		
  214. 		uart_rxd<=1'b1;//传输最低位，第1位
  215. 	#CNT		
  216. 		uart_rxd<=1'b0;//传输第2位
  217. 	#CNT		
  218. 		uart_rxd<=1'b1;//传输第3位
  219. 	#CNT		
  220. 		uart_rxd<=1'b1;	//传输第4位
  221. 	#CNT		
  222. 		uart_rxd<=1'b1;//传输第5位
  223. 	#CNT		
  224. 		uart_rxd<=1'b1;//传输第6位
  225. 	#CNT		
  226. 		uart_rxd<=1'b1;//传输第7位
  227. 	#CNT		
  228. 		uart_rxd<=1'b1;	//传输最高位，第8位
  229. 	#CNT		
  230. 		uart_rxd<=1'b1;	//传输终止位
  231. 		//右
  232. 	#(CNT/2)	
  233. 		uart_rxd<=1'b1;//开始传输起始位
  234. 	#(CNT/2)	
  235. 		uart_rxd<=1'b0;//开始传输起始位
  236. 	#CNT		
  237. 		uart_rxd<=1'b0;//传输最低位，第1位
  238. 	#CNT		
  239. 		uart_rxd<=1'b0;//传输第2位
  240. 	#CNT		
  241. 		uart_rxd<=1'b1;//传输第3位
  242. 	#CNT		
  243. 		uart_rxd<=1'b0;	//传输第4位
  244. 	#CNT		
  245. 		uart_rxd<=1'b1;//传输第5位
  246. 	#CNT		
  247. 		uart_rxd<=1'b0;//传输第6位
  248. 	#CNT		
  249. 		uart_rxd<=1'b0;//传输第7位
  250. 	#CNT		
  251. 		uart_rxd<=1'b0;	//传输最高位，第8位
  252. 	#CNT		
  253. 		uart_rxd<=1'b1;	//传输终止位
  254. 	//FC	
  255. 	#(CNT/2)	
  256. 		uart_rxd<=1'b1;//开始传输起始位
  257. 	#(CNT/2)	
  258. 		uart_rxd<=1'b0;//开始传输起始位
  259. 	#CNT		
  260. 		uart_rxd<=1'b0;//传输最低位，第1位
  261. 	#CNT		
  262. 		uart_rxd<=1'b0;//传输第2位
  263. 	#CNT		
  264. 		uart_rxd<=1'b1;//传输第3位
  265. 	#CNT		
  266. 		uart_rxd<=1'b1;	//传输第4位
  267. 	#CNT		
  268. 		uart_rxd<=1'b1;//传输第5位
  269. 	#CNT		
  270. 		uart_rxd<=1'b1;//传输第6位
  271. 	#CNT		
  272. 		uart_rxd<=1'b1;//传输第7位
  273. 	#CNT		
  274. 		uart_rxd<=1'b1;	//传输最高位，第8位
  275. 	#CNT		
  276. 		uart_rxd<=1'b1;	//传输终止位
  277. 		//00
  278. 	#(CNT/2)	
  279. 		uart_rxd<=1'b1;//开始传输起始位
  280. 	#(CNT/2)	
  281. 		uart_rxd<=1'b0;//开始传输起始位
  282. 	#CNT		
  283. 		uart_rxd<=1'b0;//传输最低位，第1位
  284. 	#CNT		
  285. 		uart_rxd<=1'b0;//传输第2位
  286. 	#CNT		
  287. 		uart_rxd<=1'b0;//传输第3位
  288. 	#CNT		
  289. 		uart_rxd<=1'b0;	//传输第4位
  290. 	#CNT		
  291. 		uart_rxd<=1'b0;//传输第5位
  292. 	#CNT		
  293. 		uart_rxd<=1'b0;//传输第6位
  294. 	#CNT		
  295. 		uart_rxd<=1'b0;//传输第7位
  296. 	#CNT		
  297. 		uart_rxd<=1'b0;	//传输最高位，第8位
  298. 	#CNT		
  299. 		uart_rxd<=1'b1;	//传输终止位
  300. end
  301.  
  302. always begin
  303. 	#5	sys_clk=~sys_clk;	//时钟20ns,100M
  304. end
  305. // always begin
  306. //	#10	sys_clk=~sys_clk;	//时钟20ns,50M
  307. //end
  308. endmodule 
  309.

        以上便实现了FPGA的接收功能，此时FPGA可以接收FF--FE--FD--FC--的信号，其中--代表16进制数，FF后的16进制数乘100加FE后面的16进制数及为左电机的电机值，同理，FD后面的乘100加FC后面的为右电机的电机值，我们只需要在单片机上实现发送FF--FE--FD--FC--的信号的功能即可完成全部过程。 

       仿真图如下所示：

      从仿真可以看出实验非常成功，对应项目的无人船而言也十分成功。欢迎大家积极讨论留言！！！

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/羊村懒王/article/detail/455844
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号