esp32-coreboard-v2

Constants

const (
	CLK	= GPIO6
	CMD	= GPIO11
	IO0	= GPIO0
	IO1	= GPIO1
	IO2	= GPIO2
	IO3	= GPIO3
	IO4	= GPIO4
	IO5	= GPIO5
	IO9	= GPIO9
	IO10	= GPIO10
	IO16	= GPIO16
	IO17	= GPIO17
	IO18	= GPIO18
	IO19	= GPIO19
	IO21	= GPIO21
	IO22	= GPIO22
	IO23	= GPIO23
	IO25	= GPIO25
	IO26	= GPIO26
	IO27	= GPIO27
	IO32	= GPIO32
	IO33	= GPIO33
	IO34	= GPIO34
	IO35	= GPIO35
	IO36	= GPIO36
	IO39	= GPIO39
	RXD	= GPIO3
	SD0	= GPIO7
	SD1	= GPIO8
	SD2	= GPIO9
	SD3	= GPIO10
	SVN	= GPIO39
	SVP	= GPIO36
	TCK	= GPIO13
	TD0	= GPIO15
	TDI	= GPIO12
	TMS	= GPIO14
	TXD	= GPIO1
)
const LED = IO2

Built-in LED on some ESP32 boards.

const (
	SPI0_SCK_PIN	= IO18
	SPI0_SDO_PIN	= IO23
	SPI0_SDI_PIN	= IO19
	SPI0_CS0_PIN	= IO5
)

SPI pins

const (
	SDA_PIN	= IO21
	SCL_PIN	= IO22
)

I2C pins

const (
	ADC0	Pin	= IO34
	ADC1	Pin	= IO35
	ADC2	Pin	= IO36
	ADC3	Pin	= IO39
)

ADC pins

const (
	UART_TX_PIN	= IO1
	UART_RX_PIN	= IO3
)

UART0 pins

const (
	UART1_TX_PIN	= IO9
	UART1_RX_PIN	= IO10
)

UART1 pins

const (
	PWM0_PIN	Pin	= IO2
	PWM1_PIN	Pin	= IO0
	PWM2_PIN	Pin	= IO4
)

PWM pins

const Device = deviceName

Device is the running program’s chip name, such as “ATSAMD51J19A” or “nrf52840”. It is not the same as the CPU name.

The constant is some hardcoded default value if the program does not target a particular chip but instead runs in WebAssembly for example.

const (
	KHz	= 1000
	MHz	= 1000_000
	GHz	= 1000_000_000
)

Generic constants.

const NoPin = Pin(0xff)

NoPin explicitly indicates “not a pin”. Use this pin if you want to leave one of the pins in a peripheral unconfigured (if supported by the hardware).

const (
	PinOutput	PinMode	= iota
	PinInput
	PinInputPullup
	PinInputPulldown
)
const (
	GPIO0	Pin	= 0
	GPIO1	Pin	= 1
	GPIO2	Pin	= 2
	GPIO3	Pin	= 3
	GPIO4	Pin	= 4
	GPIO5	Pin	= 5
	GPIO6	Pin	= 6
	GPIO7	Pin	= 7
	GPIO8	Pin	= 8
	GPIO9	Pin	= 9
	GPIO10	Pin	= 10
	GPIO11	Pin	= 11
	GPIO12	Pin	= 12
	GPIO13	Pin	= 13
	GPIO14	Pin	= 14
	GPIO15	Pin	= 15
	GPIO16	Pin	= 16
	GPIO17	Pin	= 17
	GPIO18	Pin	= 18
	GPIO19	Pin	= 19
	GPIO21	Pin	= 21
	GPIO22	Pin	= 22
	GPIO23	Pin	= 23
	GPIO25	Pin	= 25
	GPIO26	Pin	= 26
	GPIO27	Pin	= 27
	GPIO32	Pin	= 32
	GPIO33	Pin	= 33
	GPIO34	Pin	= 34
	GPIO35	Pin	= 35
	GPIO36	Pin	= 36
	GPIO37	Pin	= 37
	GPIO38	Pin	= 38
	GPIO39	Pin	= 39
)

Hardware pin numbers

const (
	Mode0	= 0
	Mode1	= 1
	Mode2	= 2
	Mode3	= 3
)

SPI phase and polarity configs CPOL and CPHA

const (
	// ParityNone means to not use any parity checking. This is
	// the most common setting.
	ParityNone	UARTParity	= iota

	// ParityEven means to expect that the total number of 1 bits sent
	// should be an even number.
	ParityEven

	// ParityOdd means to expect that the total number of 1 bits sent
	// should be an odd number.
	ParityOdd
)

Variables

