RIOT-OS/RIOT
RIOT-OS/RIOT
1
0
Fork 0
mirror of https://github.com/RIOT-OS/RIOT.git synced 2024-12-29 04:50:03 +01:00
Code Releases Activity

doc: add wiki documentation to Doxygen files

Browse Source
This commit is contained in:
Jose Alamos 2018-07-26 11:48:55 +02:00
parent f03e52d157
commit a1e17ab5af
109 changed files with 5972 additions and 218 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
boards/acd52832/doc.txt Normal file
View File

@ -0,0 +1,5 @@
/**
@defgroup boards_acd52832 ACD52832
@ingroup boards
@brief Support for the aconno™ ACD52832
*/

250
boards/airfy-beacon/doc.txt Normal file
View File

@ -0,0 +1,250 @@
/**
@defgroup boards_airfy-beacon Airfy Beacon
@ingroup boards
@brief Support for the Airfy Beacon board
## Overview
The Airfy Beacon is utilizing a Nordics NRF51822QFAA SoC.
The SoC features 16Kb of RAM, 256Kb of flash ROM and comes on top of the
usual micro-controller peripherals with a 2.4GHz radio that supports both
Nordics proprietary ShockBurst as well as Bluetooth Low Energy (BLE).
The board was available via
[Indiegogo](https://www.indiegogo.com/projects/airfy-beacon-make-your-smart-
home-even-smarter).
## Hardware
![airfy-beacon](https://raw.githubusercontent.com/wiki/RIOT-
OS/RIOT/images/airfy-beacon.jpg)
| MCU | NRF51822QFAA |
|:------------- |:--------------------- |
| Family | ARM Cortex-M0 |
| Vendor | Nordic Semiconductor |
| RAM | 16Kb |
| Flash | 256Kb |
| Frequency | 16MHz |
| FPU | no |
| Timers | 3 (2x 16-bit, 1x 32-bit [TIMER0]) |
| ADCs | 1x 10-bit (8 channels) |
| UARTs | 1 |
| SPIs | 2 |
| I2Cs | 2 |
| Vcc | 1.8V - 3.6V |
| Reference Manual | [Reference Manual](http://www.100y.com.tw/pdf_file/39-Nordic-NRF51822.pdf) |
## Unlocking the flash memory
If you're holding a new device in your hands, there is a high change that
your device's flash memory is locked and RIOT's `make flash` command will fail,
saying something like erasing the flash was not possible.
A solution for this is to reset the chips code memory and user information
registers. Just follow these steps:
1. Follow the steps described above for manually flashing the device:
1. start openocd using the correct config file `openocd -f boards/airfy-
beacon/dist/openocd.cfg`
2. connect to openocd using telnet `telnet localhost 4444`
2. type `halt` to stop the device
3. type `nrf51 mass_erase` to reset the code memory
4. all done, `make flash` should now work as expected.
## Flashing and Debugging
The Airfy Beacon comes without any on-board programming and flashing
capabilities. It supports however to be programmed using off-the-shelf
programmers such as Segger's JLink or STM's STLink.
A very simple and affordable way to program and debug this module is to use
the integrated ST-Link/V2 programmer of any STM32Fx-discovery board. The needed
steps are described in the following sections. If you want to use a standalone
ST-Link adapter, you just simply have to alter the wiring to fit for your
programmer, the software part is identical.
### Hardware
First of all make sure the your ST-Link device is detected and can be
accessed properly. In Linux you might have to adept your `udev` rules
accordingly:
```
> cat 49-stlinkv2.rules
# stm32 discovery boards, with onboard st/linkv2
# ie, STM32L, STM32F4.
# STM32VL has st/linkv1, which is quite different
SUBSYSTEMS=="usb", ATTRS{idVendor}=="0483", ATTRS{idProduct}=="3748", \
MODE:="0666", \
SYMLINK+="stlinkv2_%n"
# If you share your linux system with other users, or just don't like the
# idea of write permission for everybody, you can replace MODE:="0666" with
# OWNER:="yourusername" to create the device owned by you, or with
# GROUP:="somegroupname" and mange access using standard unix groups.
> sudo cp 49-stlinkv2.rules /etc/udev/rules.d/
> sudo udevadm control --reload-rules
> sudo udevadm trigger
```
now replug the usb cable and flash.
Have a look at the 'Setting up udev rules' section in this [README
file](https://github.com/texane/stlink/blob/master/README) if you need help.
Second you need to enable the standalone ST-Link mode of the discovery board
by removing the two `CN2` jumpers, found somewhere in the upper left part of the
board. This disconnects the ST-Link programmer from the micro-controller part of
the port and enables direct access through the pin-header `CN3`, also labled
`SWD`.
This module supports the Serial Wire Debug (SWD) interface. To access the
device the following four lines need to be connected with the STM32x-discovery
board:
```
Airfy Beacon STM32Fx-discovery
common ground: GND <-----------> GND
supply voltage: VDD <-----------> 3V
SWD clock: SWDCLK <-----------> SWCLK (CN3, pin2)
SWD data I/O: SWDIO <-----------> SWDIO (CN3, pin4)
```
The following image shows the wiring for an SWD flasher board:
![airfy-beacon-flash-connect](https://raw.githubusercontent.com/wiki/RIOT-
OS/RIOT/images/airfy-beacon-flash-connect.jpg)
### Software
Debugging and programming this module works well with [[OpenOCD]].
We suggest to use a fairly recent version, best use the upstream version from
their [git repository](http://sourceforge.net/p/openocd/code/ci/master/tree/).
Version `Open On-Chip Debugger 0.9.0-dev-00184-g885f438 (2014-10-19-14:49)`
is reported to work.
### Programming the Device
To program the Airfy Beacon, just go to your RIOT application and type:
```
make flash
```
and voila, the new firmware should be flashed onto your device.
### Resetting the Device
As the Airfy Beacon module does not provide a reset button, RIOT includes a
target to reset the board. To do that, just type
```
make reset
```
and your board will reboot.
### Debugging the Device
The debugging setup comprises of two parts: a GDB server and a GDB client. To
usual workflow is to start the GDB server first and then connect to it with some
kind of front-end (e.g. command line, IDE, ...).
To start the GDB server, just type
```
make debug-server
```
This will start a local GDB server on `port 3333`.
If you are fine with working with the GDB command line client, you can start
debugging your device by just typing
```
make debug
```
in a second terminal window. This will automatically connect to your
previously opened GDB server and will also load your corresponding .elf file.
Alternatively you can configure your IDE (e.g. eclipse or similar) to connect
directly to the GDB server. [See here for more information on how to configure
Eclipse](https://github.com/RIOT-OS/RIOT/wiki/Using-the-Eclipse-IDE-for-C-and-
CPP-Developers,-Howto)
### Program the device manually
For OpenOCD to work correctly, you need the following configuration file
(which you can also find in `RIOTDIR/boards/airfy-beacon/dist/openocd.cfg`:
```
$ cat RIOTDIR/boards/airfy-beacon/openocd.cfg
# nRF51822 Target
source [find interface/stlink-v2.cfg]
transport select hla_swd
set WORKAREASIZE 0x4000
source [find target/nrf51.cfg]
# use hardware reset, connect under reset
#reset_config srst_only srst_nogate
```
You can now program your device by doing the following:
1. start openocd with: `openocd -d3 -f RIOTDIR/boards/airfy-
beacon/dist/openocd.cfg`
2. open a new terminal an connect with telnet: `telnet 127.0.0.1 4444`
3. do the following steps to flash (only use bank #0 starting from address
0):
```
> flash banks
#0 : nrf51.flash (nrf51) at 0x00000000, size 0x00040000, buswidth 1,
chipwidth 1
#1 : nrf51.uicr (nrf51) at 0x10001000, size 0x000000fc, buswidth 1, chipwidth
1
> halt
target state: halted
target halted due to debug-request, current mode: Thread
xPSR: 0x61000000 pc: 0x00000e1a msp: 0x20001b2c
> flash write_image erase PATH-TO-YOUR-BINARY/YOUR-BINARY.bin 0
wrote xxx bytes from file PATH-TO-YOUR-BINARY/YOUR-BINARY.bin in xx.yys
(x.yyy KiB/s)
> reset
```
### Debugging manually
First you have to start OpenOCD as described in the section above.
Then enter the following in a new terminal:
```
$ arm-none-eabi-gdb -tui "<your binary ELF>"
(gdb) target remote localhost:3333
Remote debugging using localhost:3333
0x000119ce in ?? ()
(gdb) load
Loading section .text, size 0x2284 lma 0x16000
Loading section .ARM.exidx, size 0x8 lma 0x18284
Loading section .data, size 0x458 lma 0x1828c
Loading section .jcr, size 0x4 lma 0x186e4
Transfer rate: x KB/sec, xxxx bytes/write.
(gdb) monitor reset halt
target state: halted
target halted due to debug-request, current mode: Thread
xPSR: 0xc1000000 pc: 0x000006d0 msp: 0x000007c0
(gdb) break main
Breakpoint 3 at 0x123123: file ../main.c, line xx.
(gdb) continue
Continuing.
```
### Using UART
The UART pins are configured in `boards/airfy-beacon/include/periph_conf.h`.
The default values are PIN 17 and 18.
The default Baud rate is `115 200`.
*/

20
boards/arduino-due/doc.txt
View File

@ -1,13 +1,11 @@
/*
* Copyright (C) 2017 Freie Universität Berlin
*
* This file is subject to the terms and conditions of the GNU Lesser
* General Public License v2.1. See the file LICENSE in the top level
* directory for more details.
*/
/**
* @defgroup boards_arduino-due Arduino Due
* @ingroup boards
* @brief Support for the Arduino Due board
Copyright (C) 2017 Freie Universität Berlin
This file is subject to the terms and conditions of the GNU Lesser
General Public License v2.1. See the file LICENSE in the top level
directory for more details.
@defgroup boards_arduino-due Arduino Due
@ingroup boards
@brief Support for the Arduino Due board
*/

27
boards/arduino-duemilanove/doc.txt Normal file
View File

@ -0,0 +1,27 @@
/**
@defgroup boards_arduino-duemilanove Arduino Duemilanove
@ingroup boards
@brief Support for the Arduino Duemilanove board
## Overview
The Arduino Duemilanove ("2009") is a microcontroller board based on the
ATmega168 or ATmega328.
Only the ATmega328 version is supported by RIOT.
This board is very similar to the Arduino Uno board.
In fact, The Uno is just an evolution of the Duemilanove/Atmega328 version,
with a better USB/Serial chip and a new bootloader.
Otherwise it's the same. Brief descriptions of both boards are available at
the official [Arduino web site.](https://www.arduino.cc/en/Main/Boards)
For details, please look at the [Uno page.](@ref boards_arduino-uno)
## Flashing the device
Flashing RIOT on the Arduino Duemilanove is quite straight forward, just
connect your Arduino Uno using the programming port to your host computer and
type:
`make BOARD=arduino-duemilanove flash`
This should take care of everything!
*/

197
boards/arduino-mega2560/doc.txt Normal file
View File

@ -0,0 +1,197 @@
/**
@defgroup boards_arduino-mega2560 Arduino Mega 2560
@ingroup boards
@brief Support for the Arduino Mega 2560 board
## Overview
The Arduino Mega2560 is one of the larger Arduino boards. It is based on
Atmel's AVR architecture and sports an ATmega2560 MCU. It is like many Arduinos
extensible by using shields.
NOTE: In case you are wondering if flashing RIOT on your Arduino Mega2560
will overwrite the Arduino bootloader: you can be reassured. After flashing RIOT
you can without any intermediate steps just go over to flashing Arduino sketches
again.
## Hardware
![Arduino Mega2560](http://userpage.zedat.fu-
berlin.de/~hvbruinehsen/IMG_20140923_100817.jpg)
### MCU
| MCU | ATmega2560 |
|:------------- |:--------------------- |
| Family | AVR/ATmega |
| Vendor | Atmel |
| RAM | 8Kb |
| Flash | 256Kb |
| Frequency | 16MHz |
| Timers | 6 (2x 8bit, 4x 16bit) |
| ADCs | 14 analog input pins (10bit resolution|
| UARTs | 4 |
| SPIs | 1 |
| I2Cs | 1 (called TWI) |
| Vcc | 5.0V |
| Datasheet / Reference Manual | [Datasheet and Reference Manual](http://www.atmel.com/images/atmel-2549-8-bit-avr-microcontroller-atmega640-1280-1281-2560-2561_datasheet.pdf) |
| Board Manual | [Board Manual](http://arduino.cc/en/Main/arduinoBoardMega2560)|
Flashing RIOT on the Arduino Mega2560 is quite straight forward, just connect
your Arduino Mega2560 using the programming port to your host computer and type:
`make BOARD=arduino-mega2560 flash`
This should take care of everything!
We use the open `avrdude` tool to write the new code into the ATmega2560's
flash
## State
While there is basic support in RIOT, there are still some parts missing:
* Timer implementation needs love (ideally simulate a 32bit timer by adding
an overflow counter to the implementation)
* LPM driver missing
* ~~SPI driver missing~~ (See https://github.com/RIOT-OS/RIOT/pull/4045)
* I2C/TWI driver missing
* ADC driver missing
* PWM driver missing
## Debugging (WIP)
The ATmega2560 MCU supports JTAG debugging. To use the JTAG debugging on the
Arduino Mega 2560 an external JTAG debugger is required. There are several
options for this MCU/board:
* [AVR JTAGICE mkII](http://www.atmel.com/tools/avrjtagicemkii.aspx)
* [JTAGICE3](http://www.atmel.com/tools/jtagice3.aspx)
* [AVR Dragon](http://www.atmel.com/tools/avrdragon.aspx)
There may be other options as well, but I can't comment on how well they
work. I tested debugging RIOT on the Arduino Mega 2560 using an AVR Dragon.
**Important:** To use a JTAG Debugger in conjunction with the ATmega2560 it
is required to change the fuses of the MCU. Additionally it seems to be required
to overwrite the bootloader on the MCU. Because of that it is a necessity to use
an ISP (in system programmer) to do the debugging. This isn't an issue because
all of the afore mentioned devices have ISP capabilities, but it requires some
additional steps to get back normal operation after debugging:
* flash a new arduino bootloader on the device, e.g. [this one](https://raw.
githubusercontent.com/arduino/Arduino/master/hardware/arduino/bootloaders/stk500
v2/stk500boot_v2_mega2560.hex)
* restore the fuses to the default state.
### Wiring for the AVR Dragon
![Wiring for dubugging](http://userpage.zedat.fu-
berlin.de/~hvbruinehsen/IMG_20140923_100714.jpg)
In contrast to normal use (USB only), for debugging there are two separate
wiring changes to do:
* connecting the ISP headers (picture: orange cables).
* connecting the JTAG header to the respective pins on the Arduino (picture:
blue cables)
Connecting the ISP headers is straight forward: Pin1 on the Dragon connects
to Pin1 on the Arduino Mega2560 and so on.
Connecting the JTAG header needs the following pin mapping:
|AVR Dragon | Arduino Mega 2560|Signal|
|:----------|:-----------------|:-----|
|JTAG1 |A4 |TCK |
|JTAG2 o. 10|GND |GND |
|JTAG3 |A6 |TDO |
|JTAG4 |+5V |+5V |
|JTAG5 |A5 |TMS |
|JTAG9 |A7 |TDI |
Ax refers to the analog in pins on the Arduino Mega 2560.
JTAG2 and JTAG10 on the AVR Dragon are both GND, one connection suffices.
All other JTAG Pins are not needed for debugging the Arduino Mega2560
Additional information can be found
[here](http://automation.binarysage.net/?p=1515) or
[here](http://arduino.cc/en/Hacking/PinMapping2560).
### Fuses
**default:**
| Fuse | Setting |
|:--------------|:--------|
| Low Fuse | 0xFF |
| High Fuse | 0xD8 |
| Extended Fuse | 0xFD |
avrdude arguments: `-U lfuse:w:0xff:m -U hfuse:w:0xD8:m -U efuse:w:0xfd:m`
**debugging:**
| Fuse | Setting |
|:--------------|:--------|
| Low Fuse | 0xFF |
| High Fuse | 0x18 |
| Extended Fuse | 0xFD |
(Both `OCDEN` and `JTAGEN` fuse bits are enabled)
avrdude arguments: `-U lfuse:w:0xff:m -U hfuse:w:0x18:m -U efuse:w:0xfd:m`
A useful tool to calculate fuse settings yourself is this [fuse
calculator](http://www.engbedded.com/fusecalc/), which also works with other AVR
MCUs.
### Debugging RIOT on the Arduino Mega 2560
With PR [#1696](https://github.com/RIOT-OS/RIOT/pull/1696) merged the
following commands should work for debugging:
`make BOARD=arduino-mega2560 debug-server`: starts an
[avarice](http://avarice.sourceforge.net/) (avarice needs to be installed)
server that `avr-gdb` can connect to.
`make BOARD=arduino-mega2560 debug`: starts an avarice server and connects
`avr-gdb` to it.
**Note:** To flash the board via the ISP while debugging the additional flag
`PROGRAMMER=dragon_isp` is required.
For a full rebuild and debug cycle use the following command:
`make BOARD=arduino-mega2560 PROGRAMMER=dragon_isp clean all flash debug`
# Mac OSX El Capitan users
Mac users can flash this Arduino board by installing `avr-gcc` and `avrdude`
from `brew`.
Debug is possible but is not covered in this wiki, if you need it, please
refer to this [page](https://www.obdev.at/products/crosspack/index.html).
## Toolchain installation
You should have installed `brew` to follow this instructions. Otherwise,
[install](http://digitizor.com/install-homebrew-osx-el-capitan/) it.
Then, add a repository:
```
$ brew tap osx-cross/avr
```
Afterwards, install `avr-gcc`:
```
$ brew install avr-libc
```
And finally:
```
$ brew install avrdude --with-usb
```
With this you should be allowed to compile and to flash code to the Arduino
Mega.
## Troubleshooting for serial connection
In OSX El Capitan, there is no native driver working for the serial
connection.
In order to install it, you must download and install a CDC-ACM driver from
[here](http://eng.aten.eu/products/Mobility-&-USB/USB-Converters/USB-to-Serial-
Converter~UC232A.html) (Go to Resources/Software & Driver/Mac Software).
A reboot should be enough to find your Arduino on `/dev/tty.usbmodem*`
*/

5
boards/arduino-mkr1000/doc.txt Normal file
View File

@ -0,0 +1,5 @@
/**
@defgroup boards_arduino-mkr1000 Arduino MKR1000
@ingroup boards
@brief Support for the Arduino MKR1000 board.
*/

66
boards/arduino-mkrfox1200/doc.txt
View File

