Raspberry

Raspberry

Provides support for using an ADC device with the GPIO pins on the Raspberry Pi.Splashkit allows you to read and write to the GPIO pins on the Raspberry Pi.Provides support for using a motor driver with the GPIO pins on the Raspberry Pi.Provides support for using servo motors with the GPIO pins on the Raspberry Pi.

Functions

Adc Device Named

Retrieve an ADC device that has been loaded.

Parameters:

Name	Type	Description
name	String	The name of the ADC device.

Return Type: Adc Device

Returns: The adc_device pointer if found; otherwise, nullptr.

Signatures:

C++

adc_device adc_device_named(const string &name)

C#

public static AdcDevice SplashKit.AdcDeviceNamed(string name);

Python

def adc_device_named(name):

Pascal

function AdcDeviceNamed(const name: String): AdcDevice

---

Close Adc

Note

This function is overloaded. The following versions exist:

• Close Adc (adc: adc_device)
• Close Adc (name: string)

Close Adc

Closes an ADC device given its pointer.

Parameters:

Name	Type	Description
adc	Adc Device	The ADC device to close.

Signatures:

C++

void close_adc(adc_device adc)

C#

public void AdcDevice.Close();
public static void SplashKit.CloseAdc(AdcDevice adc);

Python

def close_adc(adc):

Pascal

procedure CloseAdc(adc: AdcDevice)

---

Close Adc

Closes an ADC device given its name.

Parameters:

Name	Type	Description
name	String	The name of the ADC device to close.

Signatures:

C++

void close_adc(const string &name)

C#

public static void SplashKit.CloseAdc(string name);

Python

def close_adc_named(name):

Pascal

procedure CloseAdc(const name: String)

---

Close All Adc

Closes all ADC devices that have been opened.

Signatures:

C++

void close_all_adc()

C#

public static void SplashKit.CloseAllAdc();

Python

def close_all_adc():

Pascal

procedure CloseAllAdc()

---

Has Adc Device

Checks if an ADC device with the given name has been loaded.

Parameters:

Name	Type	Description
name	String	The name used to identify the ADC device.

Return Type: Boolean

Returns: true if an ADC device with the supplied name exists.

Signatures:

C++

bool has_adc_device(const string &name)

C#

public static bool SplashKit.HasAdcDevice(string name);

Python

def has_adc_device(name):

Pascal

function HasAdcDevice(const name: String): Boolean

---

Open Adc

Note

This function is overloaded. The following versions exist:

• Open Adc (name: string, type_of_adc: adc_type)
• Open Adc (name: string, bus: int, address: int, type_of_adc: adc_type)

Open Adc

Opens an ADC device with the specified name and type. Defaults to bus 1 and address 0x48.

Parameters:

Name	Type	Description
name	String	The name of the ADC device to open.
type_of_adc	Adc Type	The type of ADC device (e.g., ADS7830, PCF8591).

Return Type: Adc Device

Returns: A valid adc_device on success, or nullptr on failure.

Signatures:

C++

adc_device open_adc(const string &name, adc_type type_of_adc)

C#

public static AdcDevice SplashKit.OpenAdc(string name, AdcType typeOfAdc);
public AdcDevice(string name, AdcType typeOfAdc);

Python

def open_adc(name, type_of_adc):

Pascal

function OpenAdc(const name: String; typeOfAdc: AdcType): AdcDevice

---

Open Adc

Loads an ADC device on the specified I2C bus at a given address.

Parameters:

Name	Type	Description
name	String	The name to assign this ADC device.
bus	Integer	The I2C bus number.
address	Integer	The I2C address of the ADC device.
type_of_adc	Adc Type	The type of ADC device (e.g., ADS7830, PCF8591).

Return Type: Adc Device

Returns: A valid adc_device on success, or nullptr on failure.

Signatures:

C++

adc_device open_adc(const string &name, int bus, int address, adc_type type_of_adc)

C#

public static AdcDevice SplashKit.OpenAdc(string name, int bus, int address, AdcType typeOfAdc);
public AdcDevice(string name, int bus, int address, AdcType typeOfAdc);

Python

def open_adc_with_bus(name, bus, address, type_of_adc):

Pascal

function OpenAdc(const name: String; bus: Integer; address: Integer; typeOfAdc: AdcType): AdcDevice

---

Read Adc

Note

This function is overloaded. The following versions exist:

• Read Adc (adc: adc_device, channel: adc_pin)
• Read Adc (name: string, channel: adc_pin)

Read Adc

Reads an 8-bit value from the specified ADC channel on the device.

Parameters:

Name	Type	Description
adc	Adc Device	The ADC device to read from.
channel	Adc Pin	The channel number to read (range depends on ADC type).

Return Type: Integer

Returns: The ADC conversion value (0–255), or -1 on error.

Signatures:

C++

int read_adc(adc_device adc, adc_pin channel)

C#

public int AdcDevice.Read(AdcPin channel);
public static int SplashKit.ReadAdc(AdcDevice adc, AdcPin channel);

Python

def read_adc(adc, channel):

Pascal

function ReadAdc(adc: AdcDevice; channel: AdcPin): Integer

---

Read Adc

Reads an 8-bit value from the specified ADC channel on the device using its name.

Parameters:

Name	Type	Description
name	String	The ADC name string to close.
channel	Adc Pin	The channel number to read (range depends on ADC type).

Return Type: Integer

