usbcore package

Submodules

usbcore.endpoint module

class usbcore.endpoint.EndpointType[source]

Bases: enum.IntEnum

An enumeration.

IN = 1
OUT = 2
BIDIR = 3
epaddr = <bound method EndpointType.epaddr of <enum 'EndpointType'>>[source]
epnum = <bound method EndpointType.epnum of <enum 'EndpointType'>>[source]
epdir = <bound method EndpointType.epdir of <enum 'EndpointType'>>[source]
class usbcore.endpoint.EndpointResponse[source]

Bases: enum.IntEnum

>>> # Clearing top bit of STALL -> NAK
>>> assert (EndpointResponse.STALL & EndpointResponse.RESET_MASK) == EndpointResponse.NAK
STALL = 3
ACK = 0
NAK = 1
NONE = 2
RESET_MASK = 1

usbcore.io module

class usbcore.io.Raw(value)[source]

Bases: migen.fhdl.specials.PreformattedParam

class usbcore.io.IoBuf(usbp_pin, usbn_pin, usb_pullup_pin=None)[source]

Bases: migen.fhdl.module.Module

class usbcore.io.FakeIoBuf[source]

Bases: migen.fhdl.module.Module

recv(v)[source]
current()[source]

usbcore.pid module

class usbcore.pid.PID[source]

Bases: enum.IntEnum

>>> bin(PID.SETUP.value)
'0b1101'
>>> PID.SETUP.encode()
'KKKKJJJJJJJJJJJJKKKKKKKKJJJJKKKK'

>>> for p in PID:
...    print("%-10s" % p, "%x" % p.value, "%02x" % p.byte(), p.encode(1))
PID.SETUP  d 2d KJJJKKJK
PID.OUT    1 e1 KJKJKKKK
PID.IN     9 69 KJKKJJJK
PID.SOF    5 a5 KJJKJJKK
PID.DATA0  3 c3 KKJKJKKK
PID.DATA1  b 4b KKJJKJJK
PID.DATA2  7 87 KKKJKJKK
PID.MDATA  f 0f KKKKJKJK
PID.ACK    2 d2 JJKJJKKK
PID.NAK    a 5a JJKKKJJK
PID.STALL  e 1e JJJJJKJK
PID.NYET   6 96 JJJKKJKK
PID.PRE    c 3c JKKKKKJK
PID.SPLIT  8 78 JKJJJJJK
PID.PING   4 b4 JKKJJJKK
PID.RESERVED 0 f0 JKJKKKKK
SETUP = 13
OUT = 1
IN = 9
SOF = 5
DATA0 = 3
DATA1 = 11
DATA2 = 7
MDATA = 15
ACK = 2
NAK = 10
STALL = 14
NYET = 6
PRE = 12
ERR = 12
SPLIT = 8
PING = 4
RESERVED = 0
byte()[source]
encode(cycles=4)[source]
class usbcore.pid.PIDTypes[source]

Bases: enum.IntEnum

>>> # Token PIDs
>>> PIDTypes.token(PID.SETUP), PIDTypes.data(PID.SETUP), PIDTypes.handshake(PID.SETUP)
(True, False, False)
>>> PIDTypes.token(PID.OUT), PIDTypes.data(PID.OUT), PIDTypes.handshake(PID.OUT)
(True, False, False)
>>> PIDTypes.token(PID.IN), PIDTypes.data(PID.IN), PIDTypes.handshake(PID.IN)
(True, False, False)
>>> PIDTypes.token(PID.SOF), PIDTypes.data(PID.SOF), PIDTypes.handshake(PID.SOF)
(True, False, False)

>>> # Data PIDs
>>> PIDTypes.token(PID.DATA0), PIDTypes.data(PID.DATA0), PIDTypes.handshake(PID.DATA0)
(False, True, False)
>>> PIDTypes.token(PID.DATA1), PIDTypes.data(PID.DATA1), PIDTypes.handshake(PID.DATA1)
(False, True, False)
>>> # USB2.0 Data PIDs
>>> PIDTypes.token(PID.DATA2), PIDTypes.data(PID.DATA2), PIDTypes.handshake(PID.DATA2)
(False, True, False)
>>> PIDTypes.token(PID.MDATA), PIDTypes.data(PID.MDATA), PIDTypes.handshake(PID.MDATA)
(False, True, False)

>>> # Handshake PIDs
>>> PIDTypes.token(PID.ACK), PIDTypes.data(PID.ACK), PIDTypes.handshake(PID.ACK)
(False, False, True)
>>> PIDTypes.token(PID.NAK), PIDTypes.data(PID.NAK), PIDTypes.handshake(PID.NAK)
(False, False, True)
>>> PIDTypes.token(PID.STALL), PIDTypes.data(PID.STALL), PIDTypes.handshake(PID.STALL)
(False, False, True)
>>> # USB2.0 Handshake PIDs
>>> PIDTypes.token(PID.NYET), PIDTypes.data(PID.NYET), PIDTypes.handshake(PID.NYET)
(False, False, True)

>>> # Special PIDs
>>> PIDTypes.token(PID.PRE), PIDTypes.data(PID.PRE), PIDTypes.handshake(PID.PRE)
(False, False, False)
TOKEN = 1
DATA = 3
HANDSHAKE = 2
SPECIAL = 0
TYPE_MASK = 3
token = <function PIDTypes.token>[source]
data = <function PIDTypes.data>[source]
handshake = <function PIDTypes.handshake>[source]
special = <function PIDTypes.special>[source]

Module contents