मैं एक राज्य मशीन को कई लक्षणों में विभाजित करने की कोशिश कर रहा हूं, इसलिए प्रति राज्य एक विशेषता। प्रत्येक राज्य में एक सबस्टेट मशीन होती है, इसलिए विभाजन मेरे लिए कोड को और अधिक पठनीय बना देगा।

असल में मैं पहली बार में असफल हो रहा हूँ जब बयान।

मेरा वास्तविक टेस्ट कोड इस तरह दिखता है:

class A extends Module with B{
    val io = IO(
        new Bundle{
            val state = Output(UInt(2.W))
            val substate = Output(UInt(2.W))
        }
    )

    lazy val state = RegInit(0.U(2.W))
    lazy val substate = RegInit(0.U(2.W))
    io.state := state
    io.substate := substate
}

trait B{
    def state : UInt
    def substate : UInt

    when(state === 0.U){
        state := 1.U
        substate := ~substate
    }
}

Verilog कोड जनरेट करते समय यह सबस्टेट के टॉगल करने के समय को अनदेखा कर देता है। तो वेरिलोग "हमेशा" असाइनमेंट के साथ इस तरह दिखता है:

  assign _T_7 = state == 2'h0; // @[traittest.scala 25:16:@9.4]
  assign _T_11 = ~ substate; // @[traittest.scala 27:21:@13.6]
  always @(posedge clock) begin
    if (reset) begin
      state <= 2'h0;
    end else begin
      if (_T_7) begin
        state <= 2'h1;
      end
    end
    if (reset) begin
      substate <= 2'h0;
    end else begin
      substate <= _T_11;
    end
  end

मैंने इसे राज्य और सबस्टेट वैल के लिए ओवरराइड और संरक्षित संशोधक के साथ करने की कोशिश की लेकिन इससे कोई फर्क नहीं पड़ता और मुझे कोई अन्य विचार नहीं है कि इसे कैसे काम करना है। शायद लक्षण उसके लिए सही निर्माण नहीं हैं?

3
julian 10 जिंदा 2021, 19:07

1 उत्तर

सबसे बढ़िया उत्तर

अच्छा प्रश्न। मुझे लगता है कि आपकी कक्षाओं के निर्माण के दौरान मूल्यांकन के आदेश से आपको काटा जा रहा है। आलसी वैल का मूल्यांकन करने से पहले लक्षणों को निष्पादित किया जाता है। राज्य मशीन निर्माण में कुछ रुचि रही है जिसे chisel3 रेपो के मुद्दों में खोज कर पाया जा सकता है, आपको वहां थोड़ा इधर-उधर करना चाहिए।

लेकिन तुरंत विचार करने के लिए यह निष्पादन योग्य उदाहरण देखें। यह स्रोत है, मुझे लगता है कि यह आप जो खोज रहे हैं उसके करीब हो सकता है।

import chisel3._
import chisel3.stage.ChiselStage
import chiseltest._
import chiseltest.experimental.ChiselTestShell

trait State {
  def state: UInt
  def substate: UInt
}

class A extends Module with State {
    val io = IO(
        new Bundle{
            val state = Output(UInt(2.W))
            val substate = Output(UInt(2.W))
        }
    )

    val state = RegInit(0.U(2.W))
    val substate = RegInit(0.U(2.W))
  
    new B(state, substate)
    new C(state, substate)
  
    io.state := state
    io.substate := substate
}

class B(val state: UInt, val substate: UInt) extends State {
    when(state === 0.U){
        state := 1.U
        substate := ~substate
    }
}

class C(val state: UInt, val substate: UInt) extends State {
    when(state === 1.U){
        state := 2.U
        substate := substate + 1.U
    }
}

println((new ChiselStage()).emitVerilog(new A))
3
Chick Markley 10 जिंदा 2021, 23:35