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. class AFix extends MultiData with Num[AFix] with BitwiseOp[AFix] with MinMaxDecimalProvider
  2. trait AllowIoBundle extends AnyRef
  3. trait Area extends NameableByComponent with ContextUser with OwnableRef with ScalaLocated with ValCallbackRec with OverridedEqualsHashCode
  4. trait AreaObject extends Area
  5. trait AreaRoot extends Area
  6. trait AssertNodeSeverity extends AnyRef
  7. trait Assignable extends AnyRef

    Assignable trait

  8. trait Attribute extends SpinalTag
  9. class AttributeFlag extends Attribute
  10. class AttributeInteger extends Attribute
  11. sealed trait AttributeKind extends AnyRef
  12. class AttributeString extends Attribute
  13. abstract class BaseType extends Data with DeclarationStatement with StatementDoubleLinkedContainer[BaseType, AssignmentStatement] with Expression

    Abstract base class of all Spinal types

  14. trait BaseTypeCast extends SFixCast with UFixCast

    Base type Cast

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

    Base type factory

  16. class BaseTypePimper[T <: BaseType] extends AnyRef
  17. trait BaseTypePrimitives[T <: BaseType] extends AnyRef
  18. implicit class BigDecimalBuilder extends AnyRef

    BigDecimal Builder

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

    BigInt Builder

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

    Represent the number of bit of a data

  21. 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

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

    Base class to create Bit Vector from literal

  23. class Bits extends BitVector with DataPrimitives[Bits] with BaseTypePrimitives[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

  24. trait BitsFactory extends AnyRef

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

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

    Bitwise Operation

    Bitwise Operation

    T

    the type which is associated with the bitwise operation

  26. 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)
}
  27. class BlackBoxImpl extends AnyRef
  28. abstract class BlackBoxULogic extends BlackBox

    Create a blackBox with std_ulogic instead of std_logic

  29. class Bool extends BaseType with DataPrimitives[Bool] with BaseTypePrimitives[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

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

    Bundle for the edge detection

  31. trait BoolFactory extends AnyRef

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

  32. class Bundle extends MultiData with Nameable with ValCallbackRec
  33. class BundleCase extends Bundle
  34. 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 SpinalTagReady with 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

  35. sealed trait ClockDomainBoolTag extends SpinalTag
  36. case class ClockDomainConfig(clockEdge: EdgeKind = RISING, resetKind: ResetKind = ASYNC, resetActiveLevel: Polarity = HIGH, softResetActiveLevel: Polarity = HIGH, clockEnableActiveLevel: Polarity = HIGH) extends Product with Serializable
  37. case class ClockDomainReportTag(clockDomain: ClockDomain) extends SpinalTag with Product with Serializable
  38. case class ClockDomainTag(clockDomain: ClockDomain) extends SpinalTag with Product with Serializable
  39. case class ClockDrivedTag(driver: Bool) extends SpinalTag with Product with Serializable
  40. case class ClockDriverTag(drived: Bool) extends SpinalTag with Product with Serializable
  41. class ClockEnableArea extends Area with PostInitCallback

    Clock Area with a special clock enable

  42. case class ClockEnableTag(clockDomain: ClockDomain) extends ClockDomainBoolTag with Product with Serializable
  43. case class ClockSyncTag(a: Bool, b: Bool) extends SpinalTag with Product with Serializable
  44. case class ClockTag(clockDomain: ClockDomain) extends ClockDomainBoolTag with Product with Serializable
  45. 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

  46. class CommentTag extends SpinalTag
  47. 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

  48. class Composite[T <: Nameable] extends Area

    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

  49. trait ConditionalContext extends GlobalDataUser
  50. trait ContextUser extends GlobalDataUser with ScalaLocated
  51. class CrossClockBufferDepth extends SpinalTag
  52. case class CyclesCount(value: BigInt) extends Product with Serializable

    Cycles number representation

  53. trait Data extends ContextUser with NameableByComponent with Assignable with SpinalTagReady with GlobalDataUser with ScalaLocated with OwnableRef with OverridedEqualsHashCode with InComponent
  54. 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

  55. trait DataPrimitives[T <: Data] extends AnyRef
  56. trait DataWrapper extends Data
  57. class DefaultTag extends SpinalTag
  58. case class Device(vendor: String = "?", family: String = "?", name: String = "?", supportBootResetKind: Boolean = true) extends Product with Serializable

    target device

  59. class DontName extends Annotation with Annotation with ClassfileAnnotation
    Annotations
    @Retention()
  60. case class DoubleBuilder(d: Double) extends Product with Serializable

    Double Builder

  61. trait DummyTrait extends AnyRef
  62. case class DumpWaveConfig(depth: Int = 0, vcdPath: String = "wave.vcd") extends Product with Serializable
  63. trait DuringWritePolicy extends AnyRef
  64. sealed trait EdgeKind extends AreaObject
  65. class ElseWhenClause extends AnyRef
  66. implicit class ElseWhenClauseBuilder extends AnyRef

    Implicit clause builder for elseWhen

  67. sealed trait Endianness extends AnyRef

    Endianness enumeration

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

    Node representation which contains the value of an SpinalEnumElement

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

    Exponent representation

  71. class ExternalDriverTag extends SpinalTag
  72. case class FixPointConfig(roundType: RoundType, symmetric: Boolean) extends Product with Serializable
  73. type FixedFrequency = core.ClockDomain.FixedFrequency
  74. class GenerationFlags extends AnyRef
  75. 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 { ... }
}
  76. case class GenericValue(e: Expression) extends SpinalTag with Product with Serializable
  77. class GlobalData extends AnyRef

    Global data

  78. trait GlobalDataUser extends AnyRef

    Get a link to the globalData

  79. class HardMap extends MultiData
  80. class HardType[T <: Data] extends OverridedEqualsHashCode
  81. case class HertzNumber(v: BigDecimal) extends PhysicalNumber[HertzNumber] with Product with Serializable

    Frequency representation

  82. type IClockDomainFrequency = ClockFrequency
  83. trait IConnectable[T <: IConnectable[T]] extends AnyRef
  84. sealed trait IODirection extends BaseTypeFactory

    Declare ports

    Declare ports

    A port is some Data with a direction, which can be in, out or inout.

    There are 4 available syntaxes, which are all equivalent:

    val braces = in(Vec(Bool, 5))

val short = in Vec (Bool, 5)

val spaceful = in port Vec(Bool, 5)

