2024嵌入式FPGA竞赛最佳创意奖-红外瞳孔追踪系统（教学向）

致谢

        特此感谢B站大磊FPGA的多目标帧差法视频，这是我写出这个作品的基础；我的老师刘宁，他给了我最初的灵感；我的队友hqy和zcy，他们是这个项目团队不可缺少的一环；CrazyBingo对于FPGA图像处理的贡献，我参考的很多代码都有他的影子。

前言 

        本人为南邮大三电科学生，技术有限，能获此殊荣噱头占比更多，算是用简单的逻辑实现了比较花哨的效果。不过FPGA代码都是我一行行敲出来的，除摄像头HDMI输出demo外未用IP核，除大磊FPGA多目标帧差外未参考其他代码。项目完成后成就感还是相当足的。这将近两个月的时间FPGA图像处理方面的编程思维开阔了不少，期望以后能更进一步。

        作品部分演示效果已在B站发布视频，期待一键三连加关注（づ￣3￣）づ╭❤️～
        

一、硬件基础（仅本项目使用，非必须）

易灵思Ti60F100，红外补光灯，VS-SC130GS（特制装载红外窄带滤波片摄像头），云台，眼球模型（开源项目），及部分3D打印支架等杂项。

二、系统框图及基本说明

        上图为设计主要模块或功能，本篇文章仅解释说明本人编写的关键模块。

        不同的厂家对摄像头基本上都会提供历程，也就是读写视频流这一步最终输出行、场同步，像素时钟，de，以及数据信号（需注意代码中行、场同步信号等是高有效还是低有效），这是基础不过多赘述，小白可看正点原子RGB-LCD彩条显示实验。

        该项目通过红外窄带滤波摄像头的得到的图像受自然光，灯光等外界干扰小，基本取决于人为的红外补光灯。由此，眼部因暗瞳效应产生的光斑极为明显，再通过一定的图像处理手段，可通过光斑定位深色瞳孔，从而捕获眼动方向。基本如下：

可控阈值二值化：对采集到的像素进行可控阈值二值化处理，以突出瞳孔等反射的亮斑。


多目标追踪定位：运用多目标追踪算法，定位并筛选出两个瞳孔亮斑的位置。


深色瞳孔提取：在瞳孔亮斑的一定相对位置处提取深色瞳孔，并进行目标追踪。


瞳孔坐标计算：得到瞳孔的坐标后，实时与参考点（眨眼或外部设定）对比，计算出眼球的                           方向。


实时画框叠加：FPGA 将获取到的相关坐标信息实时画框叠加到原始视频流中，通过 HDMI
                         接口输出实时的视频流。

三、主体模块说明

1.binarization

首先通过二值化，当亮度超过人为设定阈值之后将monoc拉高，作为信号触发目标追踪模块处理：

  1. module binarization
  2. (
  3.     input               clk          ,  
  4.     input               rst_n        ,   
  6.     input               ycbcr_vs     ,   
  7.     input               ycbcr_hs     ,   
  8.     input               ycbcr_de     ,   
  9.     input   [7:0]       luminance    ,      //pixel_data
  11.     output   reg        post_vs      ,   
  12.     output   reg        post_hs      ,  
  13.     output   reg        post_de      ,   
  14.     output   reg        monoc               // monochrome（1=white，0=black）
  15. );
  16.  
  17. reg    ycbcr_vs_d;
  18. reg    ycbcr_hs_d;
  19. reg    ycbcr_de_d;
  20.  
  21. wire  [7:0] try = 8'd220;     //threshold
  22.  
  23. //binarization
  24. always @(posedge clk or negedge rst_n) begin
  25.     if(!rst_n)
  26.         monoc <= 1'b0;
  27.     else if(ycbcr_vs)begin   
  28. 		if (luminance > try)  //threshold
  29. 			monoc <= 1'b1;
  30. 		else
  31. 			monoc <= 1'b0;
  32. 	end		
  33.     else
  34.         monoc <= 1'b0;
  35. end
  36.  
  37. //lag 1 clocks signal sync
  38. always@(posedge clk or negedge rst_n) begin
  39.     if(!rst_n) begin
  40.         post_vs <= 1'd0;
  41.         post_hs <= 1'd0;
  42.         post_de <= 1'd0;
  43.     end
  44.     else begin
  45.         post_vs <= ycbcr_vs;
  46.         post_hs <= ycbcr_hs;
  47.         post_de <= ycbcr_de;
  48.     end
  49. end
  50.  
  51. endmodule

