Getting Started with the BGM220 Explorer Kit#

MIKROE_ANALOG

J201.1

PB00

MIKROE_RST

J201.2

PC06

MIKROE_SPI_CS

J201.3

PC03

MIKROE_SPI_SCK

J201.4

PC02

MIKROE_SPI_MISO

J201.5

PC01

MIKROE_SPI_MOSI

J201.6

PC00

3V3

J201.7

VMCU - BGM220P voltage domain

GND

J201.8

GND

MIKROE_PWM

J202.1

PB04

MIKROE_INT

J202.2

PB03

MIKROE_UART_RX

J202.3

PB02

MIKROE_UART_TX

J202.4

PB01

MIKROE_I2C_SCL

J202.5

PD02

MIKROE_I2C_SDA

J202.6

PD03

+5 V

J202.7

+5 V - Board USB voltage

GND

J202.8

GND

GPIO

T_gpio_setFp T_gpio_obj::gpioGet[12]

Pointers to Get functions

GPIO_PinOutGet(), GPIO_PinInGet()

T_gpio_setFp T_gpio_obj::gpioSet[12]

Pointers to Set functions

GPIO_PinOutSet(), GPIO_PinOutClear(), GPIO_PinOutToggle()

T_mikrobus_ret mikrobus_gpioInit (T_mikrobus_soc bus, T_mikrobus_pin pin, T_gpio_dir dir)

Function sets GPIO direction. This function also should be used for GPIO availability check.

GPIO_PinModeSet(), GPIO_PinModeGet()

void hal_gpioMap(T_HAL_P gpioObj);

Initialization of the GPIO HAL (internal mapping of function pointers and driver/HAL layer initialization)

N/A

SPI

T_mikrobus_ret mikrobus_spiInit (T_mikrobus_soc bus, const uint32_t *cfg)

Function will initialize SPI peripheral on provided MIKROBUS depending on configuration provided as second argument.

USART_InitSync() or SPIDRV_Init()/SPIDRV_DeInit()

void hal_spiMap(T_HAL_P spiObj);

Initialization of the SPI HAL (internal mapping of function pointers and driver/HAL layer initialization)

N/A

static void hal_spiWrite(uint8_t *pBuf, uint16_t nBytes);

Function should execute write sequence of n bytes.

USART_SpiTransfer() (ignore return value), SPIDRV_MTransmit(), SPIDRV_MTransmitB()

static void hal_spiRead(uint8_t *pBuf, uint16_t nBytes);

Function should execute read sequence of n bytes.

USART_SpiTransfer() (read return value, pass dummy data parameter), SPIDRV_MReceive(), SPIDRV_MReceiveB()

static void hal_spiTransfer(uint8_t *pIn, uint8_t *pOut, uint16_t nBytes);

Function should execute RW sequence of n bytes

USART_SpiTransfer(), SPIDRV_MTransfer(), SPIDRV_MTransferB(), SPIDRV_MTransferSingleItemB()

I2C

T_i2c_readFp T_i2c_obj::i2cRead

Pointer to I2C Read function

I2C_Transfer()

T_i2c_restartFp T_i2c_obj::i2cRestart

Pointer to I2C Restart function

I2C_Transfer()

T_i2c_startFp T_i2c_obj::i2cStart

Pointer to I2C Start function

I2C_Transfer()

T_i2c_stopFp T_i2c_obj::i2cStop

Pointer to I2C Stop function

I2C_Transfer()

T_i2c_writeFp T_i2c_obj::i2cWrite

Pointer to I2C Write function

I2C_Transfer()

T_mikrobus_ret mikrobus_i2cInit (T_mikrobus_soc bus, const uint32_t *cfg)

Function will initialize I2C peripheral on provided MIKROBUS depending on configuration provided as second argument.

I2C_Init(), I2C_TransferInit()

void hal_i2cMap(T_HAL_P i2cObj);

Initialization of the I2C HAL (internal mapping of function pointers and driver/HAL layer initialization)

N/A

static int hal_i2cStart();

This function in the snippet above should execute start condition on the I2C BUS.

I2C_TransferInit(), I2C_Transfer()

static int hal_i2cWrite(uint8_t peripheralAddr, uint8_t *pBuff, uint16_t nBytes, uint8_t endMode);

This function in the snippet above should execute write sequence, write the data inside the pBuf and execute “end” or “restart” condition, depending on the endMode argument.

I2C_Transfer()

static int hal_i2cRead(uint8_t peripheralAddr, uint8_t *pBuff, uint16_t nBytes, uint8_t endMode);

This function in the snippet above should execute read sequence, and place the data inside the pBuf and execute “end” or “restart” condition, depending on the endMode argument.