val variadic = Vec(Bool, 5)
in(variadic)

    The "braces" syntax is short and generic, but it uses braces.

    The "short" syntax is short, but it is formatted with a space between the type and its parameters, and it can be used only with:

    • Bool
    • Bits
    • UInt
    • SInt
    • Vec

    The "spaceful" syntax is generic and beatiful, but more verbose.

    The "variadic" syntax can be used with any number of ports, but can be used only if the ports types are already declared.

    See also

    in out inout

  85. class IfDefTag extends SpinalTag
  86. 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
  87. trait InComponent extends AnyRef
  88. final class IntBuilder extends AnyVal

    Integer Builder

  89. class Interface extends Bundle

    system verilog interface

    system verilog interface

    Example

    case class MyIf(width: Int = 8) extends Interface with IMasterSlave {
 val wParam = addGeneric("WIDTH", width, default = "8")
 val a = Bits(width bits)
 tieGeneric(a, wParam)
 val b = Bool()
 val c = SInt(8 bits)

 override def asMaster = mst
 @modport
 def mst = {
   out(a, b, c)
 }

 @modport
 def slv = {
   in(a, b, c)
 }

}
  90. sealed trait Language extends AnyRef
  91. implicit class LiteralBuilder extends AnyRef

    Literal builder

    Literal builder 

    S/U/B"[[size']base]value"

    e.g.: 

    B"8'xFF"`
  92. class MaskedBoolean extends AnyRef

    Masked Literal

    Masked Literal

    Example: 

    1. val itMatch = myBits === M"00--10--" // - don't care value
  93. class MaskedLiteral extends AnyRef
  94. class Mem[T <: Data] extends DeclarationStatement with StatementDoubleLinkedContainer[Mem[_], MemPortStatement] with WidthProvider with SpinalTagReady with InComponent
  95. trait MemBlackboxingPolicy extends AnyRef
  96. trait MemPortStatement extends LeafStatement with StatementDoubleLinkedContainerElement[Mem[_], MemPortStatement] with Nameable
  97. class MemReadAsync extends MemPortStatement with WidthProvider with SpinalTagReady with ContextUser with Expression
  98. class MemReadSync extends MemPortStatement with WidthProvider with SpinalTagReady with ContextUser with Expression
  99. class MemReadWrite extends MemPortStatement with WidthProvider with SpinalTagReady with ContextUser with Expression
  100. case class MemSymbolesMapping(name: String, range: Range) extends Product with Serializable
  101. case class MemSymbolesTag(mapping: Seq[MemSymbolesMapping]) extends SpinalTag with Product with Serializable
  102. trait MemTechnologyKind extends AnyRef
  103. class MemWrite extends MemPortStatement with WidthProvider with SpinalTagReady
  104. class MemWritePayload[T <: Data] extends Bundle
  105. trait MinMaxDecimalProvider extends AnyRef
  106. trait MinMaxProvider extends AnyRef

    Min max base function

  107. type Module = Component
  108. abstract class MultiData extends Data

    Base class for multi data like Vec, Bundle

  109. trait Nameable extends OwnableRef with ContextUser
  110. trait NameableByComponent extends Nameable with GlobalDataUser
  111. class NamedType[T <: Data] extends HardType[T] with Nameable
  112. class NamingScope extends AnyRef
  113. trait Num[T <: Data] extends AnyRef

    Base operations for numbers

    Base operations for numbers

    T

    the type which is associated with the base operation

  114. trait OverridedEqualsHashCode extends AnyRef
  115. trait OwnableRef extends AnyRef
  116. abstract class PhysicalNumber[T <: PhysicalNumber[_]] extends Formattable

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

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

    When formatting (e.g. via f-interpolation) one can use: - precision to specify precsion (e.g. "%.3f" for three digits past comma) - width to pad with space to a specified length (e.g. "%5f" to get at least 5 characters) - left justified padding (e.g. "%-5f" to pad right to 5 characters) - alternate to print w/o unit (e.g. "%#f")

  117. implicit final class PhysicalNumberPimper extends AnyVal
  118. sealed trait Polarity extends AreaObject
  119. case class PosCount(value: Int) extends Product with Serializable

    Position representation

  120. case class QFormat(width: Int, fraction: Int, signed: Boolean) extends Product with Serializable
  121. class Ram_1w_1ra extends BlackBox
  122. class Ram_1w_1rs extends BlackBox
  123. class Ram_1wors extends BlackBox
  124. class Ram_1wrs extends BlackBox
  125. class Ram_2c_1w_1rs extends BlackBox
  126. class Ram_2wrs extends BlackBox
  127. class Ram_Generic extends BlackBox
  128. implicit class RangePimper extends AnyRef

    Implicit Range helper

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

    Use to give value by reference to a function

  131. class ResetArea extends Area with PostInitCallback

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

  132. sealed trait ResetKind extends AreaObject
  133. case class ResetTag(clockDomain: ClockDomain) extends ClockDomainBoolTag with Product with Serializable
  134. sealed trait RoundType extends AnyRef
  135. class SFix extends XFix[SFix, SInt]

    Signed fix point

    Signed fix point

    See also

    SFix Documentation

  136. class SFix2D extends Bundle
  137. trait SFixCast extends AnyRef
  138. trait SFixFactory extends TypeFactory
  139. class SInt extends BitVector with Num[SInt] with MinMaxProvider with DataPrimitives[SInt] with BaseTypePrimitives[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

  140. trait SIntFactory extends AnyRef

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

  141. implicit class SIntPimper extends AnyRef

    Implicit SInt helper

  142. class SafeStack[T] extends AnyRef

    Safe Stack

  143. class SafeStackWithStackable[T <: Stackable] extends SafeStack[T]
  144. trait ScalaLocated extends GlobalDataUser
  145. class ScopeProperty[T] extends AnyRef
  146. class ScopePropertyContext extends AnyRef
  147. class ScopePropertyValue extends AnyRef
  148. case class SlicesCount(value: Int) extends Product with Serializable

    Slice size representation

  149. class SlowArea extends ClockingArea

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

  150. 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 = SpinalConfig.defaultTargetDirectory, 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, caseRom: Boolean = false, romReuse: Boolean = false, genVhdlPkg: Boolean = true, verbose: Boolean = false, mergeAsyncProcess: Boolean = false, mergeSyncProcess: Boolean = true, asyncResetCombSensitivity: Boolean = false, anonymSignalUniqueness: Boolean = false, inlineConditionalExpression: Boolean = false, nameWhenByFile: Boolean = true, genLineComments: Boolean = false, noRandBoot: Boolean = false, randBootFixValue: Boolean = true, noAssert: Boolean = false, fixToWithWrap: Boolean = true, headerWithDate: Boolean = false, headerWithRepoHash: Boolean = true, removePruned: Boolean = false, allowOutOfRangeLiterals: Boolean = false, dontCareGenAsZero: Boolean = false, obfuscateNames: Boolean = false, normalizeComponentClockDomainName: Boolean = false, devicePhaseHandler: PhaseDeviceHandler = PhaseDeviceDefault, phasesInserters: ArrayBuffer[(ArrayBuffer[Phase]) ⇒ Unit] = ..., transformationPhases: ArrayBuffer[Phase] = ArrayBuffer[Phase](), memBlackBoxers: ArrayBuffer[Phase] = ..., rtlHeader: String = null, scopeProperties: LinkedHashMap[ScopeProperty[_], Any] = ..., _withEnumString: Boolean = true, enumPrefixEnable: Boolean = true, enumGlobalEnable: Boolean = false, bitVectorWidthMax: Int = 4096, singleTopLevel: Boolean = true, noAssertAtTimeZero: Boolean = false, cutLongExpressions: Boolean = true, withTimescale: Boolean = true, printFilelist: Boolean = true, emitFullComponentBindings: Boolean = true, svInterface: Boolean = false) extends Product with Serializable

    Spinal configuration for the generation of the RTL

  151. 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

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

    Hardware representation of an enumeration

  153. class SpinalEnumElement[T <: SpinalEnum] extends Nameable with SpinalTagReady

    Definition of an element of the enumeration

  154. trait SpinalEnumEncoding extends Nameable with ScalaLocated

    Trait to define an encoding

  155. class SpinalExit extends Exception
  156. trait SpinalMode extends AnyRef
  157. class SpinalReport[T <: Component] extends AnyRef

    Spinal report give after the generation of the RTL

  158. abstract class SpinalStruct extends BaseType with Nameable with ValCallbackRec with DataPrimitives[SpinalStruct] with Suffixable

    Class representing Verilog Struct and VHDL Record data types.

  159. trait SpinalTag extends AnyRef
  160. trait SpinalTagGetter[T] extends SpinalTag
  161. trait SpinalTagReady extends AnyRef
  162. trait Stackable extends AnyRef
  163. class SwitchContext extends AnyRef
  164. class TagAFixTruncated extends SpinalTag
  165. case class TimeNumber(v: BigDecimal) extends PhysicalNumber[TimeNumber] with Product with Serializable

    Time representation

  166. sealed trait TimingEndpointType extends AnyRef
  167. class ToBitsPimper extends AnyRef
  168. implicit class Tuple10Pimper extends TuplePimperBase
  169. implicit class Tuple11Pimper extends TuplePimperBase
  170. implicit class Tuple12Pimper extends TuplePimperBase
  171. implicit class Tuple13Pimper extends TuplePimperBase
  172. implicit class Tuple14Pimper extends TuplePimperBase
  173. implicit class Tuple15Pimper extends TuplePimperBase
  174. implicit class Tuple16Pimper extends TuplePimperBase
  175. implicit class Tuple17Pimper extends TuplePimperBase
  176. implicit class Tuple18Pimper extends TuplePimperBase
  177. implicit class Tuple19Pimper extends TuplePimperBase
  178. implicit class Tuple20Pimper extends TuplePimperBase
  179. implicit class Tuple21Pimper extends TuplePimperBase
  180. implicit class Tuple22Pimper extends TuplePimperBase
  181. implicit class Tuple2Pimper extends TuplePimperBase
  182. implicit class Tuple3Pimper extends TuplePimperBase
  183. implicit class Tuple4Pimper extends TuplePimperBase
  184. implicit class Tuple5Pimper extends TuplePimperBase
  185. implicit class Tuple6Pimper extends TuplePimperBase
  186. implicit class Tuple7Pimper extends TuplePimperBase
  187. implicit class Tuple8Pimper extends TuplePimperBase
  188. implicit class Tuple9Pimper extends TuplePimperBase
  189. case class TupleBundle1[T1 <: Data](payloadType1: HardType[T1]) extends TupleBundleBase with Product with Serializable
  190. case class TupleBundle10[T1 <: Data, T2 <: Data, T3 <: Data, T4 <: Data, T5 <: Data, T6 <: Data, T7 <: Data, T8 <: Data, T9 <: Data, T10 <: Data](payloadType1: HardType[T1], payloadType2: HardType[T2], payloadType3: HardType[T3], payloadType4: HardType[T4], payloadType5: HardType[T5], payloadType6: HardType[T6], payloadType7: HardType[T7], payloadType8: HardType[T8], payloadType9: HardType[T9], payloadType10: HardType[T10]) extends TupleBundleBase with Product with Serializable
  191. case class TupleBundle11[T1 <: Data, T2 <: Data, T3 <: Data, T4 <: Data, T5 <: Data, T6 <: Data, T7 <: Data, T8 <: Data, T9 <: Data, T10 <: Data, T11 <: Data](payloadType1: HardType[T1], payloadType2: HardType[T2], payloadType3: HardType[T3], payloadType4: HardType[T4], payloadType5: HardType[T5], payloadType6: HardType[T6], payloadType7: HardType[T7], payloadType8: HardType[T8], payloadType9: HardType[T9], payloadType10: HardType[T10], payloadType11: HardType[T11]) extends TupleBundleBase with Product with Serializable
  192. case class TupleBundle12[T1 <: Data, T2 <: Data, T3 <: Data, T4 <: Data, T5 <: Data, T6 <: Data, T7 <: Data, T8 <: Data, T9 <: Data, T10 <: Data, T11 <: Data, T12 <: Data](payloadType1: HardType[T1], payloadType2: HardType[T2], payloadType3: HardType[T3], payloadType4: HardType[T4], payloadType5: HardType[T5], payloadType6: HardType[T6], payloadType7: HardType[T7], payloadType8: HardType[T8], payloadType9: HardType[T9], payloadType10: HardType[T10], payloadType11: HardType[T11], payloadType12: HardType[T12]) extends TupleBundleBase with Product with Serializable
  193. case class TupleBundle13[T1 <: Data, T2 <: Data, T3 <: Data, T4 <: Data, T5 <: Data, T6 <: Data, T7 <: Data, T8 <: Data, T9 <: Data, T10 <: Data, T11 <: Data, T12 <: Data, T13 <: Data](payloadType1: HardType[T1], payloadType2: HardType[T2], payloadType3: HardType[T3], payloadType4: HardType[T4], payloadType5: HardType[T5], payloadType6: HardType[T6], payloadType7: HardType[T7], payloadType8: HardType[T8], payloadType9: HardType[T9], payloadType10: HardType[T10], payloadType11: HardType[T11], payloadType12: HardType[T12], payloadType13: HardType[T13]) extends TupleBundleBase with Product with Serializable
  194. case class TupleBundle14[T1 <: Data, T2 <: Data, T3 <: Data, T4 <: Data, T5 <: Data, T6 <: Data, T7 <: Data, T8 <: Data, T9 <: Data, T10 <: Data, T11 <: Data, T12 <: Data, T13 <: Data, T14 <: Data](payloadType1: HardType[T1], payloadType2: HardType[T2], payloadType3: HardType[T3], payloadType4: HardType[T4], payloadType5: HardType[T5], payloadType6: HardType[T6], payloadType7: HardType[T7], payloadType8: HardType[T8], payloadType9: HardType[T9], payloadType10: HardType[T10], payloadType11: HardType[T11], payloadType12: HardType[T12], payloadType13: HardType[T13], payloadType14: HardType[T14]) extends TupleBundleBase with Product with Serializable
  195. case class TupleBundle15[T1 <: Data, T2 <: Data, T3 <: Data, T4 <: Data, T5 <: Data, T6 <: Data, T7 <: Data, T8 <: Data, T9 <: Data, T10 <: Data, T11 <: Data, T12 <: Data, T13 <: Data, T14 <: Data, T15 <: Data](payloadType1: HardType[T1], payloadType2: HardType[T2], payloadType3: HardType[T3], payloadType4: HardType[T4], payloadType5: HardType[T5], payloadType6: HardType[T6], payloadType7: HardType[T7], payloadType8: HardType[T8], payloadType9: HardType[T9], payloadType10: HardType[T10], payloadType11: HardType[T11], payloadType12: HardType[T12], payloadType13: HardType[T13], payloadType14: HardType[T14], payloadType15: HardType[T15]) extends TupleBundleBase with Product with Serializable
  196. case class TupleBundle16[T1 <: Data, T2 <: Data, T3 <: Data, T4 <: Data, T5 <: Data, T6 <: Data, T7 <: Data, T8 <: Data, T9 <: Data, T10 <: Data, T11 <: Data, T12 <: Data, T13 <: Data, T14 <: Data, T15 <: Data, T16 <: Data](payloadType1: HardType[T1], payloadType2: HardType[T2], payloadType3: HardType[T3], payloadType4: HardType[T4], payloadType5: HardType[T5], payloadType6: HardType[T6], payloadType7: HardType[T7], payloadType8: HardType[T8], payloadType9: HardType[T9], payloadType10: HardType[T10], payloadType11: HardType[T11], payloadType12: HardType[T12], payloadType13: HardType[T13], payloadType14: HardType[T14], payloadType15: HardType[T15], payloadType16: HardType[T16]) extends TupleBundleBase with Product with Serializable
  197. case class TupleBundle17[T1 <: Data, T2 <: Data, T3 <: Data, T4 <: Data, T5 <: Data, T6 <: Data, T7 <: Data, T8 <: Data, T9 <: Data, T10 <: Data, T11 <: Data, T12 <: Data, T13 <: Data, T14 <: Data, T15 <: Data, T16 <: Data, T17 <: Data](payloadType1: HardType[T1], payloadType2: HardType[T2], payloadType3: HardType[T3], payloadType4: HardType[T4], payloadType5: HardType[T5], payloadType6: HardType[T6], payloadType7: HardType[T7], payloadType8: HardType[T8], payloadType9: HardType[T9], payloadType10: HardType[T10], payloadType11: HardType[T11], payloadType12: HardType[T12], payloadType13: HardType[T13], payloadType14: HardType[T14], payloadType15: HardType[T15], payloadType16: HardType[T16], payloadType17: HardType[T17]) extends TupleBundleBase with Product with Serializable
  198. case class TupleBundle18[T1 <: Data, T2 <: Data, T3 <: Data, T4 <: Data, T5 <: Data, T6 <: Data, T7 <: Data, T8 <: Data, T9 <: Data, T10 <: Data, T11 <: Data, T12 <: Data, T13 <: Data, T14 <: Data, T15 <: Data, T16 <: Data, T17 <: Data, T18 <: Data](payloadType1: HardType[T1], payloadType2: HardType[T2], payloadType3: HardType[T3], payloadType4: HardType[T4], payloadType5: HardType[T5], payloadType6: HardType[T6], payloadType7: HardType[T7], payloadType8: HardType[T8], payloadType9: HardType[T9], payloadType10: HardType[T10], payloadType11: HardType[T11], payloadType12: HardType[T12], payloadType13: HardType[T13], payloadType14: HardType[T14], payloadType15: HardType[T15], payloadType16: HardType[T16], payloadType17: HardType[T17], payloadType18: HardType[T18]) extends TupleBundleBase with Product with Serializable
  199. case class TupleBundle19[T1 <: Data, T2 <: Data, T3 <: Data, T4 <: Data, T5 <: Data, T6 <: Data, T7 <: Data, T8 <: Data, T9 <: Data, T10 <: Data, T11 <: Data, T12 <: Data, T13 <: Data, T14 <: Data, T15 <: Data, T16 <: Data, T17 <: Data, T18 <: Data, T19 <: Data](payloadType1: HardType[T1], payloadType2: HardType[T2], payloadType3: HardType[T3], payloadType4: HardType[T4], payloadType5: HardType[T5], payloadType6: HardType[T6], payloadType7: HardType[T7], payloadType8: HardType[T8], payloadType9: HardType[T9], payloadType10: HardType[T10], payloadType11: HardType[T11], payloadType12: HardType[T12], payloadType13: HardType[T13], payloadType14: HardType[T14], payloadType15: HardType[T15], payloadType16: HardType[T16], payloadType17: HardType[T17], payloadType18: HardType[T18], payloadType19: HardType[T19]) extends TupleBundleBase with Product with Serializable
  200. case class TupleBundle2[T1 <: Data, T2 <: Data](payloadType1: HardType[T1], payloadType2: HardType[T2]) extends TupleBundleBase with Product with Serializable
  201. case class TupleBundle20[T1 <: Data, T2 <: Data, T3 <: Data, T4 <: Data, T5 <: Data, T6 <: Data, T7 <: Data, T8 <: Data, T9 <: Data, T10 <: Data, T11 <: Data, T12 <: Data, T13 <: Data, T14 <: Data, T15 <: Data, T16 <: Data, T17 <: Data, T18 <: Data, T19 <: Data, T20 <: Data](payloadType1: HardType[T1], payloadType2: HardType[T2], payloadType3: HardType[T3], payloadType4: HardType[T4], payloadType5: HardType[T5], payloadType6: HardType[T6], payloadType7: HardType[T7], payloadType8: HardType[T8], payloadType9: HardType[T9], payloadType10: HardType[T10], payloadType11: HardType[T11], payloadType12: HardType[T12], payloadType13: HardType[T13], payloadType14: HardType[T14], payloadType15: HardType[T15], payloadType16: HardType[T16], payloadType17: HardType[T17], payloadType18: HardType[T18], payloadType19: HardType[T19], payloadType20: HardType[T20]) extends TupleBundleBase with Product with Serializable
  202. case class TupleBundle21[T1 <: Data, T2 <: Data, T3 <: Data, T4 <: Data, T5 <: Data, T6 <: Data, T7 <: Data, T8 <: Data, T9 <: Data, T10 <: Data, T11 <: Data, T12 <: Data, T13 <: Data, T14 <: Data, T15 <: Data, T16 <: Data, T17 <: Data, T18 <: Data, T19 <: Data, T20 <: Data, T21 <: Data](payloadType1: HardType[T1], payloadType2: HardType[T2], payloadType3: HardType[T3], payloadType4: HardType[T4], payloadType5: HardType[T5], payloadType6: HardType[T6], payloadType7: HardType[T7], payloadType8: HardType[T8], payloadType9: HardType[T9], payloadType10: HardType[T10], payloadType11: HardType[T11], payloadType12: HardType[T12], payloadType13: HardType[T13], payloadType14: HardType[T14], payloadType15: HardType[T15], payloadType16: HardType[T16], payloadType17: HardType[T17], payloadType18: HardType[T18], payloadType19: HardType[T19], payloadType20: HardType[T20], payloadType21: HardType[T21]) extends TupleBundleBase with Product with Serializable
  203. case class TupleBundle22[T1 <: Data, T2 <: Data, T3 <: Data, T4 <: Data, T5 <: Data, T6 <: Data, T7 <: Data, T8 <: Data, T9 <: Data, T10 <: Data, T11 <: Data, T12 <: Data, T13 <: Data, T14 <: Data, T15 <: Data, T16 <: Data, T17 <: Data, T18 <: Data, T19 <: Data, T20 <: Data, T21 <: Data, T22 <: Data](payloadType1: HardType[T1], payloadType2: HardType[T2], payloadType3: HardType[T3], payloadType4: HardType[T4], payloadType5: HardType[T5], payloadType6: HardType[T6], payloadType7: HardType[T7], payloadType8: HardType[T8], payloadType9: HardType[T9], payloadType10: HardType[T10], payloadType11: HardType[T11], payloadType12: HardType[T12], payloadType13: HardType[T13], payloadType14: HardType[T14], payloadType15: HardType[T15], payloadType16: HardType[T16], payloadType17: HardType[T17], payloadType18: HardType[T18], payloadType19: HardType[T19], payloadType20: HardType[T20], payloadType21: HardType[T21], payloadType22: HardType[T22]) extends TupleBundleBase with Product with Serializable
  204. case class TupleBundle3[T1 <: Data, T2 <: Data, T3 <: Data](payloadType1: HardType[T1], payloadType2: HardType[T2], payloadType3: HardType[T3]) extends TupleBundleBase with Product with Serializable
  205. case class TupleBundle4[T1 <: Data, T2 <: Data, T3 <: Data, T4 <: Data](payloadType1: HardType[T1], payloadType2: HardType[T2], payloadType3: HardType[T3], payloadType4: HardType[T4]) extends TupleBundleBase with Product with Serializable
  206. case class TupleBundle5[T1 <: Data, T2 <: Data, T3 <: Data, T4 <: Data, T5 <: Data](payloadType1: HardType[T1], payloadType2: HardType[T2], payloadType3: HardType[T3], payloadType4: HardType[T4], payloadType5: HardType[T5]) extends TupleBundleBase with Product with Serializable
  207. case class TupleBundle6[T1 <: Data, T2 <: Data, T3 <: Data, T4 <: Data, T5 <: Data, T6 <: Data](payloadType1: HardType[T1], payloadType2: HardType[T2], payloadType3: HardType[T3], payloadType4: HardType[T4], payloadType5: HardType[T5], payloadType6: HardType[T6]) extends TupleBundleBase with Product with Serializable
  208. case class TupleBundle7[T1 <: Data, T2 <: Data, T3 <: Data, T4 <: Data, T5 <: Data, T6 <: Data, T7 <: Data](payloadType1: HardType[T1], payloadType2: HardType[T2], payloadType3: HardType[T3], payloadType4: HardType[T4], payloadType5: HardType[T5], payloadType6: HardType[T6], payloadType7: HardType[T7]) extends TupleBundleBase with Product with Serializable
  209. case class TupleBundle8[T1 <: Data, T2 <: Data, T3 <: Data, T4 <: Data, T5 <: Data, T6 <: Data, T7 <: Data, T8 <: Data](payloadType1: HardType[T1], payloadType2: HardType[T2], payloadType3: HardType[T3], payloadType4: HardType[T4], payloadType5: HardType[T5], payloadType6: HardType[T6], payloadType7: HardType[T7], payloadType8: HardType[T8]) extends TupleBundleBase with Product with Serializable
  210. case class TupleBundle9[T1 <: Data, T2 <: Data, T3 <: Data, T4 <: Data, T5 <: Data, T6 <: Data, T7 <: Data, T8 <: Data, T9 <: Data](payloadType1: HardType[T1], payloadType2: HardType[T2], payloadType3: HardType[T3], payloadType4: HardType[T4], payloadType5: HardType[T5], payloadType6: HardType[T6], payloadType7: HardType[T7], payloadType8: HardType[T8], payloadType9: HardType[T9]) extends TupleBundleBase with Product with Serializable
  211. class TupleBundleBase extends Bundle
  212. class TuplePimperBase extends AnyRef
  213. trait TypeFactory extends AnyRef
  214. class UFix extends XFix[UFix, UInt]

    Unsigned fix point

    Unsigned fix point

    See also

    UFix Documentation

  215. class UFix2D extends Bundle

    Two-dimensional XFix

  216. trait UFixCast extends AnyRef
  217. trait UFixFactory extends TypeFactory
  218. class UInt extends BitVector with Num[UInt] with MinMaxProvider with DataPrimitives[UInt] with BaseTypePrimitives[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

  219. 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))
  220. trait UIntFactory extends AnyRef

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

  221. implicit class UIntPimper extends AnyRef

    Implicit UInt helper

  222. class Union extends MultiData with PostInitCallback
  223. class UnionElement[T <: Data] extends AnyRef
  224. type UnknownFrequency = core.ClockDomain.UnknownFrequency
  225. 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

  226. class VarAssignementTag extends SpinalTag
  227. 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

  228. class VecAccessAssign[T <: Data] extends Assignable
  229. class VecBitwisePimper[T <: Data with BitwiseOp[T]] extends BitwiseOp[Vec[T]]
  230. trait VecFactory extends AnyRef

    Vec factory

  231. class VecBuilder extends AnyRef
    Definition Classes
    VecFactory
  232. case class VerilogValues(v: String) extends Product with Serializable
  233. class WhenContext extends ConditionalContext with ScalaLocated

    else / else if statement

    else / else if statement

    See also

    when Documentation

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

    Base class for SFix and UFix

  235. case class crossClockFalsePath(source: Option[BaseType] = None, destType: TimingEndpointType = TimingEndpointType.DATA) extends SpinalTag with Product with Serializable
  236. case class crossClockMaxDelay(cycles: Int, useTargetClock: Boolean) extends SpinalTag with Product with Serializable
  237. type dontName = spinal.core.DontName @scala.annotation.meta.field
  238. class modport extends Annotation with Annotation with ClassfileAnnotation
    Annotations
    @Retention()

Value Members

  1. implicit def BaseTypePimped[T <: BaseType](that: T): BaseTypePimper[T]
  2. implicit def BigIntToBits(that: BigInt): Bits
  3. implicit def BigIntToBuilder(value: BigInt): BigIntBuilder
  4. implicit def BigIntToSInt(that: BigInt): SInt
  5. implicit def BigIntToUInt(that: BigInt): UInt
  6. def Bits(width: BitCount): Bits

    Create a new Bits of a given width

    Create a new Bits of a given width

    Definition Classes
    BitsFactory
  7. def Bits(u: Unit = ()): Bits

    Create a new Bits

    Create a new Bits

    Definition Classes
    BitsFactory
  8. def Bool(value: Boolean)(implicit loc: Location): Bool

    Create a new Bool with a value

    Create a new Bool with a value

    Definition Classes
    BoolFactory
  9. def Bool(u: Unit = ()): Bool

    Create a new Bool

    Create a new Bool

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

    Implicit Data helper

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

    Implicit senum conversion

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

    Implicit Int/BigInt/Double to Builder

  24. implicit def IntToSInt(that: Int): SInt
  25. implicit def IntToUInt(that: Int): UInt

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

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

    Create a new SInt of a given width

    Create a new SInt of a given width

    Definition Classes
    SIntFactory
  33. def SInt(u: Unit = ()): SInt

    Create a new SInt

    Create a new SInt

    Definition Classes
    SIntFactory
  34. def True(implicit loc: Location): Bool

    True / False definition

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

    Create a new UInt of a given width

    Create a new UInt of a given width

    Definition Classes
    UIntFactory
  38. def UInt(u: Unit = ()): UInt

    Create a new UInt

    Create a new UInt

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

    Assertion

    Assertion

    Annotations
    @elidable( ASSERTION )
  54. def assume(assertion: Bool)(implicit loc: Location): AssertStatement
  55. def assumeInitial(assertion: Bool)(implicit loc: Location): AssertStatement
  56. def cover(assertion: Bool)(implicit loc: Location): AssertStatement
  57. implicit lazy val implicitConversions: implicitConversions

    Scala implicit

  58. def postTypeFactory[T <: Data](that: T): T
    Definition Classes
    TypeFactory
  59. implicit lazy val postfixOps: postfixOps
  60. implicit lazy val reflectiveCalls: reflectiveCalls
  61. def report(message: Seq[Any], severity: AssertNodeSeverity): AssertStatement
  62. def report(message: String, severity: AssertNodeSeverity): AssertStatement
  63. def report(message: Seq[Any]): AssertStatement
  64. def report(message: String): AssertStatement
  65. implicit def tupleBunder10Pimp[T1 <: Data, T2 <: Data, T3 <: Data, T4 <: Data, T5 <: Data, T6 <: Data, T7 <: Data, T8 <: Data, T9 <: Data, T10 <: Data](pimped: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)): TupleBundle10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]
  66. implicit def tupleBunder11Pimp[T1 <: Data, T2 <: Data, T3 <: Data, T4 <: Data, T5 <: Data, T6 <: Data, T7 <: Data, T8 <: Data, T9 <: Data, T10 <: Data, T11 <: Data](pimped: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)): TupleBundle11[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11]
  67. implicit def tupleBunder12Pimp[T1 <: Data, T2 <: Data, T3 <: Data, T4 <: Data, T5 <: Data, T6 <: Data, T7 <: Data, T8 <: Data, T9 <: Data, T10 <: Data, T11 <: Data, T12 <: Data](pimped: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)): TupleBundle12[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12]
  68. implicit def tupleBunder13Pimp[T1 <: Data, T2 <: Data, T3 <: Data, T4 <: Data, T5 <: Data, T6 <: Data, T7 <: Data, T8 <: Data, T9 <: Data, T10 <: Data, T11 <: Data, T12 <: Data, T13 <: Data](pimped: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13)): TupleBundle13[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13]
  69. implicit def tupleBunder14Pimp[T1 <: Data, T2 <: Data, T3 <: Data, T4 <: Data, T5 <: Data, T6 <: Data, T7 <: Data, T8 <: Data, T9 <: Data, T10 <: Data, T11 <: Data, T12 <: Data, T13 <: Data, T14 <: Data](pimped: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)): TupleBundle14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14]
  70. implicit def tupleBunder15Pimp[T1 <: Data, T2 <: Data, T3 <: Data, T4 <: Data, T5 <: Data, T6 <: Data, T7 <: Data, T8 <: Data, T9 <: Data, T10 <: Data, T11 <: Data, T12 <: Data, T13 <: Data, T14 <: Data, T15 <: Data](pimped: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)): TupleBundle15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15]
  71. implicit def tupleBunder16Pimp[T1 <: Data, T2 <: Data, T3 <: Data, T4 <: Data, T5 <: Data, T6 <: Data, T7 <: Data, T8 <: Data, T9 <: Data, T10 <: Data, T11 <: Data, T12 <: Data, T13 <: Data, T14 <: Data, T15 <: Data, T16 <: Data](pimped: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16)): TupleBundle16[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16]
  72. implicit def tupleBunder17Pimp[T1 <: Data, T2 <: Data, T3 <: Data, T4 <: Data, T5 <: Data, T6 <: Data, T7 <: Data, T8 <: Data, T9 <: Data, T10 <: Data, T11 <: Data, T12 <: Data, T13 <: Data, T14 <: Data, T15 <: Data, T16 <: Data, T17 <: Data](pimped: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17)): TupleBundle17[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17]
  73. implicit def tupleBunder18Pimp[T1 <: Data, T2 <: Data, T3 <: Data, T4 <: Data, T5 <: Data, T6 <: Data, T7 <: Data, T8 <: Data, T9 <: Data, T10 <: Data, T11 <: Data, T12 <: Data, T13 <: Data, T14 <: Data, T15 <: Data, T16 <: Data, T17 <: Data, T18 <: Data](pimped: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18)): TupleBundle18[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18]
  74. implicit def tupleBunder19Pimp[T1 <: Data, T2 <: Data, T3 <: Data, T4 <: Data, T5 <: Data, T6 <: Data, T7 <: Data, T8 <: Data, T9 <: Data, T10 <: Data, T11 <: Data, T12 <: Data, T13 <: Data, T14 <: Data, T15 <: Data, T16 <: Data, T17 <: Data, T18 <: Data, T19 <: Data](pimped: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19)): TupleBundle19[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19]
  75. implicit def tupleBunder20Pimp[T1 <: Data, T2 <: Data, T3 <: Data, T4 <: Data, T5 <: Data, T6 <: Data, T7 <: Data, T8 <: Data, T9 <: Data, T10 <: Data, T11 <: Data, T12 <: Data, T13 <: Data, T14 <: Data, T15 <: Data, T16 <: Data, T17 <: Data, T18 <: Data, T19 <: Data, T20 <: Data](pimped: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20)): TupleBundle20[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20]
  76. implicit def tupleBunder21Pimp[T1 <: Data, T2 <: Data, T3 <: Data, T4 <: Data, T5 <: Data, T6 <: Data, T7 <: Data, T8 <: Data, T9 <: Data, T10 <: Data, T11 <: Data, T12 <: Data, T13 <: Data, T14 <: Data, T15 <: Data, T16 <: Data, T17 <: Data, T18 <: Data, T19 <: Data, T20 <: Data, T21 <: Data](pimped: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21)): TupleBundle21[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21]
  77. implicit def tupleBunder22Pimp[T1 <: Data, T2 <: Data, T3 <: Data, T4 <: Data, T5 <: Data, T6 <: Data, T7 <: Data, T8 <: Data, T9 <: Data, T10 <: Data, T11 <: Data, T12 <: Data, T13 <: Data, T14 <: Data, T15 <: Data, T16 <: Data, T17 <: Data, T18 <: Data, T19 <: Data, T20 <: Data, T21 <: Data, T22 <: Data](pimped: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22)): TupleBundle22[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22]
  78. implicit def tupleBunder2Pimp[T1 <: Data, T2 <: Data](pimped: (T1, T2)): TupleBundle2[T1, T2]
  79. implicit def tupleBunder3Pimp[T1 <: Data, T2 <: Data, T3 <: Data](pimped: (T1, T2, T3)): TupleBundle3[T1, T2, T3]
  80. implicit def tupleBunder4Pimp[T1 <: Data, T2 <: Data, T3 <: Data, T4 <: Data](pimped: (T1, T2, T3, T4)): TupleBundle4[T1, T2, T3, T4]
  81. implicit def tupleBunder5Pimp[T1 <: Data, T2 <: Data, T3 <: Data, T4 <: Data, T5 <: Data](pimped: (T1, T2, T3, T4, T5)): TupleBundle5[T1, T2, T3, T4, T5]
  82. implicit def tupleBunder6Pimp[T1 <: Data, T2 <: Data, T3 <: Data, T4 <: Data, T5 <: Data, T6 <: Data](pimped: (T1, T2, T3, T4, T5, T6)): TupleBundle6[T1, T2, T3, T4, T5, T6]
  83. implicit def tupleBunder7Pimp[T1 <: Data, T2 <: Data, T3 <: Data, T4 <: Data, T5 <: Data, T6 <: Data, T7 <: Data](pimped: (T1, T2, T3, T4, T5, T6, T7)): TupleBundle7[T1, T2, T3, T4, T5, T6, T7]
  84. implicit def tupleBunder8Pimp[T1 <: Data, T2 <: Data, T3 <: Data, T4 <: Data, T5 <: Data, T6 <: Data, T7 <: Data, T8 <: Data](pimped: (T1, T2, T3, T4, T5, T6, T7, T8)): TupleBundle8[T1, T2, T3, T4, T5, T6, T7, T8]
  85. implicit def tupleBunder9Pimp[T1 <: Data, T2 <: Data, T3 <: Data, T4 <: Data, T5 <: Data, T6 <: Data, T7 <: Data, T8 <: Data, T9 <: Data](pimped: (T1, T2, T3, T4, T5, T6, T7, T8, T9)): TupleBundle9[T1, T2, T3, T4, T5, T6, T7, T8, T9]
  86. object AF
  87. object AFix
  88. object AFixRounding extends ScopeProperty[TagAFixTruncated]
  89. object ASYNC extends ResetKind
  90. object AllowMixedWidth extends SpinalTag
  91. object AllowPartialyAssignedTag extends SpinalTag
  92. object Analog

    Set a data to Analog

  93. object AnnotationUtils
  94. object ArrayManager
  95. object B extends BitVectorLiteralFactory[Bits]

    Used to create a new Bits or cast to Bits

  96. object BIG extends Endianness

    Big-Endian

  97. object BOOT extends ResetKind
  98. object BaseType
  99. object COMMENT_ATTRIBUTE extends AttributeKind
  100. object COMMENT_TYPE_ATTRIBUTE extends AttributeKind
  101. object Cat

    Concatenate a list of data

  102. object ClassName
  103. object Clock
  104. object ClockDomain extends Serializable
  105. object ClockDomainStack extends ScopeProperty[Handle[ClockDomain]]
  106. object CombInit

    Create a new signal, assigned by the given parameter.

    Create a new signal, assigned by the given parameter. Useful to provide a "copy" of something that you can then modify with more conditional assignments.

  107. object Component
  108. object ConditionalContext
  109. object ContextSwapper
  110. object CyclesCount extends Serializable
  111. object DEFAULT_ATTRIBUTE extends AttributeKind
  112. object Data
  113. object DataAssign
  114. object Device extends Serializable
  115. object Driver
  116. object DslScopeStack extends ScopeProperty[ScopeStatement]
  117. object DummyObject extends DummyTrait
  118. object ERROR extends AssertNodeSeverity
  119. object FAILURE extends AssertNodeSeverity
  120. object FALLING extends EdgeKind
  121. object FixPointProperty extends ScopeProperty[FixPointConfig]
  122. object GenerationFlags
  123. object GlobalData
  124. object Gray
  125. object HIGH extends Polarity
  126. object HardMap
  127. object HardType
  128. object ImplicitArea
  129. object Info
  130. object InitAssign
  131. object InitialAssign
  132. object IsInterface extends SpinalTag
  133. object LITTLE extends Endianness

    Little-Endian

  134. object LOW extends Polarity
  135. object Language
  136. object Latch
  137. object LatchWhen
  138. object LocatedPendingError
  139. object LutInputs extends ScopeProperty[Int]
  140. object MaskedLiteral
  141. object Mem
  142. object MemReadAsync
  143. object MemReadSync
  144. object MemReadWrite
  145. object MemWrite
  146. object Mux

    Mux operation

  147. object NOTE extends AssertNodeSeverity
  148. object Nameable
  149. object NamedType
  150. object OnCreateStack extends ScopeProperty[(Nameable) ⇒ Unit]
  151. object OwnableRef
  152. object PendingError
  153. object Pull
  154. object REPORT_TIME
  155. object RISING extends EdgeKind
  156. object Ram_1w_1ra
  157. object Ram_1w_1rs
  158. object Reg

    Create a register

  159. object RegInit

    Declare a register with an initialize value

  160. object RegNext

    Register a signal of one clock

  161. object RegNextWhen

    Register a signal when a condition is true

  162. object RoundType
  163. object S extends BitVectorLiteralFactory[SInt]

    Used to create a new SInt or cast to SInt

  164. object SF
  165. object SFix2D

    Two-dimensional SFix

  166. object SQ
  167. object SYNC extends ResetKind
  168. object ScalaLocated
  169. object ScopeProperty
  170. object Select
  171. object Spinal
  172. object SpinalConfig extends Serializable
  173. 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 )
}
  174. object SpinalError
  175. object SpinalExit extends Serializable
  176. object SpinalInfo
  177. object SpinalLog
  178. object SpinalMap

    Spinal map

  179. object SpinalProgress
  180. object SpinalSystemVerilog
  181. object SpinalTagReady
  182. object SpinalVerilog
  183. object SpinalVhdl
  184. object SpinalWarning
  185. object SwitchStack extends ScopeProperty[SwitchContext]
  186. object SystemVerilog extends SpinalMode
  187. object TimingEndpointType
  188. object TupleBundle
  189. object U extends BitVectorLiteralFactory[UInt]

    Used to create a new UInt or cast to UInt

  190. object UF
  191. object UFix2D

    Two-dimensional UFix

  192. object UInt2D extends Serializable
  193. object UQ
  194. object UnionElement
  195. object VHDL extends SpinalMode
  196. object Verilator
  197. object Verilog extends SpinalMode
  198. object WARNING extends AssertNodeSeverity
  199. object addDefaultGenericValue extends SpinalTag

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

  200. object allowAssignmentOverride extends SpinalTag
  201. object allowDirectionLessIoTag extends SpinalTag
  202. object allowOutOfRangeLiterals extends SpinalTag
  203. object auto extends MemTechnologyKind
  204. object binaryOneHot extends SpinalEnumEncoding

    Binary One hot encoding

    Binary One hot encoding

    Example: 

    1. 001, 010, 100
  205. object binarySequential extends SpinalEnumEncoding

    Binary Sequential

    Binary Sequential

    Example: 

    1. 000, 001, 010, 011, 100, 101, ....
  206. object blackboxAll extends MemBlackboxingPolicy
  207. object blackboxAllWhatsYouCan extends MemBlackboxingPolicy
  208. object blackboxByteEnables extends MemBlackboxingPolicy
  209. object blackboxOnlyIfRequested extends MemBlackboxingPolicy
  210. object blackboxRequestedAndUninferable extends MemBlackboxingPolicy
  211. object cloneOf

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

  212. object crossClockBuffer extends SpinalTag
  213. object crossClockDomain extends SpinalTag
  214. object default

    default statement of a switch case

    default statement of a switch case

    See also

    switch Documentation

  215. object distributedLut extends MemTechnologyKind
  216. object doRead extends DuringWritePolicy
  217. object dontCare extends ReadUnderWritePolicy with DuringWritePolicy
  218. object dontObfuscate extends SpinalTag
  219. object dontRead extends DuringWritePolicy
  220. object eitherFirst extends ReadUnderWritePolicy with DuringWritePolicy
  221. object getFixRound
  222. object getFixSym
  223. object globalCache
  224. object graySequential extends SpinalEnumEncoding

    Gray encoding (sequentially assigned)

    Gray encoding (sequentially assigned)

    Example: 

    1. 000, 001, 011, 010, ...
    Note

    If used in FSM it is not ensured that only gray encoding preserving transitions are done. If that is needed e.g. for CDC reasons, the transitions must be checked manually.

  225. object ifGen
  226. object in extends IODirection

    Declare an input port

    Declare an input port

    See IODirection for syntax help.

  227. object inferred extends SpinalEnumEncoding

    Inferred encoding

  228. object inout extends IODirection

    Declare an inout port

    Declare an inout port

    See IODirection for syntax help.

  229. object is

    is statement of a switch case

    is statement of a switch case

    See also

    switch Documentation

  230. object isPow2

    Check if a number is a power of 2

  231. object log2Up

    Give number of bit to encode a given number of states

  232. object native extends SpinalEnumEncoding

    Native encoding

  233. object noBackendCombMerge extends SpinalTag
  234. object noCombinatorialLoopCheck extends SpinalTag
  235. object noInit extends SpinalTag
  236. object noLatchCheck extends SpinalTag
  237. object noNumericType extends SpinalTag

    Transform all unsigned/signed into std_logic_vector

  238. object out extends IODirection

    Declare an output port

    Declare an output port

    See IODirection for syntax help.

  239. object ramBlock extends MemTechnologyKind
  240. object randomBoot extends SpinalTag
  241. object readFirst extends ReadUnderWritePolicy
  242. object registerFile extends MemTechnologyKind
  243. object roundUp

    Round up a BigInt

  244. object signalCache
  245. 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

  246. object tagAFixResized extends SpinalTag
  247. object tagAutoResize extends SpinalTag
  248. object tagTruncated extends SpinalTag
  249. object uLogic extends SpinalTag

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

  250. object unsetRegIfNoAssignementTag extends SpinalTag
  251. object unusedTag extends SpinalTag
  252. object weakCloneOf

    Return a new data with the same data structure as the given parameter (except bit width)

  253. 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

  254. object widthOf

    Return the number of bit of the given data

  255. object writeFirst extends ReadUnderWritePolicy

Deprecated Value Members

  1. def Bool: Bool
    Definition Classes
    BoolFactory
    Annotations
    @deprecated
    Deprecated

    Use Bool() (with braces) instead

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

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

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

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

  4. object Sel

    Sel operation

    Sel operation

    Annotations
    @deprecated
    Deprecated

    (Since version ???) Use Select instead

  5. object cloneable
    Annotations
    @deprecated
    Deprecated

    (Since version ???) Use HardType instead

  6. object inWithNull extends IODirection
    Annotations
    @deprecated
    Deprecated

    Use apply or port instead: 'val b = in(maybeNull)' or 'val rgb = in port maybeNull'

  7. object outWithNull extends IODirection
    Annotations
    @deprecated
    Deprecated

    Use apply or port instead: 'val b = out(maybeNull)' or 'val rgb = out port maybeNull'

  8. 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