2.VIP_multi_target_detect(⭐)

        此代码是我从大磊视频中的代码修改而来，下面我将简单讲解，想了解代码细节推荐点击之前给的链接看看原视频，大磊老师讲的非常详细形象。

        该模块用于获取 二值化得出的亮斑 的边界：target_pos_out，注意：边界由43位组成：{Flag,ymax[41:32],xmax[31:21],ymin[20:11],xmin[10:0]}Flag位为标志位，代表该边界是否有效，后续为下、右、上、左四个边界，所有操作在一帧内完成，也就是一个vs周期内。众所周知，人有两个眼睛，所以在一般情况下，二值化输出的是两个相隔一段距离的亮斑区域——白像素之间间隔在MIN_DIST以内的白像素集，MIN_DIST自由设定。该模块我就直接设定为输出两个亮斑边界。此处祭出本人帅照以示说明，箭头所指即为暗瞳效应产生的亮斑区域：

        首先，per_frame_clken 拉高后，每个时钟x_cnt自增，到达一行像素后，x_cnt清零，y_cnt自增，由此即对每个有效像素进行了坐标标记。

        再看130行处，通过投票机制判定二值化白像素是新的亮斑区域还是落在之前亮斑区域之内的像素。target_flag用于标记亮斑区域，当target_flag[0] == 0时，证明暂未出现亮斑区域；target_flag[1] == 0时，证明暂未出现第二个亮斑区域。[1:0]new_target_flag是两个投票箱，对应两个投票区域。打个比方，在一片1280*720平米的空地上，将要按照从左到右，从上到下的顺序一颗一颗栽种一种根系范围是方形的树，树占地1平米，根系占地4*MIN_DIST²米，树可能种活也可能死，且当一棵活树在另外一棵活树的根系范围之内时，二者根系结合形成一个种群，当栽种成功两个种群时即完成指标，剩下未在根系范围内的树不再考虑。活树——亮点，死树——暗点，种群——亮斑区域。

        此刻，可能有人问了：“你二值化代码这么简单，怎么保证亮点就是暗瞳效应产生的呢？有没有改进方法？”

        有的，兄弟，有的。我们先考虑相对常见的问题：摄像头坏点——腐蚀处理；红外光强过弱导致无亮斑——见下文；红外光强过强导致一大片亮斑——见下文；鼻尖反光干扰——模块从左到右，从上到下，抓取到两个亮斑区域即止，一般人鼻子在两个眼睛下方，是抓不到的；眼睛上方背景光源干扰——见下文。

        那么就有人要问了：“我有三只眼睛怎么办，你这垃圾代码不废了吗？有没有改进方法？”

        没有，兄弟，抱歉。本眼动作品暂不支持多人运动以及外星人。若急需请赞助经费，标注外星人，我将在后续开展外星人专属业务。

  1. module VIP_multi_target_detect
  2. (	
  3.     input 				clk,
  4.     input 				rst_n,
  6.     input 				per_frame_vsync,
  7.     input 				per_frame_hs,
  8.     input 				per_frame_clken,
  9.     input 				per_img_Bit,     //white
  11.     output reg 	[42:0] 	target_pos_out1, // {Flag,ymax[41:32],xmax[31:21],ymin[20:11],xmin[10:0]}
  12.     output reg 	[42:0] 	target_pos_out2,
  13. 	
  14.     input	   	[ 9:0] 	MIN_DIST         //min domain
  15. );
  16.  
  17. //720p
  18. parameter	[10:0] IMG_HDISP = 11'd1280;
  19. parameter	[9:0]  IMG_VDISP = 10'd720 ;
  20.  
  21. //lag 1 clocks signal sync
  22. reg 	per_frame_vsync_r;
  23. reg 	per_frame_hs_r   ;
  24. reg 	per_frame_clken_r;
  25. reg 	per_img_Bit_r    ;
  26.  
  27. always@(posedge clk or negedge rst_n)begin
  28.     if(!rst_n)begin
  29.         per_frame_vsync_r 	<= 0;
  30.         per_frame_hs_r 		<= 0;
  31.         per_frame_clken_r 	<= 0;
  32.         per_img_Bit_r 		<= 0;
  33.     end
  34. 	else begin
  35. 		per_frame_vsync_r  	<= per_frame_vsync ;
  36. 		per_frame_hs_r  	<= per_frame_hs    ;
  37. 		per_frame_clken_r  	<= per_frame_clken ;
  38. 		per_img_Bit_r  		<= per_img_Bit     ; 
  39. 	end
  40. end
  41.  
  42. wire vsync_pos_flag;//rising edge of vs
  43. wire vsync_neg_flag;//falling edge if vs
  44.  
  45. assign vsync_pos_flag = per_frame_vsync & (!per_frame_vsync_r);
  46. assign vsync_neg_flag = !(per_frame_vsync) & per_frame_vsync_r;
  47.  
  48. //
  49. //count the input pixel of v/h to get v/h coordinates
  50.  
  51. reg [10:0] x_cnt;
  52. reg [9:0] y_cnt;
  53.  
  54. always@(posedge clk or negedge rst_n) begin
  55.     if(!rst_n) begin
  56.         x_cnt <= 11'd0;
  57.         y_cnt <= 10'd0;
  58.     end
  59.     else if(!per_frame_vsync) begin
  60.         x_cnt <= 11'd0;
  61.         y_cnt <= 10'd0;
  62.     end
  63.     else if(per_frame_clken) begin
  64. 		if(x_cnt < IMG_HDISP - 1) begin
  65.             x_cnt <= x_cnt + 1'b1;
  66.             y_cnt <= y_cnt;
  67. 		end
  68. 		else begin
  69. 			x_cnt <= 11'd0;
  70. 			y_cnt <= y_cnt + 1'b1;
  71. 		 end
  72.     end
  73. 	else begin
  74. 		x_cnt <= 11'd0;
  75. 		y_cnt <= y_cnt;
  76. 	end
  77. end
  78.  
  79.  
  80. // lag 1 clocks signal sync
  81. reg [10:0] x_cnt_r;
  82. reg [9:0] y_cnt_r;
  83.  
  84. always @(posedge clk or negedge rst_n) begin
  85.     if (!rst_n)
  86.         x_cnt_r <= 11'd0;
  87.     else
  88.         x_cnt_r <= x_cnt;
  89. end
  90.  
  91. always @(posedge clk or negedge rst_n) begin
  92.     if (!rst_n)
  93.         y_cnt_r <= 10'd0;
  94.     else
  95.         y_cnt_r <= y_cnt;
  96. end
  97.  
  98. // reg the boundaries of each moving object
  99. reg [42:0] target_pos1;
  100. reg [42:0] target_pos2;
  101.  
  102. // valid mark
  103. wire [1:0]target_flag;
  104.  
  105. // left/right/up/down fields for each target
  106. wire [10:0] target_left1 	;
  107. wire [10:0] target_right1 	;
  108. wire [9:0] target_top1 		;
  109. wire [9:0] target_bottom1 	;
  110.  
  111. wire [10:0] target_left2 	;
  112. wire [10:0] target_right2 	;
  113. wire [9:0] target_top2		;
  114. wire [9:0] target_bottom2 	;
  115.  
  116.  
  117. assign target_flag[0] 	= 	target_pos1[42];
  118.  
  119. assign target_bottom1 	= 	(target_pos1[41:32] < IMG_VDISP-1 	- MIN_DIST ) ? (target_pos1[41:32]	+MIN_DIST) : IMG_VDISP-1;
  120. assign target_right1 	= 	(target_pos1[31:21] < IMG_HDISP-1 	- MIN_DIST ) ? (target_pos1[31:21]	+MIN_DIST) : IMG_HDISP-1;
  121. assign target_top1   	= 	(target_pos1[20:11] > 10'd0 		+ MIN_DIST ) ? (target_pos1[20:11]	-MIN_DIST) : 10'd0;
  122. assign target_left1		=	(target_pos1[10: 0] > 11'd0 		+ MIN_DIST ) ? (target_pos1[10: 0]	-MIN_DIST) : 11'd0;
  123.  
  124. assign target_flag[1] 	= 	target_pos2[42];
  125.  
  126. assign target_bottom2 	= 	(target_pos2[41:32] < IMG_VDISP-1 	- MIN_DIST ) ? (target_pos2[41:32]	+MIN_DIST) : IMG_VDISP-1;
  127. assign target_right2 	= 	(target_pos2[31:21] < IMG_HDISP-1 	- MIN_DIST ) ? (target_pos2[31:21]	+MIN_DIST) : IMG_HDISP-1;
  128. assign target_top2   	= 	(target_pos2[20:11] > 10'd0 		+ MIN_DIST ) ? (target_pos2[20:11]	-MIN_DIST) : 10'd0;
  129. assign target_left2		=	(target_pos2[10: 0] > 11'd0 		+ MIN_DIST ) ? (target_pos2[10: 0]	-MIN_DIST) : 11'd0;
  130.  
  131.  
  132. reg  target_cnt;           
  133. reg [1:0] new_target_flag; //ballot box
  134.  
  135. always @(posedge clk or negedge rst_n) begin
  136.     if (!rst_n) begin
  137.         target_pos1 <= {1'b0, 10'd0, 11'd0, 10'd0, 11'd0};
  138.         target_pos2 <= {1'b0, 10'd0, 11'd0, 10'd0, 11'd0};
  139.         new_target_flag <= 2'd0;
  140.         target_cnt <= 1'd0;
  141.     end
  142.     
  143.     // initialize
  144.     else if(vsync_pos_flag) begin
  145.         target_pos1 <= {1'b0, 10'd0, 11'd0, 10'd0, 11'd0};
  146.         target_pos2 <= {1'b0, 10'd0, 11'd0, 10'd0, 11'd0};
  147. 		new_target_flag <= 2'd0;
  148. 		target_cnt <= 1'd0;
  149.     end
  150.     else begin
  151.         // first clk,judge new target/target in domain 
  152.         if(per_frame_clken && per_img_Bit ) begin
  153. 			if(target_flag[0] == 1'b0)			// if reg flag0 invalid,vote the bit as a new target
  154. 				new_target_flag[0] <= 1'b1;
  155. 			else begin							// if reg flag0 valid，judge whether the target is in domain
  156. 				if((x_cnt < target_left1 || x_cnt > target_right1 || y_cnt < target_top1 || y_cnt > target_bottom1))	//if out of domain，vote the bit as a new target
  157. 					new_target_flag[0] <= 1'b1;
  158. 				else
  159. 					new_target_flag[0] <= 1'b0;                
  160. 		    end
  161. 			
  162. 			if(target_flag[1] == 1'b0)		    // same	as flag0
  163. 				new_target_flag[1] <= 1'b1;
  164. 			else begin							
  165. 				if((x_cnt < target_left2 || x_cnt > target_right2 || y_cnt < target_top2 || y_cnt > target_bottom2))	
  166. 					new_target_flag[1] <= 1'b1;
  167. 				else
  168. 					new_target_flag[1] <= 1'b0;                
  169. 		    end
  170.         end
  171.         else begin
  172. 			new_target_flag <= 2'b0;
  173.         end
  174.  
  175. 		
  176.         // second clk，according to the vote，update target
  177.         if(per_frame_clken_r && per_img_Bit_r) begin
  178. 			if(new_target_flag == 2'b11) begin 	// unanimous vote，new target appear
  179. 				if(target_cnt == 1'b0)begin
  180. 					target_cnt <=1'd1;
  181. 					target_pos1 <= {1'b1, y_cnt_r, x_cnt_r, y_cnt_r, x_cnt_r};
  182. 				end				
  183. 				else if(target_cnt == 1'b1 && target_pos2[42] != 1'b1 && (x_cnt_r < target_left1 || x_cnt_r > target_right1 || y_cnt_r < target_top1 || y_cnt_r > target_bottom1))begin
  184. 					target_pos2 <= {1'b1, y_cnt_r, x_cnt_r, y_cnt_r, x_cnt_r};
  185. 					target_cnt <=1'd1;
  186. 				end
  187. 			end
  188. 			
  189. 			else if (new_target_flag > 2'd0 && new_target_flag != 2'b11) begin // target in domain
  190. 				if(new_target_flag[0] == 1'b0) begin //  flag0 == 0， target in domain1
  191. 				
  192. 					target_pos1[42] <= 1'b1;
  193.  
  194. 					if(x_cnt_r < target_pos1[10: 0]) 	// expand boundary
  195. 						target_pos1[10: 0] <= x_cnt_r;
  196. 					if(x_cnt_r > target_pos1[31:21]) 	
  197. 						target_pos1[31:21] <= x_cnt_r;
  198. 					if(y_cnt_r < target_pos1[20:11]) 	
  199. 						target_pos1[20:11] <= y_cnt_r;
  200. 					if(y_cnt_r > target_pos1[41:32]) 	
  201. 						target_pos1[41:32] <= y_cnt_r;
  202. 				end
  203. 				else if(new_target_flag[1] == 1'b0) begin // flag1 == 0， target in domain2
  204. 				
  205. 					target_pos2[42] <= 1'b1;
  206.  
  207. 					if(x_cnt_r < target_pos2[10: 0]) 	
  208. 						target_pos2[10: 0] <= x_cnt_r;
  209. 					if(x_cnt_r > target_pos2[31:21]) 	
  210. 						target_pos2[31:21] <= x_cnt_r;
  211. 					if(y_cnt_r < target_pos2[20:11]) 	
  212. 						target_pos2[20:11] <= y_cnt_r;
  213. 					if(y_cnt_r > target_pos2[41:32]) 	
  214. 						target_pos2[41:32] <= y_cnt_r;
  215. 				end
  216. 			end
  217. 		end
  218. 	end
  219. end
  220.  
  221. //reg output after a frame
  222.  
  223. always @(posedge clk or negedge rst_n)
  224. 	if(!rst_n) begin
  225. 		target_pos_out1 <= {1'd0,10'd0,11'd0,10'd0,11'd0};
  226. 		target_pos_out2 <= {1'd0,10'd0,11'd0,10'd0,11'd0};		
  227.     end
  228.     else if(vsync_neg_flag) 	begin 
  229. 		target_pos_out1 <= target_pos1;
  230. 		target_pos_out2 <= target_pos2;
  231.     end
  232.  
  233.  
  234. endmodule

3.VIP_multi_target_detect_black

在已经标定亮斑区域之后，我们便可以进一步在亮斑附近标定瞳孔（红框部分）：

       

        相对于上一个多目标追踪的代码，标定瞳孔的单目标追踪代码就简单很多了，只需要例化该模块两次，分别将左右眼亮斑接入target_pos_in即可。不同的是，该模块的per_img_Bit是通过二值化筛选出足够黑的部分（代码类似，自行修改），够黑则拉高。而vsync_neg_flag用于表示一帧的结束，也就代表着模块数据处理完毕，用于各模块协调。

        flag_black用于标定当前像素输入否已经在亮斑的某个区域范围之内（根据实际补光灯与人眼的相对位置调节参数），当per_frame_clken（像素时序），per_img_Bit（黑色瞳孔），flag_black（像素范围）同时满足时，当前像素即为组成黑色瞳孔的像素，即可根据当前像素坐标拓展框定范围，并在一帧结束后作为瞳孔坐标信息target_pos_out输出给后续画框模块处理。

        这样也就在一定程度上解决了眼睛上方背景光源干扰的问题，因为光干扰一般是一片较亮的区域，二值化后周围小范围内不会存在足够黑到per_img_Bit拉高的程度，干扰也就在该模块被阻断了。

  1. module VIP_multi_target_detect_black
  2. (
  3. 	input clk, 
  4. 	input rst_n, 
  6. 	input per_frame_vsync, 
  7. 	input per_frame_clken, 
  8. 	input per_img_Bit,                //balck
  9. 	input    	[42:0] 	target_pos_in,//{Flag,ymax[41:32],xmax[31:21],ymin[20:11],xmin[10:0]}
  11. 	output reg 	[42:0] 	target_pos_out,//{Flag,ymax[41:32],xmax[31:21],ymin[20:11],xmin[10:0]}
  12. 	output				vsync_neg_flag //mark the ending of a frame
  13. );
  14.  
  15. parameter	[10:0] IMG_HDISP = 11'd1280;
  16. parameter	[9:0]  IMG_VDISP = 10'd720;
  17.  
  18. reg 	per_frame_vsync_r; 
  19.  
  20. always@(posedge clk or negedge rst_n)
  21. begin
  22.     if(!rst_n)
  23. 		per_frame_vsync_r 	<= 0;
  24. 	else 	
  25. 		per_frame_vsync_r  	<= per_frame_vsync ;
  26. end
  27.  
  28. wire vsync_neg_flag;//falling edge
  29.  
  30. assign vsync_neg_flag = !(per_frame_vsync) & per_frame_vsync_r;
  31.  
  32. reg [10:0] x_cnt;
  33. reg [9:0] y_cnt;
  34.  
  35. reg [9:0] up_reg ;
  36. reg [9:0] down_reg ;
  37. reg [10:0] left_reg ;
  38. reg [10:0] right_reg;
  39. reg flag_reg;
  40.  
  41. //count the input pixel of v/h to get v/h coordinates
  42. always@(posedge clk or negedge rst_n)
  43. begin
  44.     if(!rst_n) begin
  45.         x_cnt <= 11'd0;
  46.         y_cnt <= 10'd0;
  47.     end
  48.     else if(!per_frame_vsync) begin
  49.         x_cnt <= 11'd0;
  50.         y_cnt <= 10'd0;
  51.     end
  52.     else if(per_frame_clken) begin
  53.         if(x_cnt < IMG_HDISP - 1) begin
  54.             x_cnt <= x_cnt + 1'b1;
  55.             y_cnt <= y_cnt;
  56.         end
  57.         else begin
  58.             x_cnt <= 11'd0;
  59.             y_cnt <= y_cnt + 1'b1;
  60.         end
  61.     end
  62. end
  63.  
  64. //mark the area from target_pos_in
  65. reg flag_black;
  66.  
  67. always@(posedge clk or negedge rst_n)
  68. 	if(!rst_n)
  69. 		flag_black <= 1'b0;
  70. 	else if(!per_frame_vsync)
  71. 		flag_black <= 1'b0;
  72. 	else if(target_pos_in[42] && per_frame_clken && y_cnt < target_pos_in[41:32] + 5'd20 && x_cnt < target_pos_in[31:21] + 5'd20 && y_cnt > target_pos_in[20:11] - 6'd32 && x_cnt > target_pos_in[10:0] - 5'd20)
  73. 		flag_black <= 1'b1;
  74. 	else
  75. 		flag_black <= 1'b0;
  76.  
  77.  
  78. //mark pupil
  79. always@(posedge clk or negedge rst_n) begin
  80.     if(!rst_n) begin
  81.         up_reg <= target_pos_in[41:32] + 5'd20;
  82.         down_reg <= 10'd0;
  83.         left_reg <= target_pos_in[31:21] + 5'd20;
  84.         right_reg <= 10'd0;
  85.         flag_reg <= 1'b0;
  86.     end 
  87.     else if(!per_frame_vsync)begin
  88.         up_reg <= target_pos_in[41:32] + 5'd20;
  89.         down_reg <= 10'd0;
  90.         left_reg <= target_pos_in[31:21] + 5'd20;
  91.         right_reg <= 11'd0;
  92.         flag_reg <= 1'b0;
  93.     end
  94.     else if (per_frame_clken && per_img_Bit && flag_black) begin
  95. 		flag_reg <= 1'b1;
  96.  
  97. 		if (x_cnt < left_reg)
  98. 			left_reg <= x_cnt; 
  99. 		else
  100. 			left_reg <= left_reg;
  101.  
  102. 		if (x_cnt > right_reg)
  103. 			right_reg <= x_cnt;
  104. 		else
  105. 			right_reg <= right_reg;
  106.  
  107. 		if (y_cnt < up_reg)
  108. 			up_reg <= y_cnt;
  109. 		else
  110. 			up_reg <= up_reg;
  111.  
  112. 		if (y_cnt > down_reg)
  113. 			down_reg <= y_cnt;
  114. 		else
  115. 			down_reg <= down_reg;
  116. 	end
  117. end
  118.  
  119. 	
  120. always @(posedge clk or negedge rst_n) begin
  121.     if (!rst_n) begin
  122.         target_pos_out <= {1'd0,10'd0,11'd0,10'd0,11'd0};
  123.     end 
  124. 	else if (vsync_neg_flag) begin
  125.         target_pos_out <= {flag_reg,down_reg,right_reg,up_reg,left_reg};
  126.     end
  127. end
  128.  
  129. endmodule

4.VIP_Video_add_rectangular

        该模块为实时画框模块，视频中呈现的瞳孔框，定位框（locater），视线追踪框（sight frame），人员标记（person number）都由该模块在原视频上叠加红框实现。此处代码基本逻辑在大磊的视频里同样解释了，再次推荐观看。各框效果如下图：

        模块per_img_red/green/blue为图片实时像素，由于红外窄带滤波灰度摄像头采集到信号为raw8格式，所以本项目中三者都为8位灰度值。此处target_pos_output为前模块输出的两个瞳孔坐标。rx_person为队友做的AI人脸识别，据此信号判断人员编号。flag_rst信号为定位框的重置信号，该信号产生模块见下文，信号用于重置与当前瞳孔位置比较的定位框位置。sit为模块判定人眼移动的方向，作为输出信号用于控制外设舵机、云台等。

        模块269行之前都为准备 框的坐标，实际画框部分从269行开始。我首先解释画框部分，以((x_cnt >   rectangular_left1) && (x_cnt <   rectangular_right1) && ((y_cnt ==   rectangular_up1) || (y_cnt ==   rectangular_down1)) && rectangular_flag1)这段用于画上下边框的或条件之一为例，当四个条件同时满足时，输出纯红像素作为上下框边界。rectangular_flag1——框坐标是否有效；x_cnt >   rectangular_left1——当前像素在左边界右；x_cnt >   rectangular_right1——当前像素在右边界左；(y_cnt ==   rectangular_up1) || (y_cnt ==   rectangular_down1)——当前像素坐标等于上/下边界。其余或条件同理。

        114行开始，解释了如何重置定位框——外界输入的flag_rst信号（可自由设定触发源，本项目用眨眼和外界按钮，会在后续功能模块说明），当其拉高时，将当前瞳孔坐标作为新的定位框坐标。之后，将定位框x/y方向坐标和rec_x/y_sum分别与瞳孔当前x/y方向坐标和x/y_sum相减取绝对值和正负号，即可进行眼动八角定位 ：

        如图黑实线为可判定的八个方向，灰虚线为方向区域范围边界，通过比较 x差值与二分之一 y（移位实现）差值，y 差值与二分之一 x 差值，以及差值正负关系，即可划分八个区域。同时使用sit将眼动方向传递至模块外以控制外设；并且根据方向的不同，控制视线追踪框rec_eye的边界定速增加或减少，以实现框随视线移动的直观效果。

  1. module VIP_Video_add_rectangular (
  3.     input       clk,      
  4.     input       rst_n,    
  5. 	
  6. 	input       per_frame_vsync,
  7. 	input       per_frame_hs,
  8. 	input       per_frame_clken,
  9. 	input [7:0]      per_img_red,
  10. 	input [7:0]      per_img_green,
  11. 	input [7:0]      per_img_blue,
  13.     input [42:0] 	target_pos_out1,// {Flag,ymax[41:32],xmax[31:21],ymin[20:11],xmin[10:0]}
  14.     input [42:0] 	target_pos_out2,
  16. 	input [3:0]     rx_person,      //person
  19.     output reg post_frame_vsync,    
  20.     output reg post_frame_hs,     
  21.     output reg post_frame_clken,    
  22.     output reg [7:0] post_img_red,  
  23.     output reg [7:0] post_img_green,
  24.     output reg [7:0] post_img_blue, 
  25. 	
  26. 	input  		flag_rst,           //rst the locater flag
  27. 	
  29. 	output  [3:0]     sit           //eye direction
  30. );
  31.  
  32. //1280*720 resolution
  33. parameter [10:0] IMG_HDISP = 11'd1280;
  34. parameter [9:0] IMG_VDISP = 10'd720;
  35. 	
  36. wire [9:0] 	rectangular_up1;    	
  37. wire [9:0] 	rectangular_up2;
  38. wire [9:0] 	rectangular_down1;    	
  39. wire [9:0] 	rectangular_down2;
  40. wire [10:0] rectangular_left1;    	
  41. wire [10:0] rectangular_left2;
  42. wire [10:0] rectangular_right1;		
  43. wire [10:0] rectangular_right2;
  44.  
  45. wire       	rectangular_flag1;		//flag whether there is a moving target
  46. wire       	rectangular_flag2;
  47.  
  48.  
  49. assign rectangular_flag1 	= 	target_pos_out1[42];
  50. assign rectangular_down1 	= 	target_pos_out1[41:32];
  51. assign rectangular_right1 	= 	target_pos_out1[31:21];
  52. assign rectangular_up1 		= 	target_pos_out1[20:11];
  53. assign rectangular_left1	= 	target_pos_out1[10:0];	
  54.  
  55. assign rectangular_flag2 	= 	target_pos_out2[42];
  56. assign rectangular_down2 	= 	target_pos_out2[41:32];
  57. assign rectangular_right2 	= 	target_pos_out2[31:21];
  58. assign rectangular_up2	 	= 	target_pos_out2[20:11];
  59. assign rectangular_left2	= 	target_pos_out2[10:0];		
  60.  
  61. 	
  62. reg [10:0] x_cnt;
  63. reg [9:0] y_cnt;
  64.  
  65.  
  66. always @(posedge clk or negedge rst_n) begin
  67.     if(!rst_n)begin
  68. 		x_cnt <= 11'd0;
  69. 		y_cnt <= 10'd0;
  70. 	end
  71. 	else begin
  72. 		if(!per_frame_vsync)begin
  73. 			x_cnt <= 11'd0;
  74. 			y_cnt <= 10'd0;
  75. 		end
  76. 		else if(per_frame_clken) begin
  77. 			if(x_cnt < IMG_HDISP - 1) begin
  78.                 x_cnt <= x_cnt + 1'b1;
  79.                 y_cnt <= y_cnt;
  80. 			end
  81. 			else begin
  82.                 x_cnt <= 11'd0;
  83.                 y_cnt <= y_cnt + 1'b1;
  84.             end
  85. 		end
  86. 		else begin
  87. 		x_cnt <= 11'd0;
  88. 		y_cnt <= y_cnt;
  89. 		end
  90. 	end		
  91. end
  92.  
  93. //sum of x/y
  94. wire [12:0]x_sum;
  95. wire [11:0]y_sum;
  96. assign 	x_sum = (rectangular_flag1 && rectangular_flag2) ? (rectangular_right1 + rectangular_right2 + rectangular_left1 + rectangular_left2):1'b0;
  97. assign 	y_sum = (rectangular_flag1 && rectangular_flag2) ? (rectangular_up1 + rectangular_up2 + rectangular_down1 + rectangular_down2):1'b0;
  98.  
  99.  
  100.  
  101. //locater
  102. wire [9:0] 	rectangular_up3;    	
  103. wire [9:0] 	rectangular_up4;
  104. wire [9:0] 	rectangular_down3;    	
  105. wire [9:0] 	rectangular_down4;
  106. wire [10:0] rectangular_left3;    	
  107. wire [10:0] rectangular_left4;
  108. wire [10:0] rectangular_right3;		
  109. wire [10:0] rectangular_right4;
  110.  
  111. reg [41:0]rec_left  = 42'b0101000000_00111011011_0100110000_00111000110;// {Flag,ymax[41:32],xmax[31:21],ymin[20:11],xmin[10:0]}
  112. reg [41:0]rec_right = 42'b0101000000_01011011011_0100110000_01011000110;// {Flag,ymax[41:32],xmax[31:21],ymin[20:11],xmin[10:0]}
  113.  
  114. //rst locater
  115. always @(posedge clk or negedge rst_n)
  116. 	if(!rst_n)begin
  117. 		rec_left  = 42'b0101000000_00111011011_0100110000_00111000110;
  118. 		rec_right = 42'b0101000000_01011011011_0100110000_01011000110;
  119. 	end
  120. 	else if(flag_rst && rectangular_flag1 && rectangular_flag2)begin
  121. 		rec_left  = target_pos_out1[41:0];
  122. 		rec_right = target_pos_out2[41:0];
  123. 	end
  124.  
  125.  
  126. wire [11:0]rec_y_sum;
  127. wire [12:0]rec_x_sum;
  128.  
  129. assign rec_x_sum = (rectangular_flag1 && rectangular_flag2) ? (rectangular_right3 + rectangular_right4 + rectangular_left3 + rectangular_left4):1'b0;
  130. assign rec_y_sum = (rectangular_flag1 && rectangular_flag2) ? (rectangular_up3 + rectangular_up4 + rectangular_down3 + rectangular_down4):1'b0;
  131.  
  132. assign rectangular_down3 	= 	rec_left[41:32];
  133. assign rectangular_right3 	= 	rec_left[31:21];
  134. assign rectangular_up3	 	= 	rec_left[20:11];
  135. assign rectangular_left3	= 	rec_left[10:0];	
  136.  
  137. assign rectangular_down4 	= 	rec_right[41:32];
  138. assign rectangular_right4 	= 	rec_right[31:21];
  139. assign rectangular_up4	 	= 	rec_right[20:11];
  140. assign rectangular_left4	= 	rec_right[10:0];
  141.  
  142.  
  143. //output eye direction
  144. reg right;
  145. reg left;
  146. reg down;
  147. reg up;
  148. wire [3:0]	sit;
  149.  
  150. //judge sight direction(now-locater)
  151. wire sign_x;
  152. wire sign_y;
  153. wire [10:0]sub_x;
  154. wire [9:0]sub_y;
  155.  
  156. assign sub_x = (x_sum > rec_x_sum) ? (x_sum - rec_x_sum) : (rec_x_sum - x_sum);
  157. assign sub_y = (y_sum > rec_y_sum) ? (y_sum - rec_y_sum) : (rec_y_sum - y_sum);
  158.  
  159. assign sign_x = (x_sum > rec_x_sum) ? 1'b1 : 1'b0;
  160. assign sign_y = (y_sum > rec_y_sum) ? 1'b1 : 1'b0;
  161.  
  162. wire h;
  163. wire v;
  164. wire h_v;
  165.  
  166. assign h   = ((sub_x >> 1) >= sub_y) ? 1'b1 : 1'b0;
  167. assign v   = ((sub_y >> 1) >= sub_x) ? 1'b1 : 1'b0;
  168. assign h_v = (((sub_y >> 1) < sub_x) && ((sub_x >> 1) < sub_y)) ? 1'b1 : 1'b0;
  169.  
  170. //sight frame
  171. reg  [41:0]rec_eye = 41'b0101100000_01011011011_0100010000_00111000110;
  172. always @(posedge clk or negedge rst_n)
  173. 	if(!rst_n)
  174. 		rec_eye = 41'b0101100000_01011011011_0100010000_00111000110;
  175. 	else if((x_cnt == IMG_HDISP - 2'b10) && (y_cnt == IMG_VDISP - 2'b10) && rectangular_flag1 && rectangular_flag2)begin
  176. 		if(h && sign_x && rec_eye[31:21] < IMG_HDISP)begin			//right
  177. 			rec_eye[31:21] <= rec_eye[31:21] + 2'b10;
  178. 			rec_eye[10:0]  <= rec_eye[10:0] + 2'b10;
  179. 			right <= 1'b1;
  180. 			left  <= 1'b0;
  181. 			down  <= 1'b0;
  182. 			up    <= 1'b0;			
  183. 		end
  184. 		else if(h && !sign_x && rec_eye[10:0] >= 1'b1)begin			//left
  185. 			rec_eye[31:21] <= rec_eye[31:21] - 2'b10;
  186. 			rec_eye[10:0]  <= rec_eye[10:0] - 2'b10;	
  187. 			right <= 1'b0;
  188. 			left  <= 1'b1;
  189. 			down  <= 1'b0;
  190. 			up    <= 1'b0;			
  191. 		end
  192. 		else if(v && sign_y && rec_eye[41:32] < IMG_VDISP)begin		//down
  193. 			rec_eye[41:32] <= rec_eye[41:32] + 2'b10;
  194. 			rec_eye[20:11] <= rec_eye[20:11] + 2'b10;
  195. 			right <= 1'b0;
  196. 			left  <= 1'b0;
  197. 			down  <= 1'b1;
  198. 			up    <= 1'b0;
  199. 		end
  200. 		else if(v && !sign_y && rec_eye[20:11] >= 1'b1)begin	    //up
  201. 			rec_eye[41:32] <= rec_eye[41:32] - 2'b10;
  202. 			rec_eye[20:11] <= rec_eye[20:11] - 2'b10;
  203. 			right <= 1'b0;
  204. 			left  <= 1'b0;
  205. 			down  <= 1'b0;
  206. 			up    <= 1'b1;
  207. 		end
  208. 		else if(h_v && sign_x && sign_y && rec_eye[31:21] < IMG_HDISP && rec_eye[41:32] < IMG_VDISP)begin	//right_down
  209. 			rec_eye[31:21] <= rec_eye[31:21] + 2'b10;
  210. 			rec_eye[10:0]  <= rec_eye[10:0] + 2'b10;
  211. 			rec_eye[41:32] <= rec_eye[41:32] + 2'b10;
  212. 			rec_eye[20:11] <= rec_eye[20:11] + 2'b10;
  213. 			right <= 1'b1;
  214. 			left  <= 1'b0;
  215. 			down  <= 1'b1;
  216. 			up    <= 1'b0;			
  217. 		end
  218. 		else if(h_v && !sign_x && sign_y && rec_eye[10:0] >= 1'b1 && rec_eye[41:32] < IMG_VDISP)begin		//left_down
  219. 			rec_eye[31:21] <= rec_eye[31:21] - 2'b10;
  220. 			rec_eye[10:0]  <= rec_eye[10:0] - 2'b10;
  221. 			rec_eye[41:32] <= rec_eye[41:32] + 2'b10;
  222. 			rec_eye[20:11] <= rec_eye[20:11] + 2'b10;
  223. 			right <= 1'b0;
  224. 			left  <= 1'b1;
  225. 			down  <= 1'b1;
  226. 			up    <= 1'b0;			
  227. 		end
  228. 		else if(h_v && !sign_y && sign_x && rec_eye[31:21] < IMG_HDISP && rec_eye[20:11] >= 1'b1)begin	//right_up
  229. 			rec_eye[31:21] <= rec_eye[31:21] + 2'b10;
  230. 			rec_eye[10:0]  <= rec_eye[10:0] + 2'b10;
  231. 			rec_eye[41:32] <= rec_eye[41:32] - 2'b10;
  232. 			rec_eye[20:11] <= rec_eye[20:11] - 2'b10;
  233. 			right <= 1'b1;
  234. 			left  <= 1'b0;
  235. 			down  <= 1'b0;
  236. 			up    <= 1'b1;
  237. 		end
  238. 		else if(h_v && !sign_y && !sign_x && rec_eye[10:0] >= 1'b1 && rec_eye[20:11] >= 1'b1)begin		//left_up
  239. 			rec_eye[31:21] <= rec_eye[31:21] - 2'b10;
  240. 			rec_eye[10:0]  <= rec_eye[10:0] - 2'b10;
  241. 			rec_eye[41:32] <= rec_eye[41:32] - 2'b10;
  242. 			rec_eye[20:11] <= rec_eye[20:11] - 2'b10;
  243. 			right <= 1'b0;
  244. 			left  <= 1'b1;
  245. 			down  <= 1'b0;
  246. 			up    <= 1'b1;
  247. 		end	
  248. 	end
  249.  
  250.  
  251. assign sit = {up, down, left, right};
  252.  
  253. wire [9:0] 	rectangular_up5;
  254. wire [9:0] 	rectangular_down5;
  255. wire [10:0] rectangular_left5;
  256. wire [10:0] rectangular_right5;
  257. 		
  258. assign rectangular_down5 	= 	rec_eye[41:32];
  259. assign rectangular_right5 	= 	rec_eye[31:21];
  260. assign rectangular_up5	 	= 	rec_eye[20:11];
  261. assign rectangular_left5	= 	rec_eye[10:0];
  262.  
  263.  
  264.  
  265.  
  266.  
  267. //draw	
  268.  
  269. always @(posedge clk or negedge rst_n) begin
  270. 	if(!rst_n) begin
  271. 		post_frame_vsync <= 1'd0; 
  272. 		post_frame_hs  <= 1'd0; 
  273. 		post_frame_clken <= 1'd0; 
  274. 		post_img_red     <= 8'd0; 
  275. 		post_img_green   <= 8'd0; 
  276. 		post_img_blue    <= 8'd0; 
  277. 	end
  278. 	else begin
  279. 		post_frame_vsync <= per_frame_vsync;
  280. 		post_frame_hs <= per_frame_hs;
  281. 		post_frame_clken <= per_frame_clken;
  282. 		if(post_frame_clken) begin 
  283. 			if(((x_cnt >   rectangular_left1) && (x_cnt <   rectangular_right1) && ((y_cnt ==   rectangular_up1) || (y_cnt ==   rectangular_down1)) && rectangular_flag1) ||
  284. 			((x_cnt >   rectangular_left2) && (x_cnt <   rectangular_right2) && ((y_cnt ==   rectangular_up2) || (y_cnt ==   rectangular_down2)) && rectangular_flag2) ||
  285. 			((x_cnt >   rectangular_left3) && (x_cnt <   rectangular_right3) && ((y_cnt ==   rectangular_up3) || (y_cnt ==   rectangular_down3))) ||
  286. 			((x_cnt >   rectangular_left4) && (x_cnt <   rectangular_right4) && ((y_cnt ==   rectangular_up4) || (y_cnt ==   rectangular_down4))) ||
  287. 			((x_cnt >   rectangular_left5) && (x_cnt <   rectangular_right5) && ((y_cnt ==   rectangular_up5) || (y_cnt ==   rectangular_down5))) ||
  288. 			((x_cnt >   rectangular_left3) && (x_cnt <   rectangular_left3 + 4'd10) && ((y_cnt == rectangular_up3 - 4'd4) || (y_cnt ==   rectangular_up3 - 5'd8) || (y_cnt ==   rectangular_up3 - 5'd1))
  289. 			&& rx_person == 4'b0010)||
  290. 			((x_cnt >   rectangular_left3) && (x_cnt <   rectangular_left3 + 4'd10) && ((y_cnt == rectangular_up3 - 4'd4) || (y_cnt ==   rectangular_up3 - 5'd8))
  291. 			&& rx_person == 4'b0100)||
  292. 			((x_cnt >   rectangular_left3) && (x_cnt <   rectangular_left3 + 4'd10) && ((y_cnt == rectangular_up3 - 4'd4))
  293. 			&& rx_person == 4'b1000))begin 
  294. 			//draw up and down
  295. 				post_img_red 	<= 8'd255;
  296. 				post_img_green 	<= 8'd0;
  297. 				post_img_blue 	<= 8'd0;
  298. 			end
  299. 			else if(((y_cnt >  rectangular_up1) && (y_cnt <   rectangular_down1) && ((x_cnt ==   rectangular_left1) || (x_cnt ==   rectangular_right1)) && rectangular_flag1)||
  300. 				   ((y_cnt >   rectangular_up2) && (y_cnt <   rectangular_down2) && ((x_cnt ==   rectangular_left2) || (x_cnt ==   rectangular_right2)) && rectangular_flag2) || 
  301. 				   ((y_cnt >   rectangular_up3) && (y_cnt <   rectangular_down3) && ((x_cnt ==   rectangular_left3) || (x_cnt ==   rectangular_right3)))||
  302. 				   ((y_cnt >   rectangular_up4) && (y_cnt <   rectangular_down4) && ((x_cnt ==   rectangular_left4) || (x_cnt ==   rectangular_right4)))||
  303. 				   ((y_cnt >   rectangular_up5) && (y_cnt <   rectangular_down5) && ((x_cnt ==   rectangular_left5) || (x_cnt ==   rectangular_right5))))begin 
  304. 				   //draw left and right
  305. 				post_img_red 	<= 8'd255;
  306. 				post_img_green 	<= 8'd0;
  307. 				post_img_blue 	<= 8'd0;
  308. 			end
  309. 			else begin
  310. 				post_img_red 	<= per_img_red ; 
  311. 				post_img_green 	<= per_img_green;
  312. 				post_img_blue 	<= per_img_blue ;
  313. 			end
  314.         end
  315. 		else begin
  316. 			post_img_red 	<= per_img_red ; 
  317. 			post_img_green 	<= per_img_green;
  318. 			post_img_blue 	<= per_img_blue ;
  319. 		end
  320.     end		
  321. end
  322.  
  323. endmodule

四、功能模块说明

1、rec_rst

        该模块利用双目信号的捕获情况，判定是否刻意眨眼，以控制flag_rst信号重置定位框，flag12为模块VIP_multi_target_detect_black输出的target_pos_out[42]，若flag1&&flag2 == 1，代表两眼信号都稳定。此处我编写了状态机以判断人是否刻意眨眼。概括来说就是稳定睁眼——稳定闭眼——稳定睁眼的过程，具体时间修改参数可调。

        IDLE：初始态，用于flag_rst信号的置零。

        S1：    双目都捕获时每帧对cnt_neg_p计数。视频是60Hz，也就是说当双目都捕获持续大约两秒后，若双目都丢失，则跳转至S2，同时cnt_neg_p清零。这是一个从睁眼到闭眼的过程。

        S2：    注意，该状态使用cnt_neg_n在双目都丢失时计数。为避免信号波动或自然眨眼影响，设定为双目都丢失1秒左右后，若再次捕获到任意信号，判定为睁眼，跳转到S3。大于半秒，小于1秒的时间内捕获信号，则判定为干扰，返回S1态。

        S3：    当双目再次被持续捕捉一秒左右，跳转至S4转态。

        S4：    回归IDLE，同时拉高flag_rst代表刻意眨眼过程完成，重置定位框。

  1. module rec_rst
  2. (	
  3.     input 				clk,
  4.     input 				rst_n,
  6.     input 				flag1,
  7.     input 				flag2,
  8.     input 				v_neg,    //falling edge
  10.     output reg 	 		flag_rst
  11. );
  12.  
  13. parameter IDLE 	= 5'b00001; 
  14. parameter S1 	= 5'b00010; //visibility
  15. parameter S2 	= 5'b00100; //lost
  16. parameter S3 	= 5'b01000; //appear
  17. parameter S4 	= 5'b10000; //output rst
  18.  
  19.  
  20. reg  [4:0]   curr_st     ;     
  21. reg  [4:0]   next_st     ;     
  22.  
  23. //Excitation signal generation
  24. reg [7:0]	cnt_neg_p;
  25. reg [7:0]	cnt_neg_n;
  26.  
  27. always @(posedge clk or negedge rst_n)
  28. 	if(!rst_n || curr_st == IDLE || curr_st == S2 || (curr_st == S3 && !flag1 && !flag2))
  29. 		cnt_neg_p <= 1'b0;
  30. 	else if(cnt_neg_p >= 8'd128)
  31. 		cnt_neg_p <= cnt_neg_p;
  32. 	else if(flag1 && flag2 && v_neg)
  33. 		cnt_neg_p <= cnt_neg_p + 1'b1;
  34.  
  35. always @(posedge clk or negedge rst_n)
  36. 	if(!rst_n || curr_st == IDLE || curr_st == S1 || flag1 || flag2)
  37. 		cnt_neg_n <= 1'b0;
  38. 	else if(cnt_neg_n >= 8'd128)
  39. 		cnt_neg_n <= cnt_neg_n;		
  40. 	else if(!flag1 && !flag2 && v_neg && curr_st == S2)
  41. 		cnt_neg_n <= cnt_neg_n + 1'b1;
  42.  
  43. always @(posedge clk or negedge rst_n)
  44. 	if(!rst_n)
  45. 		curr_st <= IDLE;
  46. 	else
  47. 		curr_st <= next_st;
  48.  
  49.  
  50. always @(curr_st)begin
  51. 	case(curr_st)
  52. 		IDLE: begin
  53. 				next_st <= S1;
  54. 				flag_rst <= 1'b0;
  55. 			  end
  56. 		S1	: if(cnt_neg_p >= 8'd128 && !flag1 && !flag2)
  57. 				next_st <= S2;
  58. 			  else
  59. 				next_st <= S1;
  60. 				
  61. 		S2	: if(cnt_neg_n >= 8'd64 && (flag1 || flag2))
  62. 				next_st <= S3;
  63. 			  else if((flag1 || flag2) && cnt_neg_n >= 8'd32)
  64. 				next_st <= S1;
  65. 			  else
  66. 				next_st <= S2;
  67. 				
  68. 		S3	: if(cnt_neg_p >= 7'd64 && flag1 && flag2)
  69. 				next_st <= S4;
  70. 			  else
  71. 				next_st <= S3;
  72.  
  73. 		S4	: if(flag1 && flag2)begin
  74. 				next_st <= IDLE;
  75. 				flag_rst <= 1'b1;
  76. 			  end
  77. 			  else
  78. 				next_st <= S4;
  79. 		default : next_st <= IDLE;
  80. 	endcase
  81. end
  82.  
  83.  
  84. endmodule

2、cnt_all

        此模块通过对一帧内所有有效像素的灰度值求和，与设定阈值对比，判断需要调高还是调低亮度，通过FPGA调控输出PWM波至外部硬件电路控制红外灯的亮度。模块相当简单，但是效果很不错，解决了很多问题。

        luminance为八位灰度图像数据，cmp为比较结果，再输入PWM模块调节PWM占空比。请根据实际环境调节代码末尾阈值上下限。

  1. module cnt_all
  2. (    
  3. 	input               clk             ,   
  4.     input               rst_n           ,   
  5.     
  6.     input               per_frame_vsync     ,   
  7.     input               ycbcr_de        ,   // en
  8.     input   [7:0]       luminance       ,
  10.     output reg [1:0]   cmp    // 00 IDLE；10 exceed；01 below；11 ok
  11. );
  12.  
  13. reg    per_frame_vsync_r; 
  14. wire   vsync_pos_flag;//rising edge
  15. wire   vsync_neg_flag;//falling edge
  16.  
  17. assign vsync_pos_flag = per_frame_vsync & (!per_frame_vsync_r);
  18. assign vsync_neg_flag = !(per_frame_vsync) & per_frame_vsync_r;
  19.  
  20. reg   [27:0] cnt_fin;
  21. reg   [27:0] cnt;
  22.  
  23.  
  24. always @(posedge clk or negedge rst_n) begin
  25.     if(!rst_n)
  26.         cnt <= 1'b0;
  27.     else if(ycbcr_de)begin  
  28.         cnt <= cnt + luminance;
  29. 	end		
  30.     else if(vsync_pos_flag)
  31.         cnt <= 1'b0;
  32. end
  33.  
  34. //delay
  35. always@(posedge clk or negedge rst_n) begin
  36.     if(!rst_n) begin
  37.         per_frame_vsync_r <= 1'd0;
  38.     end
  39.     else begin
  40.         per_frame_vsync_r <= per_frame_vsync;
  41.     end
  42. end
  43.  
  44.  
  45.  
  46. always @(posedge clk or negedge rst_n)
  47. 	if(!rst_n) begin
  48. 		cnt_fin <= 1'b0;
  49.     end
  50.     else if(vsync_neg_flag) 	begin //reg cnt after a frame
  51. 		cnt_fin <= cnt;
  52.     end
  53.  
  54. always @(posedge clk or negedge rst_n)
  55. 	if(!rst_n) begin
  56. 		cmp <= 2'b0;
  57.     end
  58.     else if(cnt_fin > 28'h2f00000) 	begin 
  59. 		cmp <= 2'b10;
  60.     end
  61.     else if(cnt_fin < 28'h2800000) 	begin 
  62. 		cmp <= 2'b01;
  63.     end
  64.     else if(cnt_fin > 28'h2800000 && cnt_fin < 28'h2f00000) 	begin 
  65. 		cmp <= 2'b11;
  66.     end
  67.  
  68. endmodule

总结（与项目无关）

 下文与本项目无关，是博主的个人感叹（碎碎念），可跳过。

        博客主体写完，心情还是比较不平静的，有很多话想说，但是又因为各种原因删了。

        大一刚入南邮时，班主任（一位非常负责的导师）在班级群问：“大家有什么问题”，

        我：“没有啥问题”，

        班主任：“没问题就是最大的问题”。

        现在想起来当时自己真是愣头青，哈哈。大学不同于高中，我认为大学首要需要学会的能力是信息获取的能力。回首过往三年，虽然不后悔，多少有些遗憾，遗憾在于大多数时间都忙于学习，追求各种指标，而没有时间停下来，用心体会学习的过程。

        对于我来说，成绩更多像是我的保护伞，保护我免受父母的唠叨，保护我作为南邮第一届创新班学委有底气跟学校交流争取自己班的利益，保护我能保留很大一部分的个人自由······现在面对保研选择，才略微有些窥探到自己的追求：心无旁骛的深入追求知识。但是这又牵扯到很多，也很难实现。嗯，不过我依然会追逐理想，我依然问心无愧。

        祝愿各位都有远大前程。

注：本文转载自blog.csdn.net的forever_00_的文章"https://blog.csdn.net/forever_00_/article/details/145709587"。版权归原作者所有，此博客不拥有其著作权，亦不承担相应法律责任。如有侵权，请联系我们删除。
复制链接
相关推荐
发表评论

评论记录：

未查询到任何数据！