@ -1,34 +1,34 @@
/**
* @defgroup boards_arduino-mkrfox1200 Arduino MKRFOX1200
* @ingroup boards
* @brief Support for the Arduino MKRFOX1200 board.
*
* ### General information
*
* The [Arduino MKRFOX1200](https://www.arduino.cc/en/Main.ArduinoBoardMKRFox1200) board is
* a learning and development board that provides Sigfox connectivity and is
* powered by an Atmel SAMD21 microcontroller.
*
* ### Pinout
*
* <img src="https://www.arduino.cc/en/uploads/Main/MKR1000_pinout.png"
* alt="Arduino MKRFOX1200 pinout" style="height:800px;"/>
*
* ### Flash the board
*
* 1. Put the board in bootloader mode by double tapping the reset button.<br/>
* When the board is in bootloader mode, the user led (green) oscillates
* smoothly.
*
*
* 2. Use `BOARD=arduino-mkrfox1200` with the `make` command.<br/>
* Example with `hello-world` application:
* ```
* make BOARD=arduino-mkrfox1200 -C examples/hello-world flash
* ```
*
* ### Accessing STDIO via UART
*
* To access the STDIO of RIOT, a FTDI to USB converter needs to be plugged to
* the RX/TX pins on the board.
*/
@defgroup boards_arduino-mkrfox1200 Arduino MKRFOX1200
@ingroup boards
@brief Support for the Arduino MKRFOX1200 board.
### General information
The [Arduino MKRFOX1200](https://www.arduino.cc/en/Main.ArduinoBoardMKRFox1200) board is
a learning and development board that provides Sigfox connectivity and is
powered by an Atmel SAMD21 microcontroller.
### Pinout
<img src="https://www.arduino.cc/en/uploads/Main/MKR1000_pinout.png"
alt="Arduino MKRFOX1200 pinout" style="height:800px;"/>
### Flash the board
1. Put the board in bootloader mode by double tapping the reset button.<br/>
When the board is in bootloader mode, the user led (green) oscillates
smoothly.
2. Use `BOARD=arduino-mkrfox1200` with the `make` command.<br/>
Example with `hello-world` application:
```
make BOARD=arduino-mkrfox1200 -C examples/hello-world flash
```
### Accessing STDIO via UART
To access the STDIO of RIOT, a FTDI to USB converter needs to be plugged to
the RX/TX pins on the board.
*/

5
boards/arduino-mkrzero/doc.txt Normal file
View File

@ -0,0 +1,5 @@
/**
@defgroup boards_arduino-mkrzero Arduino MKRZERO
@ingroup boards
@brief Support for the Arduino MKRZERO board.
*/

42
boards/arduino-uno/doc.txt Normal file
View File

@ -0,0 +1,42 @@
/**
@defgroup boards_arduino-uno Arduino Uno
@ingroup boards
@brief Support for the Arduino Uno board
## Overview
The Arduino Uno is one of the cheapest board to start and discover with
electronics and embedded coding. It is based on Atmel's AVR architecture and
sports an ATmega328p MCU. It is like many Arduinos extensible by using shields.
### MCU
| MCU | ATmega328p |
|:------------- |:--------------------- |
| Family | AVR/ATmega |
| Vendor | Atmel |
| RAM | 2Kb |
| Flash | 32Kb |
| Frequency | 16MHz |
| Timers | 3 (2x 8bit, 1x 16bit) |
| ADCs | 6 analog input pins |
| UARTs | 1 |
| SPIs | 1 |
| I2Cs | 1 (called TWI) |
| Vcc | 5.0V |
| Datasheet / Reference Manual | [Datasheet and Reference Manual](http://www.atmel.com/images/atmel-8271-8-bit-avr-microcontroller-atmega48a-48pa-88a-88pa-168a-168pa-328-328p_datasheet_complete.pdf) |
| Board Manual | [Board Manual](https://www.arduino.cc/en/Main/ArduinoBoardUno)|
## Flashing the device
Flashing RIOT on the Arduino Uno is quite straight forward, just connect your
Arduino Uno using the programming port to your host computer and type:
`make BOARD=arduino-uno flash`
This should take care of everything!
We use the open `avrdude` tool to write the new code into the ATmega328p's
flash
##Caution
Don't expect having a working network stack due to very limited resources.
*/

91
boards/arduino-zero/doc.txt Normal file
View File

@ -0,0 +1,91 @@
/**
@defgroup boards_arduino-zero Arduino Zero
@ingroup boards
@brief Support for the Arduino Zero board.
## Overview
The `Arduino Zero` is a board by Arduino/Genuino featuring a ATSAMD21G18A.
The SAMD21 is a ARM Cortex-M0+ micro-controller. It has 256Kb of flash memory
and 32Kb of RAM.
This board is available [here](https://store.arduino.cc/product/GBX00003).
## Hardware
![arduino-zero](https://www.arduino.cc/en/uploads/Main/ABX0003_iso_both.jpg)
### MCU
| MCU | ATSAMD21G18A |
|:------------- |:--------------------- |
| Family | ARM Cortex-M0+ |
| Vendor | Atmel |
| RAM | 32Kb |
| Flash | 256Kb |
| Frequency | up to 48MHz |
| FPU | no |
| Timers | 6 (1x 16-bit, 2x 24-bit, 3x 32-bit) |
| ADCs | 6x 12-bit channels) |
| UARTs | 2 |
| SPIs | max 6 (see UART) |
| I2Cs | max 6 (see UART) |
| Vcc | 1.8V - 3.6V |
| Datasheet | [Datasheet](http://www.atmel.com/Images/Atmel-42181-SAM-D21_Datasheet.pdf) |
### User Interface
1 LED:
| Device | PIN |
|:------ |:--- |
| LED0 | PA17 |
## Implementation Status
Notice that the initial support for the Arduino Zero was based on samr21-xpro
and Sodaq Autonomo.
| Device | ID | Supported | Comments |
|:------------- |:------------- |:------------- |:------------- |
| MCU | samd21 | partly | Energy saving modes not fully utilized |
| Low-level driver | GPIO | yes | |
| | PWM | to be tested | |
| | UART | yes | two UARTs|
| | I2C | yes | |
| | SPI | yes | |
| | ADC | not implemented | |
| | USB | no | |
| | RTT | yes | |
| | RTC | yes | |
| | RNG | no | no HW module |
| | Timer | yes | |
Detailed information on the board can be found on [the official web page](https://www.arduino.cc/en/Main/ArduinoBoardZero).
## Flashing the device
The standard method for flashing RIOT to the Arduino Zero is using OpenOCD.
For this to work properly, **you have to make sure to use a very recent version
of OpenOCD**. Arduino-IDE comes with openocd v0.9.0 which is known to work.
Also Ubuntu 16.04 has openocd v0.9.0.
Refer to https://github.com/RIOT-OS/RIOT/wiki/OpenOCD for building OpenOCD
and make sure "cmsis-dap" and "hidapi-libusb" are enabled.
## Supported Toolchains
To build software for the Arduino Zero board we strongly recommend the usage
of the [GNU Tools for ARM Embedded Processors](https://launchpad.net/gcc-arm-embedded) toolchain.
## Known Issues / Problems
### Stack sizes
The default stack sizes have not been tuned properly yet. If in doubt why
your application crashes try increasing the default stack sizes and use `ps` to
find out how much stack is being used.
Tracked in https://github.com/RIOT-OS/RIOT/issues/2228
*/

5
boards/avsextrem/doc.txt Normal file
View File

@ -0,0 +1,5 @@
/**
@defgroup boards_avsextrem Avsextrem
@ingroup boards
@brief Support for the Avsextrem board
*/

5
boards/b-l072z-lrwan1/doc.txt Normal file
View File

@ -0,0 +1,5 @@
/**
@defgroup boards_b-l072z-lrwan1 ST B-L072Z-LRWAN1 LoRa discovery
@ingroup boards
@brief Support for the ST B-L072Z-LRWAN1 board
*/

5
boards/b-l475e-iot01a/doc.txt Normal file
View File

@ -0,0 +1,5 @@
/**
@defgroup boards_b-l475e-iot01a ST B-L475E-IOT01A
@ingroup boards
@brief Support for the ST B-L475E-IOT01A board
*/

133
boards/bluepill/doc.txt Normal file
View File

@ -0,0 +1,133 @@
/**
@defgroup boards_bluepill Bluepill board
@ingroup boards
@brief Support for the stm32f103c8 based bluepill board.
## Overview
The bluepill is an STM32F103 based board which can be bought for around
2€ on sides like AliExpress, eBay and others. Although the STM32F130C8
MCU nominally has 64 KB flash, most [actually have 128 KB
flash][Flashsize].
## Hardware
![bluepill](https://camo.githubusercontent.com/8df2fb54f87527bdd57fe007352d72c1f377d08f/687474703a2f2f77696b692e73746d33326475696e6f2e636f6d2f696d616765732f7468756d622f312f31392f53544d33325f426c75655f50696c6c5f746f702e6a70672f38303070782d53544d33325f426c75655f50696c6c5f746f702e6a7067)
### MCU
| MCU | STM32F103C8 |
|:----------|:-----------------------|
| Family | ARM Cortex-M3 |
| Vendor | STMicroelectronics |
| RAM | 20 KB |
| Flash | 64 KB / 128 KB |
| Frequency | up to 72 MHz |
| Timer | 3x 16-Bit |
| ADC | 2x 12-bit, 10 channels |
| UART | 3 |
| SPI | 2 |
| I2C | 2 |
| CAN | 1 |
| Vcc | 2.0 to 3.6 V |
| Datasheet | [Datasheet][Datasheet] |
## Implementation Status
| ID | Supported |
|:----- |:--------- |
| GPIO | yes |
| PWM | yes |
| UART | yes |
| ADC | yes |
| I2C | no |
| SPI | yes |
| USB | no |
| Timer | yes |
| CAN | no |
## Flashing
To program and debug the board you need a SWD capable debugger. The
easiest way is using [OpenOCD][OpenOCD]. If you have OpenOCD installed,
you can flash the device with:
$ make BOARD=bluepill flash
### Additional Flash
To make use of the entire 128 KB flash, compile your application with:
$ make BOARD=bluepill CPU_MODEL=stm32f103cb
This sets the `CPU_MODEL` make variable to `stm32f103cb`, the default
value is `stm32f103c8`. These two CPU models basically only have one
major difference, the latter has 128 KB flash while the former has 64
KB.
If you want to flash a binary compiled this way you either need to
figure out how to adjust the OpenOCD configuration to make it use 128 KB
flash or use this [stlink fork][caboStlink] which has a
[patch][caboPatch] to make use of the entire 128 KB flash using:
$ C8T6HACK=1 st-flash write /dev/sgX $pathToHexFile 0x8000000
## Connecting via Serial
The default UART port used is UART2, which uses pins A2 (TX) and A3 (RX).
## Using PWM
PWM is available at pins A8 to A11.
## Known Issues
### USB connector
The Micro-USB port is sometimes not soldered properly. Also, it is
usually equipped with an incorrect resistor. [This can be fixed multiple
ways][USB].
### Flashing abortion
Some boards have problems to flash on the first try. It may help, to press
the reset-button, start the flashing and release it while doing so.
## Where to buy
The board is sold under different names. On some sites it is called
`bluepill` or `blue pill`. On others you might find it by searching for
`stm32f103c8` or `stm32f103c8t6`.
Try [eBay][eBay] or [AliExpress][AliExpress].
## Further reading
* http://wiki.stm32duino.com/index.php?title=Blue_Pill
* http://wiki.stm32duino.com/index.php?title=Maple_Mini#Clones
* http://www.st.com/content/st_com/en/products/microcontrollers/stm32-32-bit-
arm-cortex-mcus/stm32-mainstream-mcus/stm32f1-series/stm32f103/stm32f103c8.html
[Datasheet]: http://www.st.com/content/ccc/resource/technical/document/datash
eet/33/d4/6f/1d/df/0b/4c/6d/CD00161566.pdf/files/CD00161566.pdf/jcr:content/tran
slations/en.CD00161566.pdf
[Flashsize]:
http://wiki.stm32duino.com/index.php?title=Blue_Pill#128_KB_flash_on_C8_version
[eBay]: https://www.ebay.com/sch/i.html?_nkw=stm32f103c8
[AliExpress]: https://www.aliexpress.com/wholesale?SearchText=STM32F103C8T6
[OpenOCD]: https://github.com/RIOT-OS/RIOT/wiki/OpenOCD
[USB]:
http://wiki.stm32duino.com/index.php?title=Blue_Pill#Hardware_installation
[imgTop]:
http://wiki.stm32duino.com/images/thumb/1/19/STM32_Blue_Pill_top.jpg/800px-
STM32_Blue_Pill_top.jpg
[caboStlink]: https://github.com/cabo/stlink
[caboPatch]:
https://github.com/cabo/stlink/commit/e2ff1710ca6caeb55b5b99f7bd8a29181ccf533d
*/

5
boards/calliope-mini/doc.txt Normal file
View File

@ -0,0 +1,5 @@
/**
@defgroup boards_calliope-mini Calliope mini
@ingroup boards
@brief Support for the Calliope mini
*/

147
boards/cc2538dk/doc.txt Normal file
View File

@ -0,0 +1,147 @@
/**
@defgroup boards_cc2538dk CC2538DK
@ingroup boards
@brief Support for the Texas Instruments CC2538DK board.
## Overview
The [CC2538DK](http://www.ti.com/tool/cc2538dk) is Texas Instruments'
developer kit for the CC2538 SoC MCU, which combines an ARM Cortex-M3
microcontroller with an IEEE802.15.4 radio.
## Hardware
![cc2538dk](http://www.ti.com/diagrams/cc2538dk_cc2538dk_web_1.jpg)
| MCU | CC2538SF53 |
|:------------- |:--------------------- |
| Family | ARM Cortex-M3 |
| Vendor | Texas Instruments |
| RAM | 32Kb |
| Flash | 512Kb |
| Frequency | 32MHz |
| FPU | no |
| Timers | 4 |
| ADCs | 1x 12-bit (8 channels) |
| UARTs | 2 |
| SPIs | 2 |
| I2Cs | 1 |
| Vcc | 2V - 3.6V |
| Datasheet | [Datasheet](http://www.ti.com/lit/gpn/cc2538) (pdf file) |
| Reference Manual | [Reference Manual](http://www.ti.com/lit/pdf/swru319) |
## Flashing and Debugging
By default, RIOT will attempt to flash the MCU via the USB UART using a
Python script named [cc2538-bsl](https://github.com/JelmerT/cc2538-bsl).
Hold down the SELECT pushbutton while pressing RESET to activate the MCU's
internal bootloader, then run:
`make flash`
Activating this bootloader is NOT enabled if the flash content is in factory
default state (e.g. after unboxing). To set the bits in the CCA accordingly you
have to follow the guidelines found
[here](http://processors.wiki.ti.com/index.php/CC2538_Bootloader_Backdoor). To
manage this first time access you have to download the
["Uniflash"](http://processors.wiki.ti.com/index.php/Category:CCS_UniFlash) tool
at TI's website.
Some Linux machines may not recognize the CC2538DK's vendor and product ID
automatically.
If a /dev/ttyUSBx device does not appear, try specifying these codes to the
FTDI driver manually:
`echo 0403 a6d1 > /sys/bus/usb-serial/drivers/ftdi_sio/new_id`
If the path `/sys/bus/usb-serial/drivers/ftdi_sio/` doesn't exist, you also
have to load the module `ftdi_sio` by hand. Alternatively, you can install a
`udev` rule that configures this on device connection, see [this post on TI's
E2E site](https://e2e.ti.com/support/microcontrollers/c2000/f/171/p/359074/18434
85#1843485) for details.
RIOT will use /dev/ttyUSB1 by default, but if the UART is given a different
device name, you can specity it to RIOT using the PORT variable:
`make PORT=/dev/ttyUSB2 flash`
To flash using a Segger JLink JTAG adapter you need to install Segger's
JLinkExe tool, then specify `PROGRAMMER=jlink` when flashing:
`make PROGRAMMER=jlink flash`
# Mac OSX **El Capitan** users
Be prevented that you'll need to disable Apple's System Integrity Protection
to allow FTDI unsigned drivers to be loaded on your Mac.
To do this, reboot in recovery mode, by pressing simultaneously `cmd + R`
while booting.
Then, on the recovery mode go to Utilities/Terminal and type:
```
# csrutil status
```
If you see something like:
```
System Integrity Protection status: enabled.
```
You should disable it by typing:
```
# csrutil disable
```
then reboot
```
# reboot
```
and be sure that your System Integrity Protection is disabled
```
$ csrutil status
System Integrity Protection status: disabled.
```
Afterwards you'll be able to install this [driver](https://cdn.sparkfun.com/a
ssets/learn_tutorials/7/4/FTDIUSBSerialDriver_v2_3.dmg).
If everything goes OK reboot your Mac and then edit
`/System/Library/Extensions/FTDIUSBSerialDriver.kext/Contents/Info.plist` with a
text editor.
Add the following block somewhere under `IOKitPersonalities`:
```
<key>TI_XDS100v3</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.FTDI.driver.FTDIUSBSerialDriver</string>
<key>IOClass</key>
<string>FTDIUSBSerialDriver</string>
<key>IOProviderClass</key>
<string>IOUSBInterface</string>
<key>bConfigurationValue</key>
<integer>1</integer>
<key>bInterfaceNumber</key>
<integer>1</integer>
<key>idProduct</key>
<integer>42705</integer>
<key>idVendor</key>
<integer>1027</integer>
</dict>
```
Reboot again and then type:
```
$ sudo kextload /System/Library/Extensions/FTDIUSBSerialDriver.kext
```
If everything worked, the XDS will be enumerated as
`/dev/tty.usbserial-<serial-number>`
*/

6
boards/cc2650-launchpad/doc.txt
View File

@ -1,5 +1,5 @@
/**
* @defgroup boards_cc2650_launchpad TI CC2650 LaunchPad XL
* @ingroup boards
* @brief Texas Instruments SimpleLink(TM) CC2650 Wireless MCU LaunchPad(TM) Kit
@defgroup boards_cc2650_launchpad TI CC2650 LaunchPad XL
@ingroup boards
@brief Texas Instruments SimpleLink(TM) CC2650 Wireless MCU LaunchPad(TM) Kit
*/

219
boards/cc2650stk/doc.txt Normal file
View File

@ -0,0 +1,219 @@
/**
@defgroup boards_cc2650stk CC2650STK
@ingroup boards
@brief Support for the SimpleLink™ CC2650 sensor tag
![CC2650STK](http://www.ti.com/diagrams/cc2650stk_cc2650stk.jpg)
The CC2650STK is an 'IoT kit' with 10 sensors, a fancy case, and a radio unit
that is capable of irradiating IEEE802.15.4 and BLE (or SMART or whatever they
call it now).
- [Official homepage](http://www.ti.com/tool/cc2650stk)
- [Another official homepage](http://www.ti.com/ww/en/wireless_connectivity/sensortag2015)
- [Platform](http://www.ti.com/product/CC2650) <- CPU data sheet here
Use `BOARD=cc2650stk` for building RIOT for this platform.
## Components
| MCU | CC2650f128 |
|:------------- |:--------------------- |
| Family | ARM Cortex-M3 |
| Vendor | Texas Instruments |
| RAM | 20KB |
| Flash | 128KB |
| Frequency - Standby | 31.26kHz, 32kHz or 32.768kHz |
| Frequency - Active / Idle | 48MHz |
| RF core | ARM Cortex-M0 CPU, 4KB RAM |
| Timers | 4x 32-bit |
| ADCs | 1x 12-bit (8 channels) |
| UARTs | 2 |
| SPIs | 2 |
| I2C | 1 |
| I2S | 1 |
| Datasheet | [Datasheet](http://www.ti.com/lit/ds/symlink/cc2650.pdf) |
| Reference Manual | [Reference Manual](http://www.ti.com/lit/ug/swcu117d/swcu117d.pdf) |
## Implementation Status
It's an ongoing process...
| Module | Status | |
|:------------- |:--------------------- |:--------------------- |
| Cortex-M3 | Partial support | Missing: energy saving features |
| UART | OK | |
| LEDS | OK | |
| Hardware buttons | OK | |
| Timers | Unstable | See [#5631](https://github.com/RIOT-OS/RIOT/issues/5361)|
| RF core | Work in progress | See [here](https://github.com/yogo1212/RIOT/tree/cc26x0_rfc). |
## Toolchains
The arm-none-eabi toolchain works fine. You can get it
[here](https://launchpad.net/gcc-arm-embedded/+download).
## Programming and Debugging
You'll need [debugging hardware](http://processors.wiki.ti.com/index.php/CC13xx_CC26xx_Tools_Overview#Debuggers).
So far, the [XDS110 debug probe](http://www.ti.com/tool/CC-DEVPACK-DEBUG) has
been tested. That bugger requires you to load a firmware onto it each time it
powers up. The tool is contained in the Uniflash utility or the `CodeComposer
Studio` from TI. Look for a folder called `uscif` in the installation directory,
go to the folder `xds110` therein, and follow the instructions in the
`ReadMe.txt`.
The process is relying on proprietary TI softsoftware. If you're on Windows
you can use the stuff linked to on the product websites.
On Linux, there's an application called
[Uniflash](http://www.ti.com/tool/uniflash). Sadly, you'll have to install the
whole IDE just to get the scripting interface :-[
No idea about MacOSX.
In order to flash the CC2650STK you need to plug the XDS110 probe through the
JTAG and so-called "DevPack" connectors. Note that the back of the SensorTag
case has a removable plastic cut-out: as a result the XDS110 can be used while
the CC2650STK is still protected in its case. For the flashing process to be
successful, the CC2650STK needs to be powered by a working battery.
Once your application code has compiled, you need to indicate the path to
your UniFlash tool. You can do it in two ways:
1. Add `export UNIFLASH_PATH = your_path` to
`boards/cc2650stk/Makefile.include` and then run `make BOARD=cc2650stk flash`
2. Use the command `make BOARD=cc2650stk UNIFLASH_PATH=your_path flash` to
flash the board.
If you're lazy you can create an alias to do it with the following command:
`alias cc2650stkmake='make BOARD=cc2650stk UNIFLASH_PATH=your_path flash'`
In both cases you can add `term` at the end of the `make` command to enter
the pyterm console directly. After the board has been flashed, it needs to be
manually reset using the reset button on the XDS110 probe.
***
WORK IN PROGRESS
***
# **Bluetooth Low Energy on the CC2650STK**
This section is meant to provide information regarding the BLE specifications
as well as their implementation on the CC2650.
BLE support two main data format: one for advertising channels packets and
the other for data channels packets. Both formats will be described in details
in the first half of the guide. The second half will provide guidance on how to
implement the most common roles of a BLE network.
References: [BlueTooth Core Specification v4.2](https://www.bluetooth.org/DocMan/handlers/DownloadDoc.ashx?doc_id=286439),
[Core Specification Supplement v6](https://www.bluetooth.org/DocMan/handlers/DownloadDoc.ashx?doc_id=302735),
[BLE Becons by TI](http://www.ti.com.cn/cn/lit/an/swra475/swra475.pdf)
## BLE packet format for advertising channels
![pdu](https://cloud.githubusercontent.com/assets/14371243/15826178/dac1490a-2c06-11e6-95fb-4d27bdb7fd8d.png)
| Field | Size | Definition | Description |
|:------------------------|:--------|:------------------|:----------------------|
| Preamble | 1 byte | BLE specification | Always 10101010b for advertising channel packets |
| Access Address | 4 bytes | BLE specification | Always 0x8E89BED6 for advertising channel packets |
| Payload Data Unit (PDU) | 2 to 257 bytes | User defined | Advertising Channel PDU |
| CRC | 3 bytes | BLE specification | Result of a polynomial calculated based on the PDU |
### PDU for advertising channels
The RF Core will automatically build the PDU based on the content of the
radio operation command. The following table describes the format of the PDU for
advertising channels, as well as the corresponding variables in the RIOT
command.
```
typedef struct __attribute__ ((aligned(4))) {
radio_op_command_t ropCmd;
uint8_t channel;
struct {
uint8_t init:7;
uint8_t bOverride:1;
} whitening;
void *pParams; //points toward a structure of type
rfc_ble_param_advertiser_t
void *pOutput;
} ble_rop_cmd_t;
```
| Field | Size | RIOT variable | Description|
|:----------------------|:--------|:--------------|:------------------------------------------------------------|
| PDU Type | 4 bits | `ropCmd.commandNo` | PDU Type is solely dependant on the command type. See below. |
| RFU | 2 bits | - | Reserved for Future Use (RFU): [You can't touch this.](https://www.youtube.com/watch?v=otCpCn0l4Wo) Assumed to be 0.|
| TxAdd | 1 bit | `pParams->advConfig.deviceAddrType` | The field value is specific to the PDU type. |
| RxAdd | 1 bit | - | The field value is specific to the PDU type. According to the TI documentation ([23.6.4.4](http://www.ti.com/lit/ug/swcu117d/swcu117d.pdf)), this field is not available to configure and thus assumed to be 0. |
| Length | 6 bits | `pParams->advLen` + 6| Indicates the length of the payload field in bytes. 6 is added to account for the advertiser address. The payload length ranges from 6 to 37 bytes. |
| RFU | 2 bits | - | Reserved for Future Use (RFU): [You can't touch this.](https://www.youtube.com/watch?v=otCpCn0l4Wo) Assumed to be 0 |
| Advertiser address | 6 bytes | `pParams->pDeviceAddress` | First element of the payload. The different formats of address types are illustrated [here](https://cloud.githubusercontent.com/assets/14371243/15826564/4c7f5f54-2c08-11e6-8051-dc0a018f6e42.png).|
| Advertising data (AD) | 0-31 bytes | `pParams->pAdvData` | Second element of the payload. Warning: if `pParams->advLen=0` the advertiser data are disregarded.|
As mentioned in the table above, the content of some of the PDU fields are
intertwined. These relationships are established in the following tables. Please
note that the configuration of the RxAdd is not possible on the CC2650 (RxAdd=0
∀ Command No) and thus displayed for information purposes only.
| Command No | Denomination in BLE specs | Value of PDU Type | Value of TxAdd and RxAdd | Description |
|:-----------|:---------------------------|:------------------|:---------------|:------------|
| CMD_BLE_ADV | ADV_IND | 0000b | TxAdd: advertiser's address is public (0) or random (1). RxAdd: not defined. | Connectable undirected advertising event |
| CMD_BLE_ADV_DIR | ADV_DIRECT_IND | 0001b | TxAdd: advertiser's address is public (0) or random (1). RxAdd: initiator's address is public (0) or random (1). | Connectable directed advertising event |
| CMD_BLE_ADV_NC | ADV_NONCONN_IND | 0010b | TxAdd: advertiser's address is public (0) or random (1). RxAdd: not defined. | Non-connectable undirected advertising event |
| CMD_BLE_ADV_SCAN | ADV_SCAN_IND | 0110b | TxAdd: advertiser's address is public (0) or random (1). RxAdd: not defined. | Scannable undirected advertising event|
The Advertising Data (AD) field can be populated with a set of basic data
types described in chapter 1 of the [BLE core specification supplement](https://www.bluetooth.com/specifications/adopted-specifications),
e.g. service UUID, flags or manufacturer specific data.
## BLE packet format for data channels
| Field | Size | Definition | Description |
|:------------------------|:--------|:------------------|:----------------------|
| Preamble | 1 byte | BLE specification | Equal to 10101010b (LSB of Access Address is 0) or 01010101b (LSB of Access Address is 1) for data channel.|
| Access Address | 4 bytes | BLE specification | Randomly generated under constraints. |
| Payload Data Unit (PDU) | 2 to 257 bytes | User defined | Data Channel PDU|
| CRC | 3 bytes | BLE specification | Result of a polynomial calculated based on the PDU |
## Configuring a BLE beacon
In order to configure a BLE beacon, a radio operation command `cmd` of type
`ble_rop_cmd_t` must be sent to the RF core.
1. Define the parameters of the command by filling a structure of type
`rfc_ble_param_advertiser_t`. Minimum requirements are as follows:
1. Set `params->endTime = 0` and `params->endTrigger.triggerType = 0` unless
you want to do something fancy timewise.
2. Set `params->pDeviceAddress` to an `unsigned char` array containing the
[48-bit MAC address](https://en.wikipedia.org/wiki/MAC_address) of the MCU. The
MAC-48 identifier can be obtained from the function `ble_mac48_get()` defined in
`cpu/cc26x0/periph/cpuid.c`. This function returns a **public device address**,
defined in the factory config data (FCFG->MAC_BLE_n): bits 0-24 contain a serial
number unique to the MCU, while the bits 24-48 contain the Organizationally
Unique Identifier
([OUI](https://en.wikipedia.org/wiki/Organizationally_unique_identifier)) for
Texas Instrument, i.e. b0:b4:48.
3. Set `params->pAdvData` to a byte array containing the data to be
broadcasted. The size of the array must be written as `params->advLen`. Since
the advertising packet is non-connectable, the Flag data type (described in
[Core Specification Supplement v6](https://www.bluetooth.org/DocMan/handlers/DownloadDoc.ashx?doc_id=302735))
may be omitted from the advertising payload.
2. Configure the command itself by filling a structure of type
`ble_rop_cmd_t`. Minimum requirements are as follows:
1. Set `cmd.ropCmd.commandNo = CMDR_CMDID_BLE_ADV_NC`. The PDU type will be
set accordingly by the RF core.
2. Set `cmd.condition.rule = R_OP_CONDITION_RULE_NEVER` unless you plan on
executing an additional command via `cmd.pNextOp`.
3. Set `cmd.whitening.bOverride = 0` and `cmd.whitening.init = 0` unless you
understand how to use it.
4. Set `cmd.pParams` to the address of the `rfc_ble_param_advertiser_t`
structure defined in 1).
5. Set the advertising channel via `cmd.channel`. There are 3 possible
channels, each identified by a `uint8_t`: 37, 38 or 39. If you want to broadcast
on all three channels you can create three ble_rop_cmd_t commands and chain them
via `cmd.pNextOp`.
3. Send the command to be executed to the RF core via the `rfc_send_cmd()`
function
*/

44
boards/chronos/doc.txt Normal file
View File

@ -0,0 +1,44 @@
/**
@defgroup boards_chronos Chronos
@ingroup boards
@brief Support for the chronos board
# Hardware
![TI eZ430-Chronos running RIOT](http://riot-os.org/images/hardware-watch-
riot.png)
# MCU
| MCU | TI CC430F6137 |
|:------------- |:--------------------- |
| Family | MSP430 |
| Vendor | Texas Instruments |
| Package | 64VQFN |
| RAM | 4Kb |
| Flash | 32Kb |
| Frequency | 20MHz |
| FPU | no |
| Timers | 2 (2x 16bit) |
| ADCs | 1x 8 channel 12-bit |
| UARTs | 1 |
| SPIs | 2 |
| I2Cs | 1 |
| Vcc | 2.0V - 3.6V |
| Datasheet / Reference Manual | [Datasheet](http://www.ti.com/lit/gpn/cc430f6137) |
| Board Manual | [User Guide](http://www.ti.com/lit/pdf/slau292)|
## Flashing RIOT
Flashing RIOT on the eZ430-Chronos is quite straight forward, just connect
your eZ430-Chronos using the USB programming dongle to your host computer and
type:
`make flash`
This should take care of everything!
# Vendor information
[TI Wiki](http://processors.wiki.ti.com/index.php/EZ430-Chronos)
[MCU information](http://www.ti.com/product/cc430f6137)
*/

26
boards/common/doc.txt
View File

@ -1,16 +1,14 @@
/*
* Copyright (C) 2017 HAW Hamburg
*
* This file is subject to the terms and conditions of the GNU Lesser
* General Public License v2.1. See the file LICENSE in the top level
* directory for more details.
*/
/**
* @defgroup boards_common Common Board Groups
* @ingroup boards
* @brief Common definitions and implementations for board groups
*
* Several boards share many definitions and implementations, these are
* collectively stored into a common module per board group.
Copyright (C) 2017 HAW Hamburg
This file is subject to the terms and conditions of the GNU Lesser
General Public License v2.1. See the file LICENSE in the top level
directory for more details.
@defgroup boards_common Common Board Groups
@ingroup boards
@brief Common definitions and implementations for board groups
Several boards share many definitions and implementations, these are
collectively stored into a common module per board group.
*/

5
boards/ek-lm4f120xl/doc.txt Normal file
View File

@ -0,0 +1,5 @@
/**
@defgroup boards_ek-lm4f120xl EK-LM4F120XL
@ingroup boards
@brief Support for the Stellaris Launchpad LM4F120 board
*/

5
boards/f4vi1/doc.txt Normal file
View File

@ -0,0 +1,5 @@
/**
@defgroup boards_f4vi1 F4VI1
@ingroup boards
@brief Support for the F4VI1 board
*/

88
boards/feather-m0/doc.txt
View File

@ -1,45 +1,45 @@
/**
* @defgroup boards_feather-m0 Adafruit Feather M0
* @ingroup boards
* @brief Support for the Adafruit Feather M0.
*
* ### General information
*
* Feather M0 boards are development boards shipped by
* [Adafruit](https://learn.adafruit.com/adafruit-feather-m0-basic-proto/).
*
* All the feather M0 boards are built based on the same Atmel SAMD21G18A
* microcontroller. See @ref cpu_samd21.
*
* Several types of Feather M0 boards exist:
* * [Feather M0 WiFi](https://learn.adafruit.com/adafruit-feather-m0-wifi-atwinc1500/)
* * [Feather M0 BLE](https://learn.adafruit.com/adafruit-feather-m0-bluefruit-le/overview)
* * [Feather M0 Adalogger](https://learn.adafruit.com/adafruit-feather-m0-adalogger/)
* * [Feather M0 LoRa](https://learn.adafruit.com/adafruit-feather-m0-radio-with-lora-radio-module)
*
* The different modules used to differenciate the boards (ATWINC1500 WiFi,
* Bluefruit LE, SD card, LoRa) are connected via SPI (SPI_DEV(0)) to the
* SAMD21 mcu.
*
* ### Pinout
*
* <img src="https://cdn-learn.adafruit.com/assets/assets/000/030/921/original/adafruit_products_2772_pinout_v1_0.png"
* alt="Adafruit Feather M0 proto pinout" style="width:800px;"/>
*
* ### Flash the board
*
* 1. Put the board in bootloader mode by double tapping the reset button.<br/>
* When the board is in bootloader mode, the user led (red) oscillates smoothly.
*
*
* 2. Use `BOARD=feather-m0` with the `make` command.<br/>
* Example with `hello-world` application:
* ```
* make BOARD=feather-m0 -C examples/hello-world flash
* ```
*
* ### Accessing STDIO via UART
*
* To access the STDIO of RIOT, a FTDI to USB converted needs to be plugged to
* the RX/TX pins on the board.
*/
@defgroup boards_feather-m0 Adafruit Feather M0
@ingroup boards
@brief Support for the Adafruit Feather M0.
### General information
Feather M0 boards are development boards shipped by
[Adafruit](https://learn.adafruit.com/adafruit-feather-m0-basic-proto/).
All the feather M0 boards are built based on the same Atmel SAMD21G18A
microcontroller. See @ref cpu_samd21.
Several types of Feather M0 boards exist:
* [Feather M0 WiFi](https://learn.adafruit.com/adafruit-feather-m0-wifi-atwinc1500/)
* [Feather M0 BLE](https://learn.adafruit.com/adafruit-feather-m0-bluefruit-le/overview)
* [Feather M0 Adalogger](https://learn.adafruit.com/adafruit-feather-m0-adalogger/)
* [Feather M0 LoRa](https://learn.adafruit.com/adafruit-feather-m0-radio-with-lora-radio-module)
The different modules used to differenciate the boards (ATWINC1500 WiFi,
Bluefruit LE, SD card, LoRa) are connected via SPI (SPI_DEV(0)) to the
SAMD21 mcu.
### Pinout
<img src="https://cdn-learn.adafruit.com/assets/assets/000/030/921/original/adafruit_products_2772_pinout_v1_0.png"
alt="Adafruit Feather M0 proto pinout" style="width:800px;"/>
### Flash the board
1. Put the board in bootloader mode by double tapping the reset button.<br/>
When the board is in bootloader mode, the user led (red) oscillates smoothly.
2. Use `BOARD=feather-m0` with the `make` command.<br/>
Example with `hello-world` application:
```
make BOARD=feather-m0 -C examples/hello-world flash
```
### Accessing STDIO via UART
To access the STDIO of RIOT, a FTDI to USB converted needs to be plugged to
the RX/TX pins on the board.
*/

136
boards/fox/doc.txt Normal file
View File

@ -0,0 +1,136 @@
/**
@defgroup boards_fox fox
@ingroup boards
@brief Support for the fox board
## Components
| MCU | [ST2M32F103REY](http://www.st.com/web/catalog/mmc/FM141/SC1169/SS1031/LN1565/PF164485) – 32-bits|
|-------|-----------------------------------------------------------------------------------------------------|
| RAM | 64Kb |
| Flash | 512Kb |
| radio chipset | [AT86RF231](http://www.atmel.com/images/doc8111.pdf) |
| | a IEEE802.15.4-compliant radio at 2.4 GHz |
## Implementation Status
| Device | ID | Supported | Comments |
|:------------- |:------------- |:------------- |:------------- |
| MCU | [STM23F103REY](http://www.st.com/st-web-ui/static/active/en/resource/technical/document/reference_manual/CD00171190.pdf) | partly | Energy saving modes not fully utilized |
| Low-level driver | GPIO | yes | |
| | PWM | no | |
| | UART | full | |
| | I2C | yes | |
| | SPI | yes | one SPI device for now |
| | USB | no | |
| | RTT | yes | in progress |
| | RNG | no | no HW module |
| | Timer | full | |
| Radio Chip | AT86RF231 | partly | will be remodelled soon |
##### Note on at86rf231 radio driver
The current implementation of the radio driver for the at86rf231 chip uses
the basic operation modes. This gives
you basic sending and receiving functionality but no hardware address
filtering and no auto-ACKs etc. Due to the fact this radio device is an IEEE
802.15.4 compliant device it supports radio channels from 11 to 26. When trying
to set a channel out of range the driver returns an error and prints a message
with `DEVELHELP` enabled.
## Toolchains
See [ARM Family](https://github.com/RIOT-OS/RIOT/wiki/Family:-ARM)
Working:
* [gcc-arm-embedded](https://github.com/RIOT-OS/RIOT/wiki/Family:-ARM#gcc-
arm-embedded-toolchain)
* [gcc-linaro](https://github.com/RIOT-OS/RIOT/wiki/Family:-ARM#linaro-
toolchain)
### Programming and Debugging
In order to program (flash) and debug the node you need
[OpenOCD](http://openocd.sourceforge.net/) and an ARM version of gdb (`arm-none-
eabi-gdb`), which provided by most toolchains. Most Linux distributions provide
also a package for OpenOCD. The required configuration files are provided by
RIOT.
When starting the debugger with `make debug BOARD=fox` GDB connects to
openocd, loads the elf-file and puts the MCU into halt state. Before setting
breakpoints it is sometimes needed to use the following workflow
```
bash
monitor reset run
monitor reset halt
b <breakpoint>
c
```
For best debugging experience also change the `-Os` flag in
`Makefile.inlcude`'s `CFLAGS` variable to `-O0`.
## Debugging
For debugging you need to open a terminal. Here you simply have to call `make
debug` - assuming that the current directory is your application directory. It
establishes an openocd connection to the device and starts gdb connected to the
openocd instance. For example, it should look something like this
```
[user@host RIOT]$ cd examples/default/
[user@host default]$ BOARD=fox make
Building application default for fox w/ MCU stm32f1.
...
[user@hostdefault]$ BOARD=fox make debug
RIOT/boards/hikob-common/dist/debug.sh RIOT/boards/fox/dist/gdb.conf
RIOT/examples/default/bin/fox/default.elf
Open On-Chip Debugger 0.8.0 (2014-07-27-20:18)
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.4.1.20140401-cvs
Copyright (C) 2012 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=x86_64-apple-darwin10 --target=arm-none-
eabi".
For bug reporting instructions, please see:
<http://www.gnu.org/software/gdb/bugs/>...
Reading symbols from RIOT/examples/default/bin/fox/default.elf...done.
idle_thread (arg=<optimized out>) at RIOT/core/kernel_init.c:67
67 lpm_set(LPM_IDLE);
JTAG tap: stm32f1x.cpu tap/device found: 0x3ba00477 (mfg: 0x23b, part:
0xba00, ver: 0x3)
JTAG tap: stm32f1x.bs tap/device found: 0x06414041 (mfg: 0x020, part: 0x6414,
ver: 0x0)
target state: halted
target halted due to debug-request, current mode: Thread
xPSR: 0x01000000 pc: 0x0800027c msp: 0x20002200
Loading section .text, size 0x6df4 lma 0x8000000
Loading section .ARM.exidx, size 0x8 lma 0x8006df4
Loading section .relocate, size 0x120 lma 0x8006dfc
Start address 0x8000000, load size 28444
Transfer rate: 11 KB/sec, 7111 bytes/write.
(gdb) c
Continuing.
```
The node will reboot and you can continue to use `gdb` like you're used to.
In some cases it
seems necessary to prepend a `monitor reset run` before executing continue.
In general you can
use openocd commands prepended by `monitor`.
In the case the node crashes it can be reseted with the following sequence
```
Bash
(gdb) monitor reset halt
(gdb) monitor reset run
```
## Troubleshooting
For terminal output on OS X (`make term`) you need to install a driver:
http://www.ftdichip.com/Drivers/VCP.htm
http://www.ftdichip.com/Drivers/VCP.htm
*/

5
boards/frdm-k22f/doc.txt Normal file
View File

@ -0,0 +1,5 @@
/**
@defgroup boards_frdm-k22f NXP FRDM-K22F Board
@ingroup boards
@brief Support for the NXP FRDM-K22F
*/

102
boards/frdm-k64f/doc.txt Normal file
View File

@ -0,0 +1,102 @@
/**
@defgroup boards_frdm-k64f NXP FRDM-K64F Board
@ingroup boards
@brief Support for the NXP FRDM-K64F
## Overview
The board has a K64F Kinetis MCU and is supported by `cpu/kinetis_common`.
## Hardware
![frdm-k64f](http://cache.freescale.com/files/graphic/block_diagram/31958-FRD
M-K64F_BDTN.jpg)
| MCU | MK64FN1M0VLL12 |
|:------------- |:--------------------- |
| Family | ARM Cortex-M4F |
| Vendor | Freescale |
| RAM | 256Kb |
| Flash | 1024Kb |
| Frequency | 120MHz |
| FPU | yes |
| Timers | yes |
| ADCs | yes |
| UARTs | yes |
| SPIs | yes |
| I2Cs | yes |
| Ethernet | WIP |
| USB | WIP |
| LPM | TODO |
| DAC | TODO |
| Vcc | TODO |
| Reference Manual | TODO |
The board has an integrated debuger adapter (k20dx128) with the firmware from
ARMmbed.
There are three interfaces available:
* Drag-n-drop programming over Mass Storage Device
* USB Serial Port (/dev/ttyACMx) connected to a K64F UART interface
* CMSIS-DAP for debugging with e.g. OpenOCD
**Please update the firmware to version 0221, see below.**
## OpenOCD
The latest (01.07.2015) OpenOCD version (also current git) does not support
the K64F. There is a [patch](http://openocd.zylin.com/#/c/2773/) which makes
flashing and debugging possible. A refactored and rebased version can be found
[here](https://github.com/jfischer-phytec-iot/openocd/tree/wip%40phytec).<br>
## Flashing the Device
#### Over OpenOCD
make BOARD=frdm-k64f flash
#### Over MSD
Simply mount the mbed Mass Storage Device und copy new RIOT firmware.
See also the ARMmbed
[instructions](https://developer.mbed.org/platforms/FRDM-K64F/#getting-started-
with-mbed).
## Updating the Booloader
A update of CMSIS-DAP firmware is necessary to using the board with OpenOCD.
A good step by step guide is available
[here](https://developer.mbed.org/handbook/Firmware-FRDM-K64F).
## I can't flash the device with OpenOCD anymore...
When a flash process has failed or a wrong firmware has been programmed, the
following OpenOCD message may appear:
```
START...
Info : SWD IDCODE 0x2ba01477
Info : SWD IDCODE 0x2ba01477
Error: Failed to read memory at 0xe000ed00
Examination failed, GDB will be halted. Polling again in 300ms
TargetName Type Endian TapName State
-- ------------------ ---------- ------ ------------------ ------------
0* k64f.cpu cortex_m little k64f.cpu unknown
START...
Warn : *********** ATTENTION! ATTENTION! ATTENTION! ATTENTION! **********
Warn : **** ****
Warn : **** Your Kinetis MCU is in secured state, which means that, ****
Warn : **** with exception for very basic communication, JTAG/SWD ****
Warn : **** interface will NOT work. In order to restore its ****
Warn : **** functionality please issue 'kinetis mdm mass_erase' ****
Warn : **** command, power cycle the MCU and restart OpenOCD. ****
Warn : **** ****
Warn : *********** ATTENTION! ATTENTION! ATTENTION! ATTENTION! **********
in procedure 'reset'
in procedure 'ocd_bouncer'
```
Solution 1:
+ Hold the reset button and execute make BOARD=frdm-k64f flash in a project
directory
+ Release reset button just after "Info : MDM: Chip is unsecured.
Continuing."
Solution 2:
+ Comment out line `reset_config srst_only srst_nogate connect_assert_srst`
in `boards/frdm-k64f/dist/openocd.cfg`
+ Execute make BOARD=frdm-k64f flash in a project directory
Solution 3:
+ Ask Deep Thought
*/

5
boards/ikea-tradfri/doc.txt Normal file
View File

@ -0,0 +1,5 @@
/**
@defgroup boards_ikea-tradfri IKEA TRÅDFRI modules
@ingroup boards
@brief Support for the IKEA TRÅDFRI modules
*/

5
boards/iotlab-a8-m3/doc.txt Normal file
View File

@ -0,0 +1,5 @@
/**
@defgroup boards_iotlab-a8-m3 IoT-LAB A8 M3 open node
@ingroup boards
@brief Support for iotlab-m3 board.
*/

163
boards/iotlab-m3/doc.txt Normal file
View File

@ -0,0 +1,163 @@
/**
@defgroup boards_iotlab-m3 IoT-LAB M3 open node
@ingroup boards
@brief Support for the iotlab-m3 board
## Components
| MCU | [ST2M32F103REY](http://www.st.com/web/catalog/mmc/FM141/SC1169/SS1031/LN1565/PF164485) – 32-bits, 64kB RAM |
|-------|-------------------------------------------------------------------------------------------------------------------|
|sensors | Light ([ISL29020](http://www.intersil.com/en/products/optoelectronics/ambient-light-sensors/light-to-digital-sensors/ISL29020.html)) |
| | Pressure ([LPS331AP](http://www.st.com/web/catalog/sense_power/FM89/SC1316/PF251601)) |
| | Tri-axis accelerometer/magnetometer ([LSM303DLHC](http://www.st.com/web/catalog/sense_power/FM89/SC1449/PF251940)) |
| | Tri-axis gyrometer ([L3G4200D](http://www.st.com/web/catalog/sense_power/FM89/SC1288/PF250373)) |
| external memory | 128 Mbits external Nor flash ([N25Q128A13E1240F](http://www.datasheet4u.com/download.php?id=683085)) |
| power | 3,7V LiPo battery – 650 mAh ([063040](http://www.gmbattery.com/Datasheet/LIPO/LIPO-063040.pdf)) |
| radio chipset | [AT86RF231](http://www.atmel.com/images/doc8111.pdf) |
| | a IEEE802.15.4-compliant radio at 2.4 GHz |
## Board HW overview
![IoT-LAB M3 Layout](https://www.iot-lab.info/wp-
content/uploads/2013/10/m3opennode.png)
### Board Architecture
![IoT-LAB M3 Architecture](https://github.com/iot-lab/iot-
lab/wiki/Images/archiopenm3.png)
### [Board schematics](http://github.com/iot-lab/iot-lab/wiki/Docs/openm3-schematics.pdf)
, wiring, pinouts, etc...
## Implementation Status
| Device | ID | Supported | Comments |
|:------------- |:------------- |:------------- |:------------- |
| MCU | [STM23F103REY](http://www.st.com/st-web-ui/static/active/en/resource/technical/document/reference_manual/CD00171190.pdf) | partly | Energy saving modes not fully utilized |
| Low-level driver | GPIO | yes | |
| | PWM | no | #4227|
| | UART | yes | |
| | I2C | yes | |
| | SPI | yes | |
| | USB | no | |
| | RTT | yes | |
| | Timer | yes | |
| Radio Chip | AT86RF231 | yes | |
| Accelerometer | L3G4200D | yes | |
| Magnetometer | L3G4200D | yes | |
| Gyroscope | LSM303DLHC | yes | |
| Pressure Sensor | LPS331AP | yes | |
| Light Sensor | ISL29020 | yes | |
## Toolchains
See [ARM Family](https://github.com/RIOT-OS/RIOT/wiki/Family:-ARM)
Working:
* [gcc-arm-embedded](https://github.com/RIOT-OS/RIOT/wiki/Family:-ARM#gcc-
arm-embedded-toolchain)
* [gcc-linaro](https://github.com/RIOT-OS/RIOT/wiki/Family:-ARM#linaro-
toolchain)
### Programming and Debugging
In order to program (flash) and debug the node you need
[OpenOCD](http://openocd.sourceforge.net/) and an ARM version of gdb (`arm-none-
eabi-gdb`), which provided by most toolchains. Most Linux distributions provide
also a package for OpenOCD. The required configuration files are provided by
RIOT.
When starting the debugger with `make debug BOARD=iotlab-m3` GDB connects to
openocd, loads the elf-file and puts the MCU into halt state. Befor setting
breakpoints it is sometimes needed to use the following workflow
```
bash
monitor reset run
monitor reset halt
b <breakpoint>
c
```
For best debugging experience also change the `-Os` flag in
`Makefile.inlcude`'s `CFLAGS` variable to `-O0`.
## Details
The M3 Open Node can reset, debug and program the STM32 on JTAG through the
FTDI2322H connected to the USB. This component allows also a UART link to the
STM32. The Open Node connector gives access to 3 STM32/GPIO and the STM32/I2C.
Two power lines are accessible on this connector:
* a + 5.0 volts for the board power supply
* a 3.3 volts for the consumption monitoring of the STM32, the RF component
and the sensors
The M3 Open Node can be used standalone without a gateway connected to the M3
Open node connector. The powering of the board is then assumed by a battery or
by the USB connector The choice of the power input is done electronically
(power management).
![IoT-LAB M3 architecture](https://www.iot-lab.info/wp-
content/uploads/2013/10/archiopenm3.png)
## Debugging
For debugging you need to open a terminal. Here you simply have to call `make
debug` - assuming that the current directory is your application directory. It
establishes an openocd connection to the device and starts gdb connected to the
openocd instance. For example, it should look something like this
```
[user@host RIOT]$ cd examples/default/
[user@host default]$ BOARD=iotlab-m3 make
Building application default for iotlab-m3 w/ MCU stm32f1.
...
[user@hostdefault]$ BOARD=iotlab-m3 make debug
RIOT/boards/hikob-common/dist/debug.sh RIOT/boards/iotlab-m3/dist/gdb.conf
RIOT/examples/default/bin/iotlab-m3/default.elf
Open On-Chip Debugger 0.8.0 (2014-07-27-20:18)
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.4.1.20140401-cvs
Copyright (C) 2012 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=x86_64-apple-darwin10 --target=arm-none-
eabi".
For bug reporting instructions, please see:
<http://www.gnu.org/software/gdb/bugs/>...
Reading symbols from RIOT/examples/default/bin/iotlab-m3/default.elf...done.
idle_thread (arg=<optimized out>) at RIOT/core/kernel_init.c:67
67 lpm_set(LPM_IDLE);
JTAG tap: stm32f1x.cpu tap/device found: 0x3ba00477 (mfg: 0x23b, part:
0xba00, ver: 0x3)
JTAG tap: stm32f1x.bs tap/device found: 0x06414041 (mfg: 0x020, part: 0x6414,
ver: 0x0)
target state: halted
target halted due to debug-request, current mode: Thread
xPSR: 0x01000000 pc: 0x0800027c msp: 0x20002200
Loading section .text, size 0x6df4 lma 0x8000000
Loading section .ARM.exidx, size 0x8 lma 0x8006df4
Loading section .relocate, size 0x120 lma 0x8006dfc
Start address 0x8000000, load size 28444
Transfer rate: 11 KB/sec, 7111 bytes/write.
(gdb) c
Continuing.
```
The node will reboot and you can continue to use `gdb` like you're used to.
In some cases it
seems necessary to prepend a `monitor reset run` before executing continue.
In general you can
use openocd commands prepended by `monitor`.
In the case the node crashes it can be reseted with the following sequence
```
Bash
(gdb) monitor reset halt
(gdb) monitor reset run
```
## Troubleshooting
For terminal output on OS X (`make term`) you need to install a driver:
http://www.ftdichip.com/Drivers/VCP.htm
http://www.ftdichip.com/Drivers/VCP.htm
*/

85
boards/limifrog-v1/doc.txt Normal file
View File

@ -0,0 +1,85 @@
/**
@defgroup boards_limifrog-v1 LimiFrog Version 1
@ingroup boards
@brief Support for the limifrog-v1 board
## Overview
LimiFrog-v1 arose from the La BlueFrog board. LimiFrog-v1 contains the first
hardware revision of that kickstarter project. LimiFrog-v2 is already there and
the RIOT support will follow. [LimiFrog](http://www.limifrog.io/home-en-
kickstarter/) features a variety of sensors as well as an OLED Display and a BLE
(Bluetooth Low-Energy) module.
## Hardware
![Limifrog-v1](http://www.limifrog.io/wordpress/wp-content/uploads/2015/07/LeadingPhoto-W500px.jpg)
![limifrog-v1 pinout](https://raw.githubusercontent.com/wiki/RIOT-OS/RIOT/images/limifrog-v1_pinout.png)
### MCU
| MCU | STM32L151RC |
|:------------- |:--------------------- |
| Family | ARM Cortex-M3 |
| Vendor | ST Microelectronics |
| RAM | 32Kb |
| Flash | 256Kb |
| Frequency | 32MHz (no external oscilator connected) |
| FPU | no |
| Timers | 8 (8x 16-bit, 1x 32-bit [TIM5]) |
| ADCs | 1x 42-channel 12-bit |
| UARTs | 3 |
| SPIs | 2 |
| I2Cs | 2 |
| Vcc | 1.65V - 3.6V |
| Datasheet | [Datasheet](http://www.st.com/st-web-ui/static/active/en/resource/technical/document/datasheet/DM00048356.pdf) |
| Reference Manual | [Reference Manual](http://www.st.com/web/en/resource/technical/document/reference_manual/CD00240193.pdf) |
| Programming Manual | [Programming Manual](http://www.st.com/web/en/resource/technical/document/programming_manual/CD00228163.pdf) |
## User Inferface
2 Buttons:
| PIN |
|:----- |
| PA15 (IN) |
| PC8 (IN) |
1 LED:
| NAME | LED_RED|
| ----- | ----- |
| Color | red |
| Pin | PC3 |
## Implementation Status
| Device | ID | Supported | Comments |
|:------------- |:------------- |:------------- |:------------- |
| MCU | STM32L151RC | partly | Energy saving modes not fully utilized |
| Low-level driver | GPIO | yes | |
| | PWM | yes | |
| | UART | yes | |
| | I2C | yes | |
| | SPI | yes | |
| | Timer | yes | |
| Ambient Light Sensor| ST VL6180X | no | planned|
| Accelerometer | ST LSM6DS3 | no | planned |
| Magnetometer | ST LIS3MDL | no | planned |
| Gyroscope | ST LSM6DS3 | no | planned |
| atmospheric pressure (and altitude) sensor | ST SLPS25H | no | planned |
| Microphone | Knowles SPU0414HR5H-SB | no | planned |
| OLED Display | Densitron DD-160128FC-1A | no | planned |
| BLE | Panasonic PAN1740 | no | planned |
## Flashing and Debugging the device
The LimiFrog-v1 has no on-board programmer nor an USB-UART converter. It can
be programmed by using the integrated ST-Link/V2 programmer of any STM32Fx-
discovery board. See Hardware section [here](@ref boards_yunjia-nrf51822) for an example.
Another way is to use a stand-alone ST-Link V2 programmer as shown in the
picture.
![limifrog-v1 wiring](https://raw.githubusercontent.com/wiki/RIOT-OS/RIOT/images/limifrog-v1_wiring.png)
![limifrog-v1](https://raw.githubusercontent.com/wiki/RIOT-OS/RIOT/images/limifrog-v1_conntected.png)
To debug the device you may also want to use a stand-alone UART converter and
connect it to the pins PC10 and PC11 and keep the programmer plugged.
*/

5
boards/maple-mini/doc.txt Normal file
View File

@ -0,0 +1,5 @@
/**
@defgroup boards_maple-mini maple-mini
@ingroup boards
@brief Support for the maple-mini board
*/

26
boards/mbed_lpc1768/doc.txt Normal file
View File

@ -0,0 +1,26 @@
/**
@defgroup boards_mbed_lpc1768 mbed LPC1768 development kit
@ingroup boards
@brief Support for the mbed LPC1762 board
# Overview
*missing*
# Hardware
| MCU | LPC1768 |
|:------------- |:--------------------- |
| Family | ARM Cortex-M3 |
| Vendor | NXP |
| RAM | 64kB SRAM |
| Flash | 512kB |
| Frequency | up to 100MHz |
| Datasheet | [Datasheet](http://www.nxp.com/documents/data_sheet/LPC1769_68_67_66_65_64_63.pdf) |
| User Manual | [User Manual](http://www.nxp.com/documents/user_manual/UM10360.pdf)|
*missing*
# Known Issues
* Does not compile with the mentor graphics toolchain (compare
https://github.com/RIOT-OS/RIOT/issues/751)
*/

70
boards/mega-xplained/doc.txt
View File

@ -1,37 +1,37 @@
/**
* @defgroup boards_mega-xplained Mega1284P-Xplained
* @ingroup boards
* @brief Support for the Mega1284P-Xplained board.
*
* ### General information
*
* The [Mega1284P-Xplained](http://www.microchip.com/DevelopmentTools/ProductDetails.aspx?PartNO=atmega1284p-xpld)
* is an evaluation kit by Atmel (now Microchip) for their ATmega1284P microcontroller.
*
* ### Flash the board
*
* 1. The board may be flashed through JTAG or using a SPI ISP programmer. If
* the Buspirate is being used, then `make flash` can be used to flash the
* board:
* ```
* make BOARD=mega-xplained -C examples/hello-world flash
* ```
*
* 2. The default fuse settings must also be changed.<br/>
* If using the Buspirate:
* ```
* avrdude -p m1284p -c buspirate -P /dev/ttyUSB0 -U efuse:w:0xFF:m
* avrdude -p m1284p -c buspirate -P /dev/ttyUSB0 -U hfuse:w:0x99:m
* avrdude -p m1284p -c buspirate -P /dev/ttyUSB0 -U lfuse:w:0xE2:m
* ```
* WARNING: setting the fuses incorrectly can brick your board!
*
* ### Accessing STDIO via UART
*
* STDIO can be accessed through the USB connector. The on-board UART-USB
* adapter is not affected by flashing. It shows up as /dev/ttyACM0 on Linux.
* It will be used automatically with `make term`:
* ```
* make BOARD=mega-xplained -C examples/hello-world term
* ```
@defgroup boards_mega-xplained Mega1284P-Xplained
@ingroup boards
@brief Support for the Mega1284P-Xplained board.
### General information
The [Mega1284P-Xplained](http://www.microchip.com/DevelopmentTools/ProductDetails.aspx?PartNO=atmega1284p-xpld)
is an evaluation kit by Atmel (now Microchip) for their ATmega1284P microcontroller.
### Flash the board
1. The board may be flashed through JTAG or using a SPI ISP programmer. If
the Buspirate is being used, then `make flash` can be used to flash the
board:
```
make BOARD=mega-xplained -C examples/hello-world flash
```
2. The default fuse settings must also be changed.<br/>
If using the Buspirate:
```
avrdude -p m1284p -c buspirate -P /dev/ttyUSB0 -U efuse:w:0xFF:m
avrdude -p m1284p -c buspirate -P /dev/ttyUSB0 -U hfuse:w:0x99:m
avrdude -p m1284p -c buspirate -P /dev/ttyUSB0 -U lfuse:w:0xE2:m
```
WARNING: setting the fuses incorrectly can brick your board!
### Accessing STDIO via UART
STDIO can be accessed through the USB connector. The on-board UART-USB
adapter is not affected by flashing. It shows up as /dev/ttyACM0 on Linux.
It will be used automatically with `make term`:
```
make BOARD=mega-xplained -C examples/hello-world term
```
*/

80
boards/microbit/doc.txt Normal file
View File

@ -0,0 +1,80 @@
/**
@defgroup boards_microbit BBC micro:bit
@ingroup boards
@brief Support for the BBC micro:bit
## Overview
The [micro:bit](https://www.microbit.co.uk/) was designed by the BBC and
released in 2015. The boards was distributed to all 11-12 year old children
throughout the UK.
The board is based on the Nordic nRF51822 SoC, featuring 16Kb of RAM, 256Kb
of ROM, and a 2.4GHz radio, that supports Bluetooth Low Energy (BLE) as well as
a Nordic proprietary radio mode.
Additionally the boards features 2 buttons, a 5x5 LED matrix, a MAG3110
3-axis magnetometer, and a MMA8653 3-axis accelerometer.
## Hardware
![micro:bit](https://github.com/RIOT-OS/RIOT/wiki/images/board_microbit.png)
| MCU | NRF51822QFAA |
|:------------- |:--------------------- |
| Family | ARM Cortex-M0 |
| Vendor | Nordic Semiconductor |
| RAM | 16Kb |
| Flash | 256Kb |
| Frequency | 16MHz |
| FPU | no |
| Timers | 3 (2x 16-bit, 1x 32-bit [TIMER0]) |
| ADCs | 1x 10-bit (8 channels) |
| UARTs | 1 |
| SPIs | 2 |
| I2Cs | 2 |
| Vcc | 1.8V - 3.6V |
| Reference Manual | [Reference Manual](http://infocenter.nordicsemi.com/pdf/nRF51_RM_v3.0.pdf) |
## Flashing and Debugging
There are two possibilities to flash the board: using the default ARM DAPLink
or you can flash the board using Segger's JLink.
### DAPLink
The [DAPLink interface](https://www.mbed.com/en/development/hardware/prototyping-production/daplink/daplink-on-kl26z/) is the default way to flash the board and
works out of the box. When you plug the board to your host computer, it shows up
as a flash drive. To flash the board, you can simply copy your compiled `.hex`
file onto the board, and thats it.
The `micro:bit` port comes with a little script that does this automatically,
so you can flash the board as usual with
```
bash
make flash
```
The DAPLink interface provides however not means for debugging the board.
### JLink
Recently, Segger released a JLink firmware for the interface MCU on the
`micro:bit`. You have to follow [these instructions](https://www.segger.com/bbc-micro-bit.html) to flash the JLink firmware on your `micro:bit`. Don't worry,
the process is very simple and you can revert the firmware back to the DAPLink
default anytime ([as described here](https://www.mbed.com/en/development/hardware/prototyping-production/daplink/daplink-on-kl26z/)).
Once you have flashed the JLink firmware, you can flash the board like this:
```
bash
FLASHTOOL=jlink make flash
```
With the JLink firmware, you can now also do in-circuit debugging etc.
**Note: The current version of the JLink firmware
(JLink_OB_BBC_microbit_16-07-29.hex) does not support any serial port over USB,
so you can not use the RIOT shell with this firmware.**
*/

5
boards/mips-malta/doc.txt Normal file
View File

@ -0,0 +1,5 @@
/**
@defgroup boards_mips-malta MIPS MALTA
@ingroup boards
@brief Support for the MIPS Malta FPGA system
*/

5
boards/msb-430/doc.txt Normal file
View File

@ -0,0 +1,5 @@
/**
@defgroup boards_msb430 MSB-430
@ingroup boards
@brief Support for the ScatterWeb MSB-430 board
*/

62
boards/msb-430h/doc.txt Normal file
View File

@ -0,0 +1,62 @@
/**
@defgroup boards_msb430h MSB-430H
@ingroup boards
@brief Support for the ScatterWeb MSB-430H board
## Hardware
![ScatterWeb MSB-430H](http://riot-os.org/images/msb-430h_2.png)
## MCU
| MCU | TI MSP430F1612 |
|:------------- |:--------------------- |
| Family | MSP430 |
| Vendor | Texas Instruments |
| Package | 64 QFN |
| RAM | 5Kb |
| Flash | 55Kb |
| Frequency | 8MHz |
| FPU | no |
| Timers | 2 (2x 16bit) |
| ADCs | 1x 8 channel 12-bit |
| UARTs | 2 |
| SPIs | 2 |
| I2Cs | 1 |
| Vcc | 2.0V - 3.6V |
| Datasheet / Reference Manual | [Datasheet](http://www.mi.fu-berlin.de/inf/groups/ag-tech/projects/Z_Finished_Projects/ScatterWeb/moduleComponents/msp430f1612.pdf?1346661398) |
| User Guide | [User Guide](http://www.mi.fu-berlin.de/inf/groups/ag-tech/projects/Z_Finished_Projects/ScatterWeb/moduleComponents/MSP430slau049f.pdf?1346661398)|
## Radio
| RF Chip | Texas Instruments® CC1100 |
|:-------------------- |:------------------------- |
| Frequency Band | 300-348MHz, 400-464 MHz, and 800-928 MHz |
| Standard compliance | DASH7 compliant |
| Receive Sensitivity | -94dBm typ |
| Transfer Rate | 500kBaud |
| RF Power | -30dBm ~ 10dBm |
| Current Draw | RX: 14.4mA TX: 16.9mA Sleep mode: 400nA |
| RF Power Supply | 2.1V ~ 3.6V |
| Antenna | Dipole Antenna / PCB Antenna |
| Datasheet | [Datasheet](http://www.ti.com/lit/gpn/cc1100) |
## Flashing RIOT
Flashing RIOT on the MSB-430H is quite straight forward, just connect your
board using a JTAG adapter (either the original one from TI or an [Olimex
version](https://www.olimex.com/Products/MSP430/JTAG/)) to your host computer
and type:
`make flash`
This should take care of everything!
## Using the shell
The shell is using the UART interface of the MSB-430H at 115200 baud. You
need a 3.3V TTL serial cable. For USB connections you could use a [FTDI connector](http://apple.clickandbuild.com/cnb/shop/ftdichip?productID=53&op=catalogue-product_info-null&prodCategoryID=105)
## More information
[FU Berlin info page on the MSB-430H](http://www.mi.fu-berlin.de/inf/groups/ag-tech/projects/Z_Finished_Projects/ScatterWeb/modules/mod_MSB-430H.html)
*/

71
boards/msba2/doc.txt Normal file
View File

@ -0,0 +1,71 @@
/**
@defgroup boards_msba2 MSB-A2
@ingroup boards
@brief Support for the ScatterWeb MSB-A2 board
## Overview
![MSBA2 image](https://raw.githubusercontent.com/wiki/RIOT-
OS/RIOT/images/MSBA2_photo.jpg)
## Hardware
| MCU: | LPC2387 ARM7-TDMI |
|------|-------------------|
| RAM: | 96kb |
| Flash: | 512kb |
# More info
## Board Schematics
![Board schematics](https://raw.githubusercontent.com/wiki/RIOT-OS/RIOT/images/MSBA2_layout.png)
## Circuit Diagrams
![Circuit Diagram](https://raw.githubusercontent.com/wiki/RIOT-OS/RIOT/images/MSBA2_circuit_front.png)
![Circuit Diagram II](https://raw.githubusercontent.com/wiki/RIOT-OS/RIOT/images/MSBA2_circuit_back.png)
[MSB-A2 page @ Freie Universität Berlin/CST](http://www.mi.fu-berlin.de/inf/groups/ag-tech/projects/Z_Finished_Projects/ScatterWeb/modules/mod_MSB-A2.html)
## Toolchains
See: [ARM](https://github.com/RIOT-OS/RIOT/wiki/Family:-ARM)
Working:
- CodeSourcery 2013.11
- CodeSourcery 2014.05 (only hello-world tested)
- CodeSourcery 2008q3
- [GNU Tools for ARM Embedded Processors](https://launchpad.net/gcc-arm-embedded) 5.2.1 20151202 (release) (only [`default`](https://github.com/RIOT-OS/RIOT/tree/master/examples/default) tested)
Not Working:
- Arm launchpad 2013-2
- [GNU Tools for ARM Embedded Processors](https://launchpad.net/gcc-arm-embedded) 4.8.4 2014q2 (release)
## Programming and Debugging
Currently the MSBA2 boards only work properly™ with a CodeSourcery toolchain.
##### lpc2k_pgm
In order to flash the MSBA2 board you also need the `lpc2k_pgm` tool. You can
build it by navigating to the `boards/msba2-common/tools` directory and then
running `make`. The tool will be created inside the `bin/` sub-directory and has
to be copied to a directory inside the `$PATH`.
##### flashing/debugging
Build using the following set of commands:
BOARD=msba2 make flash
BOARD=msba2 make term
## Known Issues
None
*/

348
boards/msbiot/doc.txt Normal file
View File

@ -0,0 +1,348 @@
/**
@defgroup boards_msbiot MSB-IoT
@ingroup boards
@brief Support for the MSB-IoT board
# Overview
The MSB-IoT was developed at FU Berlin and is based on a STM32F415RG MCU.
![MSB-IoT](https://raw.githubusercontent.com/wiki/RIOT-OS/RIOT/images/msbiot-components.png)
# 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](http://www.st.com/web/catalog/mmc/FM141/SC1169/SS1577/LN1035/PF252143?sc=internet/mcu/product/252143.jsp).
| 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](http://www.st.com/st-web-ui/static/active/en/resource/technical/document/datasheet/DM00035129.pdf) |
| Reference Manual | [Reference Manual](http://www.st.com/st-web-ui/static/active/en/resource/technical/document/reference_manual/DM00031020.pdf)|
| Programming Manual | [Programming Manual](http://www.st.com/st-web-ui/static/active/en/resource/technical/document/programming_manual/DM00046982.pdf) |
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](https://github.com/RIOT-OS/RIOT/tree/master/cpu/stm32f4/periph) and corresponding
[Interfaces](https://github.com/RIOT-OS/RIOT/tree/master/drivers/include/periph)
* Main [STM32F4 directory](https://github.com/RIOT-OS/RIOT/tree/master/cpu/stm32f4)
and [Cortex M4 directory](https://github.com/RIOT-OS/RIOT/tree/master/cpu/cortex-m4_common)
### RIOT pin mapping
The following picture shows the easily accessible pins of the board:
![MSB-IoT Pinout](https://raw.githubusercontent.com/wiki/RIOT-OS/RIOT/images/msbiot-pinout.png)
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](https://docs.google.com/spreadsheets/d/1RLn1j5h7VIQ1zezRs5Z3A7SYCMvEukHaKjhcsyrDz6g/pubhtml)
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](https://github.com/RIOT-OS/RIOT/tree/master/boards/msbiot/include).
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](https://github.com/RIOT-OS/RIOT/tree/master/boards/msbiot/include).
### 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](https://github.com/RIOT-OS/RIOT/blob/master/drivers/include/periph/gpio.h) 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](https://github.com/RIOT-OS/RIOT/blob/master/boards/msbiot/include/board.h).
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](https://github.com/RIOT-OS/RIOT/blob/master/drivers/include/periph/gpio.h) and
[PWM](https://github.com/RIOT-OS/RIOT/blob/master/drivers/include/periph/pwm.h)
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](https://github.com/RIOT-OS/RIOT/blob/master/boards/msbiot/Makefile.include)) 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](http://www.ti.com/lit/ds/symlink/cc1101.pdf)|
| Errata Sheet | [Errata Sheet](http://www.ti.com/lit/er/swrz020d/swrz020d.pdf) |
| Other Technical Documents | [TI Webpage](http://www.ti.com/product/CC1101/technicaldocuments) |
| Driver | [Implementation](https://github.com/RIOT-OS/RIOT/tree/master/drivers/cc110x) and [Interface](https://github.com/RIOT-OS/RIOT/tree/master/drivers/include/cc110x) |
| 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](http://software-dl.ti.com/ecs/simplelink/cc3000/public/doxygen_API/v1.14/html/index.html). 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](https://github.com/RIOT-OS/RIOT/pull/2603) for progress
on the inclusion.
| Product | CC3000 |
|:------------- |:--------------------- |
| Type | 802.11b/g Wi-Fi Module |
| Vendor | Texas Instruments |
| Datasheet | [Datasheet](http://www.ti.com/lit/ds/symlink/cc3000.pdf)|
| Errata Sheet | [Errata Sheet](http://www.ti.com/lit/er/swrz044b/swrz044b.pdf) |
| Other Technical Documents | [TI Webpage](http://www.ti.com/product/CC3000/technicaldocuments) |
| TI Wiki | [Wiki](http://processors.wiki.ti.com/index.php/CC3000) |
| Driver | [Pull Request](https://github.com/RIOT-OS/RIOT/pull/2603) |
| 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](https://github.com/RIOT-OS/RIOT/blob/master/drivers/include/mpu9150.h).
A sample RIOT application for the MPU-9150 that utilizes the driver can be
found [here](https://github.com/RIOT-OS/RIOT/tree/master/tests/driver_mpu9150).
| Product | MPU-9150 |
|:------------- |:--------------------- |
| Type | Nine-Axis MotionTracking Device (Gyro, Accel and Compass) |
| Vendor | Invensense |
| Product Specification | [Product Specification](http://www.invensense.com/mems/gyro/documents/PS-MPU-9150A-00v4_3.pdf) |
| Register Map | [Register Map](http://www.invensense.com/mems/gyro/documents/RM-MPU-9150A-00v4_2.pdf) |
| Driver | [Implementation](https://github.com/RIOT-OS/RIOT/tree/master/drivers/mpu9150) and [Interface](https://github.com/RIOT-OS/RIOT/blob/master/drivers/include/mpu9150.h) |
| 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](http://www.ti.com/product/tca6416)
* 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](https://launchpad.net/gcc-arm-embedded) 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](http://openocd.org/) tool. A wiki page with
installation instructions and some other information can be found
[here](https://github.com/RIOT-OS/RIOT/wiki/OpenOCD).
### Quick start
For a quick getting started guide you can stick to the steps explained on
[this page](https://github.com/RIOT-OS/RIOT/wiki/Getting-started-with-STM32F%5B0%7C3%7C4%5Ddiscovery-boards). Just make sure to use "msbiot" as the
respective board name.
### Compiling
```
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
```
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
```
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.
*/

72
boards/mulle/doc.txt Normal file
View File

@ -0,0 +1,72 @@
/**
@defgroup boards_mulle Eistec Mulle
@ingroup boards
@brief Support for Eistec Mulle IoT boards
![Mulle](http://eistec.github.io/images/mulle-small.jpg)
The Mulle is a miniature wireless Embedded Internet System suitable for
wireless sensors connected to the Internet of Things, and designed for rapid
prototyping. It can be bought directly from [Eistec AB](http://www.eistec.se).
- [Official homepage](http://www.eistec.se/mulle)
- [Eistec wiki](https://github.com/eistec/mulle/wiki)
Use `BOARD=mulle` for building RIOT for this platform.
## Components
https://github.com/eistec/mulle/wiki/Datasheets contains a list of relevant
documentation for the components.
| MCU | MK60DN512VLL10 – Cortex-M4 |
|-------|-----------------------------------|
| RAM | 64kB |
| Flash | 512kB|
| radio chipset | AT86RF212B, sub-GHz IEEE802.15.4 transceiver, similar to the AT86RF233 |
| external flash memory | Micron M25P16 16 Mbits external NOR flash, used for storing configuration, measurements and other slow changing non-volatile data |
| external FRAM memory | Cypress/Ramtron FM25L04B 4 Kbits external F-RAM, used for storing counters and other rapidly changing non-volatile data |
| accelerometer | ST micro LIS3DH MEMS accelerometer, |
## Layout
## Implementation Status
The Mulle board is supported by mainline RIOT. See the below table for
software support status for the different components.
| Device | ID | Supported | Comments |
|:------------- |:------------- |:------------- |:------------- |
| MCU | MK60DN512VLL10 | partly | See below |
| Low-level driver | GPIO | yes | |
| | PWM | yes | |
| | UART | yes | |
| | I2C | yes | |
| | SPI | yes |Master mode works, slave mode unsupported |
| | USB | no | [PR#3890](https://github.com/RIOT-OS/RIOT/pull/3890) |
| | RTT | yes | |
| | RNG | yes | |
| | timer | yes | uses LPTMR module for TIMER_0 (used by xtimer), 32.768 kHz tick rate. PIT for additional timers, F_BUS tick rate (48 MHz default) |
| | PM/LLWU | in progress | [PR#2605](https://github.com/RIOT-OS/RIOT/pull/2605) |
| Radio Chip | AT86RF212B | yes | |
| Accelerometer | LIS3DH | yes | |
| Flash | M25P16 | in progress | [PR#6762](https://github.com/RIOT-OS/RIOT/pull/6762) |
| FRAM | FM25L04B | yes | |
## Toolchains
See [ARM Family](https://github.com/RIOT-OS/RIOT/wiki/Family:-ARM), and
[Eistec wiki - Installing-toolchain (GCC)](https://github.com/eistec/mulle/wiki/Installing-toolchain-%28GCC%29)
Working:
* [gcc-arm-embedded](https://github.com/RIOT-OS/RIOT/wiki/Family:-ARM#gcc-arm-embedded-toolchain)
* Clang 3.4 - Clang 4.0 - Install procedure not documented but pretty
straightforward, Makefiles and build system is fully functional with Clang.
### Programming and Debugging
See [Eistec wiki](https://github.com/eistec/mulle/wiki).
*/

19
boards/native/doc.txt Normal file
View File

@ -0,0 +1,19 @@
/**
@defgroup boards_native Native Board
@ingroup boards
[Family: native](https://github.com/RIOT-OS/RIOT/wiki/Family:-native)
# Overview
![Terminal running RIOT native](https://raw.githubusercontent.com/wiki/RIOT-
OS/RIOT/images/Native.jpg)
# Hardware
- CPU: Host CPU
- RAM: Host RAM
- Flash: Host file system
- Network: Tap Interface
- UART: Runtime configurable - `/dev/tty*` are supported
- Timers: Host timer
- LEDs: One red and one green LED - state changes are printed to the UART
*/

54
boards/nrf51dongle/doc.txt Normal file
View File

@ -0,0 +1,54 @@
/**
@defgroup boards_nrf51dongle nRF51 Dongle
@ingroup boards
@brief Support for the Nordic nRF51 Dongle
## Overview:
The nRF51822 is a multi-protocol SoC ideally suited for Bluetooth® low energy
and 2.4GHz ultra low-power wireless applications from Nordic Semiconductor. The
nRF51822 is built around a 32-bit ARM® Cortex™ M0 CPU with 256kB flash + 16kB
RAM. The embedded 2.4GHz transceiver supports Bluetooth low energy as well as
2.4GHz operation.
Nordic's development kit contains two different boards:
- **pca10000**: a USB-dongle containing the nRF51822 and a RGB-Led
- **pca10005**: two a basic nRF51822 boards making the MCU pins available
While the pca10000 contains an on-board J-Link debugger, the pca10005 boards
have to be flashed/debugged using the (included) external J-Link device.
## Hardware:
![Nordic Semiconductor nrF51822 Development Kit](https://www.nordicsemi.com/var/ezwebin_site/storage/images/media/images/products/nrf51822-dk/422047-1-eng-GB/nRF51822-DK.jpg)
| MCU | NRF51822QFAA |
|:------------- |:--------------------- |
| Family | ARM Cortex-M0 |
| Vendor | Nordic Semiconductor |
| RAM | 16Kb |
| Flash | 256Kb |
| Frequency | 16MHz |
| FPU | no |
| Timers | 3 (2x 16-bit, 1x 32-bit [TIMER0]) |
| ADCs | 1x 10-bit (8 channels) |
| UARTs | 1 |
| SPIs | 2 |
| I2Cs | 2 |
| Radio | 2.4GHz BLE compatiple, +4dBm to -20 dBm output, -93 dBm RX sensitivity |
| Vcc | 1.8V - 3.6V |
| Datasheet | [Datasheet](http://www.freqchina.com/cn/down.asp?ID=135) (pdf file) |
| Reference Manual | [Reference Manual](http://www.100y.com.tw/pdf_file/39-Nordic-NRF51822.pdf) |
## Flashing the Device:
The nRF51822 PC10000 board is shipped with an on-board JLink debugger.
However the PC10004/5 board uses an external flash tool as seen in the Image
above. Under Linux, the easiest way flashing the nRF51822 is using the JLink
tool(version >4.85) from [Segger](http://www.segger.com/jlink-software.html).
To interact with the board just start the tool using the following command:
`# JLinkExe -device nrf51822`
For RIOT itself there is a Flash-Script available. When using any of the
Examples type in the following command:
`# Make -B clean flash`
*/

5
boards/nrf52840dk/doc.txt Normal file
View File

@ -0,0 +1,5 @@
/**
@defgroup boards_nrf52840dk nRF52840 DK
@ingroup boards
@brief Support for the nRF52840 DK
*/

98
boards/nrf52dk/doc.txt Normal file
View File

@ -0,0 +1,98 @@
/**
@defgroup boards_nrf52dk nRF52 DK
@ingroup boards
@brief Support for the nRF52 DK
## Overview:
There are some nameless simple development Boards with an nRF52832 available.
These boards providing access to most SoC ports. There are two buttons (RST,
KEY), two LED’s (Pin 30, 31), a voltage regulator and a current messurment shunt
on board. A serial connection and flashing must be provided by external
Hardware.
The nRF52832 is a SoC with a 32-bit ARM® Cortex™-M4F CPU with 512kB Flash and
64kB RAM. The embedded 2.4GHz transceiver supports Bluetooth low energy, ANT and
proprietary 2.4 GHz protocol stack. It is on air compatible with the nRF51
Series, nRF24L and nRF24AP Series products from Nordic Semiconductor.
## Hardware:
![nRF52 minimal development
board](https://github.com/d00616/temp/raw/master/nrf52-minidev.jpg)
| MCU | NRF52832 |
|:------------- |:--------------------- |
| Family | ARM Cortex-M4F |
| Vendor | Nordic Semiconductor |
| RAM | 64Kb |
| Flash | 512Kb |
| Frequency | 64MHz |
| FPU | yes |
| Timers | 5 (32-bit) |
| RTC | 3 |
| ADCs | 1x 12-bit (8 channels) |
| UARTs | 1 |
| SPIs | 3 |
| I2Cs | 2 |
| I2S | 1 |
| PWM | 3*4 Channels |
| Radio | 2.4GHz BLE compatiple, -20 dBm to +4 dBm output, -96 dBm RX sensitivity |
| Vcc | 1.7V - 3.6V |
| Datasheet | [Datasheet](https://www.nordicsemi.com/eng/Products/Bluetooth-low-energy/nRF52832) |
| Reference Manual | [Reference Manual](http://infocenter.nordicsemi.com/index.jsp?topic=%2Fcom.nordic.infocenter.nrf52%2Fdita%2Fnrf52%2Fnrf52_series.html&cp=1) |
##Pin layout
|MCU pin|Board pin|Function|
|:-----------|:-----------|:----------|
|P0.0| n.c. | |
|P0.1| n.c. | |
|P0.2| D07 | |
|P0.3| D08 | |
|P0.4| D09 | KEY |
|P0.5| D10 | |
|P0.6| D13 | |
|P0.7| D14 | |
|P0.8| D15 | |
|P0.9| n.c. | |
|P0.10| n.c. | NFC antenna 2 (unusable) |
|P0.11| D18 | RXD (software defined) |
|P0.12| D19 | TXD (software defined) |
|P0.13| D20 | |
|P0.14| D21 | |
|P0.15| D22 | |
|P0.16| D23 | |
|P0.17| D24 | |
|P0.18| D25 | |
|P0.19| D26 | |
|P0.20| D27 | |
|P0.21| RST | RESET |
|P0.22| D28 | near Radio! -> Low drive, low frequency I/O only. |
|P0.23| D29 | near Radio! -> Low drive, low frequency I/O only. |
|P0.24| D30 | near Radio! -> Low drive, low frequency I/O only. |
|P0.25| D00 | near Radio! -> Low drive, low frequency I/O only. |
|P0.26| D01 | near Radio! -> Low drive, low frequency I/O only. |
|P0.27| D02 | near Radio! -> Low drive, low frequency I/O only. |
|P0.28| D03 | near Radio! -> Low drive, low frequency I/O only. |
|P0.29| D04 | near Radio! -> Low drive, low frequency I/O only. |
|P0.30| D05 | LED0, near Radio! -> Low drive, low frequency I/O only. |
|P0.31| D06 | LED1, near Radio! -> Low drive, low frequency I/O only. |
| | V33 | 3.3V for MCU |
| | D16 | ? |
| | D17 | ? |
| | VBUS | 5V input |
| | GND | |
| | RXD | n.c. |
| | TXD | n.c. |
| | TD0 | n.c. |
| | TD1 | n.c. |
| SWDIO | TMS | |
| SWCLK | TCK | |
**Caution**: NFC is not usable with this board.
## Current measurement:
There are two pins for current measurement on board. Don't connect these pins
to GND!. The left pin is at 3.3V level and the right pin is connected to V33.
Divide the measured voltage between this pins by 22 to get the current.
*/

5
boards/nrf6310/doc.txt Normal file
View File

@ -0,0 +1,5 @@
/**
@defgroup boards_nrf6310 NRF6310 (Nordic NRF Hardware Development Kit)
@ingroup boards
@brief Support for the nRF51 boards: nrf6310 or MOMMOSOFT BLE DEVKIT.N
*/

74
boards/nucleo-f030r8/doc.txt Normal file
View File

@ -0,0 +1,74 @@
/**
@defgroup boards_nucleo-f030r8 STM32 Nucleo-F030R8
@ingroup boards_common_nucleo64
@brief Support for the STM32 Nucleo-F030R8
## Overview
The Nucleo-F030 is a board from ST's Nucleo family supporting a ARM Cortex-M0
STM32F030R8 microcontroller with 8Kb of SRAM and 64Kb of ROM Flash.
## Hardware
![Nucleo64 F030](http://www.open-electronics.org/wp-
content/uploads/2015/08/Figura2-500x467.png)
### MCU
| MCU | STM32F030R8 |
|:------------- |:--------------------- |
| Family | ARM Cortex-M0 |
| Vendor | ST Microelectronics |
| RAM | 8Kb |
| Flash | 64Kb |
| Frequency | up to 48MHz) |
| FPU | yes |
| Timers | 11 (2x watchdog, 1 SysTick, 8x 16-bit) |
| ADCs | 1x 12-bit |
| UARTs | 6 |
| SPIs | 2 |
| I2Cs | 2 |
| RTC | 1 |
| Vcc | 2.0V - 3.6V |
| Datasheet | [Datasheet](http://www.st.com/en/evaluation-tools/nucleo-f030r8.html) |
| Reference Manual | [Reference Manual](http://www.st.com/resource/en/datasheet/stm32f030r8.pdf) |
| Programming Manual | [Programming Manual](http://www.st.com/resource/en/programming_manual/dm00051352.pdf) |
| Board Manual | [Board Manual](http://www.st.com/resource/en/user_manual/dm00105823.pdf)|
## Implementation Status
| Device | ID | Supported | Comments |
|:------------- |:------------- |:------------- |:------------- |
| MCU | STM32F030R8 | partly | Energy saving modes not fully utilized |
| Low-level driver | GPIO | yes | |
| | PWM | yes (4 pins available) | |
| | UART | 2 UARTs | USART2 via STLink/USB or D0(RX)/D1(TX) and USART1 on PA10(RX)/PA09(TX) |
| | ADC | 6 pins | |
| | I2C | no | |
| | SPI | no | |
| | USB | no | |
| | Timer | 3 16 bit timers | |
## Flashing the device
The ST Nucleo-F030 board includes an on-board ST-LINK V2 programmer. The
easiest way to program the board is to use OpenOCD. Once you have installed
OpenOCD (look [here](https://github.com/RIOT-OS/RIOT/wiki/OpenOCD) for
installation instructions), you can flash the board simply by typing
```
make BOARD=nucleo-f030 flash
```
and debug via GDB by simply typing
```
make BOARD=nucleo-f030 debug
```
## Supported Toolchains
For using the ST Nucleo-F030 board we strongly recommend the usage of the
[GNU Tools for ARM Embedded Processors](https://launchpad.net/gcc-arm-embedded)
toolchain.
*/

5
boards/nucleo-f031k6/doc.txt Normal file
View File

@ -0,0 +1,5 @@
/**
* @defgroup boards_nucleo-f031k6 STM32 Nucleo-F031K6
* @ingroup boards_common_nucleo32
* @brief Support for the STM32 Nucleo-F031K6
*/

5
boards/nucleo-f042k6/doc.txt Normal file
View File

@ -0,0 +1,5 @@
/**
* @defgroup boards_nucleo-f042k6 STM32 Nucleo-F042K6
* @ingroup boards_common_nucleo32
* @brief Support for the STM32 Nucleo-F042K6
*/

74
boards/nucleo-f070rb/doc.txt Normal file
View File

@ -0,0 +1,74 @@
/**
@defgroup boards_nucleo-f070rb STM32 Nucleo-F070RB
@ingroup boards_common_nucleo64
@brief Support for the STM32 Nucleo-F070RB
## Overview
The Nucleo-F070 is a board from ST's Nucleo family supporting a ARM Cortex-M0
STM32F070RB microcontroller with 16Kb of SRAM and 128Kb of ROM Flash.
## Hardware
![Nucleo64 F070](http://www.open-electronics.org/wp-
content/uploads/2015/08/Figura2-500x467.png)
### MCU
| MCU | STM32F070RB |
|:------------- |:--------------------- |
| Family | ARM Cortex-M0 |
| Vendor | ST Microelectronics |
| RAM | 16Kb |
| Flash | 128Kb |
| Frequency | up to 48MHz) |
| FPU | yes |
| Timers | 11 (2x watchdog, 1 SysTick, 8x 16-bit) |
| ADCs | 1x 12-bit |
| UARTs | 4 |
| SPIs | 2 |
| I2Cs | 2 |
| RTC | 1 |
| Vcc | 2.0V - 3.6V |
| Datasheet | [Datasheet](http://www.st.com/en/evaluation-tools/nucleo-f070rb.html) |
| Reference Manual | [Reference Manual](http://www.st.com/resource/en/datasheet/stm32f070rb.pdf) |
| Programming Manual | [Programming Manual](http://www.st.com/resource/en/programming_manual/dm00051352.pdf) |
| Board Manual | [Board Manual](http://www.st.com/resource/en/user_manual/dm00105823.pdf)|
## Implementation Status
| Device | ID | Supported | Comments |
|:------------- |:------------- |:------------- |:------------- |
| MCU | STM32F070RB | partly | Energy saving modes not fully utilized |
| Low-level driver | GPIO | yes | |
| | PWM | yes (4 pins available) | |
| | UART | 3 UARTs | USART2 via STLink/USB or D0(RX)/D1(TX), USART1 on PA10(RX)/PA09(TX) and USART3 on PC11(RX)/PC10(TX) |
| | ADC | 6 pins | |
| | I2C | no | |
| | SPI | no | |
| | USB | no | |
| | Timer | 3 16 bit timers | |
## Flashing the device
The ST Nucleo-F070 board includes an on-board ST-LINK V2 programmer. The
easiest way to program the board is to use OpenOCD. Once you have installed
OpenOCD (look [here](https://github.com/RIOT-OS/RIOT/wiki/OpenOCD) for
installation instructions), you can flash the board simply by typing
```
make BOARD=nucleo-f070 flash
```
and debug via GDB by simply typing
```
make BOARD=nucleo-f070 debug
```
## Supported Toolchains
For using the ST Nucleo-F070 board we strongly recommend the usage of the
[GNU Tools for ARM Embedded Processors](https://launchpad.net/gcc-arm-embedded)
toolchain.
*/

73
boards/nucleo-f072rb/doc.txt Normal file
View File

@ -0,0 +1,73 @@
/**
@defgroup boards_nucleo-f072rb STM32 Nucleo-F072RB
@ingroup boards_common_nucleo64
@brief Support for the STM32 Nucleo-F072RB
## Overview
The Nucleo-F072 is a board from ST's Nucleo family supporting a ARM Cortex-M0
STM32F072RB microcontroller with 16Kb of SRAM and 128Kb of ROM Flash.
## Hardware
![Nucleo64 F072](http://www.open-electronics.org/wp-content/uploads/2015/08/Figura2-500x467.png)
### MCU
| MCU | STM32F072RB |
|:------------- |:--------------------- |
| Family | ARM Cortex-M0 |
| Vendor | ST Microelectronics |
| RAM | 16Kb |
| Flash | 128Kb |
| Frequency | up to 48MHz) |
| FPU | yes |
| Timers | 12 (2x watchdog, 1 SysTick, 8x 16-bit, 1x 32-bit) |
| ADCs | 1x 12-bit (up to 16 channels) |
| UARTs | 4 |
| SPIs | 2 |
| I2Cs | 2 |
| RTC | 1 |
| Vcc | 2.0V - 3.6V |
| Datasheet | [Datasheet](http://www.st.com/en/evaluation-tools/nucleo-f072rb.html) |
| Reference Manual | [Reference Manual](http://www.st.com/resource/en/datasheet/stm32f072rb.pdf) |
| Programming Manual | [Programming Manual](http://www.st.com/resource/en/reference_manual/dm00031936.pdf) |
| Board Manual | [Board Manual](http://www.st.com/resource/en/user_manual/dm00105823.pdf)|
## Implementation Status
| Device | ID | Supported | Comments |
|:------------- |:------------- |:------------- |:------------- |
| MCU | STM32F072RB | partly | Energy saving modes not fully utilized |
| Low-level driver | GPIO | yes | |
| | PWM | yes (4 pins available) | |
| | UART | 3 UARTs | USART2 via STLink/USB or D0(RX)/D1(TX), USART1 on PA10(RX)/PA09(TX) and USART3 on PC11(RX)/PC10(TX) |
| | PWM | 7 pins | |
| | ADC | 6 pins | |
| | I2C | no | |
| | SPI | yes (SPI1) | |
| | USB | no | |
| | Timer | 1 32 bit timers (TIM1) | |
## Flashing the device
The ST Nucleo-F072 board includes an on-board ST-LINK V2 programmer. The
easiest way to program the board is to use OpenOCD. Once you have installed
OpenOCD (look [here](https://github.com/RIOT-OS/RIOT/wiki/OpenOCD) for
installation instructions), you can flash the board simply by typing
```
make BOARD=nucleo-f072 flash
```
and debug via GDB by simply typing
```
make BOARD=nucleo-f072 debug
```
## Supported Toolchains
For using the ST Nucleo-F072 board we strongly recommend the usage of the
[GNU Tools for ARM Embedded Processors](https://launchpad.net/gcc-arm-embedded)
toolchain.
*/

88
boards/nucleo-f091rc/doc.txt Normal file
View File

@ -0,0 +1,88 @@
/**
@defgroup boards_nucleo-f091rc STM32 Nucleo-F091RC
@ingroup boards_common_nucleo64
@brief Support for the STM32 Nucleo-F091RC
## Overview
The Nucleo-F091 is a board from ST's Nucleo family supporting a ARM Cortex-M0
STM32F091 microcontroller with 32Kb of RAM and 256Kb of ROM.
## Hardware
![STM32F3discovery image](http://media.digikey.com/Photos/STMicro%20Photos/MFG_NUCLEO.jpg)
![nucleo-f091 pinout](https://raw.githubusercontent.com/wiki/RIOT-OS/RIOT/images/nucleo-f091_pinout.png)
### MCU
| MCU | STM32F091RC |
|:------------- |:--------------------- |
| Family | ARM Cortex-M0 |
| Vendor | ST Microelectronics |
| RAM | 32Kb |
| Flash | 256Kb |
| Frequency | up to 48MHz (using the on-board 8MHz Oszillator of the ST-Link) |
| FPU | no |
| Timers | 9 (8x 16-bit, 1x 32-bit [TIM2]) |
| ADCs | 1x 12-bit |
| UARTs | 8 |
| SPIs | 2 |
| I2Cs | 2 |
| Vcc | 2.0V - 3.6V |
| Datasheet | [Datasheet](http://www.st.com/web/en/resource/technical/document/datasheet/DM00115237.pdf) |
| Reference Manual | [Reference Manual](http://www.st.com/web/en/resource/technical/document/reference_manual/DM00031936.pdf) |
| Programming Manual | [Programming Manual](http://www.st.com/web/en/resource/technical/document/programming_manual/DM00051352.pdf) |
| Board Manual | [Board Manual](http://www.st.com/st-web-ui/static/active/en/resource/technical/document/user_manual/DM00105823.pdf)|
### RIOT static pin mapping
please refer to [this](https://docs.google.com/spreadsheets/d/1gnxsux5WpFrn-33Ivb9nGgTBqooqgDYxRkhZms-cvsc/edit?usp=sharing)
document for the pin mapping as implemenented in `boards/nucleo-f091/include/periph_conf.h`
### User Interface
1 Button:
| NAME | USER |
|:----- |:----- |
| Pin | PC13 |
1 LEDs:
| NAME | LED_GREEN |
| ----- | ------------- |
| Color | orange |
| Pin | PA5 |
## Implementation Status
| Device | ID | Supported | Comments |
|:------------- |:------------- |:------------- |:------------- |
| MCU | STM32F091RC | partly | Energy saving modes not fully utilized |
| Low-level driver | GPIO | no | |
| | PWM | no | |
| | UART | full | |
| | I2C | no | |
| | SPI | no | |
| | USB | no | |
| | Timer | full | |
## Flashing the device
The ST Nucleo-F091 board includes an on-board ST-LINK V2 programmer. The
easiest way to program the board is to use OpenOCD. Once you have installed
OpenOCD (look [here](https://github.com/RIOT-OS/RIOT/wiki/OpenOCD) for
installation instructions), you can flash the board simply by typing
```
make BOARD=nucleo-f091 flash
```
and debug via GDB by simply typing
```
make BOARD=nucleo-f091 debug
```
## Supported Toolchains
For using the ST Nucleo-F091 board we strongly recommend the usage of the
[GNU Tools for ARM Embedded Processors](https://launchpad.net/gcc-arm-embedded)
toolchain.
*/

68
boards/nucleo-f103rb/doc.txt Normal file
View File

@ -0,0 +1,68 @@
/**
@defgroup boards_nucleo-f103rb STM32 Nucleo-F103RB
@ingroup boards_common_nucleo64
@brief Support for the STM32 Nucleo-F103RB
## Overview
The Nucleo-F103 is a board from ST's Nucleo family supporting a ARM Cortex-M3
STM32F103RB microcontroller with 20Kb of SRAM and 128Kb of ROM Flash.
## Hardware
![Nucleo64 F103](http://www.open-electronics.org/wp-content/uploads/2015/08/Figura2-500x467.png)
### MCU
| MCU | STM32F103RB |
|:------------- |:--------------------- |
| Family | ARM Cortex-M3 |
| Vendor | ST Microelectronics |
| RAM | 20Kb |
| Flash | 128Kb |
| Frequency | up to 72MHz |
| FPU | yes |
| Timers | 7 (2x watchdog, 1 SysTick, 4x 16-bit) |
| ADCs | 1x 12-bit |
| UARTs | 3 |
| SPIs | 2 |
| I2Cs | 2 |
| RTC | 1 |
| Vcc | 2.0V - 3.6V |
| Datasheet | [Datasheet](http://www.st.com/en/evaluation-tools/nucleo-f103rb.html) |
| Reference Manual | [Reference Manual](http://www.st.com/resource/en/datasheet/stm32f103rb.pdf) |
| Programming Manual | [Programming Manual](http://www.st.com/resource/en/programming_manual/dm00051352.pdf) |
| Board Manual | [Board Manual](http://www.st.com/resource/en/user_manual/dm00105823.pdf)|
## Implementation Status
| Device | ID | Supported | Comments |
|:------------- |:------------- |:------------- |:------------- |
| MCU | STM32F103RB | partly | Energy saving modes not fully utilized |
| Low-level driver | GPIO | yes | |
| | PWM | yes (4 pins available) | |
| | UART | 2 UARTs | USART2 via STLink/USB or D0(RX)/D1(TX), USART1 on PA10(RX)/PA09(TX) and USART3 on PB11(RX)/PB10(TX) |
| | ADC | no | |
| | I2C | yes (I2C1 and I2C2) | |
| | SPI | yes (SPI1 and SPI2) | |
| | USB | no | |
| | Timer | 2 16 bit timers (TIM2 and TIM3) | |
## Flashing the device
The ST Nucleo-F103 board includes an on-board ST-LINK V2 programmer. The
easiest way to program the board is to use OpenOCD. Once you have installed
OpenOCD (look [here](https://github.com/RIOT-OS/RIOT/wiki/OpenOCD) for
installation instructions), you can flash the board simply by typing:
```
make BOARD=nucleo-f103 flash
```
and debug via GDB by simply typing
```
make BOARD=nucleo-f103 debug
```
## Supported Toolchains
For using the ST Nucleo-F103 board we strongly recommend the usage of the
[GNU Tools for ARM Embedded Processors](https://launchpad.net/gcc-arm-embedded)
toolchain.
*/

70
boards/nucleo-f207zg/doc.txt Normal file
View File

@ -0,0 +1,70 @@
/**
@defgroup boards_nucleo-f207zg STM32 Nucleo-F207ZG
@ingroup boards_common_nucleo144
@brief Support for the STM32 Nucleo-F207ZG
## Overview
The Nucleo144-F207 is a board from ST's Nucleo family supporting a ARM
Cortex-M3
STM32F207ZG microcontroller with 128Kb of SRAM and 1Mb of ROM Flash.
## Hardware
![Nucleo144 F207](https://raw.githubusercontent.com/wiki/RIOT-OS/RIOT/images/nucleo144-board.png)
### MCU
| MCU | STM32F207ZG |
|:------------- |:--------------------- |
| Family | ARM Cortex-M3 |
| Vendor | ST Microelectronics |
| RAM | 128Kb |
| Flash | 1Mb |
| Frequency | up to 120MHz |
| FPU | yes |
| Timers | 17 (2x watchdog, 1 SysTick, 12x 16-bit, 2x 32-bit [TIM2]) |
| ADCs | 3x 12-bit |
| UARTs | 4 |
| SPIs | 3 |
| I2Cs | 3 |
| RTC | 1 |
| Vcc | 2.0V - 3.6V |
| Datasheet | [Datasheet](http://www.st.com/resource/en/datasheet/stm32f207zg.pdf) |
| Reference Manual | [Reference Manual](http://www.st.com/resource/en/reference_manual/cd00225773.pdf) |
| Programming Manual | [Programming Manual](http://www.st.com/resource/en/programming_manual/cd00228163.pdf) |
| Board Manual | [Board Manual](http://www.st.com/resource/en/user_manual/dm00244518.pdf)|
## Implementation Status
| Device | ID | Supported | Comments |
|:------------- |:------------- |:------------- |:------------- |
| MCU | STM32F207ZG | partly | Energy saving modes not fully utilized |
| Low-level driver | GPIO | yes | |
| | PWM | yes (7 pins available in see [PR #6192](https://github.com/RIOT-OS/RIOT/pull/6192)) | |
| | UART | 2 UARTs | USART2 via STLink/USB or D0(RX)/D1(TX) and USART6 on PA12(RX)/PA11(TX) |
| | I2C | 1 I2C | |
| | SPI | 1 SPI | |
| | USB | no | |
| | Timer | 2 32 bit timers | |
## Flashing the device
The ST Nucleo-F207ZG board includes an on-board ST-LINK V2-1 programmer. The
easiest way to program the board is to use OpenOCD. Once you have installed
OpenOCD (look [here](https://github.com/RIOT-OS/RIOT/wiki/OpenOCD) for
installation instructions), you can flash the board simply by typing
```
make BOARD=nucleo144-f207 flash
```
and debug via GDB by simply typing
```
make BOARD=nucleo144-f207 debug
```
## Supported Toolchains
For using the ST Nucleo144-F207 board we strongly recommend the usage of the
[GNU Tools for ARM Embedded Processors](https://launchpad.net/gcc-arm-embedded)
toolchain.
*/

83
boards/nucleo-f302r8/doc.txt Normal file
View File

@ -0,0 +1,83 @@
/**
@defgroup boards_nucleo-f302r8 STM32 Nucleo-F302R8
@ingroup boards_common_nucleo64
@brief Support for the STM32 Nucleo-F302R8
## Overview
Not yet available upstream, see [PR 6615](https://github.com/RIOT-OS/RIOT/pull/6615)
The [Nucleo-F302](http://www.st.com/en/evaluation-tools/nucleo-f302r8.html)
is
a board from ST's Nucleo family supporting a ARM Cortex-M4
[STM32F302R8](http://www.st.com/en/microcontrollers/stm32f302r8.html)
microcontroller with 16KB of RAM and 64KB of ROM.
## Hardware
![nucleo image](http://www.open-electronics.org/wp-content/uploads/2015/08/Figura2-500x467.png)
### MCU
| MCU | STM32F302R8 |
|:------------- |:--------------------- |
| Family | ARM Cortex-M4 |
| Vendor | ST Microelectronics |
| RAM | 16KB |
| Flash | 64KB |
| Frequency | up to 72MHz |
| FPU | yes |
| Timers | 9 (5x 16-bit, 1x 32-bit [TIM2], 2 watchdog, 1 systick) |
| ADCs | 1 with selectable resolution (6,8,10,12-bit) |
| UARTs | 3 |
| SPIs | 2 |
| I2Cs | 3 |
| RTC | 1 |
| Vcc | 2.0V - 3.6V |
| Datasheet | [Datasheet](http://www.st.com/resource/en/datasheet/stm32f302r6.pdf) |
| Reference Manual | [Reference Manual](http://www.st.com/resource/en/reference_manual/dm00094349.pdf) |
| Programming Manual | [Programming Manual](http://www.st.com/resource/en/programming_manual/dm00046982.pdf) |
| Board Manual | [Board Manual](http://www.st.com/st-web-ui/static/active/en/resource/technical/document/user_manual/DM00105823.pdf)|
## Implementation Status
| Device | ID | Supported | Comments |
|:------------- |:------------- |:------------- |:------------- |
| MCU | STM32F302R8 | partly | Energy saving modes not fully utilized |
| Low-level driver | GPIO | yes | |
| | PWM | one PWM (D5) | |
| | UART | three UART | |
| | I2C | no | |
| | SPI | one SPI (SPI2) | |
| | USB | no | |
| | Timer | one 32 timer (TIM2) | |
## Flashing the device
The ST Nucleo-F302 board includes an on-board ST-LINK V2-1 programmer.
The easiest way to program the board is to use OpenOCD. Once you have
installed OpenOCD (look [here](https://github.com/RIOT-OS/RIOT/wiki/OpenOCD)
for installation instructions), you can flash the board simply by typing
```
make BOARD=nucleo-f302 flash
```
and debug via GDB by simply typing
```
make BOARD=nucleo-f302 debug
```
### Troubleshooting
For some reason the ST Link programmer can be outdated, making it impossible
to
flash or to access the debug UART via USB. To fix this, please use
the ST Link firmware update tool following
[this documentation](http://www.st.com/en/embedded-software/stsw-link007.html).
## Supported Toolchains
For using the ST Nucleo-F303RE board we strongly recommend the usage of
the [GNU Tools for ARM Embedded Processors](https://launchpad.net/gcc-arm-embedded) toolchain.
*/

73
boards/nucleo-f303k8/doc.txt Normal file
View File

@ -0,0 +1,73 @@
/**
@defgroup boards_nucleo-f303k8 STM32 Nucleo-F303K8
@ingroup boards_common_nucleo32
@brief Support for the STM32 Nucleo-F303K8
## Overview
The Nucleo-F303 is a board from ST's Nucleo family supporting a ARM Cortex-M4
STM32F303RE
microcontroller with 64Kb of RAM and 512Kb of ROM.
## Hardware
![nucleo image](http://media.digikey.com/Photos/STMicro%20Photos/MFG_NUCLEO.jpg)
![nucleo-f303 pinout](https://raw.githubusercontent.com/wiki/RIOT-OS/RIOT/images/nucleo-f303_pinout.png)
### MCU
| MCU | STM32F303RE |
|:------------- |:--------------------- |
| Family | ARM Cortex-M4 |
| Vendor | ST Microelectronics |
| RAM | 64Kb |
| Flash | 512Kb |
| Frequency | up to 72MHz) |
| FPU | yes |
| Timers | 14 (13x 16-bit, 1x 32-bit [TIM2]) |
| ADCs | 4x 12-bit |
| UARTs | 5 |
| SPIs | 4 |
| I2Cs | 3 |
| RTC | 1 |
| Vcc | 2.0V - 3.6V |
| Datasheet | [Datasheet](http://www.st.com/st-web-ui/static/active/en/resource/technical/document/datasheet/DM00118585.pdf) |
| Reference Manual | [Reference Manual](http://www.st.com/web/en/resource/technical/document/reference_manual/DM00043574.pdf) |
| Programming Manual | [Programming Manual](http://www.st.com/web/en/resource/technical/document/programming_manual/DM00046982.pdf) |
| Board Manual | [Board Manual](http://www.st.com/st-web-ui/static/active/en/resource/technical/document/user_manual/DM00105823.pdf)|
## Implementation Status
| Device | ID | Supported | Comments |
|:------------- |:------------- |:------------- |:------------- |
| MCU | STM32F303RE | partly | Energy saving modes not fully utilized |
| Low-level driver | GPIO | yes | |
| | PWM | one PWM | |
| | UART | three UART | |
| | I2C | two I2C | |
| | SPI | two SPI | |
| | USB | no | |
| | Timer | one 32 timer | |
## Flashing the device
The ST Nucleo-F303RE board includes an on-board ST-LINK V2 programmer.
The easiest way to program the board is to use OpenOCD. Once you have
installed OpenOCD (look [here](https://github.com/RIOT-OS/RIOT/wiki/OpenOCD)
for installation instructions), you can flash the board simply by typing.
```
make flash
```
and debug via GDB by simply typing
```
make debug
```
## Supported Toolchains
For using the ST Nucleo-F303RE board we strongly recommend the usage of the
[GNU Tools for ARM Embedded Processors](https://launchpad.net/gcc-arm-embedded)
toolchain.
*/

73
boards/nucleo-f303re/doc.txt Normal file
View File

@ -0,0 +1,73 @@
/**
@defgroup boards_nucleo-f303re STM32 Nucleo-F303RE
@ingroup boards_common_nucleo64
@brief Support for the STM32 Nucleo-F303RE
## Overview
The Nucleo-F303 is a board from ST's Nucleo family supporting a ARM Cortex-M4
STM32F303RE
microcontroller with 64Kb of RAM and 512Kb of ROM.
## Hardware
![nucleo image](http://media.digikey.com/Photos/STMicro%20Photos/MFG_NUCLEO.jpg)
![nucleo-f303 pinout](https://raw.githubusercontent.com/wiki/RIOT-OS/RIOT/images/nucleo-f303_pinout.png)
### MCU
| MCU | STM32F303RE |
|:------------- |:--------------------- |
| Family | ARM Cortex-M4 |
| Vendor | ST Microelectronics |
| RAM | 64Kb |
| Flash | 512Kb |
| Frequency | up to 72MHz) |
| FPU | yes |
| Timers | 14 (13x 16-bit, 1x 32-bit [TIM2]) |
| ADCs | 4x 12-bit |
| UARTs | 5 |
| SPIs | 4 |
| I2Cs | 3 |
| RTC | 1 |
| Vcc | 2.0V - 3.6V |
| Datasheet | [Datasheet](http://www.st.com/st-web-ui/static/active/en/resource/technical/document/datasheet/DM00118585.pdf) |
| Reference Manual | [Reference Manual](http://www.st.com/web/en/resource/technical/document/reference_manual/DM00043574.pdf) |
| Programming Manual | [Programming Manual](http://www.st.com/web/en/resource/technical/document/programming_manual/DM00046982.pdf) |
| Board Manual | [Board Manual](http://www.st.com/st-web-ui/static/active/en/resource/technical/document/user_manual/DM00105823.pdf)|
## Implementation Status
| Device | ID | Supported | Comments |
|:------------- |:------------- |:------------- |:------------- |
| MCU | STM32F303RE | partly | Energy saving modes not fully utilized |
| Low-level driver | GPIO | yes | |
| | PWM | one PWM | |
| | UART | three UART | |
| | I2C | two I2C | |
| | SPI | two SPI | |
| | USB | no | |
| | Timer | one 32 timer | |
## Flashing the device
The ST Nucleo-F303RE board includes an on-board ST-LINK V2 programmer.
The easiest way to program the board is to use OpenOCD. Once you have
installed OpenOCD (look [here](https://github.com/RIOT-OS/RIOT/wiki/OpenOCD)
for installation instructions), you can flash the board simply by typing.
```
make flash
```
and debug via GDB by simply typing
```
make debug
```
## Supported Toolchains
For using the ST Nucleo-F303RE board we strongly recommend the usage of the
[GNU Tools for ARM Embedded Processors](https://launchpad.net/gcc-arm-embedded)
toolchain.
*/

73
boards/nucleo-f303ze/doc.txt Normal file
View File

@ -0,0 +1,73 @@
/**
@defgroup boards_nucleo-f303ze STM32 Nucleo-F303ZE
@ingroup boards_common_nucleo144
@brief Support for the STM32 Nucleo-F303ZE
## Overview
The Nucleo-F303 is a board from ST's Nucleo family supporting a ARM Cortex-M4
STM32F303RE
microcontroller with 64Kb of RAM and 512Kb of ROM.
## Hardware
![nucleo image](http://media.digikey.com/Photos/STMicro%20Photos/MFG_NUCLEO.jpg)
![nucleo-f303 pinout](https://raw.githubusercontent.com/wiki/RIOT-OS/RIOT/images/nucleo-f303_pinout.png)
### MCU
| MCU | STM32F303RE |
|:------------- |:--------------------- |
| Family | ARM Cortex-M4 |
| Vendor | ST Microelectronics |
| RAM | 64Kb |
| Flash | 512Kb |
| Frequency | up to 72MHz) |
| FPU | yes |
| Timers | 14 (13x 16-bit, 1x 32-bit [TIM2]) |
| ADCs | 4x 12-bit |
| UARTs | 5 |
| SPIs | 4 |
| I2Cs | 3 |
| RTC | 1 |
| Vcc | 2.0V - 3.6V |
| Datasheet | [Datasheet](http://www.st.com/st-web-ui/static/active/en/resource/technical/document/datasheet/DM00118585.pdf) |
| Reference Manual | [Reference Manual](http://www.st.com/web/en/resource/technical/document/reference_manual/DM00043574.pdf) |
| Programming Manual | [Programming Manual](http://www.st.com/web/en/resource/technical/document/programming_manual/DM00046982.pdf) |
| Board Manual | [Board Manual](http://www.st.com/st-web-ui/static/active/en/resource/technical/document/user_manual/DM00105823.pdf)|
## Implementation Status
| Device | ID | Supported | Comments |
|:------------- |:------------- |:------------- |:------------- |
| MCU | STM32F303RE | partly | Energy saving modes not fully utilized |
| Low-level driver | GPIO | yes | |
| | PWM | one PWM | |
| | UART | three UART | |
| | I2C | two I2C | |
| | SPI | two SPI | |
| | USB | no | |
| | Timer | one 32 timer | |
## Flashing the device
The ST Nucleo-F303RE board includes an on-board ST-LINK V2 programmer.
The easiest way to program the board is to use OpenOCD. Once you have
installed OpenOCD (look [here](https://github.com/RIOT-OS/RIOT/wiki/OpenOCD)
for installation instructions), you can flash the board simply by typing.
```
make flash
```
and debug via GDB by simply typing
```
make debug
```
## Supported Toolchains
For using the ST Nucleo-F303RE board we strongly recommend the usage of the
[GNU Tools for ARM Embedded Processors](https://launchpad.net/gcc-arm-embedded)
toolchain.
*/

73
boards/nucleo-f334r8/doc.txt Normal file
View File

@ -0,0 +1,73 @@
/**
@defgroup boards_nucleo-f334r8 STM32 Nucleo-F334R8
@ingroup boards_common_nucleo64
@brief Support for the STM32 Nucleo-F334R8
## Overview
The Nucleo-F334 is a board from ST's Nucleo family supporting a ARM Cortex-M4
STM32F334R8 microcontroller with 12Kb of RAM and 64Kb or ROM.
## Hardware
![STM32F3discovery image](http://media.digikey.com/Photos/STMicro%20Photos/MFG_NUCLEO.jpg)
![nucleo-f334 pinout](https://raw.githubusercontent.com/wiki/RIOT-OS/RIOT/images/nucleo-f334_pinout.png)
### MCU
| MCU | STM32F091RC |
|:------------- |:--------------------- |
| Family | ARM Cortex-M4 |
| Vendor | ST Microelectronics |
| RAM | 12Kb |
| Flash | 64Kb |
| Frequency | up to 72MHz) |
| FPU | yes |
| Timers | 9 (8x 16-bit, 1x 32-bit [TIM2]) |
| ADCs | 2x 12-bit |
| UARTs | 8 |
| SPIs | 1 |
| I2Cs | 1 |
| RTC | 1 |
| Vcc | 2.0V - 3.6V |
| Datasheet | [Datasheet](http://www.st.com/web/en/resource/technical/document/datasheet/DM00115237.pdf) |
| Reference Manual | [Reference Manual](http://www.st.com/web/en/resource/technical/document/reference_manual/DM00031936.pdf) |
| Programming Manual | [Programming Manual](http://www.st.com/web/en/resource/technical/document/programming_manual/DM00051352.pdf) |
| Board Manual | [Board Manual](http://www.st.com/st-web-ui/static/active/en/resource/technical/document/user_manual/DM00105823.pdf)|
## Implementation Status
| Device | ID | Supported | Comments |
|:------------- |:------------- |:------------- |:------------- |
| MCU | STM32F334R8 | partly | Energy saving modes not fully utilized |
| Low-level driver | GPIO | yes | |
| | PWM | no | |
| | UART | one UART | |
| | I2C | no | |
| | SPI | one SPI | |
| | USB | no | |
| | Timer | one 32 timer | |
## Flashing the device
The ST Nucleo-F334R8 board includes an on-board ST-LINK V2 programmer.
The easiest way to program the board is to use OpenOCD. Once you have
installed
OpenOCD (look [here](https://github.com/RIOT-OS/RIOT/wiki/OpenOCD) for
installation instructions), you can flash the board simply by typing
```
make flash
```
and debug via GDB by simply typing
```
make debug
```
## Supported Toolchains
For using the ST Nucleo-F334R8 board we strongly recommend the usage of the
[GNU Tools for ARM Embedded Processors](https://launchpad.net/gcc-arm-embedded)
toolchain.
*/

87
boards/nucleo-f401re/doc.txt Normal file
View File

@ -0,0 +1,87 @@
/**
@defgroup boards_nucleo-f401re STM32 Nucleo-F401RE
@ingroup boards_common_nucleo64
@brief Support for the STM32 Nucleo-F401RE
## Overview
The Nucleo-F401 is a board from ST's Nucleo family supporting a ARM Cortex-M4
STM32F401RE microcontroller with 96Kb of SRAM and 512Kb of ROM Flash.
## Hardware
![Nucleo64 F401](http://www.open-electronics.org/wp-
content/uploads/2015/08/Figura2-500x467.png)
### MCU
| MCU | STM32F401RE |
|:------------- |:--------------------- |
| Family | ARM Cortex-M4 |
| Vendor | ST Microelectronics |
| RAM | 96Kb |
| Flash | 512Kb |
| Frequency | up to 84MHz |
| FPU | yes |
| Timers | 11 (2x watchdog, 1 SysTick, 6x 16-bit, 2x 32-bit [TIM2]) |
| ADCs | 1x 12-bit |
| UARTs | 3 |
| SPIs | 4 |
| I2Cs | 3 |
| RTC | 1 |
| Vcc | 2.0V - 3.6V |
| Datasheet | [Datasheet](http://www.st.com/resource/en/datasheet/stm32f401re.pdf) |
| Reference Manual | [Reference Manual](http://www.st.com/web/en/resource/technical/document/reference_manual/DM00031936.pdf) |
| Programming Manual | [Programming Manual](http://www.st.com/resource/en/programming_manual/dm00046982.pdf) |
| Board Manual | [Board Manual](http://www.st.com/resource/en/user_manual/dm00105823.pdf)|
## Implementation Status
| Device | ID | Supported | Comments |
|:------------- |:------------- |:------------- |:------------- |
| MCU | STM32F401RE | partly | Energy saving modes not fully utilized |
| Low-level driver | GPIO | yes | |
| | PWM | yes (7 pins available)) | |
| | UART | 2 UARTs | USART2 via STLink/USB or D0(RX)/D1(TX) and USART6 on PA12(RX)/PA11(TX) |
| | I2C | 1 I2C | |
| | SPI | 1 SPI | |
| | USB | no | |
| | Timer | 2 32 bit timers | |
## Flashing the device
The ST Nucleo-F401RE board includes an on-board ST-LINK V2 programmer. The
easiest way to program the board is to use OpenOCD. Once you have installed
OpenOCD (look [here](https://github.com/RIOT-OS/RIOT/wiki/OpenOCD) for
installation instructions), you can flash the board simply by typing
```
make BOARD=nucleo-f401 flash
```
and debug via GDB by simply typing
```
make BOARD=nucleo-f401 debug
```
## Supported Toolchains
For using the ST Nucleo-F401 board we strongly recommend the usage of the
[GNU Tools for ARM Embedded Processors](https://launchpad.net/gcc-arm-
embedded)
toolchain.
## Issues with old Hardware Revisions
Some Nucleo 64 Boards come in different hardware revisions, which is located
on a sticker at the backside of the board. As discussed in issue
[#6721](https://github.com/RIOT-OS/RIOT/issues/6721), there are some issues with
the external clock sources in revisions smaller than `C-03`. (This would also be
true for all boards with board ID `MB1136`).
The revision `C-01` has a different configuration for the high speed external
clock (HSE), which is used in RIOT. This could be fixed by reconfiguring some
solder bridges as mentioned in the [user
manual](http://www.st.com/resource/en/user_manual/dm00105823.pdf), section
6.7.1.
The other issue is, that revision `C-01` also has no 32kHz oscillator, so the
RTC module of RIOT cannot be used.
*/

74
boards/nucleo-f410rb/doc.txt Normal file
View File

@ -0,0 +1,74 @@
/**
@defgroup boards_nucleo-f410rb STM32 Nucleo-F410RB
@ingroup boards_common_nucleo64
@brief Support for the STM32 Nucleo-F410RB
## Overview
Not yet available upstream, see [PR 6025](https://github.com/RIOT-OS/RIOT/pull/6025)
The Nucleo-F410 is a board from ST's Nucleo family supporting a ARM Cortex-M4
STM32F410RB microcontroller with 32Kb of SRAM and 128Kb of ROM Flash.
## Hardware
![Nucleo64 F410](http://www.open-electronics.org/wp-content/uploads/2015/08/Figura2-500x467.png)
### MCU
| MCU | STM32F410RB |
|:------------- |:--------------------- |
| Family | ARM Cortex-M4 |
| Vendor | ST Microelectronics |
| RAM | 32Kb |
| Flash | 128Kb |
| Frequency | up to 100MHz |
| FPU | yes |
| Timers | 9 (2x watchdog, 1 SysTick, 4x 16-bit, 1x 32-bit [TIM2] and 1 low power timer) |
| ADCs | 1x 12-bit |
| UARTs | 3 |
| SPIs | 3 |
| I2Cs | 3 |
| RTC | 1 |
| Vcc | 2.0V - 3.6V |
| Datasheet | [Datasheet](http://www.st.com/resource/en/datasheet/stm32f410rb.pdf) |
| Reference Manual | [Reference Manual](http://www.st.com/resource/en/reference_manual/dm00180366.pdf) |
| Programming Manual | [Programming Manual](http://www.st.com/resource/en/programming_manual/dm00046982.pdf) |
| Board Manual | [Board Manual](http://www.st.com/resource/en/user_manual/dm00105823.pdf)|
## Implementation Status
| Device | ID | Supported | Comments |
|:------------- |:------------- |:------------- |:------------- |
| MCU | STM32F410RB | partly | Energy saving modes not fully utilized |
| Low-level driver | GPIO | yes | |
| | PWM | yes (no pin configured) | |
| | UART | 2 UARTs | USART2 via STLink/USB or D0(RX)/D1(TX) and USART1 on PA10(RX)/PA9(TX) |
| | I2C | 1 I2C | |
| | SPI | 1 SPI | |
| | USB | no | |
| | Timer | 2 32 bit timers | |
## Flashing the device
The ST Nucleo-F410RB board includes an on-board ST-LINK V2 programmer. The
easiest way to program the board is to use OpenOCD. You need OpenOCD in
version
0.10 minimum. Once you have installed OpenOCD (look
[here](https://github.com/RIOT-OS/RIOT/wiki/OpenOCD) for installation
instructions), you can flash the board simply by typing
```
make BOARD=nucleo-f410 flash
```
and debug via GDB by simply typing
```
make BOARD=nucleo-f410 debug
```
## Supported Toolchains
For using the ST Nucleo-F410 board we strongly recommend the usage of the
[GNU Tools for ARM Embedded Processors](https://launchpad.net/gcc-arm-embedded)
toolchain.
*/

73
boards/nucleo-f411re/doc.txt Normal file
View File

@ -0,0 +1,73 @@
/**
@defgroup boards_nucleo-f411re STM32 Nucleo-F411RE
@ingroup boards_common_nucleo64
@brief Support for the STM32 Nucleo-F411RE
## Overview
The Nucleo-F411 is a board from ST's Nucleo family supporting a ARM Cortex-M4
STM32F411RE microcontroller with 128Kb of SRAM and 512Kb of ROM Flash.
## Hardware
![Nucleo64 F401](http://www.open-electronics.org/wp-
content/uploads/2015/08/Figura2-500x467.png)
### MCU
| MCU | STM32F411RE |
|:------------- |:--------------------- |
| Family | ARM Cortex-M4 |
| Vendor | ST Microelectronics |
| RAM | 128Kb |
| Flash | 512Kb |
| Frequency | up to 100MHz |
| FPU | yes |
| Timers | 11 (2x watchdog, 1 SysTick, 6x 16-bit, 2x 32-bit [TIM2]) |
| ADCs | 1x 12-bit |
| UARTs | 3 |
| SPIs | 5 |
| I2Cs | 3 |
| RTC | 1 |
| Vcc | 2.0V - 3.6V |
| Datasheet |
[Datasheet](http://www.st.com/resource/en/datasheet/stm32f411re.pdf) |
| Reference Manual | [Reference Manual](http://www.st.com/resource/en/reference_manual/dm00119316.pdf) |
| Programming Manual | [Programming Manual](http://www.st.com/resource/en/programming_manual/dm00046982.pdf) |
| Board Manual | [Board Manual](http://www.st.com/resource/en/user_manual/dm00105823.pdf)|
## Implementation Status
| Device | ID | Supported | Comments |
|:------------- |:------------- |:------------- |:------------- |
| MCU | STM32F411RE | partly | Energy saving modes not fully utilized |
| Low-level driver | GPIO | yes | |
| | PWM | yes (7 pins available)) | |
| | UART | 3 UARTs | USART2 via STLink/USB or D0(RX)/D1(TX), USART1 on PA10(RX)/PA9(TX) and USART6 on PA12(RX)/PA11(TX) |
| | I2C | 1 I2C | |
| | SPI | 1 SPI | |
| | USB | no | |
| | Timer | 1 32 bit timer (TIM5) | |
## Flashing the device
The ST Nucleo-F411RE board includes an on-board ST-LINK V2-1 programmer. The
easiest way to program the board is to use OpenOCD. Once you have installed
OpenOCD (look [here](https://github.com/RIOT-OS/RIOT/wiki/OpenOCD) for
installation instructions), you can flash the board simply by typing
```
make BOARD=nucleo-f411 flash
```
and debug via GDB by simply typing
```
make BOARD=nucleo-f411 debug
```
## Supported Toolchains
For using the ST Nucleo-F411 board we strongly recommend the usage of the
[GNU Tools for ARM Embedded Processors](https://launchpad.net/gcc-arm-
embedded)
toolchain.
*/

2
boards/nucleo-f412zg/doc.txt Normal file
View File

@ -0,0 +1,2 @@
/**
*/

2
boards/nucleo-f413zh/doc.txt Normal file
View File

@ -0,0 +1,2 @@
/**
*/

2
boards/nucleo-f429zi/doc.txt Normal file
View File

@ -0,0 +1,2 @@
/**
*/

73
boards/nucleo-f446re/doc.txt Normal file
View File

@ -0,0 +1,73 @@
/**
@defgroup boards_nucleo-f446re STM32 Nucleo-F446RE
@ingroup boards_common_nucleo64
@brief Support for the STM32 Nucleo-F446RE
## Overview
The Nucleo-F446 is a board from ST's Nucleo family supporting a ARM Cortex-M4
STM32F446RE microcontroller with 128Kb of RAM and 512Kb of ROM Flash.
## Hardware
![Nucleo64 F446](http://www.open-electronics.org/wp-
content/uploads/2015/08/Figura2-500x467.png)
### MCU
| MCU | STM32F446RE |
|:------------- |:--------------------- |
| Family | ARM Cortex-M4 |
| Vendor | ST Microelectronics |
| RAM | 128Kb |
| Flash | 512Kb |
| Frequency | up to 180MHz |
| FPU | yes |
| Timers | 11 (2x watchdog, 1 SysTick, 12x 16-bit, 2x 32-bit [TIM2]) |
| ADCs | 3x 12-bit |
| UARTs | 4 |
| SPIs | 4 |
| I2Cs | 4 |
| RTC | 1 |
| Vcc | 2.0V - 3.6V |
| Datasheet |
[Datasheet](http://www.st.com/resource/en/datasheet/stm32f446re.pdf) |
| Reference Manual | [Reference Manual](http://www.st.com/web/en/resource/technical/document/reference_manual/DM00031936.pdf) |
| Programming Manual | [Programming Manual](http://www.st.com/web/en/resource/technical/document/programming_manual/DM00051352.pdf) |
| Board Manual | [Board Manual](http://www.st.com/st-web-ui/static/active/en/resource/technical/document/user_manual/DM00105823.pdf)|
## Implementation Status
| Device | ID | Supported | Comments |
|:------------- |:------------- |:------------- |:------------- |
| MCU | STM32F446RE | partly | Energy saving modes not fully utilized |
| Low-level driver | GPIO | yes | |
| | PWM | yes (9 pins available) | |
| | UART | 3 UARTs | USART2 via STLink/USB or D0(RX)/D1(TX), USART3 on PC11(RX)/PC10(TX) and USART1 on PA10(RX)/PA9(TX) |
| | I2C | one I2C | |
| | SPI | one SPI | |
| | USB | no | |
| | Timer | one 32 bit timer | |
## Flashing the device
The ST Nucleo-F446RE board includes an on-board ST-LINK V2 programmer. The
easiest way to program the board is to use OpenOCD. Once you have installed
OpenOCD (look [here](https://github.com/RIOT-OS/RIOT/wiki/OpenOCD) for
installation instructions), you can flash the board simply by typing
```
make BOARD=nucleo-f446 flash
```
and debug via GDB by simply typing
```
make BOARD=nucleo-f446 debug
```
## Supported Toolchains
For using the ST Nucleo-F446RE board we strongly recommend the usage of the
[GNU Tools for ARM Embedded Processors](https://launchpad.net/gcc-arm-
embedded)
toolchain.
*/

73
boards/nucleo-f446ze/doc.txt Normal file
View File

@ -0,0 +1,73 @@
/**
@defgroup boards_nucleo-f446ze STM32 Nucleo-F446ZE
@ingroup boards_common_nucleo144
@brief Support for the STM32 Nucleo-F446ZE
## Overview
The Nucleo-F446 is a board from ST's Nucleo family supporting a ARM Cortex-M4
STM32F446RE microcontroller with 128Kb of RAM and 512Kb of ROM Flash.
## Hardware
![Nucleo64 F446](http://www.open-electronics.org/wp-
content/uploads/2015/08/Figura2-500x467.png)
### MCU
| MCU | STM32F446RE |
|:------------- |:--------------------- |
| Family | ARM Cortex-M4 |
| Vendor | ST Microelectronics |
| RAM | 128Kb |
| Flash | 512Kb |
| Frequency | up to 180MHz |
| FPU | yes |
| Timers | 11 (2x watchdog, 1 SysTick, 12x 16-bit, 2x 32-bit [TIM2]) |
| ADCs | 3x 12-bit |
| UARTs | 4 |
| SPIs | 4 |
| I2Cs | 4 |
| RTC | 1 |
| Vcc | 2.0V - 3.6V |
| Datasheet |
[Datasheet](http://www.st.com/resource/en/datasheet/stm32f446re.pdf) |
| Reference Manual | [Reference Manual](http://www.st.com/web/en/resource/technical/document/reference_manual/DM00031936.pdf) |
| Programming Manual | [Programming Manual](http://www.st.com/web/en/resource/technical/document/programming_manual/DM00051352.pdf) |
| Board Manual | [Board Manual](http://www.st.com/st-web-ui/static/active/en/resource/technical/document/user_manual/DM00105823.pdf)|
## Implementation Status
| Device | ID | Supported | Comments |
|:------------- |:------------- |:------------- |:------------- |
| MCU | STM32F446RE | partly | Energy saving modes not fully utilized |
| Low-level driver | GPIO | yes | |
| | PWM | yes (9 pins available) | |
| | UART | 3 UARTs | USART2 via STLink/USB or D0(RX)/D1(TX), USART3 on PC11(RX)/PC10(TX) and USART1 on PA10(RX)/PA9(TX) |
| | I2C | one I2C | |
| | SPI | one SPI | |
| | USB | no | |
| | Timer | one 32 bit timer | |
## Flashing the device
The ST Nucleo-F446RE board includes an on-board ST-LINK V2 programmer. The
easiest way to program the board is to use OpenOCD. Once you have installed
OpenOCD (look [here](https://github.com/RIOT-OS/RIOT/wiki/OpenOCD) for
installation instructions), you can flash the board simply by typing
```
make BOARD=nucleo-f446 flash
```
and debug via GDB by simply typing
```
make BOARD=nucleo-f446 debug
```
## Supported Toolchains
For using the ST Nucleo-F446RE board we strongly recommend the usage of the
[GNU Tools for ARM Embedded Processors](https://launchpad.net/gcc-arm-
embedded)
toolchain.
*/

2
boards/nucleo-f722ze/doc.txt Normal file
View File

@ -0,0 +1,2 @@
/**
*/

2
boards/nucleo-f746zg/doc.txt Normal file
View File

@ -0,0 +1,2 @@
/**
*/

2
boards/nucleo-f767zi/doc.txt Normal file
View File

@ -0,0 +1,2 @@
/**
*/

2
boards/nucleo-l031k6/doc.txt Normal file
View File

@ -0,0 +1,2 @@
/**
*/

5
boards/nucleo-l053r8/doc.txt Normal file
View File

@ -0,0 +1,5 @@
/**
@defgroup boards_nucleo-l053r8 STM32 Nucleo-L053R8
@ingroup boards_common_nucleo64
@brief Support for the STM32 Nucleo-L053R8
*/

5
boards/nucleo-l073rz/doc.txt Normal file
View File

@ -0,0 +1,5 @@
/**
@defgroup boards_nucleo-l073rz STM32 Nucleo-L073RZ
@ingroup boards_common_nucleo64
@brief Support for the STM32 Nucleo-L073RZ
*/

70
boards/nucleo-l152re/doc.txt Normal file
View File

@ -0,0 +1,70 @@
/**
@defgroup boards_nucleo-l152re STM32 Nucleo-L152RE
@ingroup boards_common_nucleo64
@brief Support for the STM32 Nucleo-L152RE
## Hardware
![st-nucleo-l1](https://cloud.githubusercontent.com/assets/56618/5190201/f87455ae-74e3-11e4-9d24-21a334e01858.png)
### MCU
| MCU | STM32L152RE |
|:------------- |:--------------------- |
| Family | ARM Cortex-M3 |
| Vendor | ST Microelectronics |
| RAM | 80Kb |
| Flash | 512Kb |
| Frequency | 32MHz (no external oscilator connected) |
| FPU | no |
| Timers | 8 (8x 16-bit, 1x 32-bit [TIM5]) |
| ADCs | 1x 42-channel 12-bit |
| UARTs | 3 |
| SPIs | 2 |
| I2Cs | 2 |
| Vcc | 1.65V - 3.6V |
| Datasheet | [Datasheet](http://www.st.com/st-web-ui/static/active/en/resource/technical/document/datasheet/DM00098321.pdf) |
| Reference Manual | [Reference Manual](http://www.st.com/resource/en/reference_manual/cd00240193.pdf) |
| Programming Manual | [Programming Manual](http://www.st.com/web/en/resource/technical/document/programming_manual/CD00228163.pdf) |
| Board Manual | [Board Manual](http://www.st.com/st-web-ui/static/active/en/resource/technical/document/user_manual/DM00105823.pdf)|
### User Interface
2 Button:
| NAME | USER | RESET |
|:----- |:----- |:--------- |
| Pin | PC13 (IN) | NRST |
1 LEDs:
| NAME | LD2 |
| ----- | ----- |
| Color | green |
| Pin | PA5 |
## Supported Toolchains
For using the st-nucleo-l1 board we strongly recommend the usage of the [GNU
Tools for ARM Embedded Processors](https://launchpad.net/gcc-arm-embedded)
toolchain.
### OpenOCD
Please use an OpenOCD version checked out after Jan. 26th 2015. Building
instructions can be found [here](https://github.com/RIOT-OS/RIOT/wiki/OpenOCD).
## Using UART
Using the UART isn't too stable right now. For some using the USB interface
just works, others have to connect the USB interface to a active USB hub and
others again can only transmit over the USB interface and receive using an
external UART adapter.
#### Connecting an external UART adapter
1. connect your usb tty to the st-link header as marked
![st-link-header](https://cloud.githubusercontent.com/assets/56618/5190200/f36aafe0-74e3-11e4-96bd-f755dd2a8b01.png)
2. done
*/

2
boards/nucleo-l432kc/doc.txt Normal file
View File

@ -0,0 +1,2 @@
/**
*/

5
boards/nucleo-l452re/doc.txt Normal file
View File

@ -0,0 +1,5 @@
/**
@defgroup boards_nucleo-l452re STM32 Nucleo-L452RE
@ingroup boards_common_nucleo64
@brief Support for the STM32 Nucleo-L452RE
*/

28
boards/nucleo-l476rg/doc.txt Normal file
View File

@ -0,0 +1,28 @@
/**
@defgroup boards_nucleo-l476rg STM32 Nucleo-L476RG
@ingroup boards_common_nucleo64
@brief Support for the STM32 Nucleo-L476RG
### MCU
| MCU | |
|:------------- |:--------------------- |
| Family | ARM Cortex-M4 |
| Vendor | ST Microelectronics |
| RAM | |
| Flash | |
| Frequency | |
| FPU | |
| Timers | |
| ADCs | |
| UARTs | |
| SPIs | |
| I2Cs | |
| RTC | |
| Vcc | |
| Datasheet | |
| Reference Manual | [Reference Manual](http://www.st.com/content/ccc/resource/technical/document/reference_manual/02/35/09/0c/4f/f7/40/03/DM00083560.pdf/files/DM00083560.pdf/jcr:content/translations/en.DM00083560.pdf) |
| Programming Manual | [Programming Manual](http://www.st.com/content/ccc/resource/technical/document/programming_manual/6c/3a/cb/e7/e4/ea/44/9b/DM00046982.pdf/files/DM00046982.pdf/jcr:content/translations/en.DM00046982.pdf) |
| Board Manual | |
*/

8
boards/nucleo-l496zg/doc.txt
View File

@ -1,5 +1,5 @@
/**
* @defgroup boards_nucleo-l496zg STM32 Nucleo-L496ZG
* @ingroup boards_common_nucleo144
* @brief Support for the STM32 Nucleo-l496zg
*/
@defgroup boards_nucleo-l496zg STM32 Nucleo-L496ZG
@ingroup boards_common_nucleo144
@brief Support for the STM32 Nucleo-l496zg
*/

105
boards/nz32-sc151/doc.txt Normal file
View File

@ -0,0 +1,105 @@
/**
@defgroup boards_nz32-sc151 NZ32-SC151
@ingroup boards
@brief Support for the Modtronix nz32-sc151 board.
This board provider is [modtronix](www.modtronix.com). They don't supply data
sheet's but there wiki can be found
[HERE](http://wiki.modtronix.com/doku.php?id=products:nz-stm32:nz32-sc151). The
schematic for there board can be found
[HERE](http://modtronix.com/prod/nz32/nz32-sc151/nz32-sc151-r1.pdf).
## Hardware
![st-
nucleo-l1](http://wiki.modtronix.com/lib/exe/fetch.php?media=products:nz-
stm32:nz32-sc151-r1_pinout_diagram_782.jpg)
### MCU
| MCU | STM32L151RC |
|:------------- |:--------------------- |
| Family | ARM Cortex-M3 |
| Vendor | ST Microelectronics |
| RAM | 32Kb |
| Flash | 256Kb |
| Frequency | 32MHz|
| FPU | no |
| Timers | 11 (8x 16-bit,2x 16-bit basic timers, 2x watchdog timers, 1x 32-bit [TIM5]) |
| ADCs | 1x 25-channel 12-bit |
| DACs | 1x 2-channel 12-bit |
| USB 2.0 | 1 |
| UARTs | 3 |
| SPIs | 3 |
| I2Cs | 2 |
| Vcc | 1.65V - 3.6V |
| Datasheet | [Datasheet](http://www.st.com/content/ccc/resource/technical/document/datasheet/2a/6e/97/91/cd/c0/43/8b/DM00048356.pdf/files/DM00048356.pdf/jcr:content/translations/en.DM00048356.pdf) |
| Reference Manual | [Reference Manual](http://www.st.com/content/ccc/resource/technical/document/reference_manual/cc/f9/93/b2/f0/82/42/57/CD00240193.pdf/files/CD00240193.pdf/jcr:content/translations/en.CD00240193.pdf) |
| Programming Manual | [Programming Manual](http://www.st.com/content/ccc/resource/technical/document/programming_manual/5b/ca/8d/83/56/7f/40/08/CD00228163.pdf/files/CD00228163.pdf/jcr:content/translations/en.CD00228163.pdf) |
| Board WIKI | [WIKI nz32-sc151](https://wiki.modtronix.com/doku.php?id=products:nz-stm32:nz32-sc151#schematics)|
### User Interface
2 Button:
| NAME | BOOT | RESET |
|:----- |:----- |:--------- |
| Pin | BOOT0 | NRST |
1 LED:
| NAME | LED |
| ----- | ----- |
| Color | red |
| Pin | PB2 |
## Using UART
This board doesn't open an UART or serial interface threw the USB
automatically, and the USB device driver hasn't been implemented to RIOT yet.
Therefore, to open an UART interface one hast to connect a usb/ttl converter to
the UART3 pins PB11 (RX3) and PB10 (TX3).
## Flashing the device
The standard method for flashing RIOT to the nz32-sc151 is using dfu. On
linux you must get dfu-util package v.8.0 or newer. You can try:
```
sudo apt-get install dfu-util
```
but most repos install older versions, therefore you should clone from [dfu-
util](git clone git://git.code.sf.net/p/dfu-util/dfu-util) and follow building
instructions [HERE](
http://dfu-util.sourceforge.net/build.html).
Once dfu-util is installed you can just flash as a normal board, although
sudo privileges are required.
```
sudo make BOARD=nz32-sc151 flash
```
NOTE: this only works for linux, for windows you can use [ST Microelectronics
DFU Bootloader](http://www.st.com/en/development-tools/stsw-stm32080.html)
although you will need to build the files independently.
## Implementation Status
| Device | ID | Supported | Comments |
|:------------- |:------------- |:------------- |:------------- |
| MCU | stm32l1 | partly | Energy saving modes not implemented |
| Low-level driver | GPIO | yes | |
| | DAC | yes | |
| | UART | yes | |
| | I2C | yes |I2C1|
| | SPI | yes | |
| | ADC | yes | Only 5 enabled PC0, PC1, PC2, and two internal ADC channels|
| | USB | no | |
| | RTT | no | |
| | PWM | yes | On PC6, PC7, PC8, PC9|
| | RTC | yes | |
| | RNG | no | |
| | Timer | yes | |
*/

5
boards/opencm904/doc.txt Normal file
View File

@ -0,0 +1,5 @@
/**
@defgroup boards_opencm904 OpenCM9.04
@ingroup boards
@brief Support for the OpenCM9.04 board
*/

61
boards/openmote-cc2538/doc.txt Normal file
View File

@ -0,0 +1,61 @@
/**
@defgroup boards_openmote-cc2538 OpenMote-cc2538
@ingroup boards
@brief Support for the OpenMote-cc2538 board
## Overview
The [OpenMote](http://www.openmote.com/) is slim board that comes with a TI
SoC combining an ARM Cortex-M3 microcontroller with an IEEE802.15.4 radio.
## Hardware
![openmote](https://raw.githubusercontent.com/wiki/RIOT-
OS/RIOT/images/openmote.jpg)
| MCU | CC2538SF53 |
|:------------- |:--------------------- |
| Family | ARM Cortex-M3 |
| Vendor | Texas Instruments |
| RAM | 32Kb |
| Flash | 512Kb |
| Frequency | 32MHz |
| FPU | no |
| Timers | 4 |
| ADCs | 1x 12-bit (8 channels) |
| UARTs | 2 |
| SPIs | 2 |
| I2Cs | 1 |
| Vcc | 2V - 3.6V |
| Datasheet | [Datasheet](http://www.ti.com/lit/gpn/cc2538) (pdf file) |
| Reference Manual | [Reference Manual](http://www.ti.com/lit/pdf/swru319) |
The OpenMote can be used with an "OpenBase" which provides an RJ-45, 2 x USB
mini ports, a JTAG header, and two pin headers which provide access to the
microprocessor pins. For example, the pins labelled DOUT/DIN provide access to
the UART Tx/Rx respectively. This UART is connected to the "USB_FTDI" port via
an FTDI FT232RQ UART/USB driver chip.
## Flashing and Debugging
Currently RIOT supports flashing the OpenMote using a Segger JLink JTAG
adapter or via USB, using the bootloader on the board.
### Flashing via USB
To flash via USB, connect the "ON/SLEEP" pin to ground, and reset the board
into the bootloader by pressing the reset button ("BUT1"). Then call "make
flash" from your application directory.
### Flashing via JTAG
To be able to flash the board via JTAG you need to install Seggers JLinkExe
tool. Once you have this in place, you can simply flash by calling
`make flash`
from your application folder.
Mac OS users may experiment a command line expecting `connect`. Just type it
and the process will continue.
*/

59
boards/pba-d-01-kw2x/doc.txt Normal file
View File

@ -0,0 +1,59 @@
/**
@defgroup boards_pba-d-01-kw2x phyWAVE-KW22 Board
@ingroup boards
@brief Support for the phyWAVE evaluation board
## Manufacturer
Designed and produced by PHYTEC Messtechnik GmbH, D-55129 Mainz.
[Homepage](http://www.phytec.de) | Ordering information via mail at
contact@phytec.de
## Overview
The [Phytec IoT wiki](https://github.com/PHYTEC-Messtechnik-GmbH/phynode-riot-examples/wiki)
describes the phyWAVE module and the phyNODE board more
detailed. The links below will guide you directly to the corresponding chapter:
* [Overview](https://github.com/PHYTEC-Messtechnik-GmbH/phynode-riot-examples/wiki/)
* [Introduction](https://github.com/PHYTEC-Messtechnik-GmbH/phynode-riot-examples/wiki/Introduction)
* Hardware descriptions for the
[phyWAVE](https://github.com/PHYTEC-Messtechnik-GmbH/phynode-riot-examples/wiki/phyWAVE-KW2x-Characteristics)
and the
[phyNODE](https://github.com/PHYTEC-Messtechnik-GmbH/phynode-riot-examples/wiki/phyNODE-Characteristics)
* [Toolchain, build and debug Information](https://github.com/PHYTEC-Messtechnik-GmbH/phynode-riot-examples/wiki/RIOT-getting-started#toolchain-summary)
* [A detailed step-by-step Guide that explains how to set up the Environment](https://github.com/PHYTEC-Messtechnik-GmbH/phynode-riot-examples/wiki/RIOT-getting-started#step-by-step-installation-guide)
The implementation status of the phyWAVE and phyNODE peripherals are listed
below. You can find links to the corresponding Pull Requests which may give you
a code reference.
<img src="https://raw.githubusercontent.com/jremmert-phytec-iot/Pictures_Phytec_IOT/master/EvalBoard_3.png" width="800" />
phyNODE board with equipped phyWAVE-KW2x processor/radio-module.
### Details
The PCB-pieces with the mounted sensors can be separated from the evaluation
board to capture sensor values from specific spatial points.
[Pinout reference](https://github.com/PHYTEC-Messtechnik-GmbH/phynode-riot-examples/wiki/Interfaces)
## Implementation Status
| Device | ID | Supported | Comments |
|:------------- |:------------- |:------------- |:------------- |
| MCU | [MKW22D512](http://www.freescale.com/webapp/sps/site/prod_summary.jsp?code=KW2x) | yes | [mainline](https://github.com/RIOT-OS/RIOT/pull/2265) |
| phyWAVE board support | [phyWAVE](http://www.phytec.de/de/produkte/internet-of-things/phywave.html) | yes | [mainline](https://github.com/RIOT-OS/RIOT/pull/2059) |
| Low-level driver | GPIO | yes | [mainline](https://github.com/RIOT-OS/RIOT/pull/2265)|
| | PWM | yes | [mainline](https://github.com/RIOT-OS/RIOT/pull/2265)|
| | UART | yes | [mainline](https://github.com/RIOT-OS/RIOT/pull/2265)|
| | I2C | yes | [mainline](https://github.com/RIOT-OS/RIOT/pull/2265)|
| | SPI | yes | [mainline](https://github.com/RIOT-OS/RIOT/pull/2265) |
| | USB-Device | yes | [WIP](https://github.com/RIOT-OS/RIOT/pull/3890)|
| | RTT | yes | [mainline](https://github.com/RIOT-OS/RIOT/pull/2265) |
| | RNG | yes | [mainline](https://github.com/RIOT-OS/RIOT/pull/2265) |
| | Timer | yes | [mainline](https://github.com/RIOT-OS/RIOT/pull/2265) |
| Radio Chip | integrated | yes | [mainline](https://github.com/RIOT-OS/RIOT/pull/2756) |
| Humidity Sensor | [HDC1000](http://www.ti.com/lit/ds/symlink/hdc1000.pdf) | yes | [mainline](https://github.com/RIOT-OS/RIOT/pull/2070) |
| Pressure Sensor | [MPL3115A2](http://www.nxp.com/products/sensors/pressure-sensors/barometric-pressure-15-to-115-kpa/20-to-110kpa-absolute-digital-pressure-sensor:MPL3115A2?) | yes | [mainline](https://github.com/RIOT-OS/RIOT/pull/2123) |
| Tri-axis Accelerometer | [MMA8652FC](http://www.nxp.com/products/sensors/accelerometers/3-axis-accelerometers/2g-4g-8g-low-g-12-bit-digital-accelerometer:MMA8652FC) | yes | [mainline](https://github.com/RIOT-OS/RIOT/pull/2119) |
| Magnetometer | [MAG3110FCR1](http://www.nxp.com/products/sensors/magnetometers/sample-data-sets-for-inertial-and-magnetic-sensors/freescale-high-accuracy-3d-magnetometer:MAG3110) | yes | [mainline](https://github.com/RIOT-OS/RIOT/pull/2121) |
| Light Sensor | [TCS3772](https://ams.com/jpn/content/download/291143/1065677/file/TCS3772_Datasheet_EN_v1.pdf) | yes | [mainline](https://github.com/RIOT-OS/RIOT/pull/3135) |
| IR-Termopile Sensor | [TMP006](http://www.ti.com/product/TMP006) |yes | [mainline](https://github.com/RIOT-OS/RIOT/pull/2148) |
| Capacitive Button | PCB | no | planned |
*/

18
boards/pic32-clicker/doc.txt Normal file
View File

@ -0,0 +1,18 @@
/**
@defgroup boards_pic32-clicker MikroE PIC32 Clicker
@ingroup boards
@brief Support for the MikroE PIC32 Clicker
For instructions on reflashing see:
https://docs.creatordev.io/clicker/guides/quick-start-guide/#programming-a-6lowpan-clicker
The RIOT build generates a hexfile compatible with MPLAB-IPE.
More general information on the board and related documentation can be found
here:
https://docs.creatordev.io/clicker/guides/quick-start-guide/#introduction
*/

21
boards/pic32-wifire/doc.txt Normal file
View File

@ -0,0 +1,21 @@
/**
@defgroup boards_pic32-wifire Digilent PIC32 WiFire
@ingroup boards
@brief Support for the Digilent PIC32 WiFire
For instructions on reflashing see:
https://docs.creatordev.io/wifire/guides/wifire-programming/
The RIOT build generates a hexfile compatible with MPLAB-IPE.
More general information on the board and related documentation can be found
here:
https://creatordev.io/wifire.html
https://docs.creatordev.io/wifire/
*/

5
boards/remote-pa/doc.txt Normal file
View File

@ -0,0 +1,5 @@
/**
@defgroup boards_remote-pa Re-Mote Prototype A
@ingroup boards
@brief Support for the Re-Mote board prototype A
*/

89
boards/remote-reva/doc.txt Normal file
View File

@ -0,0 +1,89 @@
/**
@defgroup boards_remote-reva RE-Mote Revision A
@ingroup boards
@brief Support for the RE-Mote board Revision A
The `RE-Mote` has three versions, a first prototype A (`remote-pa`) only
distributed to beta testers, its following revision A (`remote-reva`), and the
latest revision B (`remote-revb`) which are commercially available. The
following section focuses on the revision A.
The official RE-Mote wiki page is maintained by Zolertia at:
https://github.com/Zolertia/Resources/wiki
# Components
| MCU | [CC2538 (ARM Cortex-M3 with on-board 2.4GHz radio)](http://www.ti.com/product/CC2538) |
|-------|-----------------------------------------------------------------------------------------------------|
| Radio | Two radio interfaces (IEEE 802.15.4): [2.4GHz](http://www.ti.com/product/CC2538) and [863-950MHz](http://www.ti.com/product/CC1200) |
| | RP-SMA connector for external antenna (with a RF switch to select either 2.4GHz/Sub-GHz radio) |
| USB-to-Serial | [CP2104](https://www.silabs.com/products/interface/Pages/cp2104-mini.aspx) |
| Peripherals | RTCC, built-in battery charger for LiPo batteries, External WDT (optional), Micro-SD |
| Others | RGB LED, power management block (150nA when the mote is shutdown)|
# Porting status
In terms of hardware support, the following drivers have been implemented:
* CC2538 System-on-Chip:
* UART
* Random number generator
* Low Power Modes
* General-Purpose Timers
* I2C/SPI library
* LEDs
* Buttons
* RF 2.4GHz built-in in CC2538
* RF switch to programatically drive either 2.4GHz or sub-1GHz to a single
RP-SMA
And under work or pending at cc2538 base cpu:
* Built-in core temperature and battery sensor.
* CC1200 sub-1GHz radio interface.
* Micro-SD external storage.
* ADC
* USB (in CDC-ACM).
* uDMA Controller.
# Layout
![layout](http://i.imgur.com/4bV6lyYl.png)
# Flashing
The RE-Mote has built-in support to flash over USB using the BSL. Previous
versions required to unlock the bootloader by manually pressing the `user
button` and `reset button`, but the current version handles the sequence with an
on-board PIC, so automatically unlocks the bootloader upon flashing.
e.g.
```
Bash
$ make BOARD=remote-reva flash
```
The RE-Mote in its current Revision A has the following pin-out:
![RE-Mote pin-out (front)](https://raw.githubusercontent.com/contiki-os/contiki/master/platform/zoul/images/remote-reva-pinout-front.png)
![RE-Mote pin-out (back)](https://raw.githubusercontent.com/contiki-os/contiki/master/platform/zoul/images/remote-reva-pinout-back.png)
# Pin out and connectors
## RE-Mote ports and connectors
![](http://i.imgur.com/TF21Hin.png)
![](http://i.imgur.com/J7aisKJ.png)
## RE-Mote on-board connectors pin-out
The RE-Mote uses the [Molex 5-pin WM4903-ND male header connector](http://datasheets.globalspec.com/ds/5843/DigiKey/6D12815C-098E-40A3-86A0-22A3C50B75BA) to
connect digital sensors based on I2C and SPI protocols, as well as other sensors
or actuators you may need to connect. The pins are 2.54 mm spaced and the
connector has the following pin-out:
![](http://i.imgur.com/2DZ17PV.png)
![](http://i.imgur.com/q7Hb7Y8.png)
*/

5
boards/remote-revb/doc.txt Normal file
View File

@ -0,0 +1,5 @@
/**
@defgroup boards_remote-revb RE-Mote Revision B
@ingroup boards
@brief Support for the RE-Mote board Revision B
*/

5
boards/ruuvitag/doc.txt Normal file
View File

@ -0,0 +1,5 @@
/**
@defgroup boards_ruuvitag RuuviTag
@ingroup boards
@brief Support for the RuuviTag board
*/

108
boards/samd21-xpro/doc.txt Normal file
View File

@ -0,0 +1,108 @@
/**
@defgroup boards_samd21-xpro Atmel SAM D21 Xplained Pro
@ingroup boards
@brief Support for the Atmel SAM D21 Xplained Pro board.
## Overview
The `SAMD21 Xplained Pro` is an ultra-low power evaluation board by Atmel
featuring an ATSAMD21J18A SoC. The SoC includes a SAMD21 ARM Cortex-M0+ micro-
controller. For programming the MCU comes with 32Kb of RAM and 256Kb of flash
memory.
The samd21-xpro is available from various hardware vendors for ~30USD (as of
2017May).
## Hardware
![samd21-xpro image](http://www.microchip.com/_ImagedCopy/ATSAMD21-XPRO_angle.jpg)
### MCU
| MCU | ATSAMD21J18A |
|:------------- |:--------------------- |
| Family | ARM Cortex-M0+ |
| Vendor | Atmel |
| RAM | 32Kb |
| Flash | 256Kb |
| Frequency | up to 48MHz |
| FPU | no |
| Timers | 5 (16-bit) |
| ADCs | 1x 12-bit (20 channels) |
| UARTs | max 6 (shared with SPI and I2C) |
| SPIs | max 6 (see UART) |
| I2Cs | max 6 (see UART) |
| Vcc | 1.62V - 3.63V |
| Datasheet | [Datasheet](http://ww1.microchip.com/downloads/en/DeviceDoc/40001882A.pdf) |
| Board Manual | [Board Manual](http://www.atmel.com/Images/Atmel-42220-SAMD21-Xplained-Pro_User-Guide.pdf)|
### User Interface
1 User button and 1 LED:
| Device | PIN |
|:------ |:--- |
| LED0 | PB30 |
| SW0 (button) | PA15 |
## Implementation Status
| Device | ID | Supported | Comments |
|:------------- |:------------- |:------------- |:------------- |
| MCU | samd21 | partly | DFLL clock not implemented |
| Low-level driver | GPIO | yes | |
| | ADC | yes | |
| | PWM | yes | |
| | UART | yes | |
| | I2C | unknown | |
| | SPI | yes | |
| | USB | no | |
| | RTT | yes | |
| | RTC | yes | |
| | RNG | unknown | |
| | Timer | yes | |
## Flashing the device
Connect the device to your Micro-USB cable using the port labeled as *DEBUG
USB*.
The standard method for flashing RIOT to the samd21-xpro is using OpenOCD.
Refer to https://github.com/RIOT-OS/RIOT/wiki/OpenOCD for general
instructions on building OpenOCD and make sure "cmsis-dap" and "hidapi-libusb"
are enabled.
On Linux you will have to add a **udev** rule for hidraw, like
```
bash
echo 'KERNEL=="hidraw*", SUBSYSTEM=="hidraw", MODE="0664", GROUP="plugdev"' \
| sudo tee -a /etc/udev/rules.d/99-usb.rules
sudo service udev restart
```
### Arch Linux
With yaourt:
```
yaourt -S hidapi-git
yaourt -S openocd-git
# edit PKGBUILD, add "cmsis-dap hidapi-libusb" to "_features"
```
### Ubuntu
Although this refers to setting up the SAMR21, this guide is still very
helpful to understanding how to set up a solid RIOT development environment for
the SAMD21: http://watr.li/samr21-dev-setup-ubuntu.html
## Supported Toolchains
For using the samd21-xpro board we strongly recommend the usage of the
[GNU Tools for ARM Embedded Processors](https://launchpad.net/gcc-arm-embedded)
toolchain.
## Known Issues / Problems
*/

130
boards/saml21-xpro/doc.txt Normal file
View File

@ -0,0 +1,130 @@
/**
@defgroup boards_saml21-xpro Atmel SAM L21 Xplained Pro
@ingroup boards
@brief Support for the Atmel SAM L21 Xplained Pro board.
## Overview
The `SAML21 Xplained Pro` is an ultra-low power evaluation board by Atmel
featuring a ATSAML21J18A SoC. The SoC includes a SAML21 ARM Cortex-M0+ micro-
controller. For programming the MCU comes with 32Kb of RAM and 256Kb of flash
memory.
The saml21-xpro is available from various hardware vendors for ~50USD (as of
oct. 2015).
*Please note:* ATMEL's most recent SAML21s are the `B` variant, or
`ATSAML21J18B`. Because the driver changes are mostly small, throughout this
reference the device will continue to be referred to as the `ATSAML21J18[A/B]`
indiscriminately;
## Hardware
![saml21-xpro image](https://www.microchip.com/_ImagedCopy/ATSAML21-XPRO-B_angle.jpg)
### MCU
| MCU | ATSAML21J18A |
|:------------- |:--------------------- |
| Family | ARM Cortex-M0+ |
| Vendor | Atmel |
| RAM | 32Kb |
| Flash | 256Kb |
| Frequency | up to 48MHz |
| FPU | no |
| Timers | 8 (16-bit) |
| ADCs | 1x 12-bit (20 channels) |
| UARTs | max 6 (shared with SPI and I2C) |
| SPIs | max 6 (see UART) |
| I2Cs | max 6 (see UART) |
| Vcc | 1.8V - 3.6V |
| Datasheet | [Datasheet](http://www.atmel.com/Images/Atmel-42385-SAM-L21-Datasheet.pdf) |
| Board Manual | [Board Manual](http://www.atmel.com/Images/Atmel-42405-SAML21-Xplained-Pro_User-Guide.pdf)|
### User Interface
1 User button and 1 LED:
| Device | PIN |
|:------ |:--- |
| LED0 | PB10 |
| SW0 (button) | PA02 |
## Implementation Status
| Device | ID | Supported | Comments |
|:------------- |:------------- |:------------- |:------------- |
| MCU | saml21 | partly | PLL clock not implemented |
| Low-level driver | GPIO | yes | |
| | PWM | no | |
| | UART | yes | |
| | I2C | yes | |
| | SPI | yes | |
| | USB | no | |
| | RTT | yes | |
| | RTC | yes | |
| | RNG | no | |
| | Timer | yes | |
| | ADC | yes | |
## Flashing the device
Connect the device to your Micro-USB cable using the port labeled as *EDBG*.
The standard method for flashing RIOT to the saml21-xpro is using OpenOCD.
Please note that even the latest official OpenOCD (v0.9 at the time of this
writing) does not support B-variant SAML21 devices.
If you attempt to flash a board, and OpenOCD throws a `Couldn't find part
correspoding to DID XXXXXXXX` error, you will need to compile your own OpenOCD
from source.
Refer to https://github.com/RIOT-OS/RIOT/wiki/OpenOCD for general
instructions on building OpenOCD and make sure "cmsis-dap" and "hidapi-libusb"
are enabled.
On Linux you will have to add a **udev** rule for hidraw, like
```
bash
echo 'KERNEL=="hidraw*", SUBSYSTEM=="hidraw", MODE="0664", GROUP="plugdev"' \
| sudo tee -a /etc/udev/rules.d/99-usb.rules
sudo service udev restart
```
### Arch Linux
With yaourt:
```
yaourt -S hidapi-git
yaourt -S openocd-git
# edit PKGBUILD, add "cmsis-dap hidapi-libusb" to "_features"
```
### Ubuntu
Although this refers to setting up the SAMR21, this guide is still very
helpful to understanding how to set up a solid RIOT development environment for
the SAML21: http://watr.li/samr21-dev-setup-ubuntu.html
## Supported Toolchains
For using the saml21-xpro board we strongly recommend the usage of the [GNU Tools for ARM Embedded Processors](https://launchpad.net/gcc-arm-embedded)
toolchain.
## Known Issues / Problems
### Stack sizes
The default stack sizes have not been tuned properly yet. If in doubt why
your application crashes try increasing the default stack sizes and use `ps` to
find out how much stack is being used.
Tracked in https://github.com/RIOT-OS/RIOT/issues/2228
### Not flashable by OpenOCD anymore
It can happen that OpenOCD is not able to program the board, because of wrong
clock configuration or low power modes. In this case you can use
[this little tool](https://github.com/ataradov/edbg) to erase the flash. Just follow the
instructions to build it and run `./edbg -e` to erase the flash. Then press the
reset button and you're able to program via OpenOCD again.
*/

199
boards/samr21-xpro/doc.txt Normal file
View File

@ -0,0 +1,199 @@
/**
@defgroup boards_samr21-xpro Atmel SAM R21 Xplained Pro
@ingroup boards
@brief Support for the Atmel SAM R21 Xplained Pro board.
## Overview
The `SAMR21 Xplained Pro` is a compact evaluation board by Atmel featuring a
ATSAMR21G18A SoC. The SoC includes a SAMD21 ARM Cortex-M0+ micro-controller
bundled with Atmel's AT86RF233, a 2.4GHz IEEE802.15.4 compatible radio. For
programming the MCU comes with 32Kb of RAM and 256Kb of flash memory.
The samr21-xpro is available from various hardware vendors for ~40EUR (as of
sep. 2014).
## Hardware
![samr21-xpro image](http://t3.gstatic.com/images?q=tbn:ANd9GcTdbgRUFLgLPWSYq6p26mR7wwikHnO4_vcEwRhwNZqmIHGUwVws3h2nfQ)
### MCU
| MCU | ATSAMR21G18A |
|:------------- |:--------------------- |
| Family | ARM Cortex-M0+ |
| Vendor | Atmel |
| RAM | 32Kb |
| Flash | 256Kb |
| Frequency | up to 48MHz |
| FPU | no |
| Timers | 6 (1x 16-bit, 2x 24-bit, 3x 32-bit) |
| ADCs | 1x 12-bit (8 channels) |
| UARTs | max 5 (shared with SPI and I2C) |
| SPIs | max 5 (see UART) |
| I2Cs | max 5 (see UART) |
| Vcc | 1.8V - 3.6V |
| Datasheet | [Datasheet](http://www.atmel.com/Images/Atmel-42223-SAM-R21_Datasheet.pdf) |
| Board Manual | [Board Manual](http://www.atmel.com/Images/Atmel-42243-SAMR21-Xplained-Pro_User-Guide.pdf)|
### User Interface
1 User button and 1 LED:
| Device | PIN |
|:------ |:--- |
| LED0 | PA19 |
| SW0 (button) | PA28 |
### Radio
The SAMR21 SoC includes an on-chip AT86RF233 radio. It is internally
connected via SPI and some GPIO pins and behaves in exact the same way as
externally connected SPI devices.
| Sensor | AT86RF233 |
|:------------- |:--------------------- |
| Type | 2.4GHz IEEE802.15.4 radio |
| Vendor | Atmel |
| Datasheet | [Datasheet](http://www.atmel.com/images/atmel-8351-mcu_wireless-at86rf233_datasheet.pdf) |
| Connected to | SPI_0 |
| Pin Config: | |
| Device | SERCOM4 |
| MOSI | PB30 (OUT, SPI mosi) |
| MISO | PC19 (IN, SPI miso) |
| SCLK | PC18 (OUT, SPI sclk) |
| CS | PB31 (OUT, GPIO output) |
| IRQ | PB00 (IN, GPIO external interrupt) |
| RSTN | PB15 (OUT, GPIO output) |
| SLP_TR | PA20 (OUT, GPIO output) |
## Implementation Status
Please refer to [this tracker](https://github.com/RIOT-OS/RIOT/issues/1646)
to see which projects are work in progress and who is the contact person for
this.
| Device | ID | Supported | Comments |
|:------------- |:------------- |:------------- |:------------- |
| MCU | samd21 | partly | Energy saving modes not fully utilized|
| Low-level driver | GPIO | yes | |
| | PWM | yes | |
| | UART | yes | two UARTs by now|
| | I2C | yes | |
| | SPI | yes | |
| | ADC | yes | PA04 & PA05 disabled by default due to EDBG's use of them for UART, can be enabled from `periph_conf.h`|
| | USB | no | |
| | RTT | yes | |
| | RTC | yes | |
| | RNG | no | no HW module |
| | Timer | yes | |
| Radio Chip | AT86RF233 | yes | using at86rf231 driver (this will be renamed to at86rf2xx) |
## Flashing the device
Connect the device to your Micro-USB cable using the port labeled as *EDBG*.
The standard method for flashing RIOT to the samr21-xpro is using OpenOCD.
For this to work properly, **you have to make sure to use a very recent version
of OpenOCD**. The v0.8.0 release will _not_ work. If this is still the current
release you'll have to build OpenOCD from source.
Refer to https://github.com/RIOT-OS/RIOT/wiki/OpenOCD for building OpenOCD
and make sure "cmsis-dap" and "hidapi-libusb" are enabled.
On Linux you will have to add a **udev** rule for hidraw, like
```
bash
echo 'KERNEL=="hidraw*", SUBSYSTEM=="hidraw", MODE="0664", GROUP="plugdev"' \
| sudo tee -a /etc/udev/rules.d/99-usb.rules
sudo service udev restart
```
### Arch Linux
With yaourt:
```
yaourt -S hidapi-git
yaourt -S openocd-git
# edit PKGBUILD, make sure "hidapi-libusb" is in "_features"
```
The **udev** rules for Arch differ a little from the example given above:
```
bash
echo 'KERNEL=="hidraw*", SUBSYSTEM=="hidraw", MODE="0664", GROUP="uucp"' \
| sudo tee -a /etc/udev/rules.d/99-usb.rules
sudo udevadm control --reload
```
### Ubuntu
See http://watr.li/samr21-dev-setup-ubuntu.html
## Connecting multiple boards
If you have multiple boards connected to the same computer and want to flash,
this is what you can do:
First, run `make list-ttys`. This will show you a list of currently connected
boards, their serial numbers and the names of their TTYs:
Atmel Corp. EDBG CMSIS-DAP serial: 'ATML2127031800002124', tty(s):
ttyACM0
Atmel Corp. EDBG CMSIS-DAP serial: 'ATML2127031800002145', tty(s):
ttyACM1
knowing your serial number, you can flash, open a terminal or debug a
specific board like this:
BOARD=samr21-xpro SERIAL="ATML2127031800002124" make flash
BOARD=samr21-xpro SERIAL="ATML2127031800002124" make term
BOARD=samr21-xpro SERIAL="ATML2127031800002124" make debug
## Supported Toolchains
For using the samr21-xpro board we strongly recommend the usage of the
[GNU Tools for ARM Embedded Processors](https://launchpad.net/gcc-arm-embedded)
toolchain.
## Known Issues / Problems
### I2C
When connecting an I2C device and a logic analyzer to an I2C port at the same
time, the internal pull-up resistors are not sufficient for stable bus
operation. You probably have to connect external pull-ups to both bus lines. 10K
is a good value to start with.
### Stack sizes
The default stack sizes have not been tuned properly yet. If in doubt why
your application crashes try increasing the default stack sizes and use `ps` to
find out how much stack is being used.
Tracked in https://github.com/RIOT-OS/RIOT/issues/2228
### User Button
When using the SW0 user button as interrupt source it appears that this is
triggered when just tipping on the button and not really pressing it.
### Not flashable by OpenOCD anymore
It can happen that OpenOCD is not able to program the board, because of wrong
clock configuration or low power modes. In this case you can use
[this little tool](https://github.com/ataradov/edbg) to erase the flash. Just follow the
instructions to build it and run `./edbg -e` to erase the flash. Then press the
reset button and you're able to program via OpenOCD again.
### Flashing might not work in Virtual Box with Mac OS X as host
It might happen that flashing through OpenOCD works once inside Virtual Box.
But when you try to flash again, you could get a CMSIS-DAP related error. It
seems to only happen with USB 3.0 ports. You can take a look at
[Vagrant](http://en.wikipedia.org/wiki/Vagrant_%28software%29) and use a virtual
Linux to run the virtual RIOT, and flash from OS X.
*/

95
boards/seeeduino_arch-pro/doc.txt Normal file
View File

@ -0,0 +1,95 @@
/**
@defgroup boards_seeduino_arch-pro Seeeduino Arch Pro development kit
@ingroup boards
@brief Support for the Seeeduino Arch Pro board
## Overview
The Seeeduino Arch Pro is an 32-bit ARM Cortex M3 microprocessor development
board, featuring an Arduino-compatible shield interface and a RJ-45 network
interface.
## Hardware
![Seeeduino Arch Pro Development Kit](https://statics3.seeedstudio.com/images/product/arch%20pro.jpg)
### MCU
| MCU | LPC1768 |
|-----------------|------------------------------------------|
| Family | ARM Cortex-M3 |
| Vendor | NXP |
| RAM | 64KB |
| Flash | 512KB |
| EEPROM | no |
| Frequency | up to 100 MHz |
| FPU | no |
| DMA | 8 channels |
| Timers | 4 x 32-bit |
| ADCs | 12-bit ADC |
| UARTs | 3x USART |
| SPIs | 2x USART |
| I2Cs | 2x |
| Vcc | 2.4V - 3.6V |
| Datasheet | [Datasheet](http://www.nxp.com/documents/data_sheet/LPC1768_66_65_64.pdf)|
| Manual | [Manual](http://www.nxp.com/documents/user_manual/UM10360.pdf)|
| Board Manual | [Board Manual](http://www.seeedstudio.com/wiki/Arch_Pro)|
| Board Schematic | [Board Schematic](http://www.seeedstudio.com/wiki/File:Arch_Pro_V1.0_Schematic.pdf) |
### Pinout
### User interface
| Peripheral | Mapped to | Hardware | Pin | Comments |
|------------|-----------|----------|-------|------------|
| LED | LED0 | LED1 | P1_18 | Green LED |
| | LED1 | LED2 | P1_20 | Red LED |
| | LED2 | LED3 | P1_21 | Blue LED |
| | LED3 | LED4 | P1_23 | Yellow LED |
## Board configuration
### Virtual serial port
The first UART device is mapped to stdout.
Note: the board controller always configures the virtual serial port at
115200 baud with 8 bits, no parity and one stop bit. This also means that it
expects data from the MCU with the same settings.
Note: to use the virtual serial port, ensure you have the latest board
controller firmware installed.
## Flashing the device
To flash, the [OpenOCD Software](http://openocd.org/) is required.
Flashing is supported by RIOT-OS by the command below:
```
make flash
```
To run the GDB debugger, use the command:
```
make debug
```
Or, to connect with your own debugger:
```
make debug-server
```
## Image checksum
LPC ARM Cortext MCUs need a [flash image checksum](https://community.nxp.com/thread/389046). When running `make flash`,
this checksum is automatically generated and inserted into the firmware image
right before flashing.
It depends on the [lpc_checksum](https://pypi.python.org/pypi/lpc_checksum)
command-line utility, which can be installed using using `pip install
lpc_checksum` or `pip3 install lpc_checksum`. After installing this utility, it
should be available on your command-line.
## Supported toolchains
For using the Seeeduino Arch Pro development kit we strongly recommend the
usage of the [GNU Tools for ARM Embedded Processors](https://launchpad.net/gcc-arm-embedded) toolchain.
## License information
* Image: taken from Seeeduino website.
*/

5
boards/sltb001a/doc.txt Normal file
View File

@ -0,0 +1,5 @@
/**
@defgroup boards_sltb001a Silicon Labs SLTB001A starter kit
@ingroup boards
@brief Support for the Silicon Labs SLTB001A starter kit
*/

5
boards/slwstk6220a/doc.txt Normal file
View File

@ -0,0 +1,5 @@
/**
@defgroup boards_slwstk6220a Silicon Labs WSTK6220 Eval Kit
@ingroup boards
@brief Support for the Silicon Labs WSTK6220 evaluation kit
*/

118
boards/sodaq-autonomo/doc.txt Normal file
View File

@ -0,0 +1,118 @@
/**
@defgroup boards_sodaq-autonomo SODAQ Autonomo
@ingroup boards
@brief Support for the SODAQ Autonomo board.
## Overview
The `SODAQ Autonomo` is a board by SODAQ featuring a ATSAMD21J18A. The SAMD21
is a ARM Cortex-M0+ micro-controller. It has 256Kb of flash memory and 32Kb of
RAM.
The Autonomo is available from the SODAQ [shop](http://shop.sodaq.com/).
## Hardware
![sodaq-autonomo image](http://static.webshopapp.com/shops/104792/files/050759716/sodaq-sodaq-autonomo.jpg)
### MCU
| MCU | ATSAMD21J18A |
|:------------- |:--------------------- |
| Family | ARM Cortex-M0+ |
| Vendor | Atmel |
| RAM | 32Kb |
| Flash | 256Kb |
| Frequency | up to 48MHz |
| FPU | no |
| Timers | 6 (1x 16-bit, 2x 24-bit, 3x 32-bit) |
| ADCs | 1x 12-bit (8 channels) |
| UARTs | max 6 (SERCOMs shared with SPI and I2C) |
| SPIs | max 6 (see UART) |
| I2Cs | max 6 (see UART) |
| Vcc | 1.8V - 3.6V |
| Datasheet | [Datasheet](http://www.atmel.com/Images/Atmel-42181-SAM-D21_Datasheet.pdf) |
### User Interface
1 LED:
| Device | PIN |
|:------ |:--- |
| LED0 | PA19 |
## Implementation Status
Please refer to [this tracker](https://github.com/RIOT-OS/RIOT/issues/1646)
to see which projects are work in progress and who is the contact person for
this. Notice that the initial support for the Autonomo was based on
samr21-xpro. At some point we will add a separate issue to track changes for
this board.
| Device | ID | Supported | Comments |
|:------------- |:------------- |:------------- |:------------- |
| MCU | samd21 | partly | Energy saving modes not fully utilized|
| Low-level driver | GPIO | yes | |
| | PWM | yes | |
| | UART | yes | two UARTs by now|
| | I2C | yes | |
| | SPI | yes | |
| | ADC | yes | PA04 & PA05 disabled by default due to EDBG's use of them for UART, can be enabled from `periph_conf.h`|
| | USB | no | |
| | RTT | yes | |
| | RTC | yes | |
| | RNG | no | no HW module |
| | Timer | yes | |
## Features of the board
Besides the SAMD21 the board has the following features:
| Feature | Description |
|:------ |:--- |
| Compatibility | Arduino M0 compatible |
| Size | 58.5 x 33.5 mm |
| Operating Voltage | 3.3V |
| Digital I/O Pins | 16, with 12 PWM, UART, SPI and TWI (I2C) |
| Analog Input Pins | 6, 12-bit ADC channels |
| Analog Output Pins | 10-bit DAC |
| External Interrupts | Available on all pins except pin 4 |
| DC Current per I/O pin | 7 mA |
| EEPROM | Up to 16KB by emulation |
| Clock Speed | 48 MHz |
| Debug | Serial Wire Interface |
| Communications | Bee compatible slot for communication modules with software switchable power |
| Storage | 16Mbit Dataflash Module and Micro SD card holder |
| Power | 5V USB power and/or 3.7V LiPo battery |
| Power switch | Software switchable power for connected devices up to 1A |
| Charging | Solar charge controller, up to 500mA charge current|
| LED's | Yellow charge LED and green LED on pin 13 |
## Flashing the device
The Autonomo has a 10 pin header compatible with the Atmel-ICE. The standard
method for flashing RIOT to the sodaq-autonomo is using OpenOCD. For this to
work properly, **you have to make sure to use a very recent version of
OpenOCD**. Arduino-IDE comes with openocd v0.9.0 which is known to work. Also
Ubuntu 16.04 has openocd v0.9.0.
Refer to https://github.com/RIOT-OS/RIOT/wiki/OpenOCD for building OpenOCD
and make sure "cmsis-dap" and "hidapi-libusb" are enabled.
## Supported Toolchains
To build software for the autonomo board we strongly recommend the usage of
the [GNU Tools for ARM Embedded Processors](https://launchpad.net/gcc-arm-embedded) toolchain.
## Known Issues / Problems
### Stack sizes
The default stack sizes have not been tuned properly yet. If in doubt why
your application crashes try increasing the default stack sizes and use `ps` to
find out how much stack is being used.
Tracked in https://github.com/RIOT-OS/RIOT/issues/2228
*/

56
boards/sodaq-explorer/doc.txt
View File

@ -1,29 +1,29 @@
/**
* @defgroup boards_sodaq-explorer SODAQ ExpLoRer
* @ingroup boards
* @brief Support for the SODAQ ExpLoRer board
*
* ### General information
*
* General information about this board can be found on the
* [SODAQ support](http://support.sodaq.com/sodaq-one/explorer/) website.
*
* ### Flash the board
*
* 1. Put the board in bootloader mode by double tapping the reset button.<br/>
* When the board is in bootloader mode, the user led (blue) oscillates
* smoothly.
*
*
* 2. Use `BOARD=sodaq-explorer` with the `make` command.<br/>
* Example with `hello-world` application:
* ```
* make BOARD=sodaq-explorer -C examples/hello-world flash
* ```
*
* ### Accessing STDIO via UART
*
* To access the STDIO of RIOT, a FTDI to USB converter needs to be plugged to
* the RX/TX pins on the board.
*
*/
@defgroup boards_sodaq-explorer SODAQ ExpLoRer
@ingroup boards
@brief Support for the SODAQ ExpLoRer board
### General information
General information about this board can be found on the
[SODAQ support](http://support.sodaq.com/sodaq-one/explorer/) website.
### Flash the board
1. Put the board in bootloader mode by double tapping the reset button.<br/>
When the board is in bootloader mode, the user led (blue) oscillates
smoothly.
2. Use `BOARD=sodaq-explorer` with the `make` command.<br/>
Example with `hello-world` application:
```
make BOARD=sodaq-explorer -C examples/hello-world flash
```
### Accessing STDIO via UART
To access the STDIO of RIOT, a FTDI to USB converter needs to be plugged to
the RX/TX pins on the board.
*/

119
boards/spark-core/doc.txt Normal file
View File

@ -0,0 +1,119 @@
/**
@defgroup boards_spark-core Spark-Core
@ingroup boards
@brief Support for the spark-core board
## Overview
Spark's hardware dev kit, the Spark Core, provides everything you need to
build a connected product. We combine a powerful ARM Cortex M3 micro-controller
with a Wi-Fi module to get you started quickly. The design is open source, so
when you're ready to integrate the Core into your product, you can.
## Hardware
![Spark-Core image](https://raw.githubusercontent.com/wiki/RIOT-
OS/RIOT/images/spark-core.jpg)
Link to [product website](http://docs.spark.io/hardware/).
### MCU
| MCU | STM32F103CB |
|:------------- |:--------------------- |
| Family | ARM Cortex-M3 |
| Vendor | ST Microelectronics |
| RAM | 20Kb |
| Flash | 128Kb |
| Frequency | up to 72MHz (using the on-board 8MHz Oszillator of the ST- Link) |
| FPU | yes |
| Timers | 10 (9x 16-bit, 1x 32-bit [TIM2]) |
| ADCs | 4x 12-bit |
| UARTs | 5 |
| SPIs | 3 |
| I2Cs | 2 |
| Vcc | 2.0V - 3.6V |
| Datasheet | [Datasheet](https://github.com/spark/core/blob/master/Datasheets/ST_STM32F103CB.pdf) |
| Reference Manual | [Reference Manual](xxx) |
| Programming Manual | [Programming Manual](xxx) |
| Board Manual | [Board Manual](http://docs.spark.io/hardware/)|
# Hardware connection
First of all make sure the your spark core device is detected and can be
accessed properly. In Linux you might have to adept your udev rules accordingly:
```
$ cat 50-openmoko.rules
#Bus 001 Device 022: ID 1d50:607f OpenMoko, Inc.
SUBSYSTEMS=="usb", ATTRS{idVendor}=="1d50", ATTRS{idProduct}=="607f", \
MODE:="0666", \
SYMLINK+="openmoko_%n"
# If you share your linux system with other users, or just don't like the
# idea of write permission for everybody, you can replace MODE:="0666" with
# OWNER:="yourusername" to create the device owned by you, or with
# GROUP:="somegroupname" and mange access using standard unix groups.
sudo cp 50-openmoko.rules /etc/udev/rules.d/
sudo udevadm control --reload-rules
sudo udevadm trigger
```
now replug the usb cable and flash.
# Flashing
To flash RIOT to the spark core you need to install `dfu-util` (tested with
0.7 and 0.8).
Power the device and press the the `mode` button until the LED flashes
yellow/orange: now the device is ready to get flashed.
# Firmware upgrade
To run RIOT it is required that you run the newest spark bootloader on your
core:
from https://community.spark.io/t/replace-core-firmware-with-riot-os/7007/7
```
Here is the core-firmware branch for this:
https://github.com/spark/core-firmware/tree/bootloader-patch-update1
However care should be taken not to disturb the patch update process by
accidentally removing usb power or through reset.
Following is the procedure to update the bootloader-patch
1)cd core-firmware
2)git pull
3)git checkout bootloader-patch-update
4)cd build [No need to run make]
5)Enter usb dfu/bootloader mode => Yellow flashes
6) dfu-util -d 1d50:607f -a 0 -s 0x08005000:leave -D core-firmware.bin
7)Upon execution, the bootloader should be updated within a second or two and
normal core-firmware should start executing.
8)Congrats! your core is loaded with latest bootloader without the hassle of
going through ST-Link JTAG programming
```
Build and flash
===============
1. clone RIOT-OS
2. cd to e.g. `examples/hello_world`
3. enter `BOARD=spark-core make clean all flash`
Use the UART
============
1. RIOT is using the UART PINs on the board, they are labeled as `RT` and
`TX`.
2. Connect your TTY to them and `BOARD=spark-core make term`.
3. In a different terminal enter `BOARD=spark-core make reset`
Pin mapping in RIOT
===================
Please refer to [this document](http://docs.spark.io/assets/images/spark-
pinout.png) for RIOTs static pin mapping chosen for this board. This mapping is
completely arbitrary, it can be adjusted in `boards/spark-
core/include/periph_conf.h`
*/

5
boards/stm32f0discovery/doc.txt Normal file
View File

@ -0,0 +1,5 @@
/**
@defgroup boards_stm32f0discovery STM32F0Discovery
@ingroup boards
@brief Support for the STM32F0Discovery board
*/

160
boards/stm32f3discovery/doc.txt Normal file
View File

@ -0,0 +1,160 @@
/**
@defgroup boards_stm32f3discovery STM32F3Discovery
@ingroup boards
@brief Support for the STM32F3Discovery board
## Overview
The STM32F3-discovery is cheap evaluation board designed by ST for pushing
the STM32F3 microcontoller to a broad audience. It features an STM32F303VC
microcontroller with 48Kb of RAM and 256Kb flash memory running with up to
72MHz. Addionially it provides USB host capabilities, 8 LEDs and sensors for a
9-degree of freedom initial measurement unit (3-axis accelerometer, 3-axis gyro
and 3-axis magnetometer).
The board does however not provide any radio capabilities, radio devices have
to be connected externally via I2C, SPI, UART or similar.
See [this page](https://github.com/RIOT-OS/RIOT/wiki/Getting-started-with-STM32F%5B0%7C3%7C4%5Ddiscovery-boards)
for a quick getting started guide.
## Hardware
![STM32F3discovery image](http://www.st.com/st-web-ui/static/active/en/fragment/product_related/rpn_information/board_photo/stm32f3discovery.jpg)
### MCU
| MCU | STM32F303VC |
|:------------- |:--------------------- |
| Family | ARM Cortex-M4 |
| Vendor | ST Microelectronics |
| RAM | 48Kb (40Kb RAM + 8Kb CCM RAM) |
| Flash | 256Kb |
| Frequency | up to 72MHz (using the on-board 8MHz Oszillator of the ST-Link) |
| FPU | yes |
| Timers | 10 (9x 16-bit, 1x 32-bit [TIM2]) |
| ADCs | 4x 12-bit |
| UARTs | 5 |
| SPIs | 3 |
| I2Cs | 2 |
| Vcc | 2.0V - 3.6V |
| Datasheet | [Datasheet](http://www.st.com/web/en/resource/technical/document/datasheet/DM00058181.pdf) |
| Reference Manual | [Reference Manual](http://www.st.com/web/en/resource/technical/document/reference_manual/DM00043574.pdf) |
| Programming Manual | [Programming Manual](http://www.st.com/st-web-ui/static/active/en/resource/technical/document/programming_manual/DM00046982.pdf) |
| Board Manual | [Board Manual](http://www.st.com/st-web-ui/static/active/en/resource/technical/document/user_manual/DM00063382.pdf)|
### RIOT static pin mapping
please refer to [this](https://docs.google.com/spreadsheets/d/1gnxsux5WpFrn-33Ivb9nGgTBqooqgDYxRkhZms-cvsc/edit?usp=sharing)
* document for the pin mapping as
implemenented in `boards/stm32f3discovery/include/periph_conf.h`
### User Interface
2 Buttons:
| NAME | USER | RESET |
|:----- |:----- |:--------- |
| Pin | PA0 (IN) | NRST |
8 LEDs:
| NAME | LD3 | LD4 | LD5 | LD6 | LD7 | LD8 | LD9 | LD10 |
| ----- | ----- | ----- | ----- | ----- | ----- | ----- | ----- | ----- |
| Color | red | blue | orange| green | green | orange| blue | red |
| Pin | PE9 | PE8 | PE10 | PE15 | PE11 | PE14 | PE12 | PE13 |
### E-Compass / Accelerometer
The board has an on-board MEMS-chip that is an integrated accelerometer and
e-compass.
| Sensor | LSM303DLHC |
|:------------- |:--------------------- |
| Type | Accelerometer and magnetometer |
| Vendor | ST Microelectronics |
| Datasheet | [Datasheet](http://www.st.com/st-web-ui/static/active/en/resource/technical/document/datasheet/DM00027543.pdf)|
| Errata Sheet | [Errata Sheet](http://www.st.com/st-web-ui/static/active/en/fragment/legal/statements/disclaimer/disclaimer_errata.pdf)|
| Connected to | I2C_0 |
| Pin Config: | |
| Device | I2C1 |
| SCL | PB6 (OUT, I2C1_SCL) |
| SDA | PB7 (OUT, I2C1_SDA) |
| DRDY | PE2 (IN) |
| INT1 | PE4 (IN) |
| INT2 | PE5 (IN) |
### Gyroscope
An 3-axis gyroscope is soldered on the board.
| Sensor | L3GD20 |
|:------------- |:--------------------- |
| Type | Gyroscope |
| Vendor | ST Microelectronics |
| Datasheet | [Datasheet](http://www.st.com/st-web-ui/static/active/en/resource/technical/document/datasheet/DM00036465.pdf) |
| Errata Sheet | [Errata Sheet](http://www.st.com/st-web-ui/static/active/en/fragment/legal/statements/disclaimer/disclaimer_errata.pdf)|
| Connected to | SPI_0 |
| Pin Config: | |
| Device | SPI1 |
| SCK | PA5 (OUT, SPI1_SCK) |
| MISO | PA6 (IN, SPI1_MISO) |
| MOSI | PA7 (OUT, SPI1_MOSI) |
| CS | PE3 (OUT) |
| INT1 | PE0 (IN) |
| INT2/DRDY | PE1 (IN) |
## Implementation Status
| Device | ID | Supported | Comments |
|:------------- |:------------- |:------------- |:------------- |
| MCU | STM23F303VC | partly | Energy saving modes not fully utilized |
| Low-level driver | GPIO | yes | |
| | PWM | yes | |
| | UART | full | |
| | I2C | no | in progress |
| | SPI | no | in progress |
| | USB | no | |
| | Timer | full | |
| | Inpute Capture| no | |
| Accelerometer | LSM303DLHC | no | planned |
| Magnetometer | LSM303DLHC | no | planned |
| Gyroscope | L3GD20 | no | planned |
## Flashing the device
The STM32F3discovery board includes an on-board ST-LINK V2 programmer. The
easiest way to program the board is to use OpenOCD. Once you have installed
OpenOCD (look [here](https://github.com/RIOT-OS/RIOT/wiki/OpenOCD) for
installation instructions), you can flash the board simply by typing
```
make flash
```
and debug via GDB by simply typing
```
make debug
```
## Supported Toolchains
For using the STM32F3discovery board we strongly recommend the usage of the
[GNU Tools for ARM Embedded Processors](https://launchpad.net/gcc-arm-embedded)
toolchain.
## Using UART
1. connect your usb tty to: RX=PA10 TX=PA9 and GND=GND
- **PA10** is connected with **TX** on the UART converter
- **PA9** is connected with **RX** on the UART converter
2. done
*/

181
boards/stm32f4discovery/doc.txt Normal file
View File

@ -0,0 +1,181 @@
/**
@defgroup boards_stm32f4discovery STM32F4Discovery
@ingroup boards
@brief Support for the STM32F4Discovery board
## Overview
See [this page](https://github.com/RIOT-OS/RIOT/wiki/Getting-started-with-STM32F%5B0%7C3%7C4%5Ddiscovery-boards)
for a quick getting started guide.
## Hardware
![Stm32f4discovery with RIOT pin names](https://raw.githubusercontent.com/wiki/RIOT-OS/RIOT/images/stm32f4discovery_pinout_RIOT.png)
### MCU
| MCU | STM32F407VGT6 |
|:------------- |:--------------------- |
| Family | ARM Cortex-M4 |
| Vendor | ST Microelectronics |
| Package | LQFP100 |
| RAM | 192Kb (128Kb RAM + 64Kb CCMRAM) |
| Flash | 1024Kb |
| Frequency | up to 168MHz |
| FPU | yes |
| Timers | 14 (12x 16bit, 2x 32bit [TIM2 + TIM5]) |
| ADCs | 3x 16 channel 6 to 12-bit |
| UARTs | 6 |
| SPIs | 3 |
| I2Cs | 3 |
| Vcc | 2.0V - 3.6V |
| Datasheet | [Datasheet](http://www.st.com/web/en/resource/technical/document/datasheet/DM00037051.pdf) |
| Reference Manual | [Reference Manual](http://www.st.com/web/en/resource/technical/document/reference_manual/DM00031020.pdf) |
| Programming Manual | [Programming Manual](http://www.st.com/web/en/resource/technical/document/programming_manual/DM00023388.pdf) |
| Board Manual | [Board Manual](http://www.st.com/st-web-ui/static/active/en/resource/technical/document/user_manual/DM00039084.pdf)|
### RIOT pin mapping
Please refer to [this document](https://docs.google.com/spreadsheets/d/11iqdux3K1-7FPZChufNgpChwENkgCiLrnKJPoCcJxdg/edit?usp=sharing)
for the RIOTs pin
mapping for the stm32f4discovery board. The pin mapping is chosen completely
arbitrary and can be altered by editing the
`boards/stm32f4discovery/include/periph_conf.h` header file.
### User Interface
2 Buttons:
| NAME | USER | RESET |
|:----- |:----- |:--------- |
| Pin | PA0 (IN) | NRST |
6 User controllable LEDs:
| NAME | LD3 | LD4 | LD5 | LD6 | LD7 | LD8 |
| ----- | ----- | ----- | ----- | ----- | ----- | ------ |
| Color | orange| green | red | blue | green | red |
| Pin | PD13 | PD12 | PD14 | PD15 | PA9 | PD5 |
LEDs LD7 and LD8 are used by the USB connector for over-current (LD8) and
data (LD7) indication.
### Accelerometer
The STM32F4discovery board contains a 3-axis MEMS accelerometer that can
sample with up to 1.6kHz.
| Sensor | LIS3DSH |
|:------------- |:--------------------- |
| Type | Accelerometer |
| Vendor | ST Microelectronics |
| Datasheet | [Datasheet](http://www.st.com/st-web-ui/static/active/en/resource/technical/document/datasheet/DM00040962.pdf)|
| Connected to | SPI_0 |
| Pin Config: | |
| Device | SPI1 |
| SCK | PA5 (OUT, SPI1_SCK) |
| MISO | PA6 (IN, SPI1_MISO) |
| MOSI | PA7 (OUT, SPI1_MOSI) |
| INT1 | PE0 (IN) |
| INT2 | PE1 (IN) |
| CS | PE3 (OUT) |
### Digital Microphone
The STM32F4discovery board contains a on-board MEMS audio sensor.
| Sensor | MP45DT02 |
|:------------- |:--------------------- |
| Type | Audio sensor |
| Vendor | ST Microelectronics |
| Datasheet | [Datasheet](http://www.st.com/st-web-ui/static/active/en/resource/technical/document/datasheet/DM00025467.pdf)|
| Connected to | n/a |
| Pin Config: | |
| Device | I2S2 |
| CLK | PB10 |
| DOUT | PC3 |
### Audio DAC with integrated class D speaker driver
The board contains an digital analog converter (DAC) with integrated class D
speaker driver.
| Device | CS43L22 |
|:------------- |:--------------------- |
| Type | DAC |
| Vendor | Cirrus Logic |
| Datasheet | [Datasheet](http://www.cirrus.com/en/pubs/proDatasheet/CS43L22_F2.pdf) |
| Connected to | DAC + I2C + I2S |
| Pin Config: | |
| Device | DAC1 + I2C1 + I2S3 |
| AIN1 | PA4 (DAC1_OUT) |
| SCL | PB6 (I2C1_SCL) |
| SDA | PB9 (I2C1_SDA) |
| MCLK | PC7 (I2S3_MCK) |
| SCLK | PC10 (I2S3_CK) |
| SDIN | PC12 (I2S3_SD) |
| RESET | PD4 (OUT) |
## Supported Toolchains
For using the STM32F4discovery board we strongly recommend the usage of the
[GNU Tools for ARM Embedded Processors](https://launchpad.net/gcc-arm-embedded)
toolchain.
# Alternative way to flash
## Using openocd to flash the RIOT binary to the board
1. Compile your code to have a .hex file
2. Connect the board with the mini usb cable, on the debugger side to your PC
3. run openocd with `$ sudo /usr/local/bin/openocd -f interface/stlink-v2.cfg
-f target/stm32f4x_stlink.cfg`
4. in a new terminal connect: `telnet 127.0.0.1 4444`
5. run:
```
> flash banks
#0 : stm32f4x.flash (stm32f2x) at 0x08000000, size 0x00100000, buswidth 0,
chipwidth 0
> halt
target state: halted
target halted due to debug-request, current mode: Thread
xPSR: 0x21000000 pc: 0x0800251a msp: 0x20000c4c
> flash write_image erase unlock /home/c/git/RIOT-
OS/RIOT/examples/ipc_pingpong/bin/stm32f4discovery/ipc_pingpong.hex 0
auto erase enabled
auto unlock enabled
target state: halted
target halted due to breakpoint, current mode: Thread
xPSR: 0x61000000 pc: 0x20000042 msp: 0x20000c4c
wrote 16384 bytes from file /home/c/git/RIOT-
OS/RIOT/examples/ipc_pingpong/bin/stm32f4discovery/ipc_pingpong.hex in 1.200528s
(13.327 KiB/s)
> reset
```
The board is now flashed with your RIOT binary
## Using UART
1. connect your usb tty to: RX=PA3 TX=PA2 and GND=GND
- **PA3** is connected with **TX** on the UART converter
- **PA2** is connected with **RX** on the UART converter
2. done
## Known Issues / Problems
### I2C
When connecting an I2C device and a logic analyzer to an I2C port at the same
time, the internal pull-up resistors are not sufficient for stable bus
operation. You probably have to connect external pull-ups to both bus lines. 10K
is a good value to start with.
### OS X & make term
If you want the terminal to work using `make term` command and get a message
about missing tty device install the driver from
http://www.silabs.com/products/mcu/pages/usbtouartbridgevcpdrivers.aspx .
*/

5
boards/stm32f769i-disco/doc.txt Normal file
View File

@ -0,0 +1,5 @@
/**
@defgroup boards_stm32f769i-disco STM32F769I-DISCO board
@ingroup boards
@brief Support for the STM32F769I-DISCO board
*/

Some files were not shown because too many files have changed in this diff Show More