Returns: The ADC conversion value (0–255), or -1 on error.

Signatures:

C++

int read_adc(const string &name, adc_pin channel)

C#

public static int SplashKit.ReadAdc(string name, AdcPin channel);

Python

def read_adc_named(name, channel):

Pascal

function ReadAdc(const name: String; channel: AdcPin): Integer

---

Get Alpha Font 14 Seg  {</>}

Converts an ASCII character to a binary value to be used with the Quad 14-segment display module (HT16K33 backpack).

Parameters:

Name	Type	Description
ascii_char	Char	The ascii character to be converted to a 16-bit binary value.

Return Type: undefined

Returns: The binary value used to display a character on the 14-segment display.

Signatures:

C++

unsigned short get_alpha_font_14_seg(char ascii_char)

C#

public static ushort SplashKit.GetAlphaFont14Seg(char asciiChar);

Python

def get_alpha_font_14_seg(ascii_char):

Pascal

function GetAlphaFont14Seg(asciiChar: Char): Word

Usage:  {</>}

See Implementations

API Documentation Code Examples:

• Raspi I2c Write: LED Text Scrolling

---

Gpio Pin To Int

Converts the specified pin value to an integer, to use in calculations.

Parameters:

Name	Type	Description
value	Gpio Pin Value	The pin to read the value from.

Return Type: Integer

Returns: The pin value as an integer.

Signatures:

C++

int gpio_pin_to_int(gpio_pin_value value)

C#

public static int SplashKit.GpioPinToInt(GpioPinValue value);

Python

def gpio_pin_to_int(value):

Pascal

function GpioPinToInt(value: GpioPinValue): Integer

---

Has Gpio

Checks if the system has GPIO capabilities.

Return Type: Boolean

Returns: true if the system has GPIO capabilities, false otherwise.

Signatures:

C++

bool has_gpio()

C#

public static bool SplashKit.HasGpio();

Python

def has_gpio():

Pascal

function HasGpio(): Boolean

---

Raspi Cleanup  {</>}

This function should be called when you are finished using the GPIO library. It sets all pin modes to INPUT and values to LOW.

Signatures:

C++

void raspi_cleanup()

C#

public static void SplashKit.RaspiCleanup();

Python

def raspi_cleanup():

Pascal

procedure RaspiCleanup()

Usage:  {</>}

See Implementations

Tutorials and Guides:

• Get Started with SplashKit GPIO
• Reading Button Presses
• Using PWM to control LED brightness
• Modify PWM through button presses

API Documentation Code Examples:

• Raspi I2c Write: LED Text Scrolling

---

Raspi Get Mode

This function retrieves the mode of the specified pin.

Parameters:

Name	Type	Description
pin	Gpio Pin	The pin to get the mode for.

Return Type: Gpio Pin Mode

Returns: The mode of the pin.

Signatures:

C++

gpio_pin_mode raspi_get_mode(gpio_pin pin)

C#

public static GpioPinMode SplashKit.RaspiGetMode(GpioPin pin);

Python

def raspi_get_mode(pin):

Pascal

function RaspiGetMode(pin: GpioPin): GpioPinMode

---

Raspi Get Servo Pulsewidth

This function retrieves the pulse width for the specified pin.

Parameters:

Name	Type	Description
pin	Gpio Pin	The pin to get the pulse width for.

Return Type: Integer

Returns: The pulse width of the pin.

Signatures:

C++

int raspi_get_servo_pulsewidth(gpio_pin pin)

C#

public static int SplashKit.RaspiGetServoPulsewidth(GpioPin pin);

Python

def raspi_get_servo_pulsewidth(pin):

Pascal

function RaspiGetServoPulsewidth(pin: GpioPin): Integer

---

Raspi I2c Open  {</>}

Opens I2C communication on selected address. It will return -1 if not using Raspberry Pi.

Parameters:

Name	Type	Description
bus	Integer	The bus of the I2C device.
address	Integer	The address of the I2C device.

Return Type: Integer

Returns: The handle referencing this particular connection.

Signatures:

C++

int raspi_i2c_open(int bus, int address)

C#

public static int SplashKit.RaspiI2cOpen(int bus, int address);

Python

def raspi_i2c_open(bus, address):

Pascal

function RaspiI2cOpen(bus: Integer; address: Integer): Integer

Usage:  {</>}

See Implementations

API Documentation Code Examples:

• Raspi I2c Write: LED Text Scrolling

---

Raspi I2c Write  {</>}

Note

This function is overloaded. The following versions exist:

• Raspi I2c Write (handle: int, data: int)  {</>}
• Raspi I2c Write (handle: int, reg: int, data: int, bytes: int)  {</>}

Raspi I2c Write  {</>}

Writes data to specified I2C connection.

Parameters:

Name	Type	Description
handle	Integer	The reference for a specific I2C connection.
data	Integer	The data to send.

Signatures:

C++

void raspi_i2c_write(int handle, int data)

C#

public static void SplashKit.RaspiI2cWrite(int handle, int data);

Python

def raspi_i2c_write(handle, data):

Pascal

procedure RaspiI2cWrite(handle: Integer; data: Integer)

Usage:  {</>}

See Implementations

API Documentation Code Examples:

• Raspi I2c Write: LED Text Scrolling

---

Raspi I2c Write  {</>}

Writes 8-bit (1 byte) or 16-bit (2 bytes) data to specified I2C connection.

Parameters:

Name	Type	Description
handle	Integer	The reference for a specific I2C connection.
reg	Integer	The register to send the data to
data	Integer	The data to send.
bytes	Integer	The number of bytes to be transferred.

Signatures:

C++

void raspi_i2c_write(int handle, int reg, int data, int bytes)

C#

public static void SplashKit.RaspiI2cWrite(int handle, int reg, int data, int bytes);

Python

def raspi_i2c_write_data(handle, reg, data, bytes):

Pascal

procedure RaspiI2cWrite(handle: Integer; reg: Integer; data: Integer; bytes: Integer)

Usage:  {</>}

See Code Examples

Example 21: LED Text Scrolling

The following example requires the Quad 14 Segment Alphanumeric Display Module, connected to the Raspberry Pi GPIO pins using the wiring diagram below.

Wiring diagram:

C++

#include "splashkit.h"

int main()
{
    write_line("Testing Quad 14-segment alphanumeric display with HT16K33 I2C driver...");

    raspi_init();

    int i2c_device = raspi_i2c_open(1, 0x70);

    raspi_i2c_write(i2c_device, 0b00100001); // Turn on system oscillator
    raspi_i2c_write(i2c_device, 0b10000001); // no blink, display on
    raspi_i2c_write(i2c_device, 0b11100011); // lower brightness

    // clear display
    for (uint8_t i = 0; i < 16; i++)
    {
        raspi_i2c_write(i2c_device, i, 0, 2);
    }

    string message = "HELLO WORLD FROM SPLASHKIT";
    string text = "    " + message + "    ";

    for (int i = 0; i < text.length() - 3; i++)
    {
        for (int j = 0; j < 4; j++)
        {
            raspi_i2c_write(i2c_device, j * 2, get_alpha_font_14_seg(text[i + j]), 2);
        }
        delay(200);
    }

    // Turn off LED device
    raspi_i2c_write(i2c_device, 0b00100000); // Turn off system oscillator

    // Clean up the GPIO
    raspi_cleanup();

    return 0;
}

C#

Top-level Statements

using static SplashKitSDK.SplashKit;

WriteLine("Testing Quad 14-segment alphanumeric display with HT16K33 I2C driver...");

RaspiInit();

int i2c_device = RaspiI2cOpen(1, 0x70);

RaspiI2cWrite(i2c_device, 0b00100001); // Turn on system oscillator
RaspiI2cWrite(i2c_device, 0b10000001); // no blink, display on
RaspiI2cWrite(i2c_device, 0b11100011); // lower brightness

// clear display
for (int i = 0; i < 16; i++)
{
    RaspiI2cWrite(i2c_device, i, 0, 2);
}

string message = "HELLO WORLD FROM SPLASHKIT";
string text = "    " + message + "    ";

for (int i = 0; i < text.Length - 3; i++)
{
    for (int j = 0; j < 4; j++)
    {
        RaspiI2cWrite(i2c_device, j * 2, GetAlphaFont14Seg(text[i + j]), 2);
    }
    Delay(200);
}

// Turn off LED device
RaspiI2cWrite(i2c_device, 0b00100000); // Turn off system oscillator

// Clean up the GPIO
RaspiCleanup();

Object-Oriented

using SplashKitSDK;

namespace RaspiI2cWriteDataExample
{
    public static class Program
    {
        public static void Main()
        {

            SplashKit.WriteLine("Testing Quad 14-segment alphanumeric display with HT16K33 I2C driver...");

            SplashKit.RaspiInit();

            int i2c_device = SplashKit.RaspiI2cOpen(1, 0x70);

            SplashKit.RaspiI2cWrite(i2c_device, 0b00100001); // Turn on system oscillator
            SplashKit.RaspiI2cWrite(i2c_device, 0b10000001); // no blink, display on
            SplashKit.RaspiI2cWrite(i2c_device, 0b11100011); // lower brightness

            // clear display
            for (int i = 0; i < 16; i++)
            {
                SplashKit.RaspiI2cWrite(i2c_device, i, 0, 2);
            }

            string message = "HELLO WORLD FROM SPLASHKIT";
            string text = "    " + message + "    ";

            for (int i = 0; i < text.Length - 3; i++)
            {
                for (int j = 0; j < 4; j++)
                {
                    SplashKit.RaspiI2cWrite(i2c_device, j * 2, SplashKit.GetAlphaFont14Seg(text[i + j]), 2);
                }
                SplashKit.Delay(200);
            }

            // Turn off LED device
            SplashKit.RaspiI2cWrite(i2c_device, 0b00100000); // Turn off system oscillator

            // Clean up the GPIO
            SplashKit.RaspiCleanup();

        }
    }
}

Python

from splashkit import *

write_line("Testing Quad 14-segment alphanumeric display with HT16K33 I2C driver...")

raspi_init()

i2c_device = raspi_i2c_open(1, 0x70)

raspi_i2c_write(i2c_device, 0b00100001) # Turn on system oscillator
raspi_i2c_write(i2c_device, 0b10000001) # no blink, display on
raspi_i2c_write(i2c_device, 0b11100011) # lower brightness

# clear display
for i in range(16):
    raspi_i2c_write_data(i2c_device, i, 0, 2)

message = "HELLO WORLD FROM SPLASHKIT"
text = "    " + message + "    "

for i in range(len(text) - 3):
    for j in range(4):
        raspi_i2c_write_data(i2c_device, j * 2, get_alpha_font_14_seg(text[i + j]), 2)
    delay(200)

