eb001/src/main/scala/backBoard/shin/SlaveSendGen.scala

package BACK

import chisel3._
import chisel3.util._


class SubMsgTxInfo extends SubMsgHeader{
  val source = UInt(2.W)
}


class SlaveSendGenIO extends Bundle{
  val data = Vec(2, Flipped( Decoupled(UInt(8.W)) ) )



  val frameReq  = Flipped(Decoupled( new FrameHeader ))
  val subMsgHeadReq = Flipped(Decoupled( new SubMsgTxInfo ))
  val subMsgTailReq = Flipped(Decoupled( new SubMsgTail ))

  val send = Decoupled(new AXIS_Bundle(8))

  val isError = Output(Bool())
  val stateCurr = Output(UInt(3.W))
}




class SlaveSendGen extends Module{
  val io: SlaveSendGenIO = IO(new SlaveSendGenIO)


  val crc = Module(new crc32_8)

  val FRAME_STYLE_COMMON = 0.U
  val FRAME_STYLE_PROBE  = 1.U

  val STATE_IDLE            = 0.U //空闲
  val STATE_FRAME_HEADER    = 1.U //长度/ /保留2bits //包类型
  val STATE_SUBMSG_HEADER   = 2.U
  val STATE_SUBMSG_DATA     = 3.U
  val STATE_SUBMSG_TAIL     = 4.U
  val STATE_CRC             = 5.U //CRC校验
  val STATE_WAIT            = 6.U


  val stateNext = Wire(UInt(3.W))
  val stateCurr = RegNext(stateNext, STATE_IDLE); io.stateCurr := stateCurr

  io.isError := false.B//stateCurr === STATE_ERROR

  crc.io.isEnable := io.send.fire & (
    stateCurr === STATE_FRAME_HEADER |
    stateCurr === STATE_SUBMSG_HEADER |
    stateCurr === STATE_SUBMSG_DATA    
  )




  crc.reset := reset.asBool | stateCurr === STATE_IDLE



  val frameInfo = Reg(new FrameHeader)

  val subMsgHeadInfo = Reg(new SubMsgTxInfo)
  val subMsgTailInfo = Reg(new SubMsgTail)




  when( io.frameReq.fire ){
    frameInfo := io.frameReq.bits
  }

  when( io.subMsgHeadReq.fire ){
    subMsgHeadInfo := io.subMsgHeadReq.bits
  }

  when( io.subMsgTailReq.fire ){
    subMsgTailInfo := io.subMsgTailReq.bits
  }



  val lengthCnt   = Reg(UInt(12.W))
  val frameLenCnt = Reg(UInt(12.W))

  when( io.send.fire ){
    when( stateCurr === STATE_FRAME_HEADER ){
      frameLenCnt := 0.U
    } .elsewhen( stateCurr === STATE_SUBMSG_HEADER || stateCurr === STATE_SUBMSG_DATA || stateCurr === STATE_SUBMSG_TAIL ){
      frameLenCnt := frameLenCnt + 1.U
    }    
  }


  when( stateCurr =/= stateNext ){
    lengthCnt := 0.U
  } .elsewhen(io.send.fire){
    lengthCnt := lengthCnt + 1.U
  }



  io.frameReq.ready := true.B
  io.subMsgHeadReq.ready := stateCurr =/= STATE_SUBMSG_HEADER & stateNext === STATE_SUBMSG_HEADER
  io.subMsgTailReq.ready := stateCurr =/= STATE_SUBMSG_TAIL   & stateNext === STATE_SUBMSG_TAIL


  stateNext := Mux1H(Seq(
    (stateCurr === STATE_IDLE)          -> Mux( io.frameReq.fire, STATE_FRAME_HEADER, STATE_IDLE ),
    (stateCurr === STATE_FRAME_HEADER)  -> Mux( io.send.fire, Mux( lengthCnt === (4-1).U, Mux( 
      frameInfo.frameStyle === FRAME_STYLE_COMMON,
        Mux(io.subMsgHeadReq.valid, STATE_SUBMSG_HEADER, STATE_WAIT),
        STATE_CRC ),
      STATE_FRAME_HEADER), STATE_FRAME_HEADER ),
    (stateCurr === STATE_SUBMSG_HEADER) -> Mux( io.send.fire, Mux( lengthCnt === (6-1).U, STATE_SUBMSG_DATA, STATE_SUBMSG_HEADER), STATE_SUBMSG_HEADER),
    
    (stateCurr === STATE_SUBMSG_DATA)   -> Mux( io.send.fire, 
      Mux( lengthCnt === subMsgHeadInfo.length-1.U, STATE_SUBMSG_TAIL, STATE_SUBMSG_DATA ), //已经发送完成该子报文
      STATE_SUBMSG_DATA ),
    
    (stateCurr === STATE_SUBMSG_TAIL)   -> Mux( io.send.fire, 
      Mux( lengthCnt === (2-1).U,    //已经发送完成该子报文尾
        Mux( frameLenCnt === frameInfo.frameLenAim -1.U, STATE_CRC, //主报文长度达到， 进CRC
          Mux( io.subMsgHeadReq.valid, STATE_SUBMSG_HEADER, STATE_WAIT ) ), //主报文长度未到，进下一个子报文
        STATE_SUBMSG_TAIL
      ), STATE_SUBMSG_TAIL ),

    (stateCurr === STATE_CRC)           -> Mux( io.send.fire, Mux( lengthCnt === (4-1).U, STATE_IDLE, STATE_CRC ), STATE_CRC),
    // (stateCurr === STATE_ERROR)         -> Mux( io.send.fire, STATE_IDLE, STATE_ERROR),
    (stateCurr === STATE_WAIT)          -> Mux( io.subMsgHeadReq.valid, STATE_SUBMSG_HEADER, STATE_WAIT),
  ))

