SpinalWorkshop实验笔记(一)

概述

最近在学习SpinalHDL,在github上看到了SpinalHDL实验,于是试着做了做。虽然这些实验的答案在仓库里给出来了,但我是FPGA初学者,虽然会一点verilog却对各种总线一窍不通,也不了解scala,所以即使要理解这些实验也花费了一番功夫。在这里记录一下我做这些实验的感想。本文涉及Counter、PWM、UART、Prime四个实验。

内容

Counter

Counter实验很简单,只要实现一个计数器,并且不要求时钟信号。所以直接按教程里的图片连线即可:

  val r = Reg(UInt(width bits)) init(0)
  r := io.clear ? U(0) | r + 1
  io.value := r
  io.full := r === (1 << width) - 1

注意的点:

  • 比较SpinalHDL的类型需要使用三等于号
  • 寄存器声明的时候一定要初始化,不初始化测试会出错

PWM

难度陡然上升(当然可能是我太菜)。这个实验的关键是理解SpinalHDL的master/slave模型。我们可以把实现了IMasterSlave的端口集合理解为一个两种用途的端口集合。当它在模块里被声明成master时,集合里某些端口是输入端口,另一些是输出,而被声明成slave时,那些master时的输入端口此时变为输出端口,master的输出端口变为输入端口。也就是所有端口的输入输出方向发生了反转。

由于教程的Component interfaces指定了模块的apb端口集合是slave类型的,所以我们需要APB这个端口集合中哪些端口在被声明成slave时是输入端口,哪些是输出端口。这回我们需要理解这个模块是干啥的,查看波形可以发现这个模块似乎是一个方波发生器,就是比较timer寄存器和dutycycle寄存器的值,前者小于后者输出高电平,否则输出低电平。同时有另外一个需求,就是外面的模块要能读写enable和dutycycle两个寄存器(其实我一开始没看出来,这教程写得不清不楚的)。很容易想出当APB作为slave时,是外界向本模块提供要写入的值,同时读出值。因此,写相关的端口当然是输入,读相关的端口当然是输出。加上一些控制信号PSEL、PENABLE和PADDR也明显是输入进这些模块的,因此就可以写出APB的声明:

//APB interface definition
case class Apb(config: ApbConfig) extends Bundle with IMasterSlave {
  //TODO define APB signals
  val PSEL = Bits(config.selWidth bits)
  val PENABLE = Bool()
  val PWRITE = Bool()
  val PADDR = UInt(config.addressWidth bits)
  val PWDATA = Bits(config.dataWidth bits)
  val PRDATA = Bits(config.dataWidth bits)
  val PREADY = Bool()

  override def asMaster(): Unit = {
    //TODO define direction of each signal in a master mode
    out(PSEL, PENABLE, PWRITE, PADDR, PWDATA)
    in(PRDATA, PREADY)

  }
}

声明里定义端口的输入和输出是通过重写asMaster方法,而且针对的是master声明的,因此需要将我们刚才的讨论倒过来,就是上面的代码。

io端口的声明和logic块很简单,和Counter实验差不多:

  val io = new Bundle{
    val apb = slave(Apb(apbConfig)) //TODO
    val pwm = out Bool() //TODO
  }

  val logic = new Area {
    //TODO define the PWM logic
    val enable = Reg(False)
    val timer = Reg(UInt(timerWidth bits)) init(0)
    when (enable) {
      timer := timer + 1
    }
    val dutycycle = Reg(UInt(timerWidth bits)) init(0)
    val output = Reg(False)
    output := timer < dutycycle
    io.pwm := output
  }

control块就比较复杂,其负责控制那两个寄存器的读写,所以首先需要根据地址来决定读写那个寄存器,同时写寄存器需要收到控制信号的制约,包括片选信号(PSEL)、使能信号(PENABLE)和写信号(PWRITE)。读寄存器直接读,写寄存器需要控制信号均为真才可以写:

  val control = new Area{
    //TODO define the APB slave logic that will make PWM's registers writable/readable
    val doWrite = io.apb.PSEL(0) && io.apb.PENABLE && io.apb.PWRITE
    io.apb.PRDATA := 0
    io.apb.PREADY := True
    switch(io.apb.PADDR){
      is(0){
        io.apb.PRDATA(0) := logic.enable
        when(doWrite){
          logic.enable := io.apb.PWDATA(0)
        }
      }
      is(4){
        io.apb.PRDATA := logic.dutycycle.asBits.resized
        when(doWrite){
          logic.dutycycle := io.apb.PWDATA.asUInt.resized
        }
      }
    }
  }

UART