I2C_Transfer()

UART

T_mikrobus_ret mikrobus_uartInit (T_mikrobus_soc bus, const uint32_t *cfg)

Function will initialize UART peripheral on MIKROBUS1 and assign proper pointers to click driver.

USART_InitAsync(), UARTDRV_InitUart(), UARTDRV_InitLeuart() and UARTDRV_DeInit()

void hal_uartMap(T_HAL_P uartObj);

Initialization of the UART HAL (internal mapping of function pointers and driver/HAL layer initialization)

N/A

static void hal_uartWrite(uint8_t input);

Write one byte over UART

USART_Tx(), UARTDRV_Transmit(), UARTDRV_TransmitB()

static uint8_t hal_uartRead();

Read one byte over UART

USART_Rx(), UARTDRV_Receive(), UARTDRV_ReceiveB()

static uint8_t hal_uartReady();

USART_StatusGet(), UARTDRV_GetReceiveStatus() and UARTDRV_GetTransmitStatus()

GPIO

pinMode()

Configures the specified pin to behave either as an input or an output.

GPIO_PinModeSet(), GPIO_PinModeGet()

digitalRead()

Reads the value from a specified digital pin, either HIGH or LOW.

GPIO_PinOutGet(), GPIO_PinInGet()

digitalWrite()

Write a HIGH or a LOW value to a digital pin.

GPIO_PinOutSet(), GPIO_PinOutClear(), GPIO_PinOutToggle()

SPI

SPISettings

The SPISettings object is used to configure the SPI port for your SPI device. All 3 parameters are combined to a single SPISettings object, which is given to SPI.beginTransaction()

USART_InitSync_TypeDef Struct

begin()

Initializes the SPI bus by setting SCK, MOSI, and SS to outputs, pulling SCK and MOSI low, and SS high.

USART_InitSync() with GPIO_PinModeSet() OR SPIDRV_Init()

end()

Disables the SPI bus (leaving pin modes unchanged).

USART_Enable() with parameter enable = false

beginTransaction()

Initializes the SPI bus using the defined SPISettings.

USART_InitSync() with GPIO_PinModeSet() OR SPIDRV_Init()

endTransaction()

Stop using the SPI bus. Normally, this is called after de-asserting the chip select, to allow other libraries to use the SPI bus.

USART_Enable() with parameter enable = false, USART_Reset(), and GPIO_PinModeSet() OR SPIDRV_DeInit()

setBitOrder()

Sets the order of the bits shifted out of and into the SPI bus, either LSBFIRST (least-significant bit first) or MSBFIRST (most-significant bit first).

set by "msbf" element of USART_InitSync_TypeDef structure and passed to USART_InitSync(); OR set by "bitOrder" element of SPIDRV_Init structure and passed to SPIDRV_Init()

setClockDivider()

Sets the SPI clock divider relative to the system clock. Depricated for Arduino??

use USART_BaudrateSyncSet(), USART_InitSync(), SPIDRV_Init()

setDataMode()

Sets the SPI data mode: that is, clock polarity and phase. Deprecated for Arduino??

set by "clockMode" element of USART_InitSync_TypeDef structure and passed to USART_InitSync(); OR set by "clockMode" element of SPIDRV_Init structure and passed to SPIDRV_Init()

transfer()

SPI transfer is based on a simultaneous send and receive: the received data is returned in receivedVal (or receivedVal16). In case of buffer transfers the received data is stored in the buffer in-place (the old data is replaced with the data received).

USART_SpiTransfer(), SPIDRV_MTransfer(), SPIDRV_MTransferB(), SPIDRV_MTransferSingleItemB()

usingInterrupt()

If your program will perform SPI transactions within an interrupt, call this function to register the interrupt number or name with the SPI library. This allows SPI.beginTransaction() to prevent usage conflicts. Note that the interrupt specified in the call to usingInterrupt() will be disabled on a call to beginTransaction() and re-enabled in endTransaction().

use USART_IntEnable() and USART_IntDisable()

shiftOut()

Bit bang (software) SPI TX.

USART_SpiTransfer(), SPIDRV_MTransfer(), SPIDRV_MTransferB(), SPIDRV_MTransferSingleItemB()

shiftIn()

Bit bang (software) SPI RX.

USART_SpiTransfer() (read return value, pass dummy data parameter), SPIDRV_MReceive(), SPIDRV_MReceiveB()

I2C

begin()

Initiate the Wire library and join the I2C bus as a central or peripheral. This should normally be called only once.

I2C_Init()

requestFrom()

Used by the central to request bytes from a peripheral device. The bytes may then be retrieved with the available() and read() functions.

I2C_TransferInit()

beginTransmission()