var (
	ErrTimeoutRNG		= errors.New("machine: RNG Timeout")
	ErrClockRNG		= errors.New("machine: RNG Clock Error")
	ErrSeedRNG		= errors.New("machine: RNG Seed Error")
	ErrInvalidInputPin	= errors.New("machine: invalid input pin")
	ErrInvalidOutputPin	= errors.New("machine: invalid output pin")
	ErrInvalidClockPin	= errors.New("machine: invalid clock pin")
	ErrInvalidDataPin	= errors.New("machine: invalid data pin")
	ErrNoPinChangeChannel	= errors.New("machine: no channel available for pin interrupt")
)
var (
	ErrInvalidSPIBus = errors.New("machine: invalid SPI bus")
)
var DefaultUART = UART0
var (
	UART0	= &_UART0
	_UART0	= UART{Bus: esp.UART0, Buffer: NewRingBuffer()}
	UART1	= &_UART1
	_UART1	= UART{Bus: esp.UART1, Buffer: NewRingBuffer()}
	UART2	= &_UART2
	_UART2	= UART{Bus: esp.UART2, Buffer: NewRingBuffer()}
)
var (
	// SPI0 and SPI1 are reserved for use by the caching system etc.
	SPI2	= SPI{esp.SPI2}
	SPI3	= SPI{esp.SPI3}
)
var (
	ErrPWMPeriodTooLong = errors.New("pwm: period too long")
)
var Serial = DefaultUART

Serial is implemented via the default (usually the first) UART on the chip.

var (
	ErrTxInvalidSliceSize		= errors.New("SPI write and read slices must be same size")
	errSPIInvalidMachineConfig	= errors.New("SPI port was not configured properly by the machine")
)

func CPUFrequency

func CPUFrequency() uint32

CPUFrequency returns the current CPU frequency of the chip. Currently it is a fixed frequency but it may allow changing in the future.

func InitSerial

func InitSerial()

func NewRingBuffer

func NewRingBuffer() *RingBuffer

NewRingBuffer returns a new ring buffer.

type ADC

type ADC struct {
	Pin Pin
}

type ADCConfig

type ADCConfig struct {
	Reference	uint32	// analog reference voltage (AREF) in millivolts
	Resolution	uint32	// number of bits for a single conversion (e.g., 8, 10, 12)
	Samples		uint32	// number of samples for a single conversion (e.g., 4, 8, 16, 32)
	SampleTime	uint32	// sample time, in microseconds (µs)
}

ADCConfig holds ADC configuration parameters. If left unspecified, the zero value of each parameter will use the peripheral’s default settings.

type NullSerial

type NullSerial struct {
}

NullSerial is a serial version of /dev/null (or null router): it drops everything that is written to it.

func (NullSerial) Buffered

func (ns NullSerial) Buffered() int

Buffered returns how many bytes are buffered in the UART. It always returns 0 as there are no bytes to read.

func (NullSerial) Configure

func (ns NullSerial) Configure(config UARTConfig) error

Configure does nothing: the null serial has no configuration.

func (NullSerial) ReadByte

func (ns NullSerial) ReadByte() (byte, error)

ReadByte always returns an error because there aren’t any bytes to read.

func (NullSerial) Write

func (ns NullSerial) Write(p []byte) (n int, err error)

Write is a no-op: none of the data is being written and it will not return an error.

func (NullSerial) WriteByte

func (ns NullSerial) WriteByte(b byte) error

WriteByte is a no-op: the null serial doesn’t write bytes.

type PDMConfig

type PDMConfig struct {
	Stereo	bool
	DIN	Pin
	CLK	Pin
}

type PWMConfig

type PWMConfig struct {
	// PWM period in nanosecond. Leaving this zero will pick a reasonable period
	// value for use with LEDs.
	// If you want to configure a frequency instead of a period, you can use the
	// following formula to calculate a period from a frequency:
	//
	//     period = 1e9 / frequency
	//
	Period uint64
}

PWMConfig allows setting some configuration while configuring a PWM peripheral. A zero PWMConfig is ready to use for simple applications such as dimming LEDs.

type Pin

type Pin uint8

Pin is a single pin on a chip, which may be connected to other hardware devices. It can either be used directly as GPIO pin or it can be used in other peripherals like ADC, I2C, etc.

func (Pin) Configure

func (p Pin) Configure(config PinConfig)

Configure this pin with the given configuration.

func (Pin) Get

func (p Pin) Get() bool

Get returns the current value of a GPIO pin when the pin is configured as an input or as an output.

func (Pin) High

func (p Pin) High()

High sets this GPIO pin to high, assuming it has been configured as an output pin. It is hardware dependent (and often undefined) what happens if you set a pin to high that is not configured as an output pin.

func (Pin) Low

func (p Pin) Low()

Low sets this GPIO pin to low, assuming it has been configured as an output pin. It is hardware dependent (and often undefined) what happens if you set a pin to low that is not configured as an output pin.

