改为甲方需要的滤波方式

src/main/scala/backBoard/LocalRegisters.scala

@@ -37,7 +37,7 @@ abstract class BackBoardSlvLocal extends BackBoardSlvBase with BackBoardSlvDown
   val rankNum    = downReg(4)
   val statusLed  = downReg(5)(1,0)
 
-  val (us10Counter, us10Trigger) = Counter(Range(0, 500))
+  val (us10Counter, us10Trigger) = Counter(Range(0, 100))
 
   when( true.B ){
 
@@ -69,18 +69,18 @@ abstract class BackBoardSlvLocal extends BackBoardSlvBase with BackBoardSlvDown
 }
 
 trait BackBoardSlvStatusLed { this: BackBoardSlvLocal =>
-  val flashCounter = RegInit( 0.U( 20.W ) )
+  val flashCounter = RegInit( 0.U( 17.W ) )
 
   when( us10Trigger ){
-    when( flashCounter === 100000.U ){
+    when( flashCounter >= 100000.U ){
       flashCounter := 0.U
     } .otherwise{
       flashCounter := flashCounter + 1.U      
     }
   }
 
-  val flash1HZ = flashCounter.extract(19)
+  val flash1HZ = flashCounter.extract(16)
-  val flash2HZ = flashCounter.extract(18)
+  val flash2HZ = flashCounter.extract(15)
 
   val LED_PR = IO(Output( Bool() ))
 
@@ -99,51 +99,105 @@ trait BackBoardSlvIn { this: BackBoardSlvLocal =>
   def gp: Int
 
   val flitCfg = Seq(
-    ( 0.U  -> 0.S ),
+    // ( 0.U  -> 0.S ),
-    ( 1.U  -> 10.S),
+    ( 1.U -> (1/2).U), // -> 25.S   
-    ( 2.U  -> 25.S),
+    ( 2.U -> (2/2).U), // -> 50.S   
-    ( 3.U  -> 50.S),
+    ( 3.U -> (4/2).U), // -> 100.S  
-    ( 4.U  -> 100.S),
+    ( 4.U -> (8/2).U), // -> 200.S  
-    ( 5.U  -> 200.S),
+    ( 5.U -> (16/2).U), // -> 400.S  
-    ( 6.U  -> 400.S),
+    ( 6.U -> (32/2).U), // -> 800.S  
-    ( 7.U  -> 800.S),
+    ( 7.U -> (64/2).U), // -> 1600.S 
-    ( 8.U  -> 1600.S),
+    ( 8.U -> (128/2).U), // -> 3200.S 
-    ( 9.U  -> 3200.S),
-    ( 10.U -> 6400.S),
   )
 
   val in = IO(Input(UInt((8*gp).W)))
 
-  val digitalIn = Reg( Vec( 8*gp, Bool() ) )
+  val flitCnt = RegInit(MixedVecInit(Seq( 0.U(1.W), 0.U(5.W), 0.U(1.W), 0.U(1.W), 0.U(1.W), 0.U(1.W), 0.U(1.W), 0.U(1.W), 0.U(1.W)) ))
+  val flitTrigger = Wire(Vec(9, Bool()))
 
+  flitTrigger(0) := true.B
+
+  flitTrigger(1) := flitCnt(1) === 24.U
+  when( ~RegNext(us10Trigger) & us10Trigger ){
+    flitCnt(1) := Mux( flitCnt(1) >= 24.U, 0.U, flitCnt(1) + 1.U )
+  }
+
+  flitTrigger(2) := flitCnt(2) === 1.U
+  when( ~RegNext(flitTrigger(1)) & flitTrigger(1) ){
+    flitCnt(2) := flitCnt(2) + 1.U
+  }
+
+  flitTrigger(3) := flitCnt(3) === 1.U
+  when( ~RegNext(flitTrigger(2)) & flitTrigger(2) ){
+    flitCnt(3) := flitCnt(3) + 1.U
+  }
+
+  flitTrigger(4) := flitCnt(4) === 1.U
+  when( ~RegNext(flitTrigger(3)) & flitTrigger(3) ){
+    flitCnt(4) := flitCnt(4) + 1.U
+  }
+
+  flitTrigger(5) := flitCnt(5) === 1.U
+  when( ~RegNext(flitTrigger(4)) & flitTrigger(4) ){
+    flitCnt(5) := flitCnt(5) + 1.U
+  }
+
+  flitTrigger(6) := flitCnt(6) === 1.U
+  when( ~RegNext(flitTrigger(5)) & flitTrigger(5) ){
+    flitCnt(6) := flitCnt(6) + 1.U
+  }
+
+  flitTrigger(7) := flitCnt(7) === 1.U
+  when( ~RegNext(flitTrigger(6)) & flitTrigger(6) ){
+    flitCnt(7) := flitCnt(7) + 1.U
+  }
+
+  flitTrigger(8) := flitCnt(8) === 1.U
+  when( ~RegNext(flitTrigger(7)) & flitTrigger(7) ){
+    flitCnt(8) := flitCnt(8) + 1.U
+  }
 
   for( j <- 0 until gp ) {
-    when( true.B ) { upReg( 2+j ) := Cat( ( 8*j+7 to 8*j ).map{ k => digitalIn(k) } ) }
 
     val digitalFilter = downReg(0+j)
+    val digitalIn = Wire( Vec(8, Bool()) )
+
+    when(true.B){ upReg( 2+j ) := Cat( digitalIn.reverse  ) }
 
     for( i <- 0 until 8 ) {
-      val toCnt = RegInit( 0.S( 16.W ) )
 
-      flitCfg.map{ ( cfg: (UInt,SInt) ) => 
+      val flitter = RegInit(VecInit( Seq.fill(25){false.B}))
-        when( digitalFilter === cfg._1 ){
+      val flitHi  = RegInit(0.U(5.W))
-          when( in(i+8*j) ){
+
-            when( toCnt >= cfg._2 ){
+      digitalIn(i) := upReg( 2+j )(i)
-              toCnt := cfg._2
+
-              digitalIn(i+8*j) := true.B
+      ( 0 until 9 ).map{ k => 
-            } .otherwise{
+        when( digitalFilter === k.U ){
-              toCnt := toCnt + 1.S
+          when( flitTrigger(k) ){
-            }
+            flitter(0) := in(i+8*j)
-          } .otherwise{
+            (1 until 25).map{ k =>
-            when( toCnt <= -cfg._2 ){
+              flitter(k) := flitter(k-1)
-              toCnt := -cfg._2
-              digitalIn(i+8*j) := false.B
-            } .otherwise{
-              toCnt := toCnt - 1.S
-            }
-          }
             }
 
+            when( (~flitter(24) & ~in(i+8*j)) | (flitter(24) & in(i+8*j)) ){
+              flitHi := flitHi
+            } .elsewhen( ~flitter(24) & in(i+8*j) ){
+              flitHi := flitHi + 1.U
+            } .elsewhen( flitter(24) & ~in(i+8*j) ){
+              flitHi := flitHi - 1.U
+            }
+
+            when( flitHi >= 20.U ){
+              digitalIn(i) := true.B
+            } .elsewhen( flitHi <= 5.U ){
+              digitalIn(i) := false.B
+            }      
+
+            assert( flitHi <= 25.U )
+            assert( flitter.count( (k:Bool) => k === true.B ) === flitHi )
+
+          }
+        }
       }
     }
   }