Begin a transmission to the I2C device with the given address. Subsequently, queue bytes for transmission with the write() function and transmit them by calling endTransmission().

I2C_TransferInit()

endTransmission()

Ends a transmission to a device that was begun by beginTransmission() and transmits the bytes that were queued by write().

I2C_Transfer()

write()

Writes data from a peripheral device in response to a request from a central, or queues bytes for transmission from a central to peripheral device (in-between calls to beginTransmission() and endTransmission()).

I2C_Transfer()

available()

Returns the number of bytes available for retrieval with read(). This should be called on a central device after a call to requestFrom() or on a inside the onReceive() handler.

N/A

read()

Reads a byte that was transmitted from a peripheral device to a central after a call to requestFrom() or was transmitted from a central to a . read() inherits from the Stream utility class.

I2C_Transfer()

SetClock()

This function modifies the clock frequency for I2C communication. I2C peripheral devices have no minimum working clock frequency, however 100KHz is usually the baseline.

I2C_BusFreqSet(), I2C_BusFreqGet()

onReceive()

Registers a function to be called when a device receives a transmission from a central.

use I2C_IntEnable(), I2C_IntDisable(), I2C_IntGet(), I2C_IntClear(), I2C_IntGetEnabled(), I2C_IntSet(), and I2C ISR to manage I2C interrupts, if used

onRequest()

Register a function to be called when a central requests data from this peripheral device.

use I2C_IntEnable(), I2C_IntDisable(), I2C_IntGet(), I2C_IntClear(), I2C_IntGetEnabled(), I2C_IntSet(), and I2C ISR to manage I2C interrupts, if used

if(Serial)

Indicates if the specified Serial port is ready.

USART_StatusGet()

available()

Get the number of bytes (characters) available for reading from the serial port. This is data that’s already arrived and stored in the serial receive buffer (which holds 64 bytes).

UARTDRV_GetReceiveStatus()

availableForWrite()

Get the number of bytes (characters) available for writing in the serial buffer without blocking the write operation

UARTDRV_GetTransmitDepth(), UARTDRV_GetTransmitStatus()

begin()

Sets the data rate in bits per second (baud) for serial data transmission. For communicating with Serial Monitor, make sure to use one of the baud rates listed in the menu at the bottom right corner of its screen. You can, however, specify other rates - for example, to communicate over pins 0 and 1 with a component that requires a particular baud rate. An optional second argument configures the data, parity, and stop bits. The default is 8 data bits, no parity, one stop bit.

USART_InitAsync(), UARTDRV_InitUart(), RETARGET_SerialInit()

end()

Disables serial communication, allowing the RX and TX pins to be used for general input and output. To re-enable serial communication, call Serial.begin().

USART_Reset(), USART_Enable() with enable = false, use GPIO functions to change pin modes; UARTDRV_DeInit()

find()

Serial.find() reads data from the serial buffer until the target is found. The function returns true if target is found, false if it times out.

N/A; This must be user-implemented

findUntil()

Serial.findUntil() reads data from the serial buffer until a target string of given length or terminator string is found. The function returns true if the target string is found, false if it times out.

N/A; This must be user-implemented

flush()

Waits for the transmission of outgoing serial data to complete. (Prior to Arduino 1.0, this instead removed any buffered incoming serial data.)

RETARGET_SerialFlush()

parseFloat()

Serial.parseFloat() returns the first valid floating point number from the Serial buffer. parseFloat() is terminated by the first character that is not a floating point number. The function terminates if it times out (see Serial.setTimeout()).

N/A; This must be user-implemented; may be possible to use stdio functions with RetargetIo to assist in implementation

parseInt()

Looks for the next valid integer in the incoming serial. The function terminates if it times out (see Serial.setTimeout()).

N/A; This must be user-implemented; may be possible to use stdio functions with RetargetIo to assist in implementation

peek()

Returns the next byte (character) of incoming serial data without removing it from the internal serial buffer. That is, successive calls to peek() will return the same character, as will the next call to read().

No API support. Firmware should issue a direct read of the USART_RXDATAXP or USART_RXDOUBLEXP peek registers.

print()

Prints data to the serial port as human-readable ASCII text. This command can take many forms. Numbers are printed using an ASCII character for each digit. Floats are similarly printed as ASCII digits, defaulting to two decimal places. Bytes are sent as a single character. Characters and strings are sent as is. For example-

RetargetSerial enables this functionality using stdio functions (i.e. printf(), etc.)

println()

Prints data to the serial port as human-readable ASCII text followed by a carriage return character (ASCII 13, or '\r') and a newline character (ASCII 10, or '\n'). This command takes the same forms as Serial.print().

