STM32 on BlocNotes

LoRaWAN on RAK3172 thanks to ST CubeMX, with VS Code

Thu, 06 Jan 2022 00:00:00 +0000

Kongduino kindly sent me a WisDuo RAK3272s few weeks ago, it is a a breakout board for RAK nice module (RAK3172) around the STM32WL5 system on chip from ST. Let’s see how to use STM32 CubeMX to generate the initialization files and the LoRaWAN stack, then setup Visual Studio code debugger.

1. STM32 CubeMX

Download STM32 CubeMX from ST website, install it as instructed.
Open it then create a new project thanks to ACCESS TO MCU SELECTOR. In the Part Number searchbox look for STM32WLE5CC then select STM32WLE5CCUx and Start Project. CubeMX will now create empty project with only the RF and oscillator pins initialized plus some core peripherals, we have to select the features we want:

1.1 Pinout & configuration tab

Analog -> ADC

Check Vrefint Channel, it will be used by the demo application.

Timers -> RTC

Check Activate Clock Source and Activate calendar. Add the following values in configuration section, tab User constants:

RTC_PREDIV_A: ((1<<(15-RTC_N_PREDIV_S))-1)
RTC_N_PREDIV_S: 10
RTC_PREDIV_S: ((1<<RTC_N_PREDIV_S)-1)

In Parameters Settings tab:

Bin mode: Free running binary mode
Asynchronous predivider value: RTC_PREDIV_A

Connectivity -> SUBGHZ

Check Activated to use the LoRa IP.

Connectivity -> USART2

To send traces (printf) from the STM32 to the computer.

Select Mode to Asynchronous
In Configuration section, tab DMA Settings:
1. Click on Add
2. In DMA request select USART2 TX
3. In Channel select DMA 1 channel 5
4. In Direction select Memory to peripheral
5. In Priority select Low
Tab GPIO Settings should already have:
- PA2 as USART2_TX
- PA3 as USART2_RX

Middleware -> LoRaWAN

Check enabled to add the LoRaWAN stack to the project then in the configuration section, tab LoRaWAN Middleware:

lorawan_conf: select your region
Tx Rfo Config: CONF RFO HP

In tab LoraWAN Application:

Application: End Node skeleton
LoRa App->Active region: Select your region

In tab Platform Settings:

Name	IPs or Components	Found Solutions
ADC	ADC: Vrefint channel	ADC
USART	USART: Asynchronous	USART2
RTC	RTC: RTC Enabled	RTC

Note: If you do not know which EUI/Key to use follow the chapter TTN OTAA Device Registration in RAK’s quickstart.

In tab LoRaWAN commissioning:

Check Static Device Eui
Fill LoRaWAN device eui, App/JoinEUI and Application key

System core -> NVIC

Check SUBGHZ Radio Interrupt.

Pin configuration

On the STM32 picture click on:

Pin PB0: select VDDTCXO
Pin PC14: select RCC_OSC32_IN
Pin PC15: select RCC_OSC32_OUT

1.2 Clock Configuration tab

In RTC Clock Mux select LSE input
MSI RC can be pushed to 48000

1.3 Project Manager tab

Set Project name, then in Toolchain/IDE select Makefile.
The project is ready, click on GENERATE CODE in top right corner.

When generated you can open the folder in your favorite editor, I will use VS Code.

2. Configure the C code

Now the program skeleton is generated but it can not be compiled yet, otherwise the compiler with output warnings like:

#warning user to provide its board definitions pins

We have to provide some specifics about the radio pins. Download radio_board_if_c.patch and radio_board_if_h.patch, place them in the root directory of your project then:

patch -u LoRaWAN/Target/radio_board_if.c -i radio_board_if_c.patch
patch -u LoRaWAN/Target/radio_board_if.h -i radio_board_if_h.patch

3. Compile the binary

Download arm-none-eabi toolchain, add it to your path then it is as simple as make -j.

4. Flash the microcontroller

RAK official documentation is using a serial<>USB converter and the integrated STM32 serial bootloader to flash the firmware, but I prefer an ST-Link as I will also be able to debug the code.

