Userspace

build_info

Get some identification about the version of the code running on your board.

COMMIT_TEXT_LEN

How long the buffer for commit’s text is.

struct build_info_t

Information about a build.

char commit[COMMIT_TEXT_LEN]

Short commit hash, and marker if tree is dirty.

As granted by QMK’s version.h

enabled_features_t features

Set of features enabled on this build.

Granted by my generated/features.h.

void build_info_init(void)

Initialize the feature.

build_info_t get_build_info(void)

Get current binary’s information.

void set_build_info(build_info_t new_build_info)

Set the current binary’s information.

This is used so that slave side has up-to-date information, without reflashing both halves. Data is sent over.

keylog

Utility to track last keys pressed in a string.

This could later be shown on a screen, for example.

void keylog_process(uint16_t keycode, keyrecord_t *record)

Hook into process_record_user() that performs the tracking.

const char *get_keylog(void)

Read the current state of the keylog.

bool is_keylog_dirty(void)

Whether anything has been written since keylog was last fetched.

void keycode_repr(const char **str)

Takes a basic string representation of a keycode and replace it with a prettier one. Eg: KC_A becomes A

ring_buffer

Implementation of a ring buffer.

Tiny wrapper on top of an array.

new_rbuf(type, size, name)

Create a new ring buffer.

Parameters:

• type – Of the values being stored.

• size – Capacity of the buffer.

• name – Of the ring buffer variable to be created.

rbuf_push(rbuf, value)

Insert an element into a buffer.

rbuf_pop(rbuf, max, dest)

Read data from a buffer.

Parameters:

• rbuf – The ring buffer.

• max – Elements to be read at most. 0 -> Read everything

• dest – Memory where data is read.

Returns:

Number of bytes read.

rbuf_clear(rbuf)

Mark a buffer as empty.

Note

Does not zero out the memory.

rbuf_size(rbuf)

Get the size of a buffer.

rbuf_full(rbuf)

Check if the buffer is completely filled.

sipo

Driver for 74HC595 Serial In - Parallel Out shift registers.

configure_sipo_pins(pin_names...)

Configure a list of “pin” names, aka: identifiers for register(s) output.

Caution

You will get a build error if N_SIPO_PINS is not correctly set up.

void set_sipo_pin(uint8_t pin, bool state)

Update the state of a pin in the internal buffer.

Hint

This will not apply the setting yet, because of performance issues.

You should call send_sipo_state() to get it flushed.

Parameters:

• pin – The name defined on configure_sipo_pins.

• state – Whether low or high output is desired.

void send_sipo_state(void)

Flush the internal buffer into the hardware, to actually get outputs set low/high as desired.

spi_custom

Some patching on QMK’s spi_master.h driver, to allow using multiple buses.

Caution

The following must be set up:

• SPI_DRIVERS

• SPI_SCK_PINS

• SPI_MOSI_PINS

• SPI_MISO_PINS

They will be automatically configured with their single-driver counterparts, if available.

enum spi_status_t

enumerator SPI_STATUS_SUCCESS = 0

enumerator SPI_STATUS_ERROR = -1

enumerator SPI_STATUS_TIMEOUT = -2

void spi_custom_init(uint8_t n)

Initialize the n’th driver.

bool spi_custom_start(pin_t slavePin, bool lsbFirst, uint8_t mode, uint16_t divisor, uint8_t n)

Set up the n’th driver for a transmission.

Parameters:

• slavePin – The chip select pin for the target device.

• lsbFirst – Whether Least Significant Bit is sent first or last.

• mode – SPI clocks’ mode (0-3).

• divisor – Control the clock’s speed.

• n – Index of the driver to be used.

Returns:

Whether operation was successful.

spi_status_t spi_custom_write(uint8_t data, uint8_t n)

Send a single byte (data) over the n’th driver.

spi_status_t spi_custom_read(uint8_t n)

Read a single byte (return) over the n’th driver.

spi_status_t spi_custom_transmit(const uint8_t *data, uint16_t length, uint8_t n)

Send length bytes from data over the n’th driver.

spi_status_t spi_custom_receive(uint8_t *data, uint16_t length, uint8_t n)

Read length bytes into data over the n’th driver.

