Web UI Device Dashboard
a complete guide

The table below summarises peripherals for various boards:

Step 1. Start Cube IDE. Choose File / New / STM32 project
Step 2. In the "part number" field, type the microcontroller name, for example "H743ZI". That should narrow down the MCU/MPU list selection in the bottom right corner to a single row. Click on the row at the bottom right, then click on the Next button
Step 3. In the project name field, type any name, click Finish. Answer "yes" if a pop-up dialog appears
Step 4. A configuration window appears. Click on Clock configuration tab. Find a field with a system clock value. Type the maximum value, hit enter, answer "yes" on auto-configuration question, wait until configured
Step 5. Switch to the Pinout tab, Connectivity, then enable the UART controller and pins (see table above), choose "Asynchronous mode"
Step 6. Click on Connectivity / ETH, Choose Mode / RMII, verify that the configured pins are like in the table above - if not, change pins
Step 7. Click on System core / GPIO. Lookup LED pins from the table above. For eaсh LED, click on the corresponding pin, select GPIO_output
Step 8. Click Ctrl+S to save the configuration. This generates the code and opens main.c file
Step 9. Navigate to the main() function and add some logging to the while loop. Make sure to insert your code between the "USER CODE" comments, because CubeIDE will preserve it during code regeneration:

/* USER CODE BEGIN WHILE */
NVIC_EnableIRQ(ETH_IRQn);

while (1) {
  printf("Tick: %lu\r\n", HAL_GetTick());
  HAL_Delay(500);

Step 10. Redirect printf() to the UART. This is also called "IO retargeting". ARM GCC is bundled with a C library called Newlib, developed by RedHat. Newlib implements standard C IO functions like fopen(), fclose(), fread(), fwrite(), fprintf(), printf() in a way that they call a low level "syscall" functions - hence in Cube projects, there is a file syscalls.c. Default syscalls implementations have weak linkage, so it is possible to override a default with our own implementation. Let's do it for the _write() syscall, that is called by printf(). Add the following snippet right after the /* USER CODE BEGIN 0 */ line. Note that if the UART is other that USART3, change the huart3 variable accordingly:

int _write(int fd, unsigned char *buf, int len) {
  if (fd == 1 || fd == 2) {                     // stdout or stderr ?
    HAL_UART_Transmit(&huart3, buf, len, 999);  // Print to the UART
  }
  return len;
}

Step 11. Add mg_millis() function that returns a number of milliseconds since boot. This function will be required for accurate timer tracking. Add it just below the _write() function:

uint64_t mg_millis(void) {
  return HAL_GetTick();
}

Step 12. Click on "Run" button to flash this firmware to the board.
Step 13. Attach a serial monitor tool (e.g. putty on Windows, or cu -l COMPORT -s 115200 on Mac/Linux) and observe UART logs:

Tick: 90358
Tick: 90860
...

Our skeleton firmware is ready!

Step 1. Install necessary packs. Start Keil, click on "Pack Installer" to start an installer. There in the search input, type "stm32f7", then click on "STM32F7 Series". On the right side of the window, you should see "Device Specific / Keil::STM32F7xx_DFP" pack, click on "Install" if it is not yet installed. When installed, install "Generic / Cesanta::Mongoose" pack

Step 2. Start a new project. Create a new project. In the Search filter, type "stm32f756zg", select first device. In the RTE window, check "Device/Startup", click on "Resolve", click OK.

Step 3. Create main.c. Right click on "Source group 1", "Add new file", "C file", type "main", click "Add". Copy/paste the following content, then save:

int main(void) {
  return 0;
}

Step 4. Update settings. Click on "Options for target" in the toolbar,

• On the "Device Target", check "Use MicroLIB"
• On the "User" tab, uncheck "Beep when complete"
• On the C/C++ tab, select Warnings / MISRA compatible
• On the Debug tab, select Use / ST-Link debugger
• Click on debugger "Settings", "Flash Download" tab, check "Reset and Run"
• Increase stack / heap size: open Project files / Device / startup_xxx.s, click on configuration wizard. Set stack to 8192, heap to 128000

Step 5. Build project. Click on "Build" toolbar button. The project should be built with zero errors and warnings.

Step 6. Configure the board. Instead of using CubeMX to configure clock, UART and LED, we'll copy a small HAL header and use it to achieve the same in a much quicker way.

• Open hal.h and copy file contents to the clipboard.
• Right click on "Source Group1", choose "Add new file", name it "hal.h", paste the contents, save
• Do the same for hal.c
• copy it into the project
• Update main.c code with the following:

#include "hal.h"

extern uint64_t mg_millis(void);

int main(void) {
  hal_init();

  uint64_t timer = 0;
  for (;;) {
    if (timer < mg_millis()) {
      timer += 500;
      gpio_toggle(LED1);
      printf("hi! tick is %lu\r\n", (unsigned long) mg_millis());
    }
  }

  return 0;
}

• Click on "Load" toolbar button to flash this firmware
• If you see a message "Flash Download Failed - Target DLL has been cancelled", then you need to update your USB drivers. Open Keil installation folder, Keil_v5 / ARM / STLink / USBDriver, run dpinst_arm64.
• The green LED should start blinking
• Open device manager, look up what COM port device corresponds to your board
• Start putty, and open a serial port with baud 115200
• You should see messages like this:

  hi! tick is 1559001
  hi! tick is 1559501
  hi! tick is 1560001
  

• Congratulations! We have minimal skeleton firmware working

The table below summarises peripherals for various boards:

Step 1. Create a new project. Open the MCUXpresso IDE and go to File -> New -> C/C++ Project.

Step 2. Choosing/Installing the board package.

• Under 'Board and/or Device Selection page', expand the 'SDK MCUs' section and choose the package corresponding to your RT10xx board. If your board is not listed, click the blue 'x' button to download the package. Choose the corresponding package (e.g., for RT1060 EVKB board, select 'evkbimxrt1060') and click 'Install'. A new window appears, make sure the SDK package is selected, and click 'Finish'. Wait for the SDK installation to finish. Once the installation has finished, return to step 1 to create a new project and choose again the package you need. Click 'Next'.

Step 3. Configuring the project.

• After completing the previous step, you will reach the 'Configure the project' section. Leave it as it is and click 'Next' to go to 'Advanced project settings'.
• Here, in the 'Advanced project settings', ensure to tick 'Redirect printf/scanf to UART' and click Finish.

Step 4. Configure the board.

• The project now opens. On the top-right side of the screen, you will notice some green icons representing the IDE perspectives (Develop, Pins, Clocks, Peripherals). These perspectives are used to configure clocks, pins and peripherals. For example, you can configure the clock by clicking the 'clock' perspective. For our minimal skeleton firmware, we will want to configure the pins for the LED, UART and Ethernet. For that, click on the 'Pins' perspective to switch to it.

• On the left-hand side of the window, in the 'Peripheral signals' section, find the corresponding GPIO port, and enable the LED pin. For example, on RT1060 EVKB, the LED pin is the 8th one on the 1st port (GPIO1). Therefore, we will expand the 'GPIO1' section and tick 'gpio_io, 08'.

• Next, the pin will appear below, in the 'Routing details' section. We need to configure it to output mode. To do this, click on the 'Direction' field and select 'Output'.

• Click 'Update Code' in the toolbar and wait for the update to complete.

• UART and Ethernet pins are configured correctly by default. To confirm, you can check this in the 'Pins' perspective by selecting BOARD_InitDEBUG_UART and BOARD_InitENET from the Toolbar's 'Functional Group' section and inspecting the corresponding pins.

Step 5. Update main.c code

• Switch to the 'Develop' perspective.
• Open main.c from the 'source' directory.
• Below the line /* TODO: insert other definitions and declarations here. */, add the code below to get the number of milliseconds since boot.

static volatile uint64_t s_ticks;  // Milliseconds since boot
void SysTick_Handler(void) {       // SyStick IRQ handler, triggered every 1ms
    s_ticks++;
}

uint64_t mg_millis(void) {  // Let Mongoose use our uptime function
  return s_ticks;           // Return number of milliseconds since boot
}

• Replace the main function with the provided one below. Important: Change the line GPIO_PinWrite(GPIO1, 8u, val) with correct LED pin on your board. In this example, we are using pin number 8 from port 1.

int main(void) {
    /* Init board hardware. */
    BOARD_ConfigMPU();
    BOARD_InitBootPins();
    BOARD_InitBootClocks();
    BOARD_InitBootPeripherals();
#ifndef BOARD_INIT_DEBUG_CONSOLE_PERIPHERAL
    /* Init FSL debug console. */
    BOARD_InitDebugConsole();
#endif

    SysTick_Config(SystemCoreClock / 1000);
    uint64_t now = mg_millis();
    bool val = true;
    while (1) {
        if (mg_millis() - now > 999) {
            now = mg_millis();
            printf("hi! tick is %lu\r\n", (unsigned long) now);
            GPIO_PinWrite(GPIO1, 8u, val);
            val = !val;
        }
    }
    return 0 ;
}

Step 6. Building and running.

• Right-click on the project's root folder in the workspace and click 'Build project'.
• To run, click the down arrow next to the green Run button, select Run Configurations. Click 'Launch group' -> 'New launch configuration' -> 'Add' -> select 'C/C++ (NXP Semiconductors) MCU Application'. In the launch mode at the bottom of the window, select 'Debug' and click 'Run'. The firmware will be flashed on the board.
• The program will halt at the first instruction in main, so in order to run, in the toolbar, click 'Resume' or press 'F8' key.

Step 7. Observing the results.

• After flashing, the firmware will start and the LEDs will blink once every second.

• Attach a serial monitor tool (e.g. putty on Windows, or cu -l COMPORT -s 115200 on Mac/Linux) and observe UART logs:

  hi! tick is 4290000
  hi! tick is 4291000
  hi! tick is 4292000
  hi! tick is 4293000
  ...
  

• Congratulations! We have minimal skeleton firmware working

Step 1. Start Modus IDE and create a new project

• Navigate to "File" -> "New" and select "ModusToolbox Application"
• In the pop-up window for the package selector, expand "XMC BSPs" and select "KIT_XMC72_EVK" from the corresponding XMC7 package. Click next.
• Expand "Getting Started" and tick the box corresponding to "Empty App" to choose the empty application template.
• Optionally, name your application "XMC7_skel".
• Click the "Create" button and wait for the installation of dependencies and environment initialization.

Step 2. Open main.c file On the left-hand side, in the 'Project Explorer' section, expand the project root directory and double-click on the 'main.c' file to open it. Replace the entire code with the following code snippet:

int main() {
  return 0;
}

Step 3. Configure the board. In order to configure the board settings (clocks, leds, UART and Ethernet), we are going to use a small HAL header.

• Open hal.h and copy the content to clipboard.
• In "Project Explorer", right click on the project name, choose "New -> File", name it "hal.h", paste the contents and save the file.

Step 4. Update the main.c file In this step, we will add the required functionalities to the main.c file in order to construct a basic firmware skeleton. Add the following code snippets to the main.c file:

• Include 'hal.h' file:

#include "hal.h"

• Provide the actual implementation of the Cy_SystemInit function. This function is called during device startup by the reset handler:

void Cy_SystemInit(void) {
    __enable_irq();
    clock_init();                            // Set system clock to SYS_FREQUENCY
    SystemCoreClock = SYS_FREQUENCY;         // Update SystemCoreClock global var
    SysTick_Config(SystemCoreClock / 1000);  // Sys tick every 1ms
    rng_init();                              // Initialise random number generator

    uart_init(UART_DEBUG, 115200);  // Initialise UART
    gpio_output(LED1);              // Initialise LED1
    gpio_output(LED2);              // Initialise LED2
    gpio_output(LED3);              // Initialise LED3
    ethernet_init();                // Initialise Ethernet pins
}

• Implement SysTick_Handler and get the number of milliseconds since boot:

static volatile uint64_t s_ticks;  // Milliseconds since boot
void SysTick_Handler(void) {       // SyStick IRQ handler, triggered every 1ms
  s_ticks++;
}

uint64_t mg_millis(void) {  // Let Mongoose use our uptime function
  return s_ticks;           // Return number of milliseconds since boot
}

• Redirect printf() to the UART by providing the implementation for the "_write" syscall, which "printf" calls.

int _write(int fd, char *ptr, int len) {
  (void) fd, (void) ptr, (void) len;
  if (fd == 1) uart_write_buf(UART_DEBUG, ptr, (size_t) len);
  return -1;
}

• Finally, update the main function to include LED blinking and UART usage.

int main(void) {
  uint64_t timer = mg_millis();
  for (;;) {
    if (mg_millis() - timer > 999) {
      timer = mg_millis();
      gpio_toggle(LED1);
      printf("hi! tick is %lu\r\n", (unsigned long) mg_millis());
    }
  }

  return 0;
}

Step 5. Register the Ethernet IRQ handler needed by the network driver

• In the 'Project Explorer', open the 'startup_cm7.c' file (found at the path bsps/TARGET_APP_KIT_XMC72_EVK/COMPONENT_CM7/) and add the following line just below the other interrupt handler declarations (right before the line extern const cy_israddress __Vectors[VECTORTABLE_SIZE];):

void ETH_IRQHandler(void) __attribute__((weak, alias("Default_Handler")));

• Then go to system_cm7.c file in the same directory as startup_cm7.c and register the handler by replacing the code from section Function Name: SystemIRQInit with the following:

extern void ETH_IRQHandler(void);
void SystemIrqInit(void) {
    for (int i=0; i<(int)CPUSS_SYSTEM_INT_NR; i++) {
        Cy_SystemIrqUserTable[i] = DEFAULT_HANDLER_NAME;
    }
    Cy_SystemIrqUserTable[eth_1_interrupt_eth_0_IRQn] = ETH_IRQHandler;
    Cy_SysInt_SystemIrqUserTableRamPointer = Cy_SystemIrqUserTable;
}

Step 6. Build and flash the firmware In the file menu bar, go to 'Project' and click 'Build Application'. The firmware will start building and it should finish without any warnings and errors. Once this is completed, make sure the board is connected to your computer. To flash the firmware, in the 'Project explorer', right-click on the project's root directory, and go to 'Run as' -> 'Run Configurations..'. Under 'GDB OpenOCD Debugging' select the 'attach' probe corresponding to your project (example: if the project is named 'XMC7_skel', then select probe "XMC7_skel Attach (KitProg3_MiniProg4)") and click the 'Run' button. The debugger will connect to the board and flashing will start.

Step 7. Observing the results

• After flashing, the firmware will start and the LEDs will blink once every second.
• Attach a serial monitor tool (e.g. putty on Windows, or cu -l COMPORT -s 115200 on Mac/Linux) and observe UART logs:

  hi! tick is 4290000
  hi! tick is 4291000
  hi! tick is 4292000
  hi! tick is 4293000
  ...
  

• Congratulations! We have a working minimal skeleton firmware!

Create an empty project using your favorite IDE or editor. The main.c file should looks like this:

#include "hal.h"

int main(void) {
  hal_init();  // Cross-platform hardware init

  for (;;) {
  }

  return 0;
}

The hal.h file should look like this:

#define LED1 PIN('A', 0)
#define LED2 PIN('A', 1)
#define UART_DEBUG NULL

#define BIT(x) (1UL << (x))
#define CLRSET(reg, clear, set) ((reg) = ((reg) & ~(clear)) | (set))
#define PIN(bank, num) ((((bank) - 'A') << 8) | (num))
#define PINNO(pin) (pin & 255)
#define PINBANK(pin) (pin >> 8)

// No-op HAL API implementation for a device with GPIO and UART
#define hal_init()
#define hal_ram_free() 0
#define hal_ram_used() 0
#define gpio_output(pin)
#define gpio_toggle(pin)
#define gpio_read(pin) 0
#define gpio_write(pin, val)
#define uart_init(uart, baud) 
#define uart_read_ready(uart) 0
#define uart_write_byte(uart, ch)
#define uart_write_buf(uart, buf, len)

Now, build and run this - it should do nothing apart from taking all your CPU. Our skeleton app is ready to go.