line

　　小君童靴说头儿给了他一个project，实现给出屏幕上任意两个点，求出这两个点之间直线上的所有的点。觉得这个很好玩，就自己也写了一点code

 /*
 date : 2014/10/21
 version : QuartusII 14.0 + DE1-SOC(cycloneV)
 function: 输入两个点 Xmax = 1023  Ymax = 511 ，计算出中间点的坐标 

 说明 : (1)1023=0x3ff  (10bit)    511 = 0x1ff (9bit)
        (2)直线方程： y=kx+m ;
        (3)第116行 装载Ymin值的时候-1， 要求输入Ymin不可以小于1：如
 果这个地方不剪掉1，会导致输出有(Ymax-Ymin)个脉冲的延时
        (4)现象三的原因是 144 行的判定方法导致。判定当前点为合适点的
 方式是第二次离直线最近，第一次prev2_dm 较大，第三次curr_dm也较大，116
 行不减1就无法满足“远，近，远”的判定，从而一直扫到最后都找不到合适点。
        (5)本程序的计算方式是最直接的运算，计算量大，浪费硬件资源，更
 好的算法等待大家的指点
        (6)由于计算输出延时了三个周期，如150行，所以最后三个点无法覆盖到。
 */

 module line (
             clock ,
             reset ,
             xs_in ,        //输入的X 点的起始坐标
             ys_in ,        // 输入的Y 点的起始坐标
             xe_in ,        //输入X点的终止坐标
             ye_in ,        //输入Y 点的终止坐标
             in_en ,        //当前输入信号有效标志    1:有效    0:无效

             x_ou,         //输出的X 点的坐标
             y_ou,         // 输出的Y 点的坐标
             fini_flag     //计算完成标志位
             );
   input         clock ,reset  ;
   input         in_en ;
   input [:]     xs_in  ,xe_in ;
   input [:]     ys_in  ,ye_in ; 

   output reg [:]    x_ou ;
   output reg [:]    y_ou ;
   output reg        fini_flag ; 

   wire signed [:] dx  ;     // X方向上的变化量
   wire signed [:] dy  ;     //Y方向上的变化量
   reg signed  [:] line_k ;  // 用来存储线条的斜率
   reg signed  [:]  line_m ;  // 直线的常数项
   reg signed  [:]  curr_m ;     //当前m值
   reg         [:]  curr_dm ; //当前的m偏差量
   reg         [:]  prev1_dm ; //上一次的m偏差量
   reg         [:]  prev2_dm ; //上上一次m的偏差量
   reg                    point_flag ; //找到当前最近点的标志位    

   wire signed  [:] Xmin ;
   wire signed  [:] Xmax ;
   wire signed  [:] Ymin ;
   wire signed  [:] Ymax ; 

   assign dx = xe_in-xs_in;  //得出X方向上的差值
   assign dy = ye_in-ys_in;  //得出Y方向上的差值

   //求得所需的直线就在这么一个矩形框内，针对这个矩形框进行运算
   assign Xmin = (xs_in<xe_in)? xs_in : xe_in ;
   assign Xmax = (xs_in<xe_in)? xe_in : xs_in ;
   assign Ymin = (ys_in<ye_in)? ys_in : ye_in ;
   assign Ymax = (ys_in<ye_in)? ye_in : ys_in ;

   //绝对值函数
   function [:] abs (input signed[:] data1,  input signed [:] data2 );
         abs = (data1>data2) ? (data1-data2):(data2-data1);
   endfunction 

 //*********斜率的计算，并且扩大了2^6次方倍，并得出M值的2^6倍的大小******************
   always @ (posedge clock)
         if(!in_en)
             begin
                     //line_k <= 16'd0 ;
                     //line_m <= 16'd0 ;
             end
         else
             begin
                     line_k <= (dy<<)/(dx) ;
                     line_m <= (ye_in<<) - line_k*xe_in ;
             end 

 reg  [:] x_cnt ;        // X 坐标计数
 reg  [:] y_cnt ;        // Y 坐标计数
 //*********************矩形框X方向上计数*********************************
 always @ (posedge clock )
     if(!reset)
             begin
                     x_cnt     <= 'd0 ;
                     fini_flag <= 'd0  ;
             end
     else if (in_en) //装载Xmin值
             begin
                     x_cnt     <= Xmin + 'd1 ;
                     fini_flag <= 'd0  ;
             end
     else if (x_cnt == Xmax) //矩形框扫描完毕
             begin
                     fini_flag <= 'd1  ;
             end
     else if ((y_cnt==Ymax)||(point_flag))  //列扫描完毕，x+1
             begin
                     x_cnt     <= x_cnt + 'd1 ;
                     fini_flag <= 'd0 ;
             end 

 //********************矩形框Y方向上计数 **************
 always @ (posedge clock )
     if(!reset)
             begin
                     y_cnt   <= 'd0 ;
             end
     else if (in_en)  //装载Ymin值
             begin
                     y_cnt   <= Ymin - 'd1 ;
             end
     else if ((y_cnt == Ymax)||(point_flag)) //列扫描完毕重新装载运算
             begin
                     y_cnt     <= Ymin ;
             end
     else     begin
                     y_cnt   <= y_cnt + 'd1 ;
             end 

   always @ (posedge clock )
     if ((!reset) || (in_en))
             begin
                     x_ou       <= 'd0 ;
                     y_ou       <= 'd0  ;
                     point_flag <= 'd0  ;
                     prev1_dm   <= 'd0 ;
                     prev2_dm   <= 'd0 ;
                     curr_dm    <= 'd0 ;
             end
     else if (!fini_flag)
             begin
                     //point_flag <= 1'd0 ;
                     curr_m  <= (y_cnt<<)-(x_cnt*line_k) ;
                     prev1_dm <= curr_dm ;
                     prev2_dm <= prev1_dm;
                     curr_dm <= abs(curr_m , line_m) ;
                     if((prev1_dm<curr_dm) &&(prev1_dm < prev2_dm)) //当前点在远离直线，以上一次的点有效
                             begin
                                     point_flag <= 'd1 ; //找到最近点，x，y跳转，结束x列的查找
                                     prev1_dm   <= 'h00 ;
                                     curr_dm    <= 'h00 ;
                                     prev2_dm   <= 'h00 ;
                                     x_ou <= x_cnt;
                                     y_ou <= y_cnt - 'd3 ;
                             end
                     else     point_flag <= 'd0 ;
             end
     else    begin
                     point_flag <= 'd0 ;
                     prev1_dm   <= 'h00 ;
                     curr_dm    <= 'h00 ;
                     prev2_dm   <= 'h00 ;
                     x_ou       <= 'd0 ;
                     y_ou       <= 'd0  ;
             end 

 endmodule 