4.1 ST-Link pinout and wiring

You can use an ST-Link or any Nucleo header as long as it is broke from the target board or the jumpers ST-LINK are removed. Then the connector SWD/CN4 must be wired to the RAK module, Nucleo’s serial<>USB converter can be used thanks to CN3:

Signal name	Nucleo header	RAK3272s
VDD_ref (optional)	CN4->1	3V3
SWCLK	CN4->2	SWCLK-PA14
GND	CN4->3	GND
SWDIO	CN4->4	SWDIO-PA13
nRST	CN4->5	RST
UART_TX	CN3->1	UART2_TX
UART_RX	CN3->2	UART2_RX
Power Supply (3.3V)	CN1->1	3V3

4.2 Use ST-Link USB mass storage

You can flash the microcontroler by copy/pasting the .bin file in the ST Link folder.

4.3 OpenOCD

Required only if you want to use the debugger. As of december 2021 most OpenOCD releases does not yet include STM32WL support, it has to be compiled from the sources. The steps are easy for Linux:

git clone https://git.code.sf.net/p/openocd/code openocd-code
apt install make libtool pkg-config autoconf automake texinfo libusb-1.0-0 libusb-1.0-0-dev
./bootstrap
./configure --enable-stlink
make
make install

4.5 VS Code

Install the extension Cortex-Debug if you want to use the debugger, then edit the launch.json file, or create it if required, to have

{
    "version": "0.2.0",
    "configurations": [
        {
            "name": "Cortex Debug",
            "cwd": "${workspaceRoot}",
            "executable": "./build/${workspaceFolderBasename}.elf",
            "request": "launch",
            "type": "cortex-debug",
            "servertype": "openocd",
            "configFiles": [
                "interface/stlink.cfg",
                "target/stm32wlx.cfg"
            ],
        }
    ]
}

5. LoRaWAN uplinks

TTN uplinks in the console

If you have any issue the project is available on Gitlab. The project also contains a populated SendTxData() function to actually send uplinks :)

6. Next steps

Now that we are connected to the network the next post should be about optimizing power consumption and enter in stop mode to only consume µAmps when not sending data.

STM32 - Custom USB HID device step by step

Fri, 16 Dec 2016 20:49:40 +0000

Step by step guide to do a custom USB HID device on STM32 using ST CubeMX. There is already one page addressing it but without any details for beginners.
I will use my custom board based on STM32L0, but any Nucleo can be used by wiring a USB cable to 5V, GND, USB_D+, USB_D-.

Step 1 - CubeMX Open it, start a project to select your processor or board.

In Pinout tab configuration->peripheral->usb and check Device (FS). It will tell CubeMX that we want to use USB pins.
You can check Activate OE if you want to see a led blink when there is traffic on USB lines. Then connect a resistor+led on the pin.
Now, to speed up development, we want to use ST’s USB library, so in configuration -> USB_Device select Human interface device class (HID). Be sure to avoid custom class, we want ST working example to test our setup. It will generate a mouse device.
Then in the Clock configuration tab select USBCLK from RC 48 MHZ if your µC is compatible: ST implemented a nice feature allowing us to avoid adding an external quartz by trimming internal 48 MHz RC against USB clock sent by the host. If your uC is not crystal-less you must find a way to have accurate 48 MHz on USBCLK (hint: use HSE)
Then in Configuration tab select Middlewares->USB_Devices. Here you can customize the Device descriptor tab with PID/VID, manufacturer…
Now, generate the project for your IDE.

Step 2 - Test the mouse example First, before modifying anything, we will try

ST’s mouse example. The USB stack is handled by ST’s library so we just need to call it to move the mouse.

Modify main.c to declare and initialise data to be send to the computer, in USER CODE BEGIN 1:

  // HID Mouse
  struct mouseHID_t {
      uint8_t buttons;
      int8_t x;
      int8_t y;
      int8_t wheel;
  };
  struct mouseHID_t mouseHID;
  mouseHID.buttons = 0;
  mouseHID.x = 10;
  mouseHID.y = 0;
  mouseHID.wheel = 0;