RetargetSerial enables this functionality using stdio functions (i.e. printf(), etc.)

read()

Reads incoming serial data.

USART_Rx(), UARTDRV_Receive(), UARTDRV_ReceiveB(), RETARGET_ReadChar (void)()

readBytes()

Serial.readBytes() reads characters from the serial port into a buffer. The function terminates if the determined length has been read, or it times out (see Serial.setTimeout()). Serial.readBytes() returns the number of characters placed in the buffer. A 0 means no valid data was found.

USART_Rx(), UARTDRV_Receive(), UARTDRV_ReceiveB(), RETARGET_ReadChar (void)()

readBytesUntil()

Serial.readBytesUntil() reads characters from the serial buffer into an array. The function terminates (checks being done in this order) if the determined length has been read, if it times out (see Serial.setTimeout()), or if the terminator character is detected (in which case the function returns the characters up to the last character before the supplied terminator). The terminator itself is not returned in the buffer. Serial.readBytesUntil() returns the number of characters read into the buffer. A 0 means that the length parameter <= 0, a time out occurred before any other input, or a termination character was found before any other input.

USART_Rx(), UARTDRV_Receive(), UARTDRV_ReceiveB(), RETARGET_ReadChar (void)()

readString()

Serial.readString() reads characters from the serial buffer into a String. The function terminates if it times out (see setTimeout()).

N/A; This must be user-implemented

readStringUntil()

readStringUntil() reads characters from the serial buffer into a String. The function terminates if it times out (see setTimeout()).

N/A; This must be user-implemented

setTimeout()

Serial.setTimeout() sets the maximum milliseconds to wait for serial data. It defaults to 1000 milliseconds.

N/A; This must be user-implemented

write()

Writes binary data to the serial port. This data is sent as a byte or series of bytes; to send the characters representing the digits of a number use the print() function instead.

USART_Tx(), UARTDRV_Transmit(), UARTDRV_TransmitB(), RETARGET_WriteChar(), RETARGET_WriteString()

serialEvent()

Called when data is available. Use Serial.read() to capture this data.

N/A; use USART_IntEnable(), USART_IntDisable(), USART_IntGet(), USART_IntClear(), USART_IntGetEnabled(), USART_IntSet(), and USART ISR to manage USART interrupts, if used

SoftwareSerial()

SoftwareSerial is used to create an instance of a SoftwareSerial object, whose name you need to provide as in the example below. The inverse_logic argument is optional and defaults to false. See below for more details about what it does. Multiple SoftwareSerial objects may be created, however only one can be active at a given moment.

N/A

available()

Get the number of bytes (characters) available for reading from a software serial port. This is data that's already arrived and stored in the serial receive buffer.

UARTDRV_GetReceiveStatus()

begin()

Sets the speed (baud rate) for the serial communication. Supported baud rates are 300, 600, 1200, 2400, 4800, 9600, 14400, 19200, 28800, 31250, 38400, 57600, and 115200.

USART_InitAsync(), UARTDRV_InitUart(), RETARGET_SerialInit()

isListening()

Tests to see if requested software serial port is actively listening.

N/A, however Silicon Labs' USART have a loopback feature that can be enabled

overflow()

Tests to see if a software serial buffer overflow has occurred. Calling this function clears the overflow flag, meaning that subsequent calls will return false unless another byte of data has been received and discarded in the meantime.

N/A

peek()

Return a character that was received on the RX pin of the software serial port. Unlike read(), however, subsequent calls to this function will return the same character.

No API support. Firmware should issue a direct read of the USART_RXDATAXP or USART_RXDOUBLEXP peek registers.

read()

Return a character that was received on the RX pin of the software serial port. Note that only one SoftwareSerial instance can receive incoming data at a time (select which one with the listen() function).

USART_Rx(), UARTDRV_Receive(), UARTDRV_ReceiveB(), RETARGET_ReadChar (void)()

print()

Prints data to the transmit pin of the software serial port. Works the same as the Serial.print() function.

RetargetSerial enables this functionality using stdio functions (i.e. printf(), etc.)

println()

Prints data to the transmit pin of the software serial port, followed by a carriage return and line feed. Works the same as the Serial.println() function.

RetargetSerial enables this functionality using stdio functions (i.e. printf(), etc.)

listen()

Enables the selected software serial port to listen. Only one software serial port can listen at a time; data that arrives for other ports will be discarded. Any data already received is discarded during the call to listen() (unless the given instance is already listening).

N/A

write()

Prints data to the transmit pin of the software serial port as raw bytes. Works the same as the Serial.write() function.

USART_Tx(), UARTDRV_Transmit(), UARTDRV_TransmitB(), RETARGET_WriteChar(), RETARGET_WriteString()