Lightweight Embedded Design Framework: Truly Lightweight!

Introduction to mr-library

MR framework is a lightweight framework designed specifically for embedded systems, taking into full consideration the resource and performance requirements of embedded systems. By providing standardized device management interfaces, it greatly simplifies the difficulty of embedded application development, helping developers quickly build embedded applications.

The framework provides standardized interfaces for opening (open), closing (close), controlling (ioctl), reading (read), and writing (write). It decouples the application from the underlying hardware drivers, allowing applications to operate without needing to understand the implementation details of the drivers.

When hardware changes, only the underlying drivers need to be adapted, allowing applications to seamlessly migrate to new hardware. This greatly enhances software reusability and scalability in response to new hardware.

Key Features

• Standardized device access interfaces
• Decoupling of application and driver development
• Simplified development of underlying drivers and applications
• Lightweight and easy to use, low resource consumption
• Modular design, with decoupled and independently developed components, extremely low hardware migration costs
• Supports use in bare-metal environments and operating system environments

Main Components

• Device framework: provides standardized device access interfaces
• Memory management: dynamic memory management
• Tools: commonly used data structures such as linked lists, queues, balanced trees, etc.
• Various functional components

Standardized Device Interface

All operations on the device can be achieved through the following interfaces:

Example:

struct mr_spi_dev spi_dev;

int main(void)
{
    /* Register SPI10 device (CS active low) to SPI1 bus */
    mr_spi_dev_register(&spi_dev, "spi1/spi10", 0, MR_SPI_CS_ACTIVE_LOW);

    /* Open SPI10 device on SPI1 bus */
    int ds = mr_dev_open("spi1/spi10", MR_OFLAG_RDWR);
    
    /* Send data */
    uint8_t wr_buf[] = {0x01, 0x02, 0x03, 0x04};
    mr_dev_write(ds, wr_buf, sizeof(wr_buf));
    
    /* Receive data */
    uint8_t rd_buf[4] = {0};
    mr_dev_read(ds, rd_buf, sizeof(rd_buf));
    
    /* Close device */
    mr_dev_close(ds);
}

Configuration Tool

MR provides a Kconfig visual configuration tool, allowing developers to configure without needing to delve into the source code.

Kconfig automatically generates a configuration options interface based on the configuration file. Developers can choose the functionality components to enable and set related parameters through simple operations.

By modifying parameters, quickly trim the required functionality. After configuration, the configuration file is automatically generated through a Python script.

Directory Structure

Getting Started

Configure Kconfig Environment

Note: Kconfig is not mandatory, but recommended (installation and configuration are very quick, and subsequent tutorials will take Kconfig as an example).

1. Verify if the Python environment is installed on the system. Run python --version in the command line to check the Python version (since Kconfig depends on python, please install python if it is not available).

2. Use the command shown in the command line to install Kconfig:

   python -m pip install windows-curses
   python -m pip install kconfiglib
   

3. Run menuconfig -h in the command line to verify if the installation was successful.

Import Framework into Project

1. Download the latest version of the source code from Gitee or Github repository to your local machine.

2. Import the source code into the directory where your project is located. For example, for an STM32 project:

   

3. If the chip you are using has already been adapted with BSP, please refer to the configuration tutorial in the corresponding BSP to complete the BSP configuration.

4. Remove unnecessary files from the bsp, document, and module directories (if GIT is not needed, you can also remove the .git file). After completion, the directory structure is as follows:

   

5. Add the files to the IDE (most IDEs can automatically recognize the files under the project path, so this step is not necessary). For example, in keil:

   

   Add all files under the source, device, driver directories.

Configure Menu Options

1. Open the command line tool in the mr-library directory and run menuconfig for menu configuration.

   

   Note: After adding the corresponding chip driver, Device configure and Driver configure will be displayed. Please refer to the tutorial in BSP for Driver configure.

2. Select Device configure and press enter to enter the menu, configure functionalities as needed.

   

3. After configuration is complete, press Q to exit the menu configuration interface, and press Y to save the configuration.

Generate Configuration File

1. Open the command line tool in the mr-library directory and run python kconfig.py to automatically generate the configuration file mr_config.h.

Add Include Path

1. Add the include path of mr-library in the compiler, for example:

   

2. Configure automatic initialization (GCC environment), find the linking script file with a .ld suffix under your project (usually link.ld), add the following code to the script file: Note: If you are in an environment that can automatically generate linking scripts like keil, please skip this step.

   /* mr-library auto init */
   . = ALIGN(4);
   _mr_auto_init_start = .;
   KEEP(*(SORT(.auto_init*)))
   _mr_auto_init_end = .;
   

   Example:

   

3. Configure GNU syntax. If you are using a non-GCC compiler, please enable GNU syntax. For example:

   AC5:

   

   AC6:

   

4. Include #include "include/mr_lib.h" in your project.

5. Add mr_auto_init(); automatic initialization function in the main function.

Let’s Turn on the Light

#include "include/mr_lib.h"

/* Define LED pin (PC13)*/
#define LED_PIN_NUMBER                  45

int main(void)
{
    /* Automatic initialization */
    mr_auto_init();

    /* Open PIN device */
    int ds = mr_dev_open("pin", MR_OFLAG_RDWR);
    /* Set to LED pin */
    mr_dev_ioctl(ds, MR_CTL_PIN_SET_NUMBER, mr_make_local(int, LED_PIN_NUMBER));
    /* Set LED pin to push-pull output mode */
    mr_dev_ioctl(ds, MR_CTL_PIN_SET_MODE, mr_make_local(int, MR_PIN_MODE_OUTPUT));

    while(1)
    {
        /* Light up LED */
        mr_dev_write(ds, mr_make_local(uint8_t, MR_PIN_HIGH_LEVEL), sizeof(uint8_t));
        mr_delay_ms(500);
        mr_dev_write(ds, mr_make_local(uint8_t, MR_PIN_LOW_LEVEL), sizeof(uint8_t));
        mr_delay_ms(500);
    }
}

Hello World

#include "include/mr_lib.h"

int main(void)
{
    /* Automatic initialization */
    mr_auto_init();

    /* Open Serial-1 device */
    int ds = mr_dev_open("serial1", MR_OFLAG_RDWR);
    /* Output Hello World */
    mr_dev_write(ds, "Hello World\r\n", sizeof("Hello World\r\n"));
    
    while(1);
}

-END-

Embedded industrial tool, RK3568J supports asymmetric AMP: Linux + RTOS/bare metal!

How to let embedded projects unknowingly head towards a dead end?

A piece of employment information for embedded engineers