  io.data(0).ready := io.send.fire & (stateCurr === STATE_SUBMSG_DATA) & (subMsgHeadInfo.source === 0.U)
  io.data(1).ready := io.send.fire & (stateCurr === STATE_SUBMSG_DATA) & (subMsgHeadInfo.source === 1.U)

  assert( ~(io.data(0).ready & ~io.data(0).valid) )
  assert( ~(io.data(1).ready & ~io.data(1).valid) )



  io.send.valid := 
    (stateCurr === STATE_FRAME_HEADER)  |
    (stateCurr === STATE_SUBMSG_HEADER) |
    (stateCurr === STATE_SUBMSG_DATA & ( (io.data(0).valid & subMsgHeadInfo.source === 0.U) | (io.data(1).valid & subMsgHeadInfo.source === 1.U)  ))   |
    (stateCurr === STATE_SUBMSG_TAIL) |
    (stateCurr === STATE_CRC)


  val tdata_frame_header = Mux1H(Seq(
    (lengthCnt === 0.U) -> frameInfo.frameLenAim(11,4),
    (lengthCnt === 1.U) -> Cat( frameInfo.frameLenAim(3,0), 0.U(2.W), frameInfo.frameStyle),
    (lengthCnt === 2.U) -> frameInfo.frameInfo(15,8),
    (lengthCnt === 3.U) -> frameInfo.frameInfo( 7,0),
  ))

  val tdata_submsg_header = Mux1H(Seq(
    (lengthCnt === 0.U) -> subMsgHeadInfo.devIndex(13,6),
    (lengthCnt === 1.U) -> Cat( subMsgHeadInfo.devIndex(5,0), subMsgHeadInfo.style),
    (lengthCnt === 2.U) -> subMsgHeadInfo.address(15,8),
    (lengthCnt === 3.U) -> subMsgHeadInfo.address(7,0),
    (lengthCnt === 4.U) -> Cat(subMsgHeadInfo.operator, subMsgHeadInfo.length(11,8)),
    (lengthCnt === 5.U) -> subMsgHeadInfo.length(7,0),
  ))

  val tdata_submsg_data = Mux1H(Seq(
    (subMsgHeadInfo.source === 0.U) -> io.data(0).bits,
    (subMsgHeadInfo.source === 1.U) -> io.data(1).bits,
  ))

  val tdata_submsg_tail = Mux1H(Seq(
    (lengthCnt === 0.U) -> subMsgTailInfo.workCnt(15,8),
    (lengthCnt === 1.U) -> subMsgTailInfo.workCnt( 7,0),
  ))

  crc.io.dataIn := Mux1H(Seq(
    (stateCurr === STATE_FRAME_HEADER)  -> tdata_frame_header,
    (stateCurr === STATE_SUBMSG_HEADER) -> tdata_submsg_header,
    (stateCurr === STATE_SUBMSG_DATA)   -> tdata_submsg_data,
    (stateCurr === STATE_SUBMSG_TAIL)   -> tdata_submsg_tail,
  ))


  val tdata_crc = Mux1H(Seq(
    (lengthCnt === 0.U) -> crc.io.crc(31,24),
    (lengthCnt === 1.U) -> crc.io.crc(23,16),
    (lengthCnt === 2.U) -> crc.io.crc(15, 8),
    (lengthCnt === 3.U) -> crc.io.crc( 7, 0),
  ))

  io.send.bits.tdata := Mux1H(Seq(
    (stateCurr === STATE_FRAME_HEADER)  -> tdata_frame_header,
    (stateCurr === STATE_SUBMSG_HEADER) -> tdata_submsg_header,
    (stateCurr === STATE_SUBMSG_DATA)   -> tdata_submsg_data,
    (stateCurr === STATE_SUBMSG_TAIL)   -> tdata_submsg_tail,
    (stateCurr === STATE_CRC)           -> tdata_crc,
  ))

  io.send.bits.tuser := false.B//(stateCurr === STATE_ERROR & stateNext === STATE_IDLE)
  io.send.bits.tlast := (stateCurr === STATE_CRC & stateNext === STATE_IDLE) //|| (stateCurr === STATE_ERROR & stateNext === STATE_IDLE)



}