# Turn off LED device
raspi_i2c_write(i2c_device, 0b00100000) # Turn off system oscillator

# Clean up the GPIO
raspi_cleanup()

Output:

---

Raspi Init  {</>}

This function initializes the GPIO library for use. It should be called before any other GPIO functions.

Signatures:

C++

void raspi_init()

C#

public static void SplashKit.RaspiInit();

Python

def raspi_init():

Pascal

procedure RaspiInit()

Usage:  {</>}

See Implementations

Tutorials and Guides:

• Get Started with SplashKit GPIO
• Reading Button Presses
• Using PWM to control LED brightness
• Modify PWM through button presses

API Documentation Code Examples:

• Raspi I2c Write: LED Text Scrolling

---

Raspi Read  {</>}

This function reads the value from the specified pin.

Parameters:

Name	Type	Description
pin	Gpio Pin	The pin to read the value from.

Return Type: Gpio Pin Value

Returns: The value read from the pin.

Signatures:

C++

gpio_pin_value raspi_read(gpio_pin pin)

C#

public static GpioPinValue SplashKit.RaspiRead(GpioPin pin);

Python

def raspi_read(pin):

Pascal

function RaspiRead(pin: GpioPin): GpioPinValue

Usage:  {</>}

See Implementations

Tutorials and Guides:

• Reading Button Presses
• Modify PWM through button presses

---

Raspi Set Mode  {</>}

This function sets the mode of the specified pin to the specified mode.

Parameters:

Name	Type	Description
pin	Gpio Pin	The pin to set the mode for.
mode	Gpio Pin Mode	The mode to set for the pin.

Signatures:

C++

void raspi_set_mode(gpio_pin pin, gpio_pin_mode mode)

C#

public static void SplashKit.RaspiSetMode(GpioPin pin, GpioPinMode mode);

Python

def raspi_set_mode(pin, mode):

Pascal

procedure RaspiSetMode(pin: GpioPin; mode: GpioPinMode)

Usage:  {</>}

See Implementations

Tutorials and Guides:

• Get Started with SplashKit GPIO
• Reading Button Presses
• Using PWM to control LED brightness
• Modify PWM through button presses

---

Raspi Set Pull Up Down  {</>}

This function sets the pull-up/down mode for the specified pin.

Parameters:

Name	Type	Description
pin	Gpio Pin	The pin to set the pull up/down mode for.
pud	Pull Up Down	The pull up/down mode to set for the pin.

Signatures:

C++

void raspi_set_pull_up_down(gpio_pin pin, pull_up_down pud)

C#

public static void SplashKit.RaspiSetPullUpDown(GpioPin pin, PullUpDown pud);

Python

def raspi_set_pull_up_down(pin, pud):

Pascal

procedure RaspiSetPullUpDown(pin: GpioPin; pud: PullUpDown)

Usage:  {</>}

See Implementations

Tutorials and Guides:

• Reading Button Presses
• Modify PWM through button presses

---

Raspi Set Pwm Dutycycle  {</>}

This function sets the PWM duty cycle for the specified pin.

Parameters:

Name	Type	Description
pin	Gpio Pin	The pin to set the PWM duty cycle for.
dutycycle	Integer	The PWM duty cycle to set for the pin.

Signatures:

C++

void raspi_set_pwm_dutycycle(gpio_pin pin, int dutycycle)

C#

public static void SplashKit.RaspiSetPwmDutycycle(GpioPin pin, int dutycycle);

Python

def raspi_set_pwm_dutycycle(pin, dutycycle):

Pascal

procedure RaspiSetPwmDutycycle(pin: GpioPin; dutycycle: Integer)

Usage:  {</>}

See Implementations

Tutorials and Guides:

• Using PWM to control LED brightness
• Modify PWM through button presses

---

Raspi Set Pwm Frequency  {</>}

This function sets the PWM frequency for the specified pin.

Parameters:

Name	Type	Description
pin	Gpio Pin	The pin to set the PWM frequency for.
frequency	Integer	The PWM frequency to set for the pin.

Signatures:

C++

void raspi_set_pwm_frequency(gpio_pin pin, int frequency)

C#

public static void SplashKit.RaspiSetPwmFrequency(GpioPin pin, int frequency);

Python

def raspi_set_pwm_frequency(pin, frequency):

Pascal

procedure RaspiSetPwmFrequency(pin: GpioPin; frequency: Integer)

Usage:  {</>}

See Implementations

Tutorials and Guides:

• Using PWM to control LED brightness
• Modify PWM through button presses

---

Raspi Set Pwm Range  {</>}

This function sets the PWM range for the specified pin. Valid values for the range are 25 - 40000

Parameters:

Name	Type	Description
pin	Gpio Pin	The pin to set the PWM range for.
range	Integer	The PWM range to set for the pin.

Signatures:

C++

void raspi_set_pwm_range(gpio_pin pin, int range)

C#

public static void SplashKit.RaspiSetPwmRange(GpioPin pin, int range);

Python

def raspi_set_pwm_range(pin, range):

Pascal

procedure RaspiSetPwmRange(pin: GpioPin; range: Integer)

Usage:  {</>}

See Implementations

Tutorials and Guides:

• Using PWM to control LED brightness

---

Raspi Set Servo Pulsewidth

This function sets the pulse width for the specified pin.

Parameters:

Name	Type	Description
pin	Gpio Pin	The pin to set the pulse width for.
pulsewidth	Integer	The pulse width to set for the pin.

Signatures:

C++

void raspi_set_servo_pulsewidth(gpio_pin pin, int pulsewidth)

C#

public static void SplashKit.RaspiSetServoPulsewidth(GpioPin pin, int pulsewidth);

Python

def raspi_set_servo_pulsewidth(pin, pulsewidth):

Pascal

procedure RaspiSetServoPulsewidth(pin: GpioPin; pulsewidth: Integer)

---

Raspi Spi Close

This function closes SPI communication on a particular channel.

Parameters:

Name	Type	Description
handle	Integer	A reference to the specific SPI connection to close.

Return Type: Integer

Returns: A value indicating success or failure.

Signatures:

C++

int raspi_spi_close(int handle)

C#

public static int SplashKit.RaspiSpiClose(int handle);

Python

def raspi_spi_close(handle):

Pascal

function RaspiSpiClose(handle: Integer): Integer

---

Raspi Spi Open

This function opens SPI communication on a particular channel. It will return -1 if not using Raspberry Pi.

Parameters:

Name	Type	Description
channel	Integer	The SPI channel to use.
speed	Integer	The speed of data transfer (in baud).
spi_flags	Integer	Optional flags for the SPI modes and settings.

Return Type: Integer

Returns: The handle referencing this particular connection.

Signatures:

C++

int raspi_spi_open(int channel, int speed, int spi_flags)

C#

public static int SplashKit.RaspiSpiOpen(int channel, int speed, int spiFlags);

Python

def raspi_spi_open(channel, speed, spi_flags):

Pascal

function RaspiSpiOpen(channel: Integer; speed: Integer; spiFlags: Integer): Integer

---

Raspi Spi Transfer

This function transfers data through SPI, it sends data from sendBuf and receives it into recvBuf.

Parameters:

Name	Type	Description
handle	Integer	The reference for a specific SPI connection.
send	String	The data to send.
count	Integer	The number of bytes to be transferred.
bytes_transfered	Integer	The number of bytes transferred (output)

Return Type: String

Returns: The data returned from the spi transfer

Signatures:

C++

string raspi_spi_transfer(int handle, const string &send, int count, int &bytes_transfered)

C#

public static string SplashKit.RaspiSpiTransfer(int handle, string send, int count, ref int bytesTransfered);

Python

def raspi_spi_transfer(handle, send, count, bytes_transfered):

Pascal

function RaspiSpiTransfer(handle: Integer; const send: String; count: Integer; var bytesTransfered: Integer): String

---

Raspi Write  {</>}

This function writes the specified value to the specified pin.

Parameters:

Name	Type	Description
pin	Gpio Pin	The pin to write the value to.
value	Gpio Pin Value	The value to write to the pin.

Signatures:

C++

void raspi_write(gpio_pin pin, gpio_pin_value value)

C#

public static void SplashKit.RaspiWrite(GpioPin pin, GpioPinValue value);

Python

def raspi_write(pin, value):

Pascal

procedure RaspiWrite(pin: GpioPin; value: GpioPinValue)

Usage:  {</>}

See Implementations

Tutorials and Guides:

• Get Started with SplashKit GPIO
• Reading Button Presses

---

Remote Raspi Cleanup

This function closes the connection to the remote Raspberry Pi and releases any resources associated with it.

Parameters:

Name	Type	Description
pi	Connection	The connection object to the remote Raspberry Pi.

Return Type: Boolean

Returns: true if the cleanup was successful, false otherwise.

Signatures:

C++

bool remote_raspi_cleanup(connection pi)

C#

public static bool SplashKit.RemoteRaspiCleanup(Connection pi);

Python

def remote_raspi_cleanup(pi):

Pascal

function RemoteRaspiCleanup(pi: Connection): Boolean

---

Remote Raspi Get Mode

This function retrieves the mode of a specific pin on a remote Raspberry Pi.

Parameters:

Name	Type	Description
pi	Connection	The connection object to the remote Raspberry Pi.
pin	Gpio Pin	The pin to get the mode for.

Return Type: Gpio Pin Mode

Returns: The mode of the pin.

Signatures:

C++

gpio_pin_mode remote_raspi_get_mode(connection pi, gpio_pin pin)

C#

public static GpioPinMode SplashKit.RemoteRaspiGetMode(Connection pi, GpioPin pin);

Python

def remote_raspi_get_mode(pi, pin):

Pascal

function RemoteRaspiGetMode(pi: Connection; pin: GpioPin): GpioPinMode

---

Remote Raspi Init

This function initialises a connection to a remote Raspberry Pi using the specified name, host, and port.

Parameters:

Name	Type	Description
name	String	The name of the connection.
host	String	The host address of the Raspberry Pi.
port	unsigned short	The port to use for the connection.

Return Type: Connection

Returns: The connection object used to communicate with the remote Raspberry Pi.

Signatures:

C++

connection remote_raspi_init(const string &name, const string &host, unsigned short port)

C#

public static Connection SplashKit.RemoteRaspiInit(string name, string host, ushort port);

Python

def remote_raspi_init(name, host, port):

Pascal

function RemoteRaspiInit(const name: String; const host: String; port: Word): Connection

---

Remote Raspi Read

This function reads the value from a specific pin on a remote Raspberry Pi.

Parameters:

Name	Type	Description
pi	Connection	The connection object to the remote Raspberry Pi.
pin	Gpio Pin	The pin to read the value from.

Return Type: Gpio Pin Value

Returns: The value read from the pin.

Signatures:

C++

gpio_pin_value remote_raspi_read(connection pi, gpio_pin pin)

C#

public static GpioPinValue SplashKit.RemoteRaspiRead(Connection pi, GpioPin pin);

Python

def remote_raspi_read(pi, pin):

Pascal

function RemoteRaspiRead(pi: Connection; pin: GpioPin): GpioPinValue

---

Remote Raspi Set Mode

This function sets the mode of a specific pin on a remote Raspberry Pi.

Parameters:

Name	Type	Description
pi	Connection	The connection object to the remote Raspberry Pi.
pin	Gpio Pin	The pin to set the mode for.
mode	Gpio Pin Mode	The mode to set for the pin.

Signatures:

C++

void remote_raspi_set_mode(connection pi, gpio_pin pin, gpio_pin_mode mode)

C#

public static void SplashKit.RemoteRaspiSetMode(Connection pi, GpioPin pin, GpioPinMode mode);

Python

def remote_raspi_set_mode(pi, pin, mode):

Pascal

procedure RemoteRaspiSetMode(pi: Connection; pin: GpioPin; mode: GpioPinMode)

---

Remote Raspi Set Pull Up Down

This function sets the pull-up/down mode of a specific pin on a remote Raspberry Pi.

Parameters:

Name	Type	Description
pi	Connection	The connection object to the remote Raspberry Pi.
pin	Gpio Pin	The pin to set the pull up/down mode for.
pud	Pull Up Down	The pull up/down mode to set for the pin.

Signatures:

C++

void remote_raspi_set_pull_up_down(connection pi, gpio_pin pin, pull_up_down pud)

C#

public static void SplashKit.RemoteRaspiSetPullUpDown(Connection pi, GpioPin pin, PullUpDown pud);

Python

def remote_raspi_set_pull_up_down(pi, pin, pud):

Pascal

procedure RemoteRaspiSetPullUpDown(pi: Connection; pin: GpioPin; pud: PullUpDown)

---

Remote Raspi Set Pwm Dutycycle

This function sets the PWM duty cycle for a specific pin on a remote Raspberry Pi.

Parameters:

Name	Type	Description
pi	Connection	The connection object to the remote Raspberry Pi.
pin	Gpio Pin	The pin to set the PWM duty cycle for.
dutycycle	Integer	The PWM duty cycle to set for the pin.

Signatures:

C++

void remote_raspi_set_pwm_dutycycle(connection pi, gpio_pin pin, int dutycycle)

C#

public static void SplashKit.RemoteRaspiSetPwmDutycycle(Connection pi, GpioPin pin, int dutycycle);

Python

def remote_raspi_set_pwm_dutycycle(pi, pin, dutycycle):

Pascal

procedure RemoteRaspiSetPwmDutycycle(pi: Connection; pin: GpioPin; dutycycle: Integer)

---

Remote Raspi Set Pwm Frequency

This function sets the PWM frequency for a specific pin on a remote Raspberry Pi.

Parameters:

Name	Type	Description
pi	Connection	The connection object to the remote Raspberry Pi.
pin	Gpio Pin	The pin to set the PWM frequency for.
frequency	Integer	The PWM frequency to set for the pin.

Signatures:

C++

void remote_raspi_set_pwm_frequency(connection pi, gpio_pin pin, int frequency)

C#

public static void SplashKit.RemoteRaspiSetPwmFrequency(Connection pi, GpioPin pin, int frequency);

Python

def remote_raspi_set_pwm_frequency(pi, pin, frequency):

Pascal

procedure RemoteRaspiSetPwmFrequency(pi: Connection; pin: GpioPin; frequency: Integer)

---

Remote Raspi Set Pwm Range

This function sets the PWM range for a specific pin on a remote Raspberry Pi. Valid values for the range are 25 - 40000

Parameters:

Name	Type	Description
pi	Connection	The connection object to the remote Raspberry Pi.
pin	Gpio Pin	The pin to set the PWM range for.
range	Integer	The PWM range to set for the pin.

Signatures:

C++

void remote_raspi_set_pwm_range(connection pi, gpio_pin pin, int range)

C#

public static void SplashKit.RemoteRaspiSetPwmRange(Connection pi, GpioPin pin, int range);

Python

def remote_raspi_set_pwm_range(pi, pin, range):

Pascal

procedure RemoteRaspiSetPwmRange(pi: Connection; pin: GpioPin; range: Integer)

---

Remote Raspi Write

This function writes a specified value to a specific pin on a remote Raspberry Pi.

Parameters:

Name	Type	Description
pi	Connection	The connection object to the remote Raspberry Pi.
pin	Gpio Pin	The pin to write the value to.
value	Gpio Pin Value	The value to write to the pin.

Signatures:

C++

void remote_raspi_write(connection pi, gpio_pin pin, gpio_pin_value value)

C#

public static void SplashKit.RemoteRaspiWrite(Connection pi, GpioPin pin, GpioPinValue value);

Python

def remote_raspi_write(pi, pin, value):

Pascal

procedure RemoteRaspiWrite(pi: Connection; pin: GpioPin; value: GpioPinValue)

---

Close All Motors

Closes all opened motor devices.

Signatures:

C++

void close_all_motors()

C#