Then send them in USER CODE BEGIN 3:

    // Send HID report
    mouseHID.x = 10;
    USBD_HID_SendReport(&hUsbDeviceFS, &mouseHID, sizeof(struct mouseHID_t));
    HAL_Delay(1000);

Compile, then test: the mouse is now slowly drifting to the right :-)

Step 3 - Modifications for custom HID Now we want to change the mouse example

to our custom descriptor. For this tutorial, we will use the keyboard+consumer device (media) descriptor explained in my previous post.
We can add it in Middlewares->...->Src->usbd_hid.c.

Find HID_MOUSE_ReportDesc array and comment or delete it, then add the custom descriptor.

__ALIGN_BEGIN static uint8_t HID_CUSTOM_ReportDesc[HID_CUSTOM_REPORT_DESC_SIZE]  __ALIGN_END = {
  // 78 bytes
  0x05, 0x01,        // Usage Page (Generic Desktop Ctrls)
  0x09, 0x06,        // Usage (Keyboard)
  0xA1, 0x01,        // Collection (Application)
  0x85, 0x01,        //   Report ID (1)
  0x05, 0x07,        //   Usage Page (Kbrd/Keypad)
  0x75, 0x01,        //   Report Size (1)
  0x95, 0x08,        //   Report Count (8)
  0x19, 0xE0,        //   Usage Minimum (0xE0)
  0x29, 0xE7,        //   Usage Maximum (0xE7)
  0x15, 0x00,        //   Logical Minimum (0)
  0x25, 0x01,        //   Logical Maximum (1)
  0x81, 0x02,        //   Input (Data,Var,Abs,No Wrap,Linear,Preferred State,No Null Position)
  0x95, 0x03,        //   Report Count (3)
  0x75, 0x08,        //   Report Size (8)
  0x15, 0x00,        //   Logical Minimum (0)
  0x25, 0x64,        //   Logical Maximum (100)
  0x05, 0x07,        //   Usage Page (Kbrd/Keypad)
  0x19, 0x00,        //   Usage Minimum (0x00)
  0x29, 0x65,        //   Usage Maximum (0x65)
  0x81, 0x00,        //   Input (Data,Array,Abs,No Wrap,Linear,Preferred State,No Null Position)
  0xC0,              // End Collection
  0x05, 0x0C,        // Usage Page (Consumer)
  0x09, 0x01,        // Usage (Consumer Control)
  0xA1, 0x01,        // Collection (Application)
  0x85, 0x02,        //   Report ID (2)
  0x05, 0x0C,        //   Usage Page (Consumer)
  0x15, 0x00,        //   Logical Minimum (0)
  0x25, 0x01,        //   Logical Maximum (1)
  0x75, 0x01,        //   Report Size (1)
  0x95, 0x08,        //   Report Count (8)
  0x09, 0xB5,        //   Usage (Scan Next Track)
  0x09, 0xB6,        //   Usage (Scan Previous Track)
  0x09, 0xB7,        //   Usage (Stop)
  0x09, 0xB8,        //   Usage (Eject)
  0x09, 0xCD,        //   Usage (Play/Pause)
  0x09, 0xE2,        //   Usage (Mute)
  0x09, 0xE9,        //   Usage (Volume Increment)
  0x09, 0xEA,        //   Usage (Volume Decrement)
  0x81, 0x02,        //   Input (Data,Var,Abs,No Wrap,Linear,Preferred State,No Null Position)
  0xC0,              // End Collection
};

Then in USBD_HID_CfgDesc change

bInterfaceSubClass to 0, the keyboard does not respect boot specifications
nInterfaceProtocol to 1 (keyboard)

All references to mouse in the file should be changed to custom.

In Middlewares->...->Src->usbd_hid.h, change:

HID_EPIN_SIZE to 5, the max report size
HID_CUSTOM_REPORT_DESC_SIZE to 78, the length of our new descriptor.

Finally in main.c:
Add reports initialization in USER CODE BEGIN 1

  // HID Keyboard
  struct keyboardHID_t {
      uint8_t id;
      uint8_t modifiers;
      uint8_t key1;
      uint8_t key2;
      uint8_t key3;
  };
  struct keyboardHID_t keyboardHID;
  keyboardHID.id = 1;
  keyboardHID.modifiers = 0;
  keyboardHID.key1 = 0;
  keyboardHID.key2 = 0;
  keyboardHID.key3 = 0;
  // HID Media
  struct mediaHID_t {
    uint8_t id;
    uint8_t keys;
  };
  struct mediaHID_t mediaHID;
  mediaHID.id = 2;
  mediaHID.keys = 0;

And send it in USER CODE BEGIN 3

    // Send HID report
    mediaHID.keys = USB_HID_VOL_DEC;
    USBD_HID_SendReport(&hUsbDeviceFS, &mediaHID, sizeof(struct mediaHID_t));
    HAL_Delay(30);
    mediaHID.keys = 0;
    USBD_HID_SendReport(&hUsbDeviceFS, &mediaHID, sizeof(struct mediaHID_t));
    HAL_Delay(30);

    keyboardHID.modifiers = USB_HID_MODIFIER_RIGHT_SHIFT;
    keyboardHID.key1 = USB_HID_KEY_L;
    USBD_HID_SendReport(&hUsbDeviceFS, &keyboardHID, sizeof(struct keyboardHID_t));
    HAL_Delay(30);
    keyboardHID.modifiers = 0;
    keyboardHID.key1 = 0;
    USBD_HID_SendReport(&hUsbDeviceFS, &keyboardHID, sizeof(struct keyboardHID_t));

Note: There is no need to use two structures if memory optimization is required, but it simplifies the example.

Compile, send to uC and…
The volume is decreasing while ‘L’ characters appear on your screen :-)

Full code can be found on Github, and commit diff from example is there.

Edit 21/02/17: Correction of consumer control descriptor size

Custom USB HID device descriptor: consumer device (media) + keyboard

Tue, 13 Dec 2016 22:02:09 +0000

For a project, I need media keys (play, volume, mute, …) and a way to lock a computer under Windows (Windows+L keys). There is a lot of HID keyboard descriptors on the Internet, some are for keyboards + media but all contain at least one unused byte… Not a good thing for embedded systems with constraint memory. Why? The descriptor can be found in USB-IF example (Appendix B) and describe a boot compatible keyboard. So unless you need your keyboard in boot menus, this byte can be dropped. Also, the example defines 6 simultaneous keys, I decreased it to three as I don’t need more.

Consumer device profile allows a lot of actions, which can be found in HID usage tables document, in §15 consumer page. I selected some relevant to my application (media keys), but you can add more if required: just increase the report count and add the new key.
Note that each started byte must be padded with constant bits, so if your report count is not a multiple of 8, add a constant section.

How to use it?

Prepare an uint8_t table with a size matching the amount of data you have to send plus one for the descriptor (first byte). For media keys, each bit of the second byte will correspond to one key, LSB is the first in the descriptor. For a keyboard, the second byte is for modifiers, and the third, fourth, fifth are for keys.

Those examples are related to the following descriptor.

uint8_t bufferHID[5] = {0, 0, 0, 0, 0};
// Send media mute
bufferHID[0] = 2;      // Start with the report ID
bufferHID[1] = 0x20;   // Set mute bit to 1
USB_HID_SendReport(bufferHID, 2); // Only 2 bytes required : report ID + media keys byte.
// Send Windows+L
bufferHID[0] = 1;      // Start with the report ID
bufferHID[1] = 0x08;   // Set left GUI bit to 1 - Windows or Apple/Cmd key
bufferHID[2] = 0x0F;   // 'l' key
USB_HID_SendReport(bufferHID, 5); // 5 bytes required : report ID + keyboard[4]
delay(30);             // Leave some time for the USB stack
bufferHID[1] = 0;      // Release keys
bufferHID[2] = 0;
USB_HID_SendReport(bufferHID, 5); // Send released keys

Descriptor

Keyboard
Modifiers (MSB-LSB) : RIGHT_GUI-RIGHT_ALT-RIGHT_SHIFT-RIGHT_CTRL-LEFT_GUI-LEFT_ALT-LEFT_SHIFT-LEFT_CTRL
Media keys
Keys (MSB-LSB) : Next-Previous-Stop-Eject-Play/Pause-Mute-Vol inc-Vol dec

Descriptor

// 78 bytes
0x05, 0x01,        // Usage Page (Generic Desktop Ctrls)
0x09, 0x06,        // Usage (Keyboard)
0xA1, 0x01,        // Collection (Application)
0x85, 0x01,        //   Report ID (1)
0x05, 0x07,        //   Usage Page (Kbrd/Keypad)
0x75, 0x01,        //   Report Size (1)
0x95, 0x08,        //   Report Count (8)
0x19, 0xE0,        //   Usage Minimum (0xE0)
0x29, 0xE7,        //   Usage Maximum (0xE7)
0x15, 0x00,        //   Logical Minimum (0)
0x25, 0x01,        //   Logical Maximum (1)
0x81, 0x02,        //   Input (Data,Var,Abs,No Wrap,Linear,Preferred State,No Null Position)
0x95, 0x03,        //   Report Count (3)
0x75, 0x08,        //   Report Size (8)
0x15, 0x00,        //   Logical Minimum (0)
0x25, 0x64,        //   Logical Maximum (100)
0x05, 0x07,        //   Usage Page (Kbrd/Keypad)
0x19, 0x00,        //   Usage Minimum (0x00)
0x29, 0x65,        //   Usage Maximum (0x65)
0x81, 0x00,        //   Input (Data,Array,Abs,No Wrap,Linear,Preferred State,No Null Position)
0xC0,              // End Collection
0x05, 0x0C,        // Usage Page (Consumer)
0x09, 0x01,        // Usage (Consumer Control)
0xA1, 0x01,        // Collection (Application)
0x85, 0x02,        //   Report ID (2)
0x05, 0x0C,        //   Usage Page (Consumer)
0x15, 0x00,        //   Logical Minimum (0)
0x25, 0x01,        //   Logical Maximum (1)
0x75, 0x01,        //   Report Size (1)
0x95, 0x07,        //   Report Count (7)
0x09, 0xB5,        //   Usage (Scan Next Track)
0x09, 0xB6,        //   Usage (Scan Previous Track)
0x09, 0xB7,        //   Usage (Stop)
0x09, 0xB8,        //   Usage (Eject)
0x09, 0xCD,        //   Usage (Play/Pause)
0x09, 0xE2,        //   Usage (Mute)
0x09, 0xE9,        //   Usage (Volume Increment)
0x09, 0xEA,        //   Usage (Volume Decrement)
0x81, 0x02,        //   Input (Data,Var,Abs,No Wrap,Linear,Preferred State,No Null Position)
0xC0,              // End Collection

Helpful defines

// USB media codes
#define USB_HID_SCAN_NEXT 0x01
#define USB_HID_SCAN_PREV 0x02
#define USB_HID_STOP      0x04
#define USB_HID_EJECT     0x08
#define USB_HID_PAUSE     0x10
#define USB_HID_MUTE      0x20
#define USB_HID_VOL_UP    0x40
#define USB_HID_VOL_DEC   0x80

// USB keyboard codes
#define USB_HID_MODIFIER_LEFT_CTRL   0x01
#define USB_HID_MODIFIER_LEFT_SHIFT  0x02
#define USB_HID_MODIFIER_LEFT_ALT    0x04
#define USB_HID_MODIFIER_LEFT_GUI    0x08 // (Win/Apple/Meta)
#define USB_HID_MODIFIER_RIGHT_CTRL  0x10
#define USB_HID_MODIFIER_RIGHT_SHIFT 0x20
#define USB_HID_MODIFIER_RIGHT_ALT   0x40
#define USB_HID_MODIFIER_RIGHT_GUI   0x80
#define USB_HID_KEY_L     0x0F

Documentation

Most useful page I read about custom HID descriptors
USB HID usage table to find key codes.
Next, how to implemnt it on STM32 targets.

STM32 - Log and printf

Sun, 27 Nov 2016 09:41:28 +0000

I am currently using a library which heavily uses LOG() functions, which requires to output text on printf() or one of its derivative. As I am also evaluating ST’s HAL, I tried to use it instead of the low level putc() function.

First, we need to be able to use printf() in combination with HAL_UART_Transmit().
For that, a small trick called variadic functions is required, it allows passing multiple arguments to our function. The other trick is vprintf() which is a printf() with variadic args input and char* output.
Two functions are implemented to be able to match the library Log prototype: void logE(const char* fmt, ...)

#include <stdio.h>
#include <stdarg.h>
#include <string.h>

#define PRINT_BUFFER_SIZE 100

/** Custom printf function in order to use HAL_UART_Transmit()
 * @param *fmt String to print
 * @param argp Parameters list
 */
void HAL_printf_valist(const char *fmt, va_list argp) {
  char string[PRINT_BUFFER_SIZE];

  if (vsprintf(string, fmt, argp) > 0) {
    HAL_UART_Transmit(&HAL_PRINT_UART, (uint8_t*)string, strlen(string), HAL_MAX_DELAY); // send message via UART
  } else {
	HAL_UART_Transmit(&HAL_PRINT_UART, (uint8_t*)"E - Print\n", 14, HAL_MAX_DELAY);
  }
}

/** Custom printf function, only translate to va_list arg HAL_UART.
 * @param *fmt String to print
 * @param ... Data
 */
void HAL_printf(const char *fmt, ...) {
  va_list argp;

  va_start(argp, fmt);
  HAL_printf_valist(fmt, argp);
  va_end(argp);
}

Now serial printf() can be used with a simple HAL_printf("Test: %d", value); call.

And now the implementation of logI() and logE() is obvious:

/** Generic LOG procedure
 * @param Log level
 * @param *fmt String to print
 * @param argp Parameters list
 */
static void log(uint8_t level, const char *fmt, va_list argp) {
	HAL_printf("%c - ", level);
	HAL_printf_valist(fmt, argp);
}

/** LOG procedure - Info
 * @param *fmt String to print
 * @param ... Parameters list
 */
void logI(const char* fmt, ...) {
  va_list argp;

	va_start(argp, fmt);
	log('I', fmt, argp);
	va_end(argp);
}

/** LOG procedure - Error
 * @param *fmt String to print
 * @param .. Parameters list
 */
void logE(const char* fmt, ...) {
  va_list argp;

  va_start(argp, fmt);
  log('E', fmt, argp);
  va_end(argp);
}

Notes:

If you want to display floats with %f and you use GNU ARM provided by OpenSTM32, the flag -u _printf_float must be added to linker options otherwise the data will be only whitespaces.
The main drawback of this method is the size of the char* buffer defined by PRINT_BUFFER_SIZE, you have to be sure that it is big enough for all your strings.

STM32 - Designing an STM32L0xx board

Wed, 09 Nov 2016 15:13:15 +0000

After the STM32L151, I am now designing a board for STM32L052. Following are some notes about ST application notes I read to design an board.

All documents can be found here.
Datasheet, Reference manual, Errata sheet.

Hardware development

AN4467 - Getting started with STM32L0xx hardware development

Hardware

Voltage range, p6
- Full speed (Range 1) : 2.0 to 3.6 VDC
- USB : 3.0 to 3.6 VDC
Power supply capacitors, p11
100 nF by VDD pin
Min 4.7µf for the chip, 10µF recommended
100 nF by VDDA pin
1 µF for the chip, or 10 µF if high sampling rate ADC
Reset circuit, p16
No component mandatory
10 nF to 100 nF pull-down can be added as EMS protection
Clock, p17
No external required
Better to provide a 32.768 kHz quartz for RTC accuracy
Recommended load capacitance for HSE is 2 to 7pF
SWD port, p25
Signals required are: NRST, SWDIO, SWCLK, GND

Debug

No JTAG port
SWD: SerialWire Debug

Boot

See AN2606
Boot configuration
- BOOT1 bit in user option byte, set to 0 by default
- BOOT0 pin, inline 10 kOhm resistor recommended
Boot selection (BOOT1 - BOOT0)
- x-0: Flash memory
- 0-1: System memory (ST bootloader)
- 1-1: SRAM memory
ST bootloader on
- USART1, USART2 (pulls-up required on TX and RX)
- SPI1, SPI2 (pull-down required on CLK)
No DFU
All pins are in floating input state during reset => Do not forget a weak pull for components like MOSFET…

Oscillator design guide

AN2867 - Oscillator design guide

§4.2, p23 - Detailed steps to select an STM32-compatible crystal
§5, p26 - Some recommended resonators for STM32 microcontrollers
§7.1, p30 - PCB design guidelines

Touch sensing

AN3960 - ESD considerations
Most used method is to add an inline 50 Ohm
AN4312 - Guidelines for designing touch sensing applications
If a LED is placed closed to touch interface, use 10 nF bypass capacitor (p15)
If possible use FT I/O instead of TT as they are clamped to VDD, or use Shottky diode with capacitance <5 pf (p15)
Recommended to use the same shape for all electrodes (p18)
Recommended electrode size is 4 times panel thickness

USB

AN4879 - USB hardware and PCB guidelines

Signal lines
90 ohm +/-15% differential
ESD protection circuits like ST USBLC6 are highly recommended

Let’s put it into practice

An open-source dev. board I designed can be found here.

STM32 - Designing an STM32L15xx board

Tue, 15 Mar 2016 11:37:08 +0000

Following are some notes about ST application notes I read to design an STM32L151 board.

All documents can be found here.

AN2606 - Microcontroller system memory boot mode

Bootloader in USART1 or USART2
Unused RX (USART1 or 2) pin must be pulled and not left floating

AN3216 - Hardware development

AN3216 - Getting started with STM32L1xxx hardware development

Hardware

Voltage range
Full speed (Range 1) : 2.0 to 3.6 VDC
Capacitors:
1x100 nF by VDD pin
Min 4.7µf for the chip, 10µF recommended
Reset and power supply supervisor
Power on/down-reset signal - No consumption
Programmable voltage detector - No consumption - between 1.85 and 3.02 V, 200 mV steps. Generates an interrupt.
Brownout detector - Slight power consumption, can be disabled by option byte
Reset circuit
A 100 nF grounded capacitor is recommended, can be reduced to 10 nF
Clock
Multi-Speed Internal : Activated on reset, can be trimmed with high speed external clock.
High Speed External clock : Optional, can be clock source (<32 MHz) or oscillator (1 to 24 MHz)
Low Speed External lock : Optional, can be clock source or oscillator (32.768 kHz). [-30%; +60%} tolerances
PLL : Hook to generate various internal clocks
Clock Security System : Disable HSE if failure detected
Boot configuration : boot0 and boot1 inputs triggers 3 modes:
x0 : Flash memory
01 : System memory (ST bootloader)
11 : SRAM memory
Inline 10 k resistor is recommended
ST bootloader via USART1 or USART2
RX pin from unused USART must not be left floating

Debug

Interface : ARM JTAG (5 pins) or SW ( SerialWire - 2 pins)
See page 23

Recommendations

Use 4 layers PCB with dedicated VSS and VDD layerS. If not, ensured good ground
Separate usages (High current, analog…)
Avoid floating pin I/O, disable unused features

AN1709 - EMC Design (hardware)

EMC design guide for ST microcontrollers

External oscillators must be as close as possible to the µC
Avoid tracks surface and inductance
- Multiple via reduce inductance
Power supply must be decoupled
Unused I/O pin must be set to low output
Shielding might improve, but depends on the selected material

AN1015 - EMC Design (software)

Software techniques for improving microcontrollers EMC performance