void spi_custom_stop(uint8_t n)

Undo the settings performced by spi_custom_start()

touch

Generic(ish) driver for touch screens.

Danger

Only XPT2046 has been implemented/tested.

struct touch_report_t

Current status of a screen.

uint16_t x

Horizontal coordinate of the touch point.

uint16_t y

Vertical coordinate of the touch point.

bool pressed

Whether it is pressed.

struct spi_touch_comms_config_t

Configuration for SPI settings.

pin_t chip_select_pin

Its CS pin.

uint16_t divisor

Speed of the communications.

bool lsb_first

Byte order.

uint8_t mode

SPI mode.

pin_t irq_pin

Interrupt pin: flags that device is pressed.

uint8_t x_cmd

Command issued to get the X coordinate.

uint8_t y_cmd

Command issued to get the Y coordinate.

struct touch_driver_t

Configuration for a touch device.

uint16_t width

Horizontal size.

uint16_t height

Vertical size.

float scale_x

Up-/down- scaling applied to raw X reading.

float scale_y

Up-/down- scaling applied to raw Y reading.

int16_t offset_x

Offset applied to X reading (after being scaled).

int16_t offset_y

Offset applied to Y reading (after being scaled).

touch_rotation_t rotation

Orientation of the device.

bool upside_down

Whether the device is flipped. Causes some maths changes.

spi_touch_comms_config_t spi_config

Communications configuration.

type touch_device_t

Handle to a device’s configuration.

bool touch_spi_init(touch_device_t device)

Initialize a device.

void report_from(int16_t x, int16_t y, touch_driver_t *driver, touch_report_t *report)

(WEAK) Low-level function that performs math.

Parameters:

• x – Raw X reading from sensor.

• y – Raw Y reading from sensor.

• driver – Handle to the device, to fetch its configuration.

• report – Output struct to be filled/updated.

touch_report_t get_spi_touch_report(touch_device_t device, bool check_irq)

Get the current state of a sensor.

Parameters:

• device – Sensor’s configuration.

• check_irq – Whether to check the IRQ’s pin state.

xap

Utilities on top of XAP.

See also

QMK’s documentation about XAP.

Caution

XAP is still work in progress.

Pull Request for the feature.

type xap_msg_id_t

Identifier for each type of message.

struct screen_pressed_msg_t

Inform about a screen press event.

xap_msg_id_t msg_id

Identify this message.

uint8_t screen_id

Identify the screen.

uint16_t x

X-coord of the touchpoint.

uint16_t y

Y-coord of the touchpoint.

void xap_screen_pressed(uint8_t screen_id, touch_report_t report)

Send a message to PC’s client about a screen press event.

struct screen_released_msg_t

Information about a screen release event.

xap_msg_id_t msg_id

Identify this message.

uint8_t screen_id

Identify the screen.

void xap_screen_released(uint8_t screen_id)

Send a message to PC’s client about a screen release event.

struct layer_change_msg_t

Information about a layer change event.

xap_msg_id_t msg_id

Identify this message.

layer_state_t layer

Layer state.

void xap_layer(layer_state_t state)

Send a message to PC’s client about a layer change event.

struct keyevent_msg_t

Information about a key event.

struct _base

Internal type used to hold event’s information.

Defined an inner struct instead of plain attributes to compute space left for the string.

xap_msg_id_t msg_id

Identify this message.

uint16_t keycode

Keycode involved.

bool pressed

Whether it got pressed or released.

uint8_t layer

Highest layer currently enabled.

uint8_t row

Electrical row of the key.

uint8_t col

Electrical column of the key.

uint8_t mods

Current modifiers.

char str[MAX_PAYLOAD - sizeof(struct _base) - 1]

String representation of the keycode.

uint8_t null

Ensure we have a null terminator byte.

void xap_keyevent(uint16_t keycode, keyrecord_t *record)

Send a message to PC’s client about a key event.

struct shutdown_msg_t

Information about shutdown event.

xap_msg_id_t msg_id

Identify this message.

bool bootloader

Whether MCU is rebooting or jumping to bootloader.

void xap_shutdown(bool bootloader)

Send a message to PC’s client about a shutdown event.