Exploring the Applications of Lua in MCU APM32F411

Introduction:

In recent years, Lua has emerged as a popular scripting language for embedded systems, particularly in the realm of microcontrollers. Its lightweight nature, ease of integration, and versatility make it an excellent choice for developing applications in this domain. In this blog post, we will delve into the various applications of Lua in embedded microcontrollers, highlighting its benefits and demonstrating its wide range of capabilities.

1. Embedded Scripting:

Lua's ability to act as an embedded scripting language is one of its key strengths. By integrating a Lua interpreter into a microcontroller's firmware, developers gain the flexibility of executing scripts on the fly. This functionality proves invaluable in scenarios requiring dynamic configuration, parameter adjustments, and firmware updates without the need for recompilation.

2. Control Logic:

Lua's flexible syntax and simplicity lend themselves to writing complex control logic for embedded systems. Whether it's implementing a state machine, handling events, or managing task scheduling, Lua provides an intuitive and efficient means of expressing control flow. The ability to write concise and readable code enhances both development and maintenance processes.

3. Data Processing:

Lua offers a rich set of data processing capabilities, including string manipulation, table operations, and regular expressions. These features prove crucial when dealing with sensor data parsing, communication with external devices, and other data-intensive tasks. Lua's extensibility also enables the creation of custom data structures and algorithms tailored to the specific requirements of the embedded project.

4. User Interface:

With the aid of Lua's integration capabilities, combined with a graphics library or display driver, developers can create user interfaces for embedded systems. This functionality paves the way for interactive applications such as menu systems, configuration interfaces, and data visualization. Furthermore, Lua's simplicity empowers non-experts to create and modify user interfaces, reducing development time and effort.

5. Resource Efficiency:

One significant advantage of Lua in embedded microcontrollers is its efficient resource utilization. Lua's small memory footprint and minimal CPU requirements make it suitable for devices with limited resources. This enables the use of Lua in low-power microcontrollers, where optimizing resource usage is crucial for prolonging battery life or reducing energy consumption.

6. Rapid Prototyping and Testing:

Lua's interpreted nature allows for rapid prototyping and iterative development cycles. Developers can write, test, and modify code on the fly without the need for time-consuming compilation. This enables faster iteration and validation of ideas, leading to shorter development cycles and quicker time-to-market for embedded projects.

7. Integration with Existing Codebase:

Many embedded projects involve existing codebases written in C or C++. Lua seamlessly integrates with such codebases through its C API, enabling communication between Lua scripts and native code. This integration simplifies the process of reusing legacy code or leveraging low-level hardware functionalities, making Lua a versatile choice for projects that require a combination of high-level scripting and low-level hardware interactions.

8. Community and Ecosystem:

Lua benefits from a vibrant and supportive community, providing access to a wide range of libraries, frameworks, and resources. Developers can leverage existing Lua libraries for image processing, networking, and other common tasks, reducing development time and effort. The Lua community also actively contributes to the development of Lua-based tools and frameworks specifically tailored for embedded systems, further enhancing the ecosystem.

9. Firmware Updates and Remote Control:

Lua's scripting capabilities can be leveraged for over-the-air firmware updates in embedded systems. By using Lua scripts, developers can remotely update and modify the functionality of the microcontroller, ensuring that the device stays up-to-date with the latest features and bug fixes. This provides a convenient and efficient way to manage and maintain a fleet of embedded devices in the field.

10. Rapid Deployment and Iteration:

Lua's dynamic nature allows for rapid deployment and iteration of code in real-time. During prototyping or testing phases, developers can modify and fine-tune the code on the microcontroller without the need for reprogramming or reassembling the firmware. This quick iteration enables fast debugging, optimization, and feature enhancement, ultimately resulting in more reliable and robust embedded systems.

11. Task Automation and Scripted Behaviors:

Lua's scripting capabilities enable the automation of tasks and the execution of scripted behaviors in embedded systems. Developers can write Lua scripts to manage events, trigger actions based on certain conditions, and orchestrate complex behaviors. This allows for greater flexibility and adaptability, as the system can dynamically respond to different scenarios and requirements.

12. Rapid Prototyping with Development Boards:

Lua's simplicity and ease of use make it an ideal choice for rapid prototyping with development boards. Many development boards, such as the ESP8266 and ESP32, have Lua interpreters built-in, allowing developers to quickly prototype and experiment with embedded applications. This streamlined prototyping process facilitates early-stage testing and validation of concepts before investing in the full-scale development of the embedded system.

13. Educational Purposes:

Lua's user-friendly syntax and simplicity make it a popular choice for introducing programming and embedded systems to beginners. Its lightweight nature and extensive documentation provide a gentle learning curve, enabling students and enthusiasts to grasp fundamental concepts while exploring the world of embedded devices. Lua's application in educational settings promotes hands-on learning and fosters creativity and innovation.

Conclusion:

Lua has emerged as a powerful scripting language for embedded microcontrollers, offering immense potential for various application domains. Its lightweight footprint, seamless integration, and flexible syntax make it an ideal choice for developers seeking an efficient and user-friendly solution. Whether it's implementing control logic, processing data, or constructing user interfaces, Lua simplifies the development process while delivering robust functionality. As the IoT and embedded systems continue to evolve, Lua remains a valuable tool in the arsenal of embedded developers, empowering innovation in the realm of microcontrollers.

Here is a guide on how to port Lua to APM32F411:

1. Preparation:

• Determine your development environment, such as Keil MDK or IAR.
• Download the latest Lua source code from the Lua official website.

http://www.lua.org/

http://www.lua.org/ftp/lua-5.4.6.tar.gz

2. Project Configuration:

- Create a new folder in your APM32F411 project to store Lua's source code and related files. You can also use the RTC_Alarm project in the SDK.

https://global.geehy.com/uploads/tool/APM32F4xx_SDK_V1.4.zip

Note that the files lua.c and luac.c are not included (they contain the main functions of the Lua interpreter and compiler on the PC), remove them or set them not to compile.

Add lua folder to compiler Include Paths:

3. Compile and Link Settings:

• Include the folder where the Lua source code files are located in the compilation options.
• Configure appropriate compilation options, such as optimization level and memory layout, according to your project requirements.

Enable MicroLIB for "Printf" function used:

Lua Hardware Requirements

l RAM >= 7.5Kb, 16KB or more recommended

l ROM >= 65kb, 128kb or more is recommended.

Change the stack size: heap minimum is 5.5kb, stack minimum is 1.5kb. in the startup file to set the heap (Heap_Size) is large enough, I set 0x00008000 (32KB) is no problem, in fact, can not be so much. It is recommended to set the stack bigger (1KB is enough)

4. Configure Lua:

• Modify the Lua configuration file "luaconf.h" based on the hardware resources and requirements of the APM32F411.
• Ensure that the hardware-related settings in the configuration file are compatible with your APM32F411 chip and peripherals.

5. Add Low-Level Support:

• To enable Lua to run on APM32F411, you need to provide low-level support code. (This example uses the default options. )
• This includes initializing the CPU and system clock, configuring UART for console output, and setting up other required peripherals and interrupt service functions.

/* printf function configs to USART1*/
#define DEBUG_USART  USART1

    USART_Config_T usartConfigStruct;

    usartConfigStruct.baudRate = 115200;
    usartConfigStruct.hardwareFlow = USART_HARDWARE_FLOW_NONE;
    usartConfigStruct.mode = USART_MODE_TX;
    usartConfigStruct.parity = USART_PARITY_NONE;
    usartConfigStruct.stopBits = USART_STOP_BIT_1;
    usartConfigStruct.wordLength = USART_WORD_LEN_8B;
    APM_MINI_COMInit(COM1, &usartConfigStruct);

6. Add lua code or your test code to the project

const char lua_test[] = {
"print(\"Hello,I am lua!\\n--this is newline printf\")\n"
"function foo()\n"
"  local i = 0\n"
"  local sum = 1\n"
"  while i <= 10 do\n"
"    sum = sum * 2\n"
"    i = i + 1\n"
"  end\n"
"return sum\n"
"end\n"
"print(\"sum =\", foo())\n"
"print(\"and sum = 2^11 =\", 2 ^ 11)\n"
"print(\"exp(200) =\", math.exp(200))\n"
};

- Add function call lua test code

static int do_file_script(void)
{
    lua_State *L;
    L = luaL_newstate(); /* 建立Lua运行环境 */
    luaL_openlibs(L);
    luaopen_base(L);
    luaL_dostring(L, lua_test); /* 运行Lua脚本 */
    lua_close(L);
    return 0;
}

-Add header file

#include "lua.h"
#include "lauxlib.h"
#include "lualib.h"
#include "stdlib.h"
#include "time.h"

-Add the following function

time_t time(time_t * time)
{
    return 0;
}
void exit(int status)
{   
}
int system(const char * string)
{
    return 0;
}

7. Build Your Application:

8. Debug and Test:

This process serves as a general guide, and the specific steps may vary depending on individual projects and requirements. Furthermore, while porting Lua, you may also need to address hardware-related issues such as porting and adapting peripheral drivers.

When porting Lua, it is recommended to consult Lua's official documentation and relevant community resources for better understanding and resolution of potential issues.