MSB-IoT

Support for the MSB-IoT board.

Overview

The MSB-IoT was developed at FU Berlin and is based on a STM32F415RG MCU.

Hardware

MCU

The centerpiece of the MSB-IoT is the STM32F415RG MCU. With a maximum frequency of 168 MHz it offers high performance for a microcontroller of its category. The STM32F415RG comes with a huge set of accessible communication interfaces and features that are listed here.

MCU STM32F415RG
Family ARM Cortex-M4
Vendor ST Microelectronics
RAM 192Kb (128Kb RAM + 64Kb CCMRAM)
Flash 1024Kb
Frequency up to 168MHz
FPU yes
Timers 14 (12x 16bit, 2x 32bit [TIM2 + TIM5])
ADCs 3x 12-bit (16 channel)
UARTs 6 (4 USART, 2 UART)
SPIs 3
I2Cs 3
Vcc 1.8V - 3.6V
Datasheet Datasheet
Reference Manual Reference Manual
Programming Manual Programming Manual
Due to licensing issues, RIOT’s driver implementations for the STM32F4 series are not based on ST’s standard peripheral library. Therefore, not every feature of the MCU is currently supported in RIOT.

For an overview on the currently supported functional units please check the following directories: Peripheral implementations and corresponding Interfaces Main STM32F4 directory and Cortex M4 directory

RIOT pin mapping

The following picture shows the easily accessible pins of the board:

RIOT uses its own naming scheme for GPIO pins and other functionality. The actual STM32F4 specific pins and functional units are mapped to RIOT internal enum values. Please refer to this document for RIOTs pin mapping for the MSB-IoT (the document only lists ports where a PIN is mapped).

The pin mapping can be altered freely by editing the boards/msbiot/include/periph_conf.h header file found here. Please keep in mind that changing pin mappings that are important for the integrated hardware could affect the corresponding driver implementations. The most important mappings needed for correct operation of the MSB-IoT with RIOT can be extracted from the boards/msbiot/include/board.h found here.

User Interface

3 Buttons:**

NAME User Button T1 User Button T2 T RESET
Pin PB13 PA0 NRST
The user buttons are mapped to GPIO_0 (Button T2) and GPIO_8 (Button T1) in the board’s default configuration file for RIOT. To configure and use the buttons, you can use the provided interface functions from RIOT’s GPIO low-level driver interface.

Pushing the reset button will always reset the board and restart your application.

3 user controllable LEDs:**

NAME LED_RED LED_YELLOW LED_GREEN
Color red yellow green
Pin PB8 PB14 PB15
The LEDs can be controlled inside your RIOT application by using the LED macros provided here.

There is also a yellow charge LED on the board indicating the charging process of the battery.

1 Beeper:**

NAME Beeper
Pin PB09
The board’s beeper allows for acoustic feedback. It needs a PWM signal between 1-5 kHz and is mapped to GPIO_5 and PWM_0 in RIOT. To configure and use the beeper inside your application, you can use the provided interface functions from RIOT’s GPIO and PWM low-level driver interfaces.

CC1101 Sub-1GHz RF Transceiver

The board has an integrated CC1101 Sub-1GHz RF Transceiver which is connected to the MCU using the SPI. The transceiver allows for energy-efficient local communication in the frequency band below 1 GHz. The CC1101 is configured as the defaulttransceiver for the MSB-IoT in RIOT (see here) and the necessary driver files are automatically included for applications that use the defaulttransceiver module.

Product CC1101
Type Sub-1GHz RF Transceiver
Vendor Texas Instruments
Datasheet Datasheet
Errata Sheet Errata Sheet
Other Technical Documents TI Webpage
Driver Implementation and Interface
SPI Device SPI1 (Mapped to SPI_0 in RIOT)
SCL PA5
MISO PA6
MOSI PA7
CS PB12 (Mapped to GPIO_7 in RIOT)
GDO0 PC4 (Mapped to GPIO_11 in RIOT)
GDO2 PC5 (Mapped to GPIO_12 in RIOT)

CC3000 802.11b/g Wi-Fi Module

In addition to the CC1101, the MSB-IoT also features a CC3000 Wi-Fi Module. The CC3000 is a self-contained wireless network module with a full embedded IPv4 TCP/IP stack that for example allows to use the MSB-IoT as a gateway node to the internet. Please note that the CC3000 only supports operation in infrastructure mode and therefore always needs to be connected to an access point to be used for communication.

