1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
|
// +build !avr,!nrf,!sam,!stm32
package machine
// Dummy machine package that calls out to external functions.
var (
SPI0 = SPI{0}
I2C0 = I2C{0}
UART0 = UART{0}
)
type PinMode uint8
const (
PinInput PinMode = iota
PinOutput
PinInputPullup
PinInputPulldown
)
func (p Pin) Configure(config PinConfig) {
gpioConfigure(p, config)
}
func (p Pin) Set(value bool) {
gpioSet(p, value)
}
func (p Pin) Get() bool {
return gpioGet(p)
}
//go:export __tinygo_gpio_configure
func gpioConfigure(pin Pin, config PinConfig)
//go:export __tinygo_gpio_set
func gpioSet(pin Pin, value bool)
//go:export __tinygo_gpio_get
func gpioGet(pin Pin) bool
type SPI struct {
Bus uint8
}
type SPIConfig struct {
Frequency uint32
SCK Pin
MOSI Pin
MISO Pin
Mode uint8
}
func (spi SPI) Configure(config SPIConfig) {
spiConfigure(spi.Bus, config.SCK, config.MOSI, config.MISO)
}
// Transfer writes/reads a single byte using the SPI interface.
func (spi SPI) Transfer(w byte) (byte, error) {
return spiTransfer(spi.Bus, w), nil
}
//go:export __tinygo_spi_configure
func spiConfigure(bus uint8, sck Pin, mosi Pin, miso Pin)
//go:export __tinygo_spi_transfer
func spiTransfer(bus uint8, w uint8) uint8
// InitADC enables support for ADC peripherals.
func InitADC() {
// Nothing to do here.
}
// Configure configures an ADC pin to be able to be used to read data.
func (adc ADC) Configure() {
}
// Get reads the current analog value from this ADC peripheral.
func (adc ADC) Get() uint16 {
return adcRead(adc.Pin)
}
//go:export __tinygo_adc_read
func adcRead(pin Pin) uint16
// InitPWM enables support for PWM peripherals.
func InitPWM() {
// Nothing to do here.
}
// Configure configures a PWM pin for output.
func (pwm PWM) Configure() {
}
// Set turns on the duty cycle for a PWM pin using the provided value.
func (pwm PWM) Set(value uint16) {
pwmSet(pwm.Pin, value)
}
//go:export __tinygo_pwm_set
func pwmSet(pin Pin, value uint16)
// I2C is a generic implementation of the Inter-IC communication protocol.
type I2C struct {
Bus uint8
}
// I2CConfig is used to store config info for I2C.
type I2CConfig struct {
Frequency uint32
SCL Pin
SDA Pin
}
// Configure is intended to setup the I2C interface.
func (i2c I2C) Configure(config I2CConfig) {
i2cConfigure(i2c.Bus, config.SCL, config.SDA)
}
// Tx does a single I2C transaction at the specified address.
func (i2c I2C) Tx(addr uint16, w, r []byte) error {
i2cTransfer(i2c.Bus, &w[0], len(w), &r[0], len(r))
// TODO: do something with the returned error code.
return nil
}
//go:export __tinygo_i2c_configure
func i2cConfigure(bus uint8, scl Pin, sda Pin)
//go:export __tinygo_i2c_transfer
func i2cTransfer(bus uint8, w *byte, wlen int, r *byte, rlen int) int
type UART struct {
Bus uint8
}
type UARTConfig struct {
BaudRate uint32
TX Pin
RX Pin
}
// Configure the UART.
func (uart UART) Configure(config UARTConfig) {
uartConfigure(uart.Bus, config.TX, config.RX)
}
// Read from the UART.
func (uart UART) Read(data []byte) (n int, err error) {
return uartRead(uart.Bus, &data[0], len(data)), nil
}
// Write to the UART.
func (uart UART) Write(data []byte) (n int, err error) {
return uartWrite(uart.Bus, &data[0], len(data)), nil
}
// Buffered returns the number of bytes currently stored in the RX buffer.
func (uart UART) Buffered() int {
return 0
}
// ReadByte reads a single byte from the UART.
func (uart UART) ReadByte() (byte, error) {
var b byte
uartRead(uart.Bus, &b, 1)
return b, nil
}
// WriteByte writes a single byte to the UART.
func (uart UART) WriteByte(b byte) error {
uartWrite(uart.Bus, &b, 1)
return nil
}
//go:export __tinygo_uart_configure
func uartConfigure(bus uint8, tx Pin, rx Pin)
//go:export __tinygo_uart_read
func uartRead(bus uint8, buf *byte, bufLen int) int
//go:export __tinygo_uart_write
func uartWrite(bus uint8, buf *byte, bufLen int) int
|