public static void SplashKit.CloseAllMotors();

Python

def close_all_motors():

Pascal

procedure CloseAllMotors()

---

Close Motor

Note

This function is overloaded. The following versions exist:

• Close Motor (name: string)
• Close Motor (dev: motor_device)

Close Motor

Closes and frees a motor device by name.

Parameters:

Name	Type	Description
name	String	Name of the motor device.

Signatures:

C++

void close_motor(const string &name)

C#

public static void SplashKit.CloseMotor(string name);

Python

def close_motor_named(name):

Pascal

procedure CloseMotor(const name: String)

---

Close Motor

Closes and frees resources for a motor device.

Parameters:

Name	Type	Description
dev	Motor Device	The motor device handle.

Signatures:

C++

void close_motor(motor_device dev)

C#

public static void SplashKit.CloseMotor(MotorDevice dev);

Python

def close_motor(dev):

Pascal

procedure CloseMotor(dev: MotorDevice)

---

Free Motor Device

Free the resources associated with a motor device.

Parameters:

Name	Type	Description
dev	Motor Device	The motor device to be destroyed.

Signatures:

C++

void free_motor_device(motor_device dev)

C#

public static void SplashKit.FreeMotorDevice(MotorDevice dev);

Python

def free_motor_device(dev):

Pascal

procedure FreeMotorDevice(dev: MotorDevice)

---

Has Motor Device

Checks if a motor device with the given name is already opened.

Parameters:

Name	Type	Description
name	String	Identifier for the motor driver.

Return Type: Boolean

Returns: true if open, false otherwise.

Signatures:

C++

bool has_motor_device(const string &name)

C#

public static bool SplashKit.HasMotorDevice(string name);

Python

def has_motor_device(name):

Pascal

function HasMotorDevice(const name: String): Boolean

---

Motor Named

Retrieves an existing motor device handle by name.

Parameters:

Name	Type	Description
name	String	Identifier for the motor driver.

Return Type: Motor Device

Returns: motor_device pointer or nullptr.

Signatures:

C++

motor_device motor_named(const string &name)

C#

public static MotorDevice SplashKit.MotorNamed(string name);

Python

def motor_named(name):

Pascal

function MotorNamed(const name: String): MotorDevice

---

Open Motor

Opens a motor device with the specified parameters.

Parameters:

Name	Type	Description
name	String	Identifier for the motor driver.
type	Motor Driver Type	Type of motor driver (e.g., L298N).
in1_pin	Gpio Pin	GPIO pin for IN1.
in2_pin	Gpio Pin	GPIO pin for IN2.
en_pin	Gpio Pin	GPIO pin for ENA.

Return Type: Motor Device

Returns: A valid motor_device on success, or nullptr on failure.

Signatures:

C++

motor_device open_motor(const string &name, motor_driver_type type, gpio_pin in1_pin, gpio_pin in2_pin, gpio_pin en_pin)

C#

public static MotorDevice SplashKit.OpenMotor(string name, MotorDriverType type, GpioPin in1Pin, GpioPin in2Pin, GpioPin enPin);

Python

def open_motor(name, type, in1_pin, in2_pin, en_pin):

Pascal

function OpenMotor(const name: String; type: MotorDriverType; in1Pin: GpioPin; in2Pin: GpioPin; enPin: GpioPin): MotorDevice

---

Set Motor Direction

Sets the motor rotation direction.

Parameters:

Name	Type	Description
dev	Motor Device	The motor device handle.
dir	Motor Direction	Desired rotation direction.

Signatures:

C++

void set_motor_direction(motor_device dev, motor_direction dir)

C#

public static void SplashKit.SetMotorDirection(MotorDevice dev, MotorDirection dir);

Python

def set_motor_direction(dev, dir):

Pascal

procedure SetMotorDirection(dev: MotorDevice; dir: MotorDirection)

---

Set Motor Speed

Sets the PWM speed of the motor (0-1).

Parameters:

Name	Type	Description
dev	Motor Device	The motor device handle.
speed	Double	Duty cycle speed (0..1).

Signatures:

C++

void set_motor_speed(motor_device dev, double speed)

C#

public static void SplashKit.SetMotorSpeed(MotorDevice dev, double speed);

Python

def set_motor_speed(dev, speed):

Pascal

procedure SetMotorSpeed(dev: MotorDevice; speed: Double)

---

Stop Motor

Stops the motor immediately (brake).

Parameters:

Name	Type	Description
dev	Motor Device	The motor device handle.

Signatures:

C++

void stop_motor(motor_device dev)

C#

public static void SplashKit.StopMotor(MotorDevice dev);

Python

def stop_motor(dev):

Pascal

procedure StopMotor(dev: MotorDevice)

---

Close All Servos

Close all servos.

Signatures:

C++

void close_all_servos()

C#

public static void SplashKit.CloseAllServos();

Python

def close_all_servos():

Pascal

procedure CloseAllServos()

---

Close Servo

Note

This function is overloaded. The following versions exist:

• Close Servo (name: string)
• Close Servo (dev: servo_device)

Close Servo

Closes a servo device given its name.

Parameters:

Name	Type	Description
name	String	The name of the servo device to close.

Signatures:

C++

void close_servo(const string &name)

C#

public static void SplashKit.CloseServo(string name);

Python

def close_servo_named(name):

Pascal

procedure CloseServo(const name: String)

---

Close Servo