The CC3000’s driver implementation for RIOT includes the full driver provided by Texas Instruments. The API documentation from TI can be found here. To use the CC3000 in RIOT, just add USEMODULE += cc3000 to your application’s Makefile.

The driver for the CC3000 is not yet merged into RIOT’s master branch. Please see pull request #2603 for progress on the inclusion.

Product CC3000
Type 802.11b/g Wi-Fi Module
Vendor Texas Instruments
Datasheet Datasheet
Errata Sheet Errata Sheet
Other Technical Documents TI Webpage
TI Wiki Wiki
Driver Pull Request
SPI Device SPI2 (Mapped to SPI_1 in RIOT)
SCL PB10
MISO PC2
MOSI PC3
CS PC1 (Mapped to GPIO_10 in RIOT)
WLAN_ENABLE PC13 (Mapped to GPIO_14 in RIOT)
IRQ Line PA10 (Mapped to GPIO_3 in RIOT)

MPU-9150 Nine-Axis MotionTracking Device

The MSB-IoT is equipped with a MPU-9150 MotionTracking Device from Invensense. The device combines a gyroscope, a magnetometer and an accelerometer in one module.

Due to licensing issues, the current MPU-9150 driver implementation for RIOT is not based on Invensense’s ‘Motion Driver’ library and offers only a limited set of features. Nonetheless, the RIOT driver allows to configure and read values from all three sensors of the device. For an overview on the supported features, you can check the driver’s interface.

A sample RIOT application for the MPU-9150 that utilizes the driver can be found here.

Product MPU-9150
Type Nine-Axis MotionTracking Device (Gyro, Accel and Compass)
Vendor Invensense
Product Specification Product Specification
Register Map Register Map
Driver Implementation and Interface
I²C Device I2C1 (Mapped to I2C_0 in RIOT)
SCL PB6
SDA PB7
IRQ Line PB11 (Mapped to GPIO_6 in RIOT)

Other components

For the following components of the MSB-IoT, there is currently no support in RIOT: TCA6416 16-Bit I/O Expander Micro-SD-Card Interface

Compiling, Flashing and Debugging

This section only covers the automated functionality provided by RIOT’s makefile system. If you don’t want to rely on RIOT’s make targets for flashing or debugging (for instance to use a different flashing tool), please check the documentation of your used tools.

Prerequisites

We strongly recommend the usage of the GNU Tools for ARM Embedded Processors toolchain for the MSB-IoT. Support for other toolchains was not tested!

RIOT’s provided functionality for debugging and flashing the MSB-IoT is based on the Open On-Chip Debugger tool. A wiki page with installation instructions and some other information can be found here.

Quick start

For a quick getting started guide you can stick to the steps explained on this page. Just make sure to use “msbiot” as the respective board name.

### Compiling 

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
fabian@fabian-ThinkPad-L412:~/myriot/RIOT/examples/hello-world$ BOARD=msbiot
make
Building application "hello-world" for "msbiot" with MCU "stm32f4".

"make" -C /home/fabian/myriot/RIOT/boards/msbiot
"make" -C /home/fabian/myriot/RIOT/core
"make" -C /home/fabian/myriot/RIOT/cpu/stm32f4
"make" -C /home/fabian/myriot/RIOT/cpu/cortex-m4_common
"make" -C /home/fabian/myriot/RIOT/cpu/stm32f4/periph
"make" -C /home/fabian/myriot/RIOT/drivers
"make" -C /home/fabian/myriot/RIOT/sys
"make" -C /home/fabian/myriot/RIOT/sys/auto_init
   text     data     bss     dec     hex filename
  11116      116    6444   17676    450c
/home/fabian/myriot/RIOT/examples/hello-world/bin/msbiot/hello-world.elf

### Flashing 

 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
fabian@fabian-ThinkPad-L412:~/myriot/RIOT/examples/hello-world$ BOARD=msbiot
make flash
Building application "hello-world" for "msbiot" with MCU "stm32f4".

"make" -C /home/fabian/myriot/RIOT/boards/msbiot
"make" -C /home/fabian/myriot/RIOT/core
"make" -C /home/fabian/myriot/RIOT/cpu/stm32f4
"make" -C /home/fabian/myriot/RIOT/cpu/cortex-m4_common
"make" -C /home/fabian/myriot/RIOT/cpu/stm32f4/periph
"make" -C /home/fabian/myriot/RIOT/drivers
"make" -C /home/fabian/myriot/RIOT/sys
"make" -C /home/fabian/myriot/RIOT/sys/auto_init
   text     data     bss     dec     hex filename
  11116      116    6444   17676    450c