附上测试tb

 `timescale 1ns/1ps

 module line_tb ;

 reg clock ,reset ;
 reg in_en ;
 reg [:] xs_in ,xe_in ;
 reg [:] ys_in ,ye_in ; 

 wire [:] x_ou ;
 wire [:] y_ou ;
 wire       fini_flag ;

 line U1_line(
             .clock (clock),
             .reset (reset),
             .xs_in (xs_in),
             .ys_in (ys_in),
             .xe_in (xe_in),
             .ye_in (ye_in),
             .in_en (in_en),       

             .x_ou (x_ou),
             .y_ou (y_ou),
             .fini_flag (fini_flag)
             );

 always  # clock = ~clock ; 

 initial
     begin
             clock = 'd0 ; reset =1'd0 ; in_en = 'd0 ;
             xs_in = 'd0 ; xe_in = 10'd0 ;
             ys_in = 'd0  ; ye_in = 9'd0 ; 

             # reset =  ; in_en =  ;
                 xs_in =  ; xe_in =  ;
                 ys_in =  ; ye_in =  ;
             # in_en =  ;
             # ;
             # ;
             in_en =  ;
             xs_in =  ; xe_in=  ;
             ys_in = ; ye_in=  ;
             # in_en =  ;
             #  $stop ; 

     end 

 endmodule 

其实我听到这个project第一反应是软件中的两个for循环查找差值最小的点，再对应到HDL中想到的是generate，generate写到一半才发现输出怎么办，难道先让结果放到memory里面再慢慢取出来？觉得这么做是不是太繁琐了，于是叉掉重现写。

第二次想到的是用if  else 实现软件中的for，写了n久都觉得这个逻辑关系很纠结，if else 都嵌套了。再加一层嵌套就不利于维护了，证明这个架构是不行的。

最后一想不是可以用计数器实现for吗，哎，是不是最近一直在看C，怎么把HDL设计思想和C 想混合了。对于大师来说我的这个思维历程很搞笑，对于菜鸟的我来说是第一次亲身感受到了软硬件代码设计思想的差异—— 以前只是书上说自己没有感触到