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.  trait DontName extends Annotation

    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 AnyRef
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 HardType[T <: Data] extends OverridedEqualsHashCode
80.  case class HertzNumber(v: BigDecimal) extends PhysicalNumber[HertzNumber] with Product with Serializable

    Frequency representation

81.  type IClockDomainFrequency = ClockFrequency
82.  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

83.  class IfDefTag extends SpinalTag
84.  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

85.  trait InComponent extends AnyRef
86.  final class IntBuilder extends AnyVal

    Integer Builder

87.  sealed trait Language extends AnyRef
88.  implicit class LiteralBuilder extends AnyRef

    Literal builder

    Literal builder

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

    e.g.:

    B"8'xFF"`

89.  class MaskedBoolean extends AnyRef

    Masked Literal

    Masked Literal

    Example:

    1. val itMatch = myBits === M"00--10--" // - don't care value

90.  class MaskedLiteral extends AnyRef
91.  class Mem[T <: Data] extends DeclarationStatement with StatementDoubleLinkedContainer[Mem[_], MemPortStatement] with WidthProvider with SpinalTagReady with InComponent
92.  trait MemBlackboxingPolicy extends AnyRef
93.  trait MemPortStatement extends LeafStatement with StatementDoubleLinkedContainerElement[Mem[_], MemPortStatement]
94.  class MemReadAsync extends MemPortStatement with WidthProvider with SpinalTagReady with ContextUser with Expression
95.  class MemReadSync extends MemPortStatement with WidthProvider with SpinalTagReady with ContextUser with Expression
96.  class MemReadWrite extends MemPortStatement with WidthProvider with SpinalTagReady with ContextUser with Expression
97.  case class MemSymbolesMapping(name: String, range: Range) extends Product with Serializable
98.  case class MemSymbolesTag(mapping: Seq[MemSymbolesMapping]) extends SpinalTag with Product with Serializable
99.  trait MemTechnologyKind extends AnyRef
100.  class MemWrite extends MemPortStatement with WidthProvider with SpinalTagReady
101.  class MemWritePayload[T <: Data] extends Bundle
102.  trait MinMaxDecimalProvider extends AnyRef
103.  trait MinMaxProvider extends AnyRef

     Min max base function

104.  type Module = Component
105.  abstract class MultiData extends Data

     Base class for multi data like Vec, Bundle

106.  trait Nameable extends OwnableRef with ContextUser
107.  trait NameableByComponent extends Nameable with GlobalDataUser
108.  class NamingScope extends AnyRef
109.  trait Num[T <: Data] extends AnyRef

     Base operations for numbers

     Base operations for numbers

     T

     the type which is associated with the base operation

110.  trait OverridedEqualsHashCode extends AnyRef
111.  trait OwnableRef extends AnyRef
112.  abstract class PhysicalNumber[T <: PhysicalNumber[_]] extends AnyRef

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

113.  sealed trait Polarity extends AnyRef
114.  case class PosCount(value: Int) extends Product with Serializable

     Position representation

115.  case class QFormat(width: Int, fraction: Int, signed: Boolean) extends Product with Serializable
116.  class Ram_1w_1ra extends BlackBox

     Ram 1w 1ra

117.  class Ram_1w_1rs extends BlackBox

     Ram 1w 1rs

118.  class Ram_1wors extends BlackBox

     Ram 1wors

119.  class Ram_1wrs extends BlackBox

     Ram 1wrs

120.  class Ram_2c_1w_1rs extends BlackBox

     Ram 2c 1w 1rs

121.  class Ram_2wrs extends BlackBox

     Ram 2wrs

122.  implicit class RangePimper extends AnyRef

     Implicit Range helper

123.  trait ReadUnderWritePolicy extends AnyRef
124.  case class Ref[T](value: T) extends Product with Serializable

     Use to give value by reference to a function

125.  class ResetArea extends Area with PostInitCallback

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

126.  sealed trait ResetKind extends AnyRef
127.  case class ResetTag(clockDomain: ClockDomain) extends ClockDomainBoolTag with Product with Serializable
128.  sealed trait RoundType extends AnyRef
129.  class SFix extends XFix[SFix, SInt]

     Signed fix point

     Signed fix point

     See also

     SFix Documentation

130.  class SFix2D extends Bundle
131.  trait SFixCast extends AnyRef
132.  trait SFixFactory extends TypeFactory
133.  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

134.  trait SIntFactory extends AnyRef

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

135.  implicit class SIntPimper extends AnyRef

     Implicit SInt helper

136.  class SafeStack[T] extends AnyRef

     Safe Stack

137.  class SafeStackWithStackable[T <: Stackable] extends SafeStack[T]
138.  trait ScalaLocated extends GlobalDataUser
139.  class ScopeProperty[T] extends AnyRef
140.  class ScopePropertyContext extends AnyRef
141.  class ScopePropertyValue extends AnyRef
142.  case class SlicesCount(value: Int) extends Product with Serializable

     Slice size representation

143.  class SlowArea extends ClockingArea

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

144.  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, romReuse: Boolean = false, genVhdlPkg: Boolean = true, verbose: Boolean = false, mergeAsyncProcess: Boolean = false, 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, phasesInserters: ArrayBuffer[(ArrayBuffer[Phase]) => Unit] = ArrayBuffer[(ArrayBuffer[Phase]) => Unit](), transformationPhases: ArrayBuffer[Phase] = ArrayBuffer[Phase](), memBlackBoxers: ArrayBuffer[Phase] = ArrayBuffer[Phase] (/*new PhaseMemBlackBoxerDefault(blackboxNothing)*/), rtlHeader: String = null, scopeProperties: LinkedHashMap[ScopeProperty[_], Any] = mutable.LinkedHashMap[ScopeProperty[_], Any](), _withEnumString: Boolean = true, enumPrefixEnable: Boolean = true, enumGlobalEnable: Boolean = false, bitVectorWidthMax: Int = 4096) extends Product with Serializable

     Spinal configuration for the generation of the RTL

145.  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

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

     Hardware representation of an enumeration

147.  class SpinalEnumElement[T <: SpinalEnum] extends Nameable

     Definition of an element of the enumeration

148.  trait SpinalEnumEncoding extends Nameable with ScalaLocated

     Trait to define an encoding

149.  class SpinalExit extends Exception
150.  trait SpinalMode extends AnyRef
151.  class SpinalReport[T <: Component] extends AnyRef

     Spinal report give after the generation of the RTL

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

     Class representing Verilog Struct and VHDL Record data types.

153.  trait SpinalTag extends AnyRef
154.  trait SpinalTagReady extends AnyRef
155.  trait Stackable extends AnyRef
156.  class SwitchContext extends AnyRef
157.  class TagAFixTruncated extends SpinalTag
158.  case class TimeNumber(v: BigDecimal) extends PhysicalNumber[TimeNumber] with Product with Serializable

     Time representation

159.  class ToBitsPimper extends AnyRef
160.  implicit class Tuple10Pimper extends TuplePimperBase
161.  implicit class Tuple11Pimper extends TuplePimperBase
162.  implicit class Tuple12Pimper extends TuplePimperBase
163.  implicit class Tuple13Pimper extends TuplePimperBase
164.  implicit class Tuple14Pimper extends TuplePimperBase
165.  implicit class Tuple15Pimper extends TuplePimperBase
166.  implicit class Tuple16Pimper extends TuplePimperBase
167.  implicit class Tuple17Pimper extends TuplePimperBase
168.  implicit class Tuple18Pimper extends TuplePimperBase
169.  implicit class Tuple19Pimper extends TuplePimperBase
170.  implicit class Tuple20Pimper extends TuplePimperBase
171.  implicit class Tuple21Pimper extends TuplePimperBase
172.  implicit class Tuple22Pimper extends TuplePimperBase
173.  implicit class Tuple2Pimper extends TuplePimperBase
174.  implicit class Tuple3Pimper extends TuplePimperBase
175.  implicit class Tuple4Pimper extends TuplePimperBase
176.  implicit class Tuple5Pimper extends TuplePimperBase
177.  implicit class Tuple6Pimper extends TuplePimperBase
178.  implicit class Tuple7Pimper extends TuplePimperBase
179.  implicit class Tuple8Pimper extends TuplePimperBase
180.  implicit class Tuple9Pimper extends TuplePimperBase
181.  case class TupleBundle1[T1 <: Data](payloadType1: HardType[T1]) extends TupleBundleBase with Product with Serializable
182.  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
183.  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
184.  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
185.  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
186.  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
187.  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
188.  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
189.  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
190.  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
191.  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
192.  case class TupleBundle2[T1 <: Data, T2 <: Data](payloadType1: HardType[T1], payloadType2: HardType[T2]) extends TupleBundleBase with Product with Serializable
193.  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
194.  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
195.  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
196.  case class TupleBundle3[T1 <: Data, T2 <: Data, T3 <: Data](payloadType1: HardType[T1], payloadType2: HardType[T2], payloadType3: HardType[T3]) extends TupleBundleBase with Product with Serializable
197.  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
198.  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
199.  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
200.  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
201.  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
202.  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
203.  class TupleBundleBase extends Bundle
204.  class TuplePimperBase extends AnyRef
205.  trait TypeFactory extends AnyRef
206.  class UFix extends XFix[UFix, UInt]

     Unsigned fix point

     Unsigned fix point

     See also

     UFix Documentation

207.  class UFix2D extends Bundle

     Two-dimensional XFix

208.  trait UFixCast extends AnyRef
209.  trait UFixFactory extends TypeFactory
210.  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

211.  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))

212.  trait UIntFactory extends AnyRef

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

213.  implicit class UIntPimper extends AnyRef

     Implicit UInt helper

214.  type UnknownFrequency = core.ClockDomain.UnknownFrequency
215.  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

216.  class VarAssignementTag extends SpinalTag
217.  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

218.  class VecAccessAssign[T <: Data] extends Assignable
219.  class VecBitwisePimper[T <: Data with BitwiseOp[T]] extends BitwiseOp[Vec[T]]
220.  trait VecFactory extends AnyRef

     Vec factory

221.  class VecBuilder extends AnyRef

     Definition Classes

     VecFactory

222.  class WhenContext extends ConditionalContext with ScalaLocated

     else / else if statement

     else / else if statement

     See also

     when Documentation

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

     Base class for SFix and UFix

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