/home/fabian/myriot/RIOT/examples/hello-world/bin/msbiot/hello-world.elf
/home/fabian/myriot/RIOT/dist/tools/openocd/openocd.sh flash
### Flashing Target ###
Open On-Chip Debugger 0.8.0 (2015-03-01-08:19)
Licensed under GNU GPL v2
For bug reports, read
 http://openocd.sourceforge.net/doc/doxygen/bugs.html
srst_only separate srst_nogate srst_open_drain connect_deassert_srst
Info : This adapter doesn't support configurable speed
Info : STLINK v2 JTAG v17 API v2 SWIM v4 VID 0x0483 PID 0x3748
Info : using stlink api v2
Info : Target voltage: 3.183191
Info : stm32f4x.cpu: hardware has 0 breakpoints, 0 watchpoints
Error: jtag status contains invalid mode value - communication failure
Polling target stm32f4x.cpu failed, GDB will be halted. Polling again in
100ms
Error: jtag status contains invalid mode value - communication failure
Polling target stm32f4x.cpu failed, GDB will be halted. Polling again in
300ms
    TargetName         Type       Endian TapName            State
--  ------------------ ---------- ------ ------------------ ------------
 0* stm32f4x.cpu       hla_target little stm32f4x.cpu       unknown
target state: halted
target halted due to debug-request, current mode: Thread
xPSR: 0x01000000 pc: 0x080002fc msp: 0x2000ab48
Polling target stm32f4x.cpu succeeded again
target state: halted
target halted due to debug-request, current mode: Thread
xPSR: 0x01000000 pc: 0x080002fc msp: 0x2000ab48
   Programming Started **
auto erase enabled
Info : stm32f4x errata detected - fixing incorrect MCU_IDCODE
Info : device id = 0x10006413
Info : flash size = 1024kbytes
target state: halted
target halted due to breakpoint, current mode: Thread
xPSR: 0x61000000 pc: 0x20000042 msp: 0x2000ab48
wrote 16384 bytes from file /home/fabian/myriot/RIOT/examples/hello-
world/bin/msbiot/hello-world.hex in 0.869447s (18.403 KiB/s)
   Programming Finished **
   Verify Started **
target state: halted
target halted due to breakpoint, current mode: Thread
xPSR: 0x61000000 pc: 0x2000002e msp: 0x2000ab48
verified 11232 bytes in 0.124356s (88.204 KiB/s)
   Verified OK **
shutdown command invoked
shutdown command invoked
Done flashing

### Debugging 

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
fabian@fabian-ThinkPad-L412:~/myriot/RIOT/examples/hello-world$ BOARD=msbiot
make debug
/home/fabian/myriot/RIOT/dist/tools/openocd/openocd.sh debug
### Starting Debugging ###
Open On-Chip Debugger 0.8.0 (2015-03-01-08:19)
Licensed under GNU GPL v2
For bug reports, read
 http://openocd.sourceforge.net/doc/doxygen/bugs.html
GNU gdb (GNU Tools for ARM Embedded Processors) 7.6.0.20131129-cvs
Copyright (C) 2013 Free Software Foundation, Inc.
License GPLv3+: GNU GPL version 3 or later <http://gnu.org/licenses/gpl.html>
This is free software: you are free to change and redistribute it.
There is NO WARRANTY, to the extent permitted by law.  Type "show copying"
and "show warranty" for details.
This GDB was configured as "--host=i686-linux-gnu --target=arm-none-eabi".
For bug reporting instructions, please see:
<http://www.gnu.org/software/gdb/bugs/>...
Reading symbols from /home/fabian/myriot/RIOT/examples/hello-
world/bin/msbiot/hello-world.elf...done.
Remote debugging using :3333
reset_handler () at /home/fabian/myriot/RIOT/cpu/stm32f4/startup.c:54
54   {
(gdb)

Using the UART for STDIO

The MCU’s USART2 is set as the default input/output for the MSB-IoT inside RIOT (mapped to UART_0). It is initialized and configured automatically for every RIOT application and can be used for communication with your computer. The easiest way is to use an USB to TTL adapter:

Step 1: Connect your adapter and the boards pin strip with RX<=>PA02, TX<=>PA03 and GND<=>GND

Step 2: Done. The MCUs USART2 is used as STDIO.