Close one servo (by handle) or by name. Closes a servo device given its pointer.

Parameters:

Name	Type	Description
dev	Servo Device	The servo device to close.

Signatures:

C++

void close_servo(servo_device dev)

C#

public void ServoDevice.Close();
public static void SplashKit.CloseServo(ServoDevice dev);

Python

def close_servo(dev):

Pascal

procedure CloseServo(dev: ServoDevice)

---

Has Servo Device

Returns true if a servo with this name is already open.

Parameters:

Name	Type	Description
name	String	Your identifier for this servo.

Return Type: Boolean

Returns: true if the servo is open, false otherwise.

Signatures:

C++

bool has_servo_device(const string &name)

C#

public static bool SplashKit.HasServoDevice(string name);

Python

def has_servo_device(name):

Pascal

function HasServoDevice(const name: String): Boolean

---

Open Servo

Open (and initialize) a servo on the given board pin.

Parameters:

Name	Type	Description
name	String	Your identifier for this servo.
control_pin	Gpio Pin	Board‐numbered GPIO pin for the servo signal line.

Return Type: Servo Device

Returns: A valid servo_device, or nullptr on failure.

Signatures:

C++

servo_device open_servo(const string &name, gpio_pin control_pin)

C#

public static ServoDevice SplashKit.OpenServo(string name, GpioPin controlPin);
public ServoDevice(string name, GpioPin controlPin);

Python

def open_servo(name, control_pin):

Pascal

function OpenServo(const name: String; controlPin: GpioPin): ServoDevice

---

Servo Named

Look up an already‐opened servo by name.

Parameters:

Name	Type	Description
name	String	Your identifier for this servo.

Return Type: Servo Device

Returns: A valid servo_device, or nullptr if not found.

Signatures:

C++

servo_device servo_named(const string &name)

C#

public static ServoDevice SplashKit.ServoNamed(string name);

Python

def servo_named(name):

Pascal

function ServoNamed(const name: String): ServoDevice

---

Set Servo Angle

Convenience: map an angle (0…180°) into the 500…2500 µs range. This is a linear mapping, so it may not be accurate for all servos.

Parameters:

Name	Type	Description
dev	Servo Device	The servo device to control.
angle_degrees	Double	The angle in degrees (0…180).

Signatures:

C++

void set_servo_angle(servo_device dev, double angle_degrees)

C#

public void ServoDevice.SetAngle(double angleDegrees);
public static void SplashKit.SetServoAngle(ServoDevice dev, double angleDegrees);

Python

def set_servo_angle(dev, angle_degrees):

Pascal

procedure SetServoAngle(dev: ServoDevice; angleDegrees: Double)

---

Stop Servo

Stop sending pulses (servo will hold last position or drift). This is a convenience function that sets the pulse width to 0.

Parameters:

Name	Type	Description
dev	Servo Device	The servo device to control.

Signatures:

C++

void stop_servo(servo_device dev)

C#

public void ServoDevice.Stop();
public static void SplashKit.StopServo(ServoDevice dev);

Python

def stop_servo(dev):

Pascal

procedure StopServo(dev: ServoDevice)

---

Types

Adc Device

The Adc Device type is used to refer to ADC (Analog-to-Digital Converter) devices that can be managed by the SplashKit ADC code, such as ADS7830. ADC devices are:

• loaded with Open Adc,
• accessed using Adc Device Named or checked with Has Adc Device,
• read using Read Adc to retrieve analog values from specific channels,
• and must be closed using Close Adc (to release a specific ADC device) or Close All Adc (to release all loaded ADC devices).

ADC devices allow you to interface with external analog sensors or inputs, converting their signals into digital values for processing in your application.

---

Motor Device

The Motor Device type is used to refer to motor driver devices that can be managed by the SplashKit motor driver code. Motor devices are:

• checked with Has Motor Device to see if a motor is already opened,

• accessed using Motor Named to retrieve an existing motor device by name,

• opened using Open Motor with specific parameters such as motor type and GPIO pins,

• controlled using Set Motor Direction to set the rotation direction and Set Motor Speed to adjust the PWM speed,

• stopped immediately using Stop Motor for braking,

• and must be released using Close Motor (to release a specific motor device by handle or name) or Close All Motors (to release all opened motor devices).

Motor devices allow you to control DC motors or similar devices using GPIO pins and PWM signals, enabling precise control over speed and direction.

Use Close Motor or Close All Motors to release resources associated with motor devices when they are no longer needed.

---

Servo Device

The Servo Device type is used to refer to servo driver devices that can be managed by the SplashKit servo driver code. Servo devices are: Opaque handle for a single‐pin servo device. Servo devices are:

• checked with Has Servo Device to see if a servo is already opened,

• accessed using Servo Named to retrieve an existing servo device by name,

• opened using Open Servo with specific parameters such as a unique name and the GPIO pin for the servo signal line,

• controlled using set_servo_pulsewidth to send raw pulse-width signals or Set Servo Angle to map an angle (0–180°) into the pulse-width range,

• stopped using Stop Servo to halt signal pulses while holding the last position or allowing the servo to drift,

• and must be released using Close Servo (to release a specific servo device by handle or name) or Close All Servos (to release all opened servo devices).

Servo devices allow you to control hobby servos or similar devices using GPIO pins and PWM signals, enabling precise control over position and movement.

Use Close Servo or Close All Servos to release resources associated with servo devices when they are no longer needed.

---