这个实验只看文档也挺懵的,实际上它描述的采样状态机应该是这样:

  • IDLE:什么也不做,直到满足跳转条件

  • START:等待一定的时间,然后跳转

  • DATA:重复8次以下操作(用bitCounter计数):

    • 获取preSamplingSize + samplingSize + postSamplingSize个采样tick里rxd信号的值,取其中出现次数超过一半的电平作为本次采样的输出电平(因为samplingSize大于preSamplingSize + samplingSize + postSamplingSize的一半)
    • 假设当前是第i次操作,那么采样的输出电平放到输出寄存器的第i-1位

    这样重复结束后输出寄存器的值就是采样得到的8位整数

  • STOP:等待preSamplingSize + samplingSize + postSamplingSize个采样tick,回到IDLE状态

DATA这一步还是比较清晰的,可能实际的电路没有那么稳定,所以才要通过采样一段时间然后用MajorityVote取出现次数超过一半的电平。但是START和STOP为什么要等待这个数量的采样tick我就不明白了,尤其是START的式子preSamplingSize + (samplingSize - 1) / 2 - 1更是奇怪,不知道怎么回事:

  // Statemachine that use all precedent area
  val stateMachine = new StateMachine {
    //TODO state machine
    val value = Reg(io.read.payload)
    io.read.valid := False
    always {
      io.read.payload := value
    }
    val IDLE: State = new State with EntryPoint {
      whenIsActive {
        when (sampler.tick && !sampler.value) {
          bitTimer.recenter := True
          goto(START)
        }
      }
    }
    val START = new State {
      whenIsActive {
        when (bitTimer.tick) {
          bitCounter.clear := True
          goto(DATA)
        }
      }
    }
    val DATA = new State {
      whenIsActive {
        when (bitTimer.tick) {
          value(bitCounter.value) := sampler.value
          when (bitCounter.value === 7) {
            goto(STOP)
          }
        }
      }
    }
    val STOP = new State {
      whenIsActive {
        when (bitTimer.tick) {
          io.read.valid := True
          goto(IDLE)
        }
      }
    }
  }

“等待一定的时间”和“采样一定的时间”这些操作都由bitTimer计算,当recenter信号被触发时,等待的采样tick是preSamplingSize + (samplingSize - 1) / 2 - 1,在START结束后bitTimer里的计数器减到0自然溢出到(1 << width) - 1,由于程序前面规定了preSamplingSize + samplingSize + postSamplingSize必须是2的幂,所以两条式子相等,之后在recenter下一次被触发前计都是按那条式子计算等待时间和采样时间。

另外是Flow的用法,当数据有效时把valid端口置为真,数据传到payload端口。注意寄存器传到payload端口这句必须放在状态机之外或者状态机内的always块里,否则会报“latch”错误。因为payload端口应该是短时间的信号而不是寄存器,所以不能在“某个状态”内赋值。同时,对于bitCounter和bitTimer内的信号进行的操作也是短时间的,在当前状态内是高电平,出了这个状态就又变回低电平了。

最后注意状态机,我用的是文档里介绍的style A写法,这种写法需要注意如果是当前声明的状态被后面声明的状态使用(如当前声明的IDLE在后面声明STOP中用到了),那么当前声明的状态就不能用自动类型推断,不然会报“递归定义”的错误。如上面的IDLE就在声明里显式指出了其类型State。

Prime

代码很简单,但是新手很容易误解。比如我,一开始看见源程序里给出了基于scala基础类型判断质数的函数apply,就在想能不能将传给我的SpinalHDL类型的数转换成基础类型然后调用apply判断,但找不到转换函数。看了答案才意识到这样肯定是不行的,因为apply不能被编译成电路,怎么能用来判断呢。正确方法是利用apply函数构造一个质数表,然后将传给我的数依次和质数表里的数比较,如果其中一个为真就返回真。这种情况下质数表可以转换成一组常量信号,然后用比较器和参数进行比较最后用一个大或门就能计算结果,可以编译成电路的形式,实际上就类似于教程里给出的Verilog代码:

  def apply(n : UInt) : Bool = {
    //TODO
    return (0 until 1 << widthOf(n)).filter(apply(_)).map(n === _).orR
  }

这里缩成一行,意思是构造整数区间[0, 1 << n的位宽)(注意是左闭右开区间),将整数区间里的所有数用apply检查一下(这里的apply是针对scala基础类型的),选出是质数的,这样就构造出了一个质数表。然后将质数表里的每个数和n比较一下,相等的为真,不等的为假,这样就构造出了一个布尔表,注意这个布尔,指的是SpinalHDL的Bool而不是scala的Boolean了,因为是UInt参与比较,用的也是三等于号。最后将布尔表或一下,如果表里有一个真值,即n和一个质数相等,则返回真。

另外scala的匿名函数写起来真爽,连lambda关键字还是箭头标识符之类的都不用了,够简洁。

posted @ 2021-12-15 11:32  YuanZiming  阅读(906)  评论(0编辑  收藏  举报