Unit SPI
From Ultibo.org
Return to Unit Reference
Description
Ultibo SPI Interface unit
SPI (Serial Peripheral Interface) is a synchronous serial bus for communication with peripheral components.
The SPI protocol is not defined by any actual standard but some pseudo standards exist with all of the available devices. SPI is a master-slave protocol where the master asserts the chip select line (CS) to select the slave device before sending data one byte at a time. For every byte written to the bus by the master the selected slave returns a byte as well so for every write there is an equivalent read. SPI can also operate in either 4 wire (standard) or 3 wire(bidirectional) modes.
Due to the lack of formal standards and the range of devices that exist various options are provided to allow setting clock phase and polarity as well chip select polarity.
For the purpose of this interface a device is the SPI controller attached to the local system and may be either a master or a slave. Since the protocol does not include any form of enumeration or identification the interface does not attempt to represent the devices connected to the bus, any driver written to communicate with a connected SPI device should know (or allow configuration of) the chip select for the for the device and the specific message format required for that device.
Constants
SPI specific constants
SPI_* SPI_NAME_PREFIX = 'SPI';
|
Name prefix for SPI Devices |
SPISLAVE_NAME_PREFIX = 'SPISlave';
|
Name prefix for SPI Slave Devices |
SPI device type
SPI_TYPE_* SPI_TYPE_NONE = 0;
|
|
SPI_TYPE_MASTER = 1;
|
|
SPI_TYPE_SLAVE = 2;
|
|
SPI_TYPE_MAX = 2;
|
|
| SPI Type Names | |
SPI_TYPE_NAMES:array[SPI_TYPE_NONE..SPI_TYPE_MAX] of String = ('SPI_TYPE_NONE', 'SPI_TYPE_MASTER', 'SPI_TYPE_SLAVE');
| |
SPI device state
SPI_STATE_* SPI_STATE_DISABLED = 0;
|
|
SPI_STATE_ENABLED = 1;
|
|
SPI_STATE_MAX = 1;
|
|
SPI device flag
SPI_FLAG_* SPI_FLAG_NONE = $00000000;
|
|
SPI_FLAG_SLAVE = $00000001;
|
Device is a slave not a master |
SPI_FLAG_4WIRE = $00000002;
|
Device supports 4 wire operation (CS/MISO/MOSI/SCLK) |
SPI_FLAG_3WIRE = $00000004;
|
Device supports 3 wire operation (CS/MIMO/SCLK) |
SPI_FLAG_LOSSI = $00000008;
|
Device supports LoSSI (Low Speed Serial) mode (CS/SCL/SDA) |
SPI_FLAG_CPOL = $00000010;
|
Device supports Clock Polarity setting |
SPI_FLAG_CPHA = $00000020;
|
Device supports Clock Phase setting |
SPI_FLAG_CSPOL = $00000040;
|
Device supports Chip Select Polarity setting |
SPI_FLAG_NO_CS = $00000080;
|
Device supports Chip Select None (CS handled externally) |
SPI_FLAG_DMA = $00000100;
|
Device supports DMA transfers |
SPI transfer flag
SPI_TRANSFER_* SPI_TRANSFER_NONE = $00000000;
|
|
SPI_TRANSFER_DMA = $00000001;
|
Use DMA for transfer (Write/Read) (Note: Buffers must be DMA compatible) |
SPI_TRANSFER_PIO = $00000002;
|
Use PIO (Polling) for transfer (Write/Read) |
SPI_TRANSFER_DELAY = $00000004;
|
Add a delay after each byte written (Write/Read) Note: Only available with PIO transfer unless provided directly by hardware |
SPI logging
SPI_LOG_* SPI_LOG_LEVEL_DEBUG = LOG_LEVEL_DEBUG;
|
SPI debugging messages |
SPI_LOG_LEVEL_INFO = LOG_LEVEL_INFO;
|
SPI informational messages, such as a device being attached or detached |
SPI_LOG_LEVEL_WARN = LOG_LEVEL_WARN;
|
SPI warning messages |
SPI_LOG_LEVEL_ERROR = LOG_LEVEL_ERROR;
|
SPI error messages |
SPI_LOG_LEVEL_NONE = LOG_LEVEL_NONE;
|
No SPI messages |
Type definitions
SPI properties
PSPIProperties = ^TSPIProperties;
TSPIProperties = record
Flags:LongWord;
|
Device flags (eg SPI_FLAG_SLAVE) |
MaxSize:LongWord;
|
Maximum supported data transfer size |
MinClock:LongWord;
|
Minimum supported clock rate |
MaxClock:LongWord;
|
Maximum supported clock rate |
SelectCount:LongWord;
|
Number of chip selects supported |
Mode:LongWord;
|
Current mode (eg SPI_MODE_4WIRE) |
ClockRate:LongWord;
|
Current clock rate |
ClockPhase:LongWord;
|
Current clock phase (CPHA) (eg SPI_CLOCK_PHASE_LOW) |
ClockPolarity:LongWord;
|
Current clock polarity (CPOL) (eg SPI_CLOCK_POLARITY_LOW) |
SelectPolarity:LongWord;
|
Default chip select polarity (eg SPI_CS_POLARITY_LOW) |
ByteDelay:LongWord;
|
Delay between bytes written (Microseconds) |
SPI chip select
PSPIChipSelect = ^TSPIChipSelect;
TSPIChipSelect = record
Pin:LongWord;
|
The GPIO pin for this chip select (eg GPIO_PIN_46)(GPIO_PIN_UNKNOWN for internal) |
Mode:LongWord;
|
The mode for this chip select (eg SPI_MODE_0) |
Divider:LongWord;
|
The clock divider for this chip select (Used internally by drivers) |
ClockRate:LongWord;
|
The clock rate for this chip select |
ClockPhase:LongWord;
|
The clock phase (CPHA) for this chip select (eg SPI_CLOCK_PHASE_LOW) |
ClockPolarity:LongWord;
|
The clock polarity (CPOL) for this chip select (eg SPI_CLOCK_POLARITY_LOW) |
SelectPolarity:LongWord;
|
The chip select polarity for this chip select (eg SPI_CS_POLARITY_LOW) |
ByteDelay:LongWord;
|
Delay between bytes written for this chip select (Microseconds) |
SPI enumeration callback
TSPIEnumerate = function(SPI:PSPIDevice; Data:Pointer):LongWord;
|
SPI notification callback
TSPINotification = function(Device:PDevice; Data:Pointer; Notification:LongWord):LongWord;
|
SPI device start
TSPIDeviceStart = function(SPI:PSPIDevice; Mode,ClockRate,ClockPhase,ClockPolarity:LongWord):LongWord;
|
SPI device stop
TSPIDeviceStop = function(SPI:PSPIDevice):LongWord;
|
SPI device read
TSPIDeviceRead = function(SPI:PSPIDevice; ChipSelect:Word; Dest:Pointer; Size,Flags:LongWord; var Count:LongWord):LongWord;
|
SPI device write
TSPIDeviceWrite = function(SPI:PSPIDevice; ChipSelect:Word; Source:Pointer; Size,Flags:LongWord; var Count:LongWord):LongWord;
|
SPI device write read
TSPIDeviceWriteRead = function(SPI:PSPIDevice; ChipSelect:Word; Source,Dest:Pointer; Size,Flags:LongWord; var Count:LongWord):LongWord;
|
SPI device get mode
TSPIDeviceGetMode = function(SPI:PSPIDevice):LongWord;
|
SPI device set mode
TSPIDeviceSetMode = function(SPI:PSPIDevice; Mode:LongWord):LongWord;
|
SPI device get clock rate
TSPIDeviceGetClockRate = function(SPI:PSPIDevice; ChipSelect:Word):LongWord;
|
SPI device set clock rate
TSPIDeviceSetClockRate = function(SPI:PSPIDevice; ChipSelect:Word; ClockRate:LongWord):LongWord;
|
SPI device get clock phase
TSPIDeviceGetClockPhase = function(SPI:PSPIDevice):LongWord;
|
SPI device set clock phase
TSPIDeviceSetClockPhase = function(SPI:PSPIDevice; ClockPhase:LongWord):LongWord;
|
SPI device get clock polarity
TSPIDeviceGetClockPolarity = function(SPI:PSPIDevice):LongWord;
|
SPI device set clock polarity
TSPIDeviceSetClockPolarity = function(SPI:PSPIDevice; ClockPolarity:LongWord):LongWord;
|
SPI device get select polarity
TSPIDeviceGetSelectPolarity = function(SPI:PSPIDevice; ChipSelect:Word):LongWord;
|
SPI device set select polarity
TSPIDeviceSetSelectPolarity = function(SPI:PSPIDevice; ChipSelect:Word; SelectPolarity:LongWord):LongWord;
|
SPI device get byte delay
TSPIDeviceGetByteDelay = function(SPI:PSPIDevice):LongWord;
|
SPI device set byte delay
TSPIDeviceSetByteDelay = function(SPI:PSPIDevice; Delay:LongWord):LongWord;
|
SPI device get properties
TSPIDeviceGetProperties = function(SPI:PSPIDevice; Properties:PSPIProperties):LongWord;
|
SPI device
PSPIDevice = ^TSPIDevice;
TSPIDevice = record
| Device Properties | |
Device:TDevice;
|
The Device entry for this SPI |
| SPI Properties | |
SPIId:LongWord;
|
Unique Id of this SPI in the SPI table |
SPIState:LongWord;
|
SPI state (eg SPI_STATE_ENABLED) |
SPIMode:LongWord;
|
SPI mode (eg SPI_MODE_4WIRE) |
DeviceStart:TSPIDeviceStart;
|
A Device specific DeviceStart method implementing the standard SPI device interface (Mandatory) |
DeviceStop:TSPIDeviceStop;
|
A Device specific DeviceStop method implementing the standard SPI device interface (Mandatory) |
DeviceRead:TSPIDeviceRead;
|
A Device specific DeviceRead method implementing the standard SPI device interface (Or nil if the default method is suitable) |
DeviceWrite:TSPIDeviceWrite;
|
A Device specific DeviceWrite method implementing the standard SPI device interface (Or nil if the default method is suitable) |
DeviceWriteRead:TSPIDeviceWriteRead;
|
A Device specific DeviceWriteRead method implementing the standard SPI device interface (Mandatory) |
DeviceGetMode:TSPIDeviceGetMode;
|
A Device specific DeviceGetMode method implementing the standard SPI device interface (Or nil if the default method is suitable) |
DeviceSetMode:TSPIDeviceSetMode;
|
A Device specific DeviceSetMode method implementing the standard SPI device interface (Or nil if the default method is suitable) |
DeviceGetClockRate:TSPIDeviceGetClockRate;
|
A Device specific DeviceGetClockRate method implementing the standard SPI device interface (Or nil if the default method is suitable) |
DeviceSetClockRate:TSPIDeviceSetClockRate;
|
A Device specific DeviceSetClockRate method implementing the standard SPI device interface (Or nil if the default method is suitable) |
DeviceGetClockPhase:TSPIDeviceGetClockPhase;
|
A Device specific DeviceGetClockPhase method implementing the standard SPI device interface (Or nil if the default method is suitable) |
DeviceSetClockPhase:TSPIDeviceSetClockPhase;
|
A Device specific DeviceSetClockPhase method implementing the standard SPI device interface (Or nil if the default method is suitable) |
DeviceGetClockPolarity:TSPIDeviceGetClockPolarity;
|
A Device specific DeviceGetClockPolarity method implementing the standard SPI device interface (Or nil if the default method is suitable) |
DeviceSetClockPolarity:TSPIDeviceSetClockPolarity;
|
A Device specific DeviceSetClockPolarity method implementing the standard SPI device interface (Or nil if the default method is suitable) |
DeviceGetSelectPolarity:TSPIDeviceGetSelectPolarity;
|
A Device specific DeviceGetSelectPolarity method implementing the standard SPI device interface (Or nil if the default method is suitable) |
DeviceSetSelectPolarity:TSPIDeviceSetSelectPolarity;
|
A Device specific DeviceSetSelectPolarity method implementing the standard SPI device interface (Or nil if the default method is suitable) |
DeviceGetByteDelay:TSPIDeviceGetByteDelay;
|
A Device specific DeviceGetByteDelay method implementing the standard SPI device interface (Or nil if the default method is suitable) |
DeviceSetByteDelay:TSPIDeviceSetByteDelay;
|
A Device specific DeviceSetByteDelay method implementing the standard SPI device interface (Or nil if the default method is suitable) |
DeviceGetProperties:TSPIDeviceGetProperties;
|
A Device specific DeviceGetProperties method implementing the standard SPI device interface (Or nil if the default method is suitable) |
| Statistics Properties | |
TransferCount:LongWord;
|
|
TransferErrors:LongWord;
|
|
| Driver Properties | |
Lock:TMutexHandle;
|
Device lock |
Wait:TSemaphoreHandle;
|
Write/Read wait event |
Divider:LongWord;
|
Clock divider (Used internally by drivers) |
ClockRate:LongWord;
|
Clock rate (Hz) |
ClockPhase:LongWord;
|
Clock Phase (eg SPI_CLOCK_PHASE_LOW) |
ClockPolarity:LongWord;
|
Clock Polarity (eg SPI_CLOCK_POLARITY_LOW) |
SelectPolarity:LongWord;
|
Default Chip Select Polarity (eg SPI_CS_POLARITY_LOW) |
Properties:TSPIProperties;
|
Device properties |
ChipSelects:array[0..SPI_CS_MAX] of TSPIChipSelect;
|
Chip selects |
| Internal Properties | |
Prev:PSPIDevice;
|
Previous entry in SPI table |
Next:PSPIDevice;
|
Next entry in SPI table |
Public variables
SPI logging
SPI_DEFAULT_LOG_LEVEL:LongWord = SPI_LOG_LEVEL_DEBUG;
|
Minimum level for SPI messages. Only messages with level greater than or equal to this will be printed. |
SPI_LOG_ENABLED:Boolean;
|
Function declarations
Initialization functions
procedure SPIInit;
Description: Initialize the SPI unit and SPI device table
| Note | Called only during system startup |
|---|
SPI functions
function SPIDeviceStart(SPI:PSPIDevice; Mode,ClockRate,ClockPhase,ClockPolarity:LongWord):LongWord;
Description: Start the specified SPI device ready for writing and reading
| SPI | The SPI device to start |
|---|---|
| Mode | The device mode to set (eg SPI_MODE_4WIRE) |
| ClockRate | The clock rate to set for the device |
| ClockPhase | The clock phase to set (eg SPI_CLOCK_PHASE_LOW) |
| ClockPolarity | The clock polarity to set (eg SPI_CLOCK_POLARITY_LOW) |
| Return | ERROR_SUCCESS if completed or another error code on failure |
function SPIDeviceStop(SPI:PSPIDevice):LongWord;
Description: Stop the specified SPI device and terminate writing and reading
| SPI | The SPI device to stop |
|---|---|
| Return | ERROR_SUCCESS if completed or another error code on failure |
function SPIDeviceRead(SPI:PSPIDevice; ChipSelect:Word; Dest:Pointer; Size,Flags:LongWord; var Count:LongWord):LongWord;
Description: Read data from the specified SPI device
| SPI | The SPI device to read from |
|---|---|
| ChipSelect | The chip select for the slave to read from (eg SPI_CS_0) |
| Dest | Pointer to a buffer to receive the data |
| Size | The size of the buffer |
| Flags | The flags for this transfer (eg SPI_TRANSFER_DMA) |
| Count | The number of bytes read on return |
| Return | ERROR_SUCCESS if completed or another error code on failure |
| Note | Because SPI writes and then reads for each byte, dummy data will be written for each byte to be read. |
function SPIDeviceWrite(SPI:PSPIDevice; ChipSelect:Word; Source:Pointer; Size,Flags:LongWord; var Count:LongWord):LongWord;
Description: Write data to the specified SPI device
| SPI | The SPI device to write to |
|---|---|
| ChipSelect | The chip select for the slave to write to (eg SPI_CS_0) |
| Source | Pointer to a buffer of data to transmit |
| Size | The size of the buffer |
| Flags | The flags for this transfer (eg SPI_TRANSFER_DMA) |
| Count | The number of bytes written on return |
| Return | ERROR_SUCCESS if completed or another error code on failure |
| Note | Because SPI writes and then reads for each byte, received data will be discarded for each byte written. |
function SPIDeviceWriteRead(SPI:PSPIDevice; ChipSelect:Word; Source,Dest:Pointer; Size,Flags:LongWord; var Count:LongWord):LongWord;
Description: Write data to and Read data from the specified SPI device in one operation
| SPI | The SPI device to write to and read from |
|---|---|
| ChipSelect | The chip select for the slave to write to and read from (eg SPI_CS_0) |
| Source | Pointer to a buffer of data to transmit |
| Dest | Pointer to a buffer to receive the data |
| Size | The size of the buffer |
| Flags | The flags for this transfer (eg SPI_TRANSFER_DMA) |
| Count | The number of bytes written and read on return |
| Return | ERROR_SUCCESS if completed or another error code on failure |
| Note | Because SPI writes and then reads for each byte, both the source and dest buffers must be the same size. |
function SPIDeviceGetMode(SPI:PSPIDevice):LongWord;
Description: Get the device mode of the specified SPI device
| SPI | The SPI device to get device mode from |
|---|---|
| Return | The device mode or SPI_MODE_UNKNOWN on failure |
function SPIDeviceSetMode(SPI:PSPIDevice; Mode:LongWord):LongWord;
Description: Set the device mode for the specified SPI device
| SPI | The SPI device to set device mode for |
|---|---|
| Mode | The device mode to set (eg SPI_MODE_4WIRE) |
| Return | ERROR_SUCCESS if completed or another error code on failure |
function SPIDeviceGetClockRate(SPI:PSPIDevice; ChipSelect:Word):LongWord;
Description: Get the clock rate of the specified SPI device
| SPI | The SPI device to get clock rate from |
|---|---|
| ChipSelect | The chip select number to get clock rate from (SPI_CS_NONE for default) |
| Return | The clock rate in Hz or 0 on failure |
function SPIDeviceSetClockRate(SPI:PSPIDevice; ChipSelect:Word; ClockRate:LongWord):LongWord;
Description: Set the clock rate for the specified SPI device
| SPI | The SPI device to set clock rate for |
|---|---|
| ChipSelect | The chip select number to set clock rate for (SPI_CS_NONE for default) |
| ClockRate | The clock rate to set in Hz |
| Return | ERROR_SUCCESS if completed or another error code on failure |
function SPIDeviceGetClockPhase(SPI:PSPIDevice):LongWord;
Description: Get the clock phase of the specified SPI device
| SPI | The SPI device to get clock phase from |
|---|---|
| Return | The clock phase or SPI_CLOCK_PHASE_UNKNOWN on failure |
function SPIDeviceSetClockPhase(SPI:PSPIDevice; ClockPhase:LongWord):LongWord;
Description: Set the clock phase for the specified SPI device
| SPI | The SPI device to set clock phase for |
|---|---|
| ClockPhase | The clock phase to set (eg SPI_CLOCK_PHASE_LOW) |
| Return | ERROR_SUCCESS if completed or another error code on failure |
function SPIDeviceGetClockPolarity(SPI:PSPIDevice):LongWord;
Description: Get the clock polarity of the specified SPI device
| SPI | The SPI device to get clock polarity from |
|---|---|
| Return | The clock polarity or SPI_CLOCK_POLARITY_UNKNOWN on failure |
function SPIDeviceSetClockPolarity(SPI:PSPIDevice; ClockPolarity:LongWord):LongWord;
Description: Set the clock polarity for the specified SPI device
| SPI | The SPI device to set clock polarity for |
|---|---|
| ClockPolarity | The clock polarity to set (eg SPI_CLOCK_POLARITY_LOW) |
| Return | ERROR_SUCCESS if completed or another error code on failure |
function SPIDeviceGetSelectPolarity(SPI:PSPIDevice; ChipSelect:Word):LongWord;
Description: Get the chip select polarity of the specified SPI device
| SPI | The SPI device to get chip select polarity from |
|---|---|
| ChipSelect | The chip select number to get polarity from (SPI_CS_NONE for default) |
| Return | The chip select polarity or SPI_CS_POLARITY_UNKNOWN on failure |
function SPIDeviceSetSelectPolarity(SPI:PSPIDevice; ChipSelect:Word; SelectPolarity:LongWord):LongWord;
Description: Set the chip select polarity for the specified SPI device
| SPI | The SPI device to set chip select polarity for |
|---|---|
| ChipSelect | The chip select number to set polarity for (SPI_CS_NONE for default) |
| SelectPolarity | The chip select polarity to set (eg SPI_CS_POLARITY_LOW) |
| Return | ERROR_SUCCESS if completed or another error code on failure |
function SPIDeviceGetByteDelay(SPI:PSPIDevice):LongWord;
Description: Get the delay between bytes written for the specified SPI device
| SPI | The SPI device to get the byte delay from |
|---|---|
| Return | The byte delay in microseconds, 0 if not set or on failure |
function SPIDeviceSetByteDelay(SPI:PSPIDevice; Delay:LongWord):LongWord;
Description: Set the delay between bytes written for the specified SPI device
| SPI | The SPI device to set byte delay for |
|---|---|
| Delay | The byte delay to set in microseconds |
| Return | ERROR_SUCCESS if completed or another error code on failure |
function SPIDeviceProperties(SPI:PSPIDevice; Properties:PSPIProperties):LongWord; inline;
Description: Get the properties for the specified SPI device
| SPI | The SPI device to get properties from |
|---|---|
| Properties | Pointer to a TSPIProperties structure to fill in |
| Return | ERROR_SUCCESS if completed or another error code on failure |
| Note | Replaced by SPIDeviceGetProperties for consistency |
function SPIDeviceGetProperties(SPI:PSPIDevice;Properties:PSPIProperties):LongWord;
Description: Get the properties for the specified SPI device
| SPI | The SPI device to get properties from |
|---|---|
| Properties | Pointer to a TSPIProperties structure to fill in |
| Return | ERROR_SUCCESS if completed or another error code on failure |
function SPIDeviceCreate:PSPIDevice;
Description: Create a new SPI entry
| Return | Pointer to new SPI entry or nil if SPI could not be created |
|---|
function SPIDeviceCreateEx(Size:LongWord):PSPIDevice;
Description: Create a new SPI entry
| Size | Size in bytes to allocate for new SPI (Including the SPI entry) |
|---|---|
| Return | Pointer to new SPI entry or nil if SPI could not be created |
function SPIDeviceDestroy(SPI:PSPIDevice):LongWord;
Description: Destroy an existing SPI entry
| SPI | The SPI device to destroy |
|---|---|
| Return | ERROR_SUCCESS if completed or another error code on failure |
function SPIDeviceRegister(SPI:PSPIDevice):LongWord;
Description: Register a new SPI in the SPI table
| SPI | The SPI device to register |
|---|---|
| Return | ERROR_SUCCESS if completed or another error code on failure |
function SPIDeviceDeregister(SPI:PSPIDevice):LongWord;
Description: Deregister an SPI from the SPI table
| SPI | The SPI device to deregister |
|---|---|
| Return | ERROR_SUCCESS if completed or another error code on failure |
function SPIDeviceFind(SPIId:LongWord):PSPIDevice;
Description: ERROR_SUCCESS if completed or another error code on failure
| SPIId | The ID number of the SPI device to find |
|---|---|
| Return | Pointer to SPI device entry or nil if not found |
function SPIDeviceFindByName(const Name:String):PSPIDevice; inline;
Description: Find an SPI device by name in the device table
| Name | The name of the SPI device to find (eg SPI0) |
|---|---|
| Return | Pointer to SPI device entry or nil if not found |
function SPIDeviceFindByDescription(const Description:String):PSPIDevice; inline;
Description: Find an SPI device by description in the device table
| Description | The description of the SPI to find (eg BCM2837 SPI0 Master) |
|---|---|
| Return | Pointer to SPI device entry or nil if not found |
function SPIDeviceEnumerate(Callback:TSPIEnumerate; Data:Pointer):LongWord;
Description: Enumerate all SPI devices in the SPI table
| Callback | The callback function to call for each SPI device in the table |
|---|---|
| Data | A private data pointer to pass to callback for each SPI device in the table |
| Return | ERROR_SUCCESS if completed or another error code on failure |
function SPIDeviceNotification(SPI:PSPIDevice; Callback:TSPINotification; Data:Pointer; Notification,Flags:LongWord):LongWord;
Description: Register a notification for SPI device changes
| Device | The SPI device to notify changes for (Optional, pass nil for all SPI devices) |
|---|---|
| Callback | The function to call when a notification event occurs |
| Data | A private data pointer to pass to callback when a notification event occurs |
| Notification | The events to register for notification of (eg DEVICE_NOTIFICATION_REGISTER) |
| Flags | The flags to control the notification (eg NOTIFIER_FLAG_WORKER) |
RTL SPI functions
function SysSPIAvailable:Boolean;
Description: Check if an SPI device is available
| Note | None documented |
|---|
function SysSPIStart(Mode,ClockRate,ClockPhase,ClockPolarity:LongWord):LongWord;
Description: Start the default SPI device ready for writing and reading
| Mode | The device mode to set (eg SPI_MODE_4WIRE) |
|---|---|
| ClockRate | The clock rate to set for the device |
| ClockPhase | The clock phase to set (eg SPI_CLOCK_PHASE_LOW) |
| ClockPolarity | The clock polarity to set (eg SPI_CLOCK_POLARITY_LOW) |
| Return | ERROR_SUCCESS if completed or another error code on failure |
function SysSPIStop:LongWord;
Description: Stop the default SPI device and terminate writing and reading
| Return | ERROR_SUCCESS if completed or another error code on failure |
|---|
function SysSPIRead(ChipSelect:Word; Dest:Pointer; Size:LongWord; var Count:LongWord):LongWord;
Description: Read data from the default SPI device
| ChipSet | The chip select for the slave to read from (eg SPI_CS_0) |
|---|---|
| Dest | Pointer to a buffer to receive the data |
| Size | The size of the buffer |
| Count | The number of bytes read on return |
| Return | ERROR_SUCCESS if completed or another error code on failure |
| Note | Because SPI writes and then reads for each byte, dummy data will be written for each byte to be read. |
function SysSPIWrite(ChipSelect:Word; Source:Pointer; Size:LongWord; var Count:LongWord):LongWord;
Description: Write data to the default SPI device
| ChipSet | The chip select for the slave to write to (eg SPI_CS_0) |
|---|---|
| Source | Pointer to a buffer of data to transmit |
| Size | The size of the buffer |
| Count | The number of bytes written on return |
| Return | ERROR_SUCCESS if completed or another error code on failure |
| Note | Because SPI writes and then reads for each byte, received data will be discarded for each byte written. |
function SysSPIWriteRead(ChipSelect:Word; Source,Dest:Pointer; Size:LongWord; var Count:LongWord):LongWord;
Description: Write data to and Read data from the default SPI device in one operation
| ChipSet | The chip select for the slave to write to and read from (eg SPI_CS_0) |
|---|---|
| Source | Pointer to a buffer of data to transmit |
| Dest | Pointer to a buffer to receive the data |
| Size | The size of the buffer |
| Count | The number of bytes written and read on return |
| Return | ERROR_SUCCESS if completed or another error code on failure |
| Note | Because SPI writes and then reads for each byte, both the source and dest buffers must be the same size. |
function SysSPIGetMode:LongWord;
Description: Get the device mode of the default SPI device
| Return | The device mode or SPI_MODE_UNKNOWN on failure |
|---|
function SysSPISetMode(Mode:LongWord):LongWord;
Description: Set the device mode for the default SPI device
| Mode | The device mode to set (eg SPI_MODE_4WIRE) |
|---|---|
| Return | ERROR_SUCCESS if completed or another error code on failure |
function SysSPIGetClockRate(ChipSelect:Word):LongWord;
Description: Get the clock rate of the default SPI device
| ChipSelect | The chip select number to get clock rate from (SPI_CS_NONE for default) |
|---|---|
| Return | The clock rate in Hz or 0 on failure |
function SysSPISetClockRate(ChipSelect:Word; ClockRate:LongWord):LongWord;
Description: Set the clock rate for the default SPI device
| ChipSelect | The chip select number to set clock rate for (SPI_CS_NONE for default) |
|---|---|
| ClockRate | The clock rate to set in Hz |
| Return | ERROR_SUCCESS if completed or another error code on failure |
function SysSPIGetClockPhase:LongWord;
Description: Get the clock phase of the default SPI device
| Return | The clock phase or SPI_CLOCK_PHASE_UNKNOWN on failure |
|---|
function SysSPISetClockPhase(ClockPhase:LongWord):LongWord;
Description: Set the clock phase for the default SPI device
| ClockPhase | The clock phase to set (eg SPI_CLOCK_PHASE_LOW) |
|---|---|
| Return | ERROR_SUCCESS if completed or another error code on failure |
function SysSPIGetClockPolarity:LongWord;
Description: Get the clock polarity of the default SPI device
| Return | The clock polarity or SPI_CLOCK_POLARITY_UNKNOWN on failure |
|---|
function SysSPISetClockPolarity(ClockPolarity:LongWord):LongWord;
Description: Set the clock polarity for the default SPI device
| ClockPolarity | The clock polarity to set (eg SPI_CLOCK_POLARITY_LOW) |
|---|---|
| Return | ERROR_SUCCESS if completed or another error code on failure |
function SysSPIGetSelectPolarity(ChipSelect:Word):LongWord;
Description: Get the chip select polarity of the default SPI device
| ChipSet | The chip select number to get polarity from (SPI_CS_NONE for default) |
|---|---|
| Return | The chip select polarity or SPI_CS_POLARITY_UNKNOWN on failure |
function SysSPISetSelectPolarity(ChipSelect:Word; SelectPolarity:LongWord):LongWord;
Description: Set the chip select polarity for the default SPI device
| ChipSet | The chip select number to set polarity for (SPI_CS_NONE for default) |
|---|---|
| SelectPolarity | The chip select polarity to set (eg SPI_CS_POLARITY_LOW) |
| Return | ERROR_SUCCESS if completed or another error code on failure |
SPI helper functions
function SPIGetCount:LongWord;
Description: Get the current SPI count
| Note | None documented |
|---|
function SPIDeviceGetDefault:PSPIDevice;
Description: Get the current default SPI device
| Note | None documented |
|---|
function SPIDeviceSetDefault(SPI:PSPIDevice):LongWord;
Description: Set the current default SPI device
| Note | None documented |
|---|
function SPIDeviceCheck(SPI:PSPIDevice):PSPIDevice;
Description: Check if the supplied SPI is in the SPI table
| Note | None documented |
|---|
function SPITypeToString(SPIType:LongWord):String;
Description: Convert an SPI type value to a string
| Note | None documented |
|---|
function SPIStateToString(SPIState:LongWord):String;
Description: Convert an SPI state value to a string
| Note | None documented |
|---|
procedure SPILog(Level:LongWord; SPI:PSPIDevice; const AText:String);
Description: To be documented
| Note | None documented |
|---|
procedure SPILogInfo(SPI:PSPIDevice; const AText:String); inline;
Description: To be documented
| Note | None documented |
|---|
procedure SPILogWarn(SPI:PSPIDevice; const AText:String); inline;
Description: To be documented
| Note | None documented |
|---|
procedure SPILogError(SPI:PSPIDevice; const AText:String); inline;
Description: To be documented
| Note | None documented |
|---|
procedure SPILogDebug(SPI:PSPIDevice; const AText:String); inline;
Description: To be documented
| Note | None documented |
|---|
function SPIChipSelectToString(ChipSelect:Word):String;
Description: To be documented
| Note | None documented |
|---|
function SPIModeToString(Mode:LongWord):String;
Description: To be documented
| Note | None documented |
|---|
function SPIClockPhaseToString(Phase:LongWord):String;
Description: To be documented
| Note | None documented |
|---|
function SPIClockPolarityToString(Polarity:LongWord):String;
Description: To be documented
| Note | None documented |
|---|
function SPISelectPolarityToString(Polarity:LongWord):String;
Description: To be documented
| Note | None documented |
|---|
Return to Unit Reference
