Packages

p

spinal

core

package core

Ordering
  1. Alphabetic
  2. By Inheritance
Inherited
  1. core
  2. BaseTypeCast
  3. UFixCast
  4. SFixCast
  5. BaseTypeFactory
  6. UFixFactory
  7. SFixFactory
  8. TypeFactory
  9. VecFactory
  10. SIntFactory
  11. UIntFactory
  12. BitsFactory
  13. BoolFactory
  14. AnyRef
  15. Any
  1. Hide All
  2. Show All
Visibility
  1. Public
  2. All

Type Members

  1. trait Area extends Nameable with ContextUser with OwnableRef with ScalaLocated with ValCallbackRec

    Sometime, creating a Component to define some logic is overkill.

    Sometime, creating a Component to define some logic is overkill. For this kind of cases you can use Area to define a group of signals/logic.

    Example:
    1. val tickConter = new Area{
        val tick = Reg(UInt(8 bits) init(0)
        tick := tick + 1
      }
    See also

    Area Documentation

  2. trait AssertNodeSeverity extends AnyRef
  3. trait Assignable extends AnyRef

    Assignable trait

  4. trait Attribute extends SpinalTag
  5. class AttributeFlag extends Attribute
  6. sealed trait AttributeKind extends AnyRef
  7. class AttributeString extends Attribute
  8. abstract class BaseType extends Data with DeclarationStatement with StatementDoubleLinkedContainer[BaseType, AssignmentStatement] with Expression

    Abstract base class of all Spinal types

  9. trait BaseTypeCast extends SFixCast with UFixCast

    Base type Cast

  10. trait BaseTypeFactory extends BoolFactory with BitsFactory with UIntFactory with SIntFactory with VecFactory with SFixFactory with UFixFactory

    Base type factory

  11. implicit class BigDecimalBuilder extends AnyRef

    BigDecimal Builder

  12. case class BigIntBuilder(i: BigInt) extends Product with Serializable

    BigInt Builder

  13. case class BitCount(value: Int) extends Product with Serializable

    Represent the number of bit of a data

  14. abstract class BitVector extends BaseType with Widthable

    BitVector is a family of types for storing multiple bits of information in a single value.

    BitVector is a family of types for storing multiple bits of information in a single value. This type has three subtypes that can be used to model different behaviours:

    • Bits
    • UInt (unsigned integer)
    • SInt (signed integer)
    See also

    BitVector Documentation

  15. abstract class BitVectorLiteralFactory[T <: BitVector] extends AnyRef

    Base class to create Bit Vector from literal

  16. class Bits extends BitVector with DataPrimitives[Bits] with BitwiseOp[Bits]

    The Bits type corresponds to a vector of bits that does not convey any arithmetic meaning.

    The Bits type corresponds to a vector of bits that does not convey any arithmetic meaning.

    Example:
    1. val myBits1 = Bits(32 bits)
      val myBits2 = B(25, 8 bits)
      val myBits3 = B"8'xFF"
      val myBits4 = B"1001_0011
    See also

    Bits Documentation

  17. trait BitsFactory extends AnyRef

    Bits factory used for instance by the IODirection to create a in/out Bits

  18. trait BitwiseOp[T <: Data] extends AnyRef

    Bitwise Operation

    Bitwise Operation

    T

    the type which is associated with the bitwise operation

  19. abstract class BlackBox extends Component

    A blackbox allows the user to integrate an existing VHDL/Verilog component into the design by just specifying the interfaces.

    A blackbox allows the user to integrate an existing VHDL/Verilog component into the design by just specifying the interfaces.

    Example:
    1.  class Ram_1w_1r(wordWidth: Int, wordCount: Int) extends BlackBox {
           val generic = new Generic {
               val wordCount = Ram_1w_1r.this.wordCount
               val wordWidth = Ram_1w_1r.this.wordWidth
           }
           val io = new Bundle {
               val clk = in Bool
               val wr = new Bundle {
                   val en   = in Bool
                   val addr = in UInt (log2Up(wordCount) bit)
                   val data = in Bits (wordWidth bit)
               }
               val rd = new Bundle {
                   val en   = in Bool
                   val addr = in UInt (log2Up(wordCount) bit)
                   val data = out Bits (wordWidth bit)
               }
           }
           mapClockDomain(clock=io.clk)
      }
  20. abstract class BlackBoxULogic extends BlackBox

    Create a blackBox with std_ulogic instead of std_logic

  21. class Bool extends BaseType with DataPrimitives[Bool] with BitwiseOp[Bool]

    The Bool type corresponds to a boolean value (True or False)

    The Bool type corresponds to a boolean value (True or False)

    Example:
    1. val myBool = Bool()
      myBool := False
      myBool := Bool(false)
    See also

    Bool Documentation

  22. case class BoolEdges() extends Bundle with Product with Serializable

    Bundle for the edge detection

  23. trait BoolFactory extends AnyRef

    Bool factory used for instance by the IODirection to create a in/out Bool

  24. class Bundle extends MultiData with Nameable with ValCallbackRec
  25. class BundleCase extends Bundle
  26. case class ClockDomain(clock: Bool, reset: Bool = null, dummyArg: DummyTrait = null, softReset: Bool = null, clockEnable: Bool = null, config: ClockDomainConfig = GlobalData.get.commonClockConfig, frequency: ClockFrequency = UnknownFrequency(), clockEnableDivisionRate: DivisionRate = ClockDomain.UnknownDivisionRate()) extends Product with Serializable

    clock and reset signals can be combined to create a clock domain.

    clock and reset signals can be combined to create a clock domain. Clock domains could be applied to some area of the design and then all synchronous elements instantiated into this area will then implicitly use this clock domain. Clock domain application work like a stack, which mean, if you are in a given clock domain, you can still apply another clock domain locally

    See also

    ClockDomain Documentation

  27. sealed trait ClockDomainBoolTag extends SpinalTag
  28. case class ClockDomainConfig(clockEdge: EdgeKind = RISING, resetKind: ResetKind = ASYNC, resetActiveLevel: Polarity = HIGH, softResetActiveLevel: Polarity = HIGH, clockEnableActiveLevel: Polarity = HIGH) extends Product with Serializable
  29. case class ClockDomainTag(clockDomain: ClockDomain) extends SpinalTag with Product with Serializable
  30. case class ClockDrivedTag(driver: Bool) extends SpinalTag with Product with Serializable
  31. case class ClockDriverTag(drived: Bool) extends SpinalTag with Product with Serializable
  32. class ClockEnableArea extends Area with PostInitCallback

    Clock Area with a specila clock enable

  33. case class ClockEnableTag(clockDomain: ClockDomain) extends ClockDomainBoolTag with Product with Serializable
  34. case class ClockSyncTag(a: Bool, b: Bool) extends SpinalTag with Product with Serializable
  35. case class ClockTag(clockDomain: ClockDomain) extends ClockDomainBoolTag with Product with Serializable
  36. class ClockingArea extends Area with PostInitCallback

    Clock domains could be applied to some area of the design and then all synchronous elements instantiated into this area will then implicitly use this clock domain.

    Clock domains could be applied to some area of the design and then all synchronous elements instantiated into this area will then implicitly use this clock domain.

    See also

    ClockDomain Documentation

  37. abstract class Component extends NameableByComponent with ContextUser with ScalaLocated with PostInitCallback with Stackable with OwnableRef with SpinalTagReady with OverridedEqualsHashCode with ValCallbackRec

    Abstract class used to create a new Component

    Abstract class used to create a new Component

    Example:
    1. class MyAndGate extends Component {
        val io = new Bundle{
          val a,b = in Bool
          val res = out Bool
        }
        io.res := io.a & io.b
      }
    See also

    Component Documentation

  38. trait ConditionalContext extends GlobalDataUser
  39. trait ContextUser extends GlobalDataUser with ScalaLocated
  40. case class CyclesCount(value: BigInt) extends Product with Serializable

    Cycles number representation

  41. trait Data extends ContextUser with NameableByComponent with Assignable with SpinalTagReady with GlobalDataUser with ScalaLocated with OwnableRef with OverridedEqualsHashCode
  42. class DataPimper[T <: Data] extends DataPrimitives[T]

    Should not extends AnyVal, Because it create kind of strange call stack move that make error reporting miss accurate

  43. trait DataPrimitives[T <: Data] extends AnyRef
  44. trait DataWrapper extends Data
  45. class DefaultTag extends SpinalTag
  46. case class Device(vendor: String = "?", family: String = "?", name: String = "?") extends Product with Serializable

    target device

  47. class DontName extends Annotation with Annotation with ClassfileAnnotation
  48. case class DoubleBuilder(d: Double) extends Product with Serializable

    Double Builder

  49. trait DummyTrait extends AnyRef
  50. case class DumpWaveConfig(depth: Int = 0, vcdPath: String = "wave.vcd") extends Product with Serializable
  51. sealed trait EdgeKind extends AnyRef
  52. class ElseWhenClause extends AnyRef
  53. implicit class ElseWhenClauseBuilder extends AnyRef

    Implicit clause builder for elseWhen

  54. class EnumLiteral[T <: SpinalEnum] extends Literal with InferableEnumEncodingImpl

    Node representation which contains the value of an SpinalEnumElement

  55. class EnumPoison extends Literal with InferableEnumEncodingImpl
  56. case class ExpNumber(value: Int) extends Product with Serializable

    Exponent representation

  57. class ExternalDriverTag extends SpinalTag
  58. case class FixPointConfig(roundType: RoundType, symmetric: Boolean) extends Product with Serializable
  59. type FixedFrequency = core.ClockDomain.FixedFrequency
  60. class GenerationFlags extends AnyRef
  61. class Generic extends AnyRef

    Create a generic for a BlackBox

    Create a generic for a BlackBox

    Example:
    1. class myMemory(sizeMem: Int) extends BlackBox{
          val generic = new Generic{
           val size = sizeMem
          }
          val io = new Bundle { ... }
      }
  62. case class GenericValue(e: Expression) extends SpinalTag with Product with Serializable
  63. class GlobalData extends AnyRef

    Global data

  64. trait GlobalDataUser extends AnyRef

    Get a link to the globalData

  65. class HardType[T <: Data] extends AnyRef
  66. case class HertzNumber(v: BigDecimal) extends PhysicalNumber[HertzNumber] with Product with Serializable

    Frequency representation

  67. type IClockDomainFrequency = ClockFrequency
  68. trait IODirection extends BaseTypeFactory

    Trait used to set the direction of a data

  69. class IfDefTag extends SpinalTag
  70. abstract class ImplicitArea[T] extends Area

    Create an Area which can be assign to a data

    Create an Area which can be assign to a data

    Example:
    1. class Counter extends ImplicitArea[UInt]{
         val cnt = Reg(UInt(8 bits)
         ...
         override def implicitValue: UInt = cnt
      }
      val myCounter = Counter()
      io.myUInt = myCounter
  71. final class IntBuilder extends AnyVal

    Integer Builder

  72. sealed trait Language extends AnyRef
  73. implicit class LiteralBuilder extends AnyRef

    Literal builder S/U/B"e.g. : B"8'xFF"

  74. class MaskedBoolean extends AnyRef

    Masked Literal

    Masked Literal

    Example:
    1. val itMatch = myBits === M"00--10--" // - don't care value
  75. class MaskedLiteral extends AnyRef
  76. class Mem[T <: Data] extends DeclarationStatement with StatementDoubleLinkedContainer[Mem[_], MemPortStatement] with WidthProvider with SpinalTagReady
  77. trait MemBlackboxingPolicy extends AnyRef
  78. trait MemPortStatement extends LeafStatement with StatementDoubleLinkedContainerElement[Mem[_], MemPortStatement]
  79. class MemReadAsync extends MemPortStatement with WidthProvider with SpinalTagReady with ContextUser with Expression
  80. class MemReadSync extends MemPortStatement with WidthProvider with SpinalTagReady with ContextUser with Expression
  81. class MemReadWrite extends MemPortStatement with WidthProvider with SpinalTagReady with ContextUser with Expression
  82. trait MemTechnologyKind extends AnyRef
  83. class MemWrite extends MemPortStatement with WidthProvider with SpinalTagReady
  84. class MemWritePayload[T <: Data] extends Bundle
  85. trait MinMaxProvider extends AnyRef

    Min max base function

  86. abstract class MultiData extends Data

    Base class for multi data like Vec, Bundle

  87. trait Nameable extends OwnableRef with ContextUser
  88. trait NameableByComponent extends Nameable with GlobalDataUser
  89. class NamingScope extends AnyRef
  90. trait Num[T <: Data] extends AnyRef

    Base operations for numbers

    Base operations for numbers

    T

    the type which is associated with the base operation

  91. trait OverridedEqualsHashCode extends AnyRef
  92. trait OwnableRef extends AnyRef
  93. abstract class PhysicalNumber[T <: PhysicalNumber[_]] extends AnyRef

    Base class for the Physical representation (Hertz, Time, ...)

  94. sealed trait Polarity extends AnyRef
  95. case class PosCount(value: Int) extends Product with Serializable

    Position representation

  96. case class QFormat(width: Int, fraction: Int, signed: Boolean) extends Product with Serializable
  97. class Ram_1w_1ra extends BlackBox

    Ram 1w 1ra

  98. class Ram_1w_1rs extends BlackBox

    Ram 1w 1rs

  99. class Ram_1wors extends BlackBox

    Ram 1wors

  100. class Ram_1wrs extends BlackBox

    Ram 1wrs

  101. class Ram_2c_1w_1rs extends BlackBox

    Ram 2c 1w 1rs

  102. class Ram_2wrs extends BlackBox

    Ram 2wrs

  103. implicit class RangePimper extends AnyRef

    Implicit Range helper

  104. trait ReadUnderWritePolicy extends AnyRef
  105. case class Ref[T](value: T) extends Product with Serializable

    Use to give value by reference to a function

  106. class ResetArea extends Area with PostInitCallback

    ResetArea allow to reset an area with a special reset combining with the current reset (cumulative)

  107. sealed trait ResetKind extends AnyRef
  108. case class ResetTag(clockDomain: ClockDomain) extends ClockDomainBoolTag with Product with Serializable
  109. sealed trait RoundType extends AnyRef
  110. class SFix extends XFix[SFix, SInt]

    Signed fix point

    Signed fix point

    See also

    SFix Documentation

  111. class SFix2D extends Bundle
  112. trait SFixCast extends AnyRef
  113. trait SFixFactory extends TypeFactory
  114. class SInt extends BitVector with Num[SInt] with MinMaxProvider with DataPrimitives[SInt] with BitwiseOp[SInt]

    The SInt type corresponds to a vector of bits that can be used for signed integer arithmetic.

    The SInt type corresponds to a vector of bits that can be used for signed integer arithmetic.

    Example:
    1. val mySInt = SInt(8 bits)
      mySInt    := S(4, 8 bits) + S"0000_1111"
      mySInt    := S(4) - S"h1A"
    See also

    SInt Documentation

  115. trait SIntFactory extends AnyRef

    SInt factory used for instance by the IODirection to create a in/out SInt

  116. implicit class SIntPimper extends AnyRef

    Implicit SInt helper

  117. class SafeStack[T] extends AnyRef

    Safe Stack

  118. class SafeStackWithStackable[T <: Stackable] extends SafeStack[T]
  119. trait ScalaLocated extends GlobalDataUser
  120. trait ScopeProperty[T] extends AnyRef
  121. class ScopePropertyValue extends AnyRef
  122. case class SlicesCount(value: Int) extends Product with Serializable

    Slice size representation

  123. class SlowArea extends ClockingArea

    Define a clock domain which is x time slower than the current clock

  124. case class SpinalConfig(mode: SpinalMode = null, flags: HashSet[Any] = mutable.HashSet[Any](), debugComponents: HashSet[Class[_]] = mutable.HashSet[Class[_]](), keepAll: Boolean = false, defaultConfigForClockDomains: ClockDomainConfig = ClockDomainConfig(), onlyStdLogicVectorAtTopLevelIo: Boolean = false, defaultClockDomainFrequency: IClockDomainFrequency = UnknownFrequency(), targetDirectory: String = ".", oneFilePerComponent: Boolean = false, netlistFileName: String = null, dumpWave: DumpWaveConfig = null, globalPrefix: String = "", privateNamespace: Boolean = false, formalAsserts: Boolean = false, anonymSignalPrefix: String = null, device: Device = Device(), inlineRom: Boolean = false, genVhdlPkg: Boolean = true, verbose: Boolean = false, mergeAsyncProcess: Boolean = false, asyncResetCombSensitivity: Boolean = false, anonymSignalUniqueness: Boolean = false, noRandBoot: Boolean = false, randBootFixValue: Boolean = true, noAssert: Boolean = false, fixToWithWrap: Boolean = true, headerWithDate: Boolean = false, headerWithRepoHash: Boolean = true, phasesInserters: ArrayBuffer[(ArrayBuffer[Phase]) ⇒ Unit] = ..., transformationPhases: ArrayBuffer[Phase] = ArrayBuffer[Phase](), memBlackBoxers: ArrayBuffer[Phase] = ..., rtlHeader: String = null, scopeProperties: LinkedHashMap[ScopeProperty[_], Any] = ..., _withEnumString: Boolean = true) extends Product with Serializable

    Spinal configuration for the generation of the RTL

  125. class SpinalEnum extends Nameable with ScalaLocated

    Base class for creating enumeration

    Base class for creating enumeration

    Example:
    1. object MyEnum extends SpinalEnum(binarySequential){
        val s1, s2, s3, s4 = newElement()
      }

      SpinalEnum contains a list of SpinalEnumElement that is the definition of an element. SpinalEnumCraft is the hardware representation of the the element.

    See also

    Enumeration Documentation

  126. class SpinalEnumCraft[T <: SpinalEnum] extends BaseType with InferableEnumEncodingImpl with DataPrimitives[SpinalEnumCraft[T]]

    Hardware representation of an enumeration

  127. class SpinalEnumElement[T <: SpinalEnum] extends Nameable

    Definition of an element of the enumeration

  128. trait SpinalEnumEncoding extends Nameable with ScalaLocated

    Trait to define an encoding

  129. class SpinalExit extends Exception
  130. trait SpinalMode extends AnyRef
  131. class SpinalReport[T <: Component] extends AnyRef

    Spinal report give after the generation of the RTL

  132. trait SpinalTag extends AnyRef
  133. trait SpinalTagReady extends AnyRef
  134. trait Stackable extends AnyRef
  135. class SwitchContext extends AnyRef
  136. case class TimeNumber(v: BigDecimal) extends PhysicalNumber[TimeNumber] with Product with Serializable

    Time representation

  137. trait TypeFactory extends AnyRef
  138. class UFix extends XFix[UFix, UInt]

    Unsigned fix point

    Unsigned fix point

    See also

    UFix Documentation

  139. class UFix2D extends Bundle

    Two-dimensional XFix

  140. trait UFixCast extends AnyRef
  141. trait UFixFactory extends TypeFactory
  142. class UInt extends BitVector with Num[UInt] with MinMaxProvider with DataPrimitives[UInt] with BitwiseOp[UInt]

    The UInt type corresponds to a vector of bits that can be used for unsigned integer arithmetic.

    The UInt type corresponds to a vector of bits that can be used for unsigned integer arithmetic.

    Example:
    1. val myUInt = UInt(8 bits)
       myUInt := U(2,8 bits)
       myUInt := U(2)
       myUInt := U"0000_0101"
       myUInt := U"h1A"
    See also

    UInt Documentation

  143. case class UInt2D(xBitCount: BitCount, yBitCount: BitCount) extends Bundle with Product with Serializable

    Define an UInt 2D point

    Define an UInt 2D point

    xBitCount

    width of the x point

    yBitCount

    width of the y point

    Example:
    1. val positionOnScreen = Reg(UInt2D(log2Up(p.screenResX) bits, log2Up(p.screenResY) bits))
  144. trait UIntFactory extends AnyRef

    UInt factory used for instance by the IODirection to create a in/out UInt

  145. implicit class UIntPimper extends AnyRef

    Implicit UInt helper

  146. type UnknownFrequency = core.ClockDomain.UnknownFrequency
  147. trait ValCallbackRec extends ValCallback

    The Bundle is a composite type that defines a group of named signals (of any SpinalHDL basic type) under a single name.

    The Bundle is a composite type that defines a group of named signals (of any SpinalHDL basic type) under a single name. The Bundle can be used to model data structures, buses and interfaces.

    Example:
    1. val cmd = new Bundle{
        val init   = in Bool
        val start  = in Bool
        val result = out Bits(32 bits)
      }
    See also

    Bundle Documentation

  148. class VarAssignementTag extends SpinalTag
  149. class Vec[T <: Data] extends MultiData with IndexedSeq[T]

    The Vec is a composite type that defines a group of indexed signals (of any SpinalHDL basic type) under a single name

    The Vec is a composite type that defines a group of indexed signals (of any SpinalHDL basic type) under a single name

    Example:
    1. val myVecOfSInt = Vec(SInt(8 bits), 2)
    See also

    Vec Documentation

  150. class VecAccessAssign[T <: Data] extends Assignable
  151. trait VecFactory extends AnyRef

    Vec factory

  152. class VecBuilder extends AnyRef
    Definition Classes
    VecFactory
  153. class WhenContext extends ConditionalContext with ScalaLocated

    else / else if statement

    else / else if statement

    See also

    when Documentation

  154. abstract class XFix[T <: XFix[T, R], R <: BitVector with Num[R]] extends MultiData

    Base class for SFix and UFix

  155. type dontName = spinal.core.DontName @scala.annotation.meta.field

Value Members

  1. implicit def BigIntToBits(that: BigInt): Bits
  2. implicit def BigIntToBuilder(value: BigInt): BigIntBuilder
  3. implicit def BigIntToSInt(that: BigInt): SInt
  4. implicit def BigIntToUInt(that: BigInt): UInt
  5. def Bits(width: BitCount): Bits

    Create a new Bits of a given width

    Create a new Bits of a given width

    Definition Classes
    BitsFactory
  6. def Bits(): Bits

    Create a new Bits

    Create a new Bits

    Definition Classes
    BitsFactory
  7. def Bool(value: Boolean): Bool

    Create a new Bool initialized with a boolean value

    Create a new Bool initialized with a boolean value

    Definition Classes
    BoolFactory
  8. def Bool(): Bool

    Create a new Bool

    Create a new Bool

    Definition Classes
    BoolFactory
  9. implicit def BooleanPimped[T <: Data](that: Boolean): BooleanPimped
  10. implicit def DataPimped[T <: Data](that: T): DataPimper[T]

    Implicit Data helper

  11. val DefaultFixPointConfig: FixPointConfig
  12. implicit def DoubleToBuilder(value: Double): DoubleBuilder
  13. implicit def EnumCtoEnumC2[T <: SpinalEnum, T2 <: T](craft: SpinalEnumCraft[T2]): SpinalEnumCraft[T]
  14. implicit def EnumCtoEnumC3[T <: SpinalEnum, T2 <: T](craft: SpinalEnumCraft[T]): SpinalEnumCraft[T2]
  15. implicit def EnumElementToCraft[T <: SpinalEnum](element: SpinalEnumElement[T]): SpinalEnumCraft[T]
  16. implicit def EnumEtoEnumE2[T <: SpinalEnum, T2 <: T](element: SpinalEnumElement[T2]): SpinalEnumElement[T]

    Implicit enum conversion

  17. implicit def EnumEtoEnumE3[T <: SpinalEnum, T2 <: T](element: SpinalEnumElement[T]): SpinalEnumElement[T2]
  18. def False: Bool
  19. def FixedFrequency(value: HertzNumber): core.ClockDomain.FixedFrequency
  20. implicit def IntToBits(that: Int): Bits
  21. implicit def IntToBuilder(value: Int): IntBuilder

    Implicit Int/BigInt/Double to Builder

  22. implicit def IntToSInt(that: Int): SInt
  23. implicit def IntToUInt(that: Int): UInt

    Implicit conversion from Int/BigInt/String to UInt/SInt/Bits

  24. implicit def LongToBits(that: Long): Bits
  25. implicit def LongToSInt(that: Long): SInt
  26. implicit def LongToUInt(that: Long): UInt
  27. val LowCostFixPointConfig: FixPointConfig
  28. def SFix(peak: ExpNumber, resolution: ExpNumber): SFix
    Definition Classes
    SFixFactory
  29. def SFix(peak: ExpNumber, width: BitCount): SFix
    Definition Classes
    SFixFactory
  30. def SInt(width: BitCount): SInt

    Create a new SInt of a given width

    Create a new SInt of a given width

    Definition Classes
    SIntFactory
  31. def SInt(): SInt

    Create a new SInt

    Create a new SInt

    Definition Classes
    SIntFactory
  32. def True: Bool

    True / False definition

  33. def UFix(peak: ExpNumber, resolution: ExpNumber): UFix
    Definition Classes
    UFixFactory
  34. def UFix(peak: ExpNumber, width: BitCount): UFix
    Definition Classes
    UFixFactory
  35. def UInt(width: BitCount): UInt

    Create a new UInt of a given width

    Create a new UInt of a given width

    Definition Classes
    UIntFactory
  36. def UInt(): UInt

    Create a new UInt

    Create a new UInt

    Definition Classes
    UIntFactory
  37. def UnknownFrequency(): core.ClockDomain.UnknownFrequency
  38. def Vec[T <: Data](firstElement: T, followingElements: T*): Vec[T]
    Definition Classes
    VecFactory
  39. def Vec[T <: Data](gen: ⇒ T, size: Int): Vec[T]
    Definition Classes
    VecFactory
  40. def Vec[T <: Data](elements: TraversableOnce[T], dataType: HardType[T] = null): Vec[T]
    Definition Classes
    VecFactory
  41. val Vec: VecBuilder
    Definition Classes
    VecFactory
  42. def assert(assertion: Bool, message: Seq[Any], severity: AssertNodeSeverity): AssertStatement
  43. def assert(assertion: Bool, message: String, severity: AssertNodeSeverity): AssertStatement
  44. def assert(assertion: Bool, message: Seq[Any]): AssertStatement
  45. def assert(assertion: Bool, message: String): AssertStatement
  46. def assert(assertion: Bool, severity: AssertNodeSeverity): AssertStatement
  47. def assert(assertion: Bool): AssertStatement
  48. final def assert(assertion: Boolean, message: ⇒ Any): Unit
    Annotations
    @elidable( ASSERTION ) @inline()
  49. def assert(assertion: Boolean): Unit

    Assertion

    Assertion

    Annotations
    @elidable( ASSERTION )
  50. def assume(assertion: Bool): AssertStatement
  51. def cover(assertion: Bool): AssertStatement
  52. implicit lazy val implicitConversions: implicitConversions

    Scala implicit

  53. def postTypeFactory[T <: Data](that: T): T
    Definition Classes
    TypeFactory
  54. implicit lazy val postfixOps: postfixOps
  55. implicit lazy val reflectiveCalls: reflectiveCalls
  56. def report(message: Seq[Any], severity: AssertNodeSeverity): AssertStatement
  57. def report(message: String, severity: AssertNodeSeverity): AssertStatement
  58. def report(message: Seq[Any]): AssertStatement
  59. def report(message: String): AssertStatement
  60. object ASYNC extends ResetKind
  61. object AllowMixedWidth extends SpinalTag
  62. object Analog

    Set a data to Analog

  63. object AnnotationUtils
  64. object ArrayManager
  65. object B extends BitVectorLiteralFactory[Bits]

    Used to create a new Bits or cast to Bits

  66. object BOOT extends ResetKind
  67. object BaseType
  68. object COMMENT_ATTRIBUTE extends AttributeKind
  69. object Cat

    Concatenate a list of data

  70. object Clock
  71. object ClockDomain extends Serializable
  72. object CombInit

    Declare a register with an initialize value

  73. object Component
  74. object ConditionalContext
  75. object CyclesCount extends Serializable
  76. object DEFAULT_ATTRIBUTE extends AttributeKind
  77. object Data
  78. object DataAssign
  79. object Device extends Serializable
  80. object Driver
  81. object ERROR extends AssertNodeSeverity
  82. object FAILURE extends AssertNodeSeverity
  83. object FALLING extends EdgeKind
  84. object FixPointProperty extends ScopeProperty[FixPointConfig]
  85. object Formal
  86. object GenerationFlags
  87. object GlobalData
  88. object HIGH extends Polarity
  89. object HardType
  90. object ImplicitArea
  91. object Info
  92. object InitAssign
  93. object LOW extends Polarity
  94. object Language
  95. object LocatedPendingError
  96. object MaskedLiteral
  97. object Mem
  98. object MemReadAsync
  99. object MemReadSync
  100. object MemReadWrite
  101. object MemWrite
  102. object Mux

    Mux operation

  103. object NOTE extends AssertNodeSeverity
  104. object Nameable
  105. object OwnableRef
  106. object PendingError
  107. object RISING extends EdgeKind
  108. object Reg

    Create a register

  109. object RegInit

    Declare a register with an initialize value

  110. object RegNext

    Register a signal of one clock

  111. object RegNextWhen

    Register a signal when a condition is true

  112. object RoundType
  113. object S extends BitVectorLiteralFactory[SInt]

    Used to create a new SInt or cast to SInt

  114. object SF
  115. object SFix2D

    Two-dimensionnal SFix

  116. object SQ
  117. object SYNC extends ResetKind
  118. object ScalaLocated
  119. object ScopeProperty
  120. object Select
  121. object Spinal
  122. object SpinalConfig extends Serializable
  123. object SpinalEnumEncoding

    Used to create a custom encoding

    Used to create a custom encoding

    Example:
    1. object BR extends SpinalEnum{
        val NE, EQ, J, JR = newElement()
        defaultEncoding = SpinalEnumEncoding("opt")(
            EQ -> 0,
            NE -> 1,
            J  -> 2,
            JR -> 3 )
      }
  124. object SpinalError
  125. object SpinalExit extends Serializable
  126. object SpinalInfo
  127. object SpinalLog
  128. object SpinalMap

    Spinal map

  129. object SpinalProgress
  130. object SpinalSystemVerilog
  131. object SpinalTagReady
  132. object SpinalVerilog
  133. object SpinalVhdl
  134. object SpinalWarning
  135. object SystemVerilog extends SpinalMode
  136. object U extends BitVectorLiteralFactory[UInt]

    Used to create a new UInt or cast to UInt

  137. object UF
  138. object UFix2D

    Two-dimensionnal UFix

  139. object UInt2D extends Serializable
  140. object UQ
  141. object VHDL extends SpinalMode
  142. object Verilator
  143. object Verilog extends SpinalMode
  144. object WARNING extends AssertNodeSeverity
  145. object addDefaultGenericValue extends SpinalTag

    In VHDL add the generic value in the definition of the blackbox

  146. object allowAssignmentOverride extends SpinalTag
  147. object allowDirectionLessIoTag extends SpinalTag
  148. object auto extends MemTechnologyKind
  149. object binaryOneHot extends SpinalEnumEncoding

    Binary One hot encoding

    Binary One hot encoding

    Example:
    1. 001, 010, 100
  150. object binarySequential extends SpinalEnumEncoding

    Binary Sequential

    Binary Sequential

    Example:
    1. 000, 001, 010, 011, 100, 101, ....
  151. object blackboxAll extends MemBlackboxingPolicy
  152. object blackboxAllWhatsYouCan extends MemBlackboxingPolicy
  153. object blackboxOnlyIfRequested extends MemBlackboxingPolicy
  154. object blackboxRequestedAndUninferable extends MemBlackboxingPolicy
  155. object cloneOf

    Return a new data with the same data structure than the given parameter (including bit width)

  156. object crossClockBuffer extends SpinalTag
  157. object crossClockDomain extends SpinalTag
  158. object default

    default statement of a switch case

    default statement of a switch case

    See also

    switch Documentation

  159. object distributedLut extends MemTechnologyKind
  160. object dontCare extends ReadUnderWritePolicy
  161. object getFixRound
  162. object getFixSym
  163. object ifGen
  164. object in extends IODirection

    Set a data to input

  165. object inWithNull extends IODirection

    Set a data to in if the data is not null

  166. object inferred extends SpinalEnumEncoding

    Inferred encoding

  167. object inout extends IODirection

    Set a data to inout

  168. object is

    is statement of a switch case

    is statement of a switch case

    See also

    switch Documentation

  169. object isPow2

    Check if a number is a power of 2

  170. object log2Up

    Give number of bit to encode a given number of states

  171. object native extends SpinalEnumEncoding

    Native encoding

  172. object noBackendCombMerge extends SpinalTag
  173. object noCombinatorialLoopCheck extends SpinalTag
  174. object noNumericType extends SpinalTag

    Transform all unsigned/signed into std_logic_vector

  175. object out extends IODirection

    Set a data to output

  176. object outWithNull extends IODirection

    Set a data to out if the data is not null

  177. object ramBlock extends MemTechnologyKind
  178. object randomBoot extends SpinalTag
  179. object readFirst extends ReadUnderWritePolicy
  180. object registerFile extends MemTechnologyKind
  181. object roundUp

    Round up a BigInt

  182. object signalCache
  183. object switch

    case/switch statement

    case/switch statement

    Example:
    1. switch(x){
          is(value1){
              //execute when x === value1
          }
          is(value2){
              //execute when x === value2
          }
          default{
             //execute if none of precedent condition meet
          }
       }
    See also

    switch Documentation

  184. object tagAutoResize extends SpinalTag
  185. object tagTruncated extends SpinalTag
  186. object uLogic extends SpinalTag

    Create a Ulogic tag used by Blackbox in order to transform std_logic into std_ulogic

  187. object unsetRegIfNoAssignementTag extends SpinalTag
  188. object unusedTag extends SpinalTag
  189. object weakCloneOf

    Return a new data with the same data structure than the given parameter (execept bit width)

  190. object when

    If statement

    If statement

    Example:
    1. when(cond1){
        myCnt := 0
      }elsewhen(cond2){
        myCnt := myCnt + 1
      }otherwise{
        myCnt := myCnt - 1
      }
    See also

    when Documentation

  191. object widthOf

    Return the number of bit of the given data

  192. object writeFirst extends ReadUnderWritePolicy

Deprecated Value Members

  1. def toSFix(sint: SInt): SFix
    Definition Classes
    SFixCast
    Annotations
    @deprecated
    Deprecated

    (Since version ???) Use xxx.toSFix instead

  2. def toUFix(uint: UInt): UFix
    Definition Classes
    UFixCast
    Annotations
    @deprecated
    Deprecated

    (Since version ???) Use xxx.toUFix instead

  3. object Sel

    Sel operation

    Sel operation

    Annotations
    @deprecated
    Deprecated

    (Since version ???) Use Select instead

  4. object cloneable
    Annotations
    @deprecated
    Deprecated

    (Since version ???) Use HardType instead

  5. object wrap
    Annotations
    @deprecated
    Deprecated

    (Since version ???) Use HardType instead

Inherited from BaseTypeCast

Inherited from UFixCast

Inherited from SFixCast

Inherited from BaseTypeFactory

Inherited from UFixFactory

Inherited from SFixFactory

Inherited from TypeFactory

Inherited from VecFactory

Inherited from SIntFactory

Inherited from UIntFactory

Inherited from BitsFactory

Inherited from BoolFactory

Inherited from AnyRef

Inherited from Any

Ungrouped