diff --git a/src/main/scala/backBoard/LocalRegisters.scala b/src/main/scala/backBoard/LocalRegisters.scala
index 9d5aae6..8cc402f 100644
--- a/src/main/scala/backBoard/LocalRegisters.scala
+++ b/src/main/scala/backBoard/LocalRegisters.scala
@@ -81,7 +81,7 @@ abstract class BackBoardSlvLocal extends BackBoardSlvBase with BackBoardSlvDown
 
 
 
-  val (us10Counter, us10Trigger) = Counter(Range(0, 100))
+  val (usCounter, usTrigger) = Counter(Range(0, 10))
 
 
 }
@@ -91,13 +91,13 @@ abstract class BackBoardSlvLocal extends BackBoardSlvBase with BackBoardSlvDown
 
 
 trait BackBoardSlvStatusPR { this: BackBoardSlvLocal =>
-  val flashCounter = RegInit( 0.U( 16.W ) )
+  val flashCounter = RegInit( 0.U( 19.W ) )
   val flash2HZ = Reg(Bool())
   val flash1HZ = Reg(Bool())
 
 
-  when( us10Trigger ){
-    when( flashCounter >= 50000.U ){
+  when( usTrigger ){
+    when( flashCounter >= 500000.U ){
       flashCounter := 0.U
       flash2HZ := ~flash2HZ
       when( flash2HZ ){
@@ -126,26 +126,27 @@ trait BackBoardSlvIn { this: BackBoardSlvLocal =>
 
   def gp: Int
 
-  // val flitCfg = Seq(
-  //   // ( 0.U  -> 0.S ),
-  //   ( 1.U -> (1/2).U), // -> 25.S   
-  //   ( 2.U -> (2/2).U), // -> 50.S   
-  //   ( 3.U -> (4/2).U), // -> 100.S  
-  //   ( 4.U -> (8/2).U), // -> 200.S  
-  //   ( 5.U -> (16/2).U), // -> 400.S  
-  //   ( 6.U -> (32/2).U), // -> 800.S  
-  //   ( 7.U -> (64/2).U), // -> 1600.S 
-  //   ( 8.U -> (128/2).U), // -> 3200.S 
-  // )
+  val flitNum = 64
+  require(flitNum <= 128)
 
   val in = IO(Input(UInt((8*gp).W)))
 
-  val flitCnt = RegInit(MixedVecInit(Seq( 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), 0.U(1.W), 0.U(1.W)) ))
+  val flitCnt = RegInit(MixedVecInit(Seq( 0.U(1.W), 0.U((log2Ceil(256/flitNum)).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) := us10Trigger
+  // flitTrigger(1) := usTrigger
+
+  flitTrigger(1) := flitCnt(1) >= (256/flitNum-1).U
+  when( ~RegNext(usTrigger) & usTrigger ){
+    when( flitTrigger(1) ){
+      flitCnt(1) := 0.U
+    } .otherwise{
+      flitCnt(1) := flitCnt(1) + 1.U      
+    }
+
+  }
 
   flitTrigger(2) := flitCnt(2) === 1.U
   when( ~RegNext(flitTrigger(1)) & flitTrigger(1) ){
@@ -196,32 +197,32 @@ trait BackBoardSlvIn { this: BackBoardSlvLocal =>
 
     for( i <- 0 until 8 ) {
 
-      val flitter = RegInit(VecInit( Seq.fill(25){false.B}))
-      val flitHi  = RegInit(0.U(5.W))
+      val flitter = RegInit(VecInit( Seq.fill(flitNum){false.B}))
+      val flitHi  = RegInit(0.U((log2Ceil(flitNum+1)).W))
 
       ( 0 until 9 ).map{ k => 
         when( digitalFilter === k.U ){
           when( flitTrigger(k) ){
             flitter(0) := in(i+8*j)
-            (1 until 25).map{ k =>
+            (1 until flitNum).map{ k =>
               flitter(k) := flitter(k-1)
             }
 
-            when( (~flitter(24) & ~in(i+8*j)) | (flitter(24) & in(i+8*j)) ){
+            when( (~flitter(flitNum-1) & ~in(i+8*j)) | (flitter(flitNum-1) & in(i+8*j)) ){
               flitHi := flitHi
-            } .elsewhen( ~flitter(24) & in(i+8*j) ){
+            } .elsewhen( ~flitter(flitNum-1) & in(i+8*j) ){
               flitHi := flitHi + 1.U
-            } .elsewhen( flitter(24) & ~in(i+8*j) ){
+            } .elsewhen( flitter(flitNum-1) & ~in(i+8*j) ){
               flitHi := flitHi - 1.U
             }
 
-            when( flitHi >= 20.U ){
+            when( flitHi >= (flitNum*4/5).U ){
               digitalIn(i) := true.B
-            } .elsewhen( flitHi <= 5.U ){
+            } .elsewhen( flitHi <= (flitNum/5).U ){
               digitalIn(i) := false.B
             }      
 
-            assert( flitHi <= 25.U )
+            assert( flitHi <= flitNum.U )
             assert( flitter.count( (k:Bool) => k === true.B ) === flitHi )
 
           }