func (Pin) PortMaskClear

func (p Pin) PortMaskClear() (*uint32, uint32)

Return the register and mask to disable a given GPIO pin. This can be used to implement bit-banged drivers.

Warning: only use this on an output pin!

func (Pin) PortMaskSet

func (p Pin) PortMaskSet() (*uint32, uint32)

Return the register and mask to enable a given GPIO pin. This can be used to implement bit-banged drivers.

Warning: only use this on an output pin!

func (Pin) Set

func (p Pin) Set(value bool)

Set the pin to high or low. Warning: only use this on an output pin!

type PinConfig

type PinConfig struct {
	Mode PinMode
}

type PinMode

type PinMode uint8

PinMode sets the direction and pull mode of the pin. For example, PinOutput sets the pin as an output and PinInputPullup sets the pin as an input with a pull-up.

type RingBuffer

type RingBuffer struct {
	rxbuffer	[bufferSize]volatile.Register8
	head		volatile.Register8
	tail		volatile.Register8
}

RingBuffer is ring buffer implementation inspired by post at https://www.embeddedrelated.com/showthread/comp.arch.embedded/77084-1.php

func (*RingBuffer) Clear

func (rb *RingBuffer) Clear()

Clear resets the head and tail pointer to zero.

func (*RingBuffer) Get

func (rb *RingBuffer) Get() (byte, bool)

Get returns a byte from the buffer. If the buffer is empty, the method will return a false as the second value.

func (*RingBuffer) Put

func (rb *RingBuffer) Put(val byte) bool

Put stores a byte in the buffer. If the buffer is already full, the method will return false.

func (*RingBuffer) Used

func (rb *RingBuffer) Used() uint8

Used returns how many bytes in buffer have been used.

type SPI

type SPI struct {
	Bus *esp.SPI_Type
}

Serial Peripheral Interface on the ESP32.

func (SPI) Configure

func (spi SPI) Configure(config SPIConfig) error

Configure and make the SPI peripheral ready to use.

func (SPI) Transfer

func (spi SPI) Transfer(w byte) (byte, error)

Transfer writes/reads a single byte using the SPI interface. If you need to transfer larger amounts of data, Tx will be faster.

func (SPI) Tx

func (spi SPI) Tx(w, r []byte) error

Tx handles read/write operation for SPI interface. Since SPI is a syncronous write/read interface, there must always be the same number of bytes written as bytes read. This is accomplished by sending zero bits if r is bigger than w or discarding the incoming data if w is bigger than r.

type SPIConfig

type SPIConfig struct {
	Frequency	uint32
	SCK		Pin
	SDO		Pin
	SDI		Pin
	LSBFirst	bool
	Mode		uint8
}

SPIConfig configures a SPI peripheral on the ESP32. Make sure to set at least SCK, SDO and SDI (possibly to NoPin if not in use). The default for LSBFirst (false) and Mode (0) are good for most applications. The frequency defaults to 1MHz if not set but can be configured up to 40MHz. Possible values are 40MHz and integer divisions from 40MHz such as 20MHz, 13.3MHz, 10MHz, 8MHz, etc.

type UART

type UART struct {
	Bus	*esp.UART_Type
	Buffer	*RingBuffer
}

func (*UART) Buffered

func (uart *UART) Buffered() int

Buffered returns the number of bytes currently stored in the RX buffer.

func (*UART) Configure

func (uart *UART) Configure(config UARTConfig)

func (*UART) Read

func (uart *UART) Read(data []byte) (n int, err error)

Read from the RX buffer.

func (*UART) ReadByte

func (uart *UART) ReadByte() (byte, error)

ReadByte reads a single byte from the RX buffer. If there is no data in the buffer, returns an error.

func (*UART) Receive

func (uart *UART) Receive(data byte)

Receive handles adding data to the UART’s data buffer. Usually called by the IRQ handler for a machine.

func (*UART) Write

func (uart *UART) Write(data []byte) (n int, err error)

Write data over the UART’s Tx. This function blocks until the data is finished being sent.

func (*UART) WriteByte

func (uart *UART) WriteByte(c byte) error

WriteByte writes a byte of data over the UART’s Tx. This function blocks until the data is finished being sent.

type UARTConfig

type UARTConfig struct {
	BaudRate	uint32
	TX		Pin
	RX		Pin
	RTS		Pin
	CTS		Pin
}

UARTConfig is a struct with which a UART (or similar object) can be configured. The baud rate is usually respected, but TX and RX may be ignored depending on the chip and the type of object.

type UARTParity

type UARTParity uint8

UARTParity is the parity setting to be used for UART communication.

Last modified April 17, 2024: Fix doc-gen and update docs (8a74a2b)