Crate peripherals

peripherals

Define and access your microcontroller peripherals

Features

• A macro to generate code for peripherals, registers, and register fields
• Zero-sized structs to represent peripherals and registers
• Enums or newtype struct to represent fields values
• Combine values to write to a regiser with | (binary or)
• Read/write access at the regiser level
• Strong typing ensure you don’t mix up registers
• Generic over the peripheral instance

Usage

Peripherals are defined with the periph! macro. Registers and fields can be defined in the same macro invocation or separately with the register! and field_type! macros. Microcontrollers / devices are then defined with the device! macro.

These macros generate types to represent fields and their values, and marker types for registers and peripherals. These types can be seen in the example module.

Registers are accessed with the Reg struct. Values are used to read and write them.

To use the generated device struct, create it from () as part of your initialisation routine. There sould be only one instance of the device (and the right one) in your whole program.

Operators

Most types implements the | (bit or), & (bit and) and ^ (xor) operators. Operations that returns that same type as their left operand can be written in the assign form, i.e. |=, &= and ^=. The operands can be of the type written in the table below, or anything that converts to that type.

Operation	Resulting type	Description
Fields | Fields	Fields	Fields in either or both operands
Fields & Fields	Fields	Fields in both operands
Fields ^ Fields	Fields	Fields in only one of the operands
FieldValues | FieldValues	FieldValues	Field values in either operand, with the value of the right operand if the field is specified in both
FieldValues & Fields	FieldValues	Field values of fields in both operands
FieldValues ^ Fields	FieldValues	Left operand with values of fields in both operands toggled (inverted)
Value | FieldValues	Value	Left operand with the values of the fields in the right operand
Value & Fields	FieldValues	Values of fields in right operand
Value ^ Fields	Value	Left operand with values of the fields in right operand toggled (inverted)

Attribute in macros

By default, attributes exand on generated types and fields, and not expand on generated impls. This can be changed by inserting type:, field:, impl: or all: to specify on what the attribute should be present. See the attributes module for examples.

This allows to use e.g. cfg and repr attribute by writting #[all: cfg(...)] and #[type: repr(...)].

Modules

attributes	Example of attribute in macros
example	Example of generated types

Macros

device	Define a microcontroller and which peripherals it has
field_type	A helper hacro to define a type that can be used in field value.
periph	Define a peripheral and all its associated registers, fields and values
register	Define a register model that can be shared accross peripherals

Structs

DynReg	A register from a peripheral only known at runtime
Field	A single register field
FieldValues	Some fields’ values read from or to be written to a register
Fields	A set of register fields
InvalidValue	Error returned when converting an interger to a field value fails
Reg	Base struct for all registers
Value	A value read from or to be written to a register

Enums

Toggle

A marker type for toggleable fields

Traits

MayToggle	Whether the fields or fields values may be toggled
Peripheral	A trait for peripheral instances
ReadRegister	A marker trait for readable registers
Register	A trait for registers This trait is implemented by the periph! macro for marker types that indicate registers.
RegisterValue	A trait for the register associated with a value
WriteRegister	A marker trait for writeable register