Zoltan Hudak / Mbed 2 deprecated MapleMini_Hello Featured

Using low cost LeafLab Maple Mini boards with mbed.

Dependencies:   mbed-MapleMini mbed

Using Maple Mini board with mbed

Sparkfun used to sell a board (now available on eBay and from other online sellers for less than $4) which provides an affordable and flexible way for users to try out new ideas and build prototypes. The board is equipped with an STM32F103CBT6 microcontroller compatible with the mbed NUCLEO-F103RB platform.

Microcontroller features

• STM32F103CBT6 in LQFP48 package
• ARM®32-bit Cortex®-M3 CPU
• 72 MHz max CPU frequency
• VDD from 2.0 V to 3.6 V
• 128 KB Flash
• 20 KB SRAM
• GPIO (34) with external interrupt capability
• 12-bit ADC (2) with 10 channels
• RTC
• Timers (4)
• I2C (2)
• USART (3)
• SPI (2)
• USB 2.0 full-speed
• CAN

Board features

• Small foot-print
• Flexible board power supply: USB VBUS or external source (3.3V, 5V)
• User LED: LED1
• Two push buttons: RESET, USER BUTTON
• Mini-B USB connector

Maple Mini board pinout

Courtesy of Wim Huiskamp Zoom in

LED1=PB_1   SERIAL_TX=PA_2  I2C_SCL=PB_6  SPI_MOSI=PA_7  PWM_OUT=PB_3
            SERIAL_RX=PA_3  I2C_SDA=PB_7  SPI_MISO=PA_6
                                          SPI_SCK =PA_5
                                          SPI_CS  =PB_6

Schematic

The schematic is available here.

Using the mbed online compiler to build programs for Maple Mini

• Create a program as if it was for a NUCLEO-F103RB board (select NUCLEO-F103RB as target platform in the online compiler).
  Or click here to import this demo into your online compiler (then you can skip the following two steps).

• Import the mbed-MapleMini library into your project.

• Add #include "MapleMini.h" to main.cpp before #include "mbed.h" (the position matters!).

#include "MapleMini.h"
#include "mbed.h"
  
int main() {
    confSysClock();     //Configure system clock (72MHz HSE clock, 48MHz USB clock)
    
    Serial      pc(PA_2, PA_3);
    DigitalOut  myled(LED1);
    
    while(1) {
        myled = 1;      // turn the on-board LED on
        wait_ms(200);   // wait 200 milliseconds
        myled = 0;      // turn the on-board LED off
        wait_ms(1000);  // wait 1000 milliseconds
        pc.printf("Blink\r\n");
    }
}

Programming the Maple mini board

You can use the NUCLEO virtual disk to program the Maple Mini (drag and drop programming). To do that, an additional NUCLEO board is needed (any type equipped with ST-LINK/V2-1 will do).

• Remove the two jumpers from the CN2 connector as illustrated in Figure 8:
  
  
  
  
• Connect the NUCLEO board CN4 debug connector to the Maple Mini board using flying wires as follows:

• Provide power for the Maple Mini board.
  
  
• Connect the NUCLEO board to your PC using a USB cable.
  
  
• Maple's flash memory is protected. In order to start downloading programs to the board the protection has to be removed. That could be acomplished with the STM32 ST-LINK Utility. Once installed and running, in Target->Settings switch to Hot Plug mode.
  
  
• In Target->Option bytes disable the Read Out Protection and turn the Flash sectors protection off as well.
  
  
• After that you'll be able to fully erase the chip (including the LeafLabs Maple boot loader).

• Exit the STM32 ST-LINK Utility. From now on you'll be able to download programs to the board.
  
  
• To program the Maple Mini board, click on the Compile button and save the binary to the NUCLEO virtual disk .
  
  For more details have a look at the User Manual, chapter 6.2.4 Using ST-LINK/V2-1 to program and debug an external STM32 application.
  
  

Using serial port (not just for debugging)

• Connect an FTDI or similar USB-Serial converter to your PC and to an on-board serial port (for example PA_2, PA_3). Make sure you connect the on-board TX pin to the converter's RX pin and the on-board RX pin to the converter's TX pin.

• In your code, create a Serial object (using TX and RX pin names of the connected serial port).

• Use printf function to send serial messages to the connected PC.
  
  

#include "mbed.h" 

// declarations needed to change the parameters of stdio UART 
extern serial_t     stdio_uart; 
extern int          stdio_uart_inited; 

int main() {
    serial_init(&stdio_uart, PA_9, PA_10); // other than Serial2
    stdio_uart_inited = 1; 
    printf("Ready for debugging\r\n");
}

Offline compilation and debugging with CooCox CoIDE

NOTE: The pictures below are just for illustration (some belong to the STM32F103C8T6 - Blue Pill project).

• I do not recommend to use the Beta version but rather install CoIDE V1.7.8.

• If not done yet then download and install the GNU Arm Embedded Toolchain onto your PC.

• Keep the NUCLEO board ( ST-LINK) connected to the Maple Mini board as in the set-up for online programming.

• Export your program from the mbed online compiler to CooCox CoIDE.

• Save the file into a folder on you PC's hard drive and unzip.
  
  
• Run CoIDE and open the project.
  
  
• On the menu bar click on Project. Choose Select Toolchain Path and select the path to the GNU Arm Embedded Toolchain. Once completed the path will apply to all projects. (It is not necessary to repeat this for each project but rather do it only once after installing the toolchain.)
  
  
  
  
  
  
• To setup the debugger, open the Debugger tab and use the following settings:
  
  
  
  
• To ensure that the execution of instructions during debugging is performed in the foreseen sequence, go to the Compile tab and select None (-O0) optimization.
  
  
• To be able to use the Serial class in application programs built offline, in the Project side bar navigate to headers/mbed/TARGET_NUCLEO_F103RB/TARGET_STM/TARGET_STM32F1 and open the device.h header file for editing by double-clicking on it. Then add a new line saying #include "mbed_config.h" as below:
  
  After such modification the program should compile with no errors.

• Another option is to use the default serial port which is automatically created by the mbed library. In such case no Serial object (like Serial pc(PA_2, PA_3);) has to be created. Instead the global printf function is called as below. In this case also the binary code becomes smaller. The default settings are 9600 bits/s, one start bit, eight data bits, no parity bit, one stop bit.

#include "MapleMini.h"
#include "mbed.h"
  
int main() {
    confSysClock();     //Configure system clock (72MHz HSE clock, 48MHz USB clock)
    
    //Serial      pc(PA_2, PA_3);
    DigitalOut  myled(LED1);
    
    while(1) {
        myled = 1;      // turn the on-board LED on
        wait_ms(200);   // wait 200 milliseconds
        myled = 0;      // turn the on-board LED off
        wait_ms(1000);  // wait 1000 milliseconds
        //pc.printf("Blink\r\n");
        printf("Blink\r\n");
    }
}

• Open main.cpp for editing and rebuild the project by clicking on the Rebuild button.
  
  
• Reprogram the board by clicking on the Download Code To Flash button:
  NOTE: Any time you launch the debugger the program is getting recompiled and the board reprogrammed. So you can skip this step. I included it just to illustrate how easily you can (re)program the board offline.
  
  
  
  
• Set up some debug points and launch the debugger by clicking on the Start Debug button:
  
  
  
  
• You can execute the instructions step by step (or run to the next debug point) and observe the variables and outputs whether they are changing as expected...
  
  
  
  

Happy coding and debugging :-)