DEV Community: Abby

Tell a Story about You & RT-Thread.

Abby — Thu, 14 Jul 2022 08:53:46 +0000

Open Source RT-Thread IoT OS Project has hit 12000 followers on social media platforms.
THANK YOU ALL FOR THE SUPPORT!

So we’re launching this Campaign: Tell a Story About You & RT-Thread!

We want to invite you to share your journeys and experiences with RT-Thread, eg, how did you get to know about RT-Thread? What features of RT-Thread IoT OS impressed you the most? What you’ve done with RT-Thread? Project Showcase? What do you expect to be featured on RT-Thread IoT OS next? Just anything you want to share.

A post or a paragraph of code, or a picture or an article, all works! Remember to mention RT-Thread IoT OS on social media platforms or send us a message to inform us.

Let’s make it more detailed:

To Enter:

Follow RT-Thread IoT OS on Twitter, Facebook, or Linkedin, to keep updated with this campaign.
Share a post, a paragraph of code, a picture, or an article that can tell your stories with RT-Thread on RT-Thread Club or anywhere you like! If you’re sharing on social media platforms don’t forget to mention RT-Thread IoT OS.

Winners: We’ll send out 10 RISC-V Instruction full picture Desk Mat to 10 participants!

Winners Announcement: August 15

Let’s Party! We are very much looking forward to receiving anything!

Day 3 of the 2022 RT-Thread IoT OS Global Tech Conference is about to Begin.

Abby — Fri, 03 Jun 2022 14:54:15 +0000

Howdy Developers!
2022 RT-Thread IoT OS Global Tech Conference is about to begin!
Click the link below to join the conference from Teams or Click the LINK here. https://bit.ly/391C3pE

Looking forward to seeing you all!

ONE Hour To GO! 2022 Open Source RT-Thread IoT OS Global Tech Conference.

Abby — Wed, 01 Jun 2022 15:06:49 +0000

Howdy Developers!

2022 RT-Thread IoT OS Global Tech Conference is about to begin!

2022 IoT OS Global Tech Conference Online & Free

Abby — Thu, 26 May 2022 13:56:01 +0000

The 2021 RT-Thread IoT OS Tech Conference has 1500+ developers registered for the conference, over 20 topics were shared, featured on the open-source RT-Thread OS projects and the new development RT-Smart Micro-Kernel OS, RISC-V ecosystems and associated manufacturers introduced, STM32 ecosystems, embedded projects showcase, IoT security, trending technical knowledge such as AI, ROS, Rust, Micropython, and more!

The 2022 RT-Thread IoT OS Global Tech Conference will continue kicking off with unique insights, exciting innovative technologies, inspiring projects showcases.

As the time for the 2022 RT-Thread IoT OS Global Tech Conference approaches, we’re happy to attach more details to this conference so you’ll know what to expect.

Free Register: http://bit.ly/3GNujSQ

The virtual conference will feature 29 trending topics, starting from June 1 to June 3. Here’s the Agenda:

Dev Boards GiveAway
We’ll randomly giveaway the RT-Thread inside Dev Boards for participants, each day 3 times, and on June 3, we’ll have a Super Luxury Dev Boards Package to give away, so keep closely with the conference and stay tuned, you’re the lucky one!

June 1-3 2022 RGTC! 28 Topics + 9 Times Dev Boards Giveaway | Free&Online

Abby — Thu, 19 May 2022 05:39:51 +0000

Hey Embedded & IoT Developer,

We're Back! The 2022 RT-Thread IoT OS Global Tech Conference

When: June 1- June 3

Location: Microsoft Teams http://bit.ly/3GNujSQ

Join us for an exclusive event! You'll learn all about game-changing inventions from our speakers, get much more useful tips for embedded and IoT development, and hear a real review from experts.

28 Topics + 9 Times Dev Boards Giveaway + Certificate for every participant.

Agenda: https://bit.ly/3lflwkq

Cheers!
RT-Thread Cathy

June1-2: Free Virtual IoT OS Tech Conference

Abby — Sat, 02 Apr 2022 06:02:55 +0000

The most inspired event for developers! You’re invited to talk, to share, to express, to discover, to explore the most cutting-edge advancements in IoT&Embedded with the others!

The 2022 RT-Thread IoT OS Global Tech Conference will continue kicking off with unique insights, exciting innovative technologies, inspiring projects showcases.

So join us to experience the next generation of IoT innovation.

Register Now: https://bit.ly/3GNujSQ

Call for Proposal: https://forms.gle/VytZsuTstebyqkA4A

About RT-Thread IoT OS:

RT-Thread is an open-source embedded real-time operating system, with its rich middle-tier components and extensive hardware and software ecosystem delivering robust support for the Internet of Things (IoT) industry. Since its inception in 2006, RT-Thread has powered 1 billion devices, which includes applications for wearable devices, smart home appliances, energy, automotive electronics, medical electronics, consumer electronics, and many other industries.

Go to RT-Thread Github: https://github.com/RT-Thread/rt-thread

Embedded GUI Contest

Abby — Mon, 21 Mar 2022 02:57:11 +0000

The Internet of Everything extends the embedded devices that emphasize human-computer interaction to describe a more intelligent connection with graphical user interface (GUI) and voice to best clarify the value of the Internet of Things.

We now have easy access to enjoy high-definition, high-nature interaction experiences pervaded through daily life, for example, the smartphone. However, introducing a colorful UI into a resource-limited embedded device (MCU) is not easy.

So RT-Thread IoT OS partnered with LVGL, STMicroelectronics, Nuvoton, and NXP to bring this contest, opening an opportunity for embedded developers that come from everywhere to explore more possibilities with embedded GUI.

The mission is to develop a project with provided hardware and run the opensource RT-Thread IoT OS and LVGL(Light and Versatile Graphics Library).

The hardware available for this contest:

NXP RT1060EVKB *20 (Free Hardware)
STM32F469 Discovery*20 (Free Hardware)
Nuvoton NuMaker-HMI-N9H30*20 (Free Hardware)

All participants whose project is selected will receive the hardware.

Cash prizes are on the line for the Embedded GUI Contest, and the stakes are extremely high:

1st prize is $1,000*1 Participant+Certificate

2nd prize is $500*2 Participants+Certificate

3rd prize is $100*5 Participants+Certificate

Getting started is easy, write your project proposal Now! Be creative, and wow us!

(Submissions deadline: May 1,2022 at 11:59 pm PST)

Resources Attached:

Open Source RT-Thread IoT OS! What’s about it?

Go to RT-Thread Github: https://github.com/RT-Thread/rt-thread

RT-Thread website: https://www.rt-thread.io/

Open Source LVGL!
LVGL (Light and Versatile Graphics Library) is a free and open-source graphics library providing everything you need to create an embedded GUI with easy-to-use graphical elements, beautiful visual effects, and a low memory footprint.

Check out the project: https://lvgl.io/

NXP Semiconductors:

NXP Semiconductors enables a smarter, safer and more sustainable world through innovation. As the world leader in secure connectivity solutions for embedded applications, NXP is pushing boundaries in the automotive, industrial & IoT, mobile, and communication infrastructure markets.

Our Purpose: Bringing together bright minds to create breakthrough technologies that make the connected world better, safer and more secure

More info about NXP RT1060EVKB:

https://www.nxp.com/products/processors-and-microcontrollers/arm-microcontrollers/i-mx-rt-crossover-mcus/i-mx-rt1060-crossover-mcu-with-arm-cortex-m7-core:i.MX-RT1060

https://github.com/RT-Thread/rt-thread/tree/master/bsp/imxrt/imxrt1060-nxp-evk

https://github.com/RT-Thread/rt-thread/tree/master/bsp/imxrt/imxrt1060-nxp-evk/applications/lvgl

ST Microelectronics:

At ST, we are 48,000 creators and makers of semiconductor technologies mastering the semiconductor supply chain with state-of-the-art manufacturing facilities. An independent device manufacturer, we work with more than 200,000 customers and thousands of partners to design and build products, solutions, and ecosystems that address their challenges and opportunities, and the need to support a more sustainable world. Our technologies enable smarter mobility, more efficient power and energy management, and the wide-scale deployment of the Internet of Things and 5G technology. ST is committed to becoming carbon neutral by 2027. Further information can be found at www.st.com.

More info about STM32F469 discovery:

https://www.st.com/en/evaluation-tools/32f469idiscovery.html

https://github.com/RT-Thread/rt-thread/tree/master/bsp/stm32/stm32f469-st-disco/applications/lvgl

https://github.com/RT-Thread/rt-thread/tree/master/bsp/stm32/stm32f469-st-disco

Nuvoton Technology:

Nuvoton Technology Corporation (Nuvoton) was founded to bring innovative semiconductor solutions to the market. Nuvoton was spun-off as a Winbond Electronics affiliate in July 2008 and went public in September 2010 on the Taiwan Stock Exchange (TWSE). Nuvoton focuses on the developments of microcontroller, microprocessor, smart home, cloud security IC, battery monitoring IC, component, visual sensing and IoT with security and has strong market share in Industrial, Automotive, Communication, Consumer and Computer markets. Nuvoton owns 6-inch wafer fabs equipped with diversified processing technologies to provide professional wafer foundry services. Nuvoton provides products with a high performance/cost ratio for its customers by leveraging flexible technology, advanced design capability, and integration of digital and analog technologies. Nuvoton values long term relationships with its partners and customers and is dedicated to continuous innovation of its products, processes, and services. Nuvoton has established subsidiaries in the USA, China, Israel, India, Singapore, Korea and Japan to strengthen regional customer support and global management. For more information, please visit http://www.nuvoton.com

More info about Nuvoton HMI EVB, check:

https://direct.nuvoton.com/tw/numaker-hmi-n9h30

https://github.com/RT-Thread/rt-thread/tree/master/bsp/nuvoton/nk-n9h30

https://blog.lvgl.io/2022-02-18/numaker-hmi-n9h30-review

Let's explore the journey of Embedded GUI Development.

Embedded GUI Webinar

Abby — Mon, 21 Feb 2022 08:46:08 +0000

As you can see, the Internet of Everything extends the embedded devices that emphasize human-computer interaction to describe a more intelligent connection with graphical user interface (GUI) and voice to best clarify the value of the Internet of Things. We now get very easy to enjoy the high-definition, high-nature interaction experiences pervaded through daily life, for example, the smartphone. However, introducing a colorful UI into a resource-limited embedded device (MCU) is not easy.

RT-Thread partnered with LVGL and manufacturers to bring this webinar(a design contest will soon be launching), opening an opportunity for embedded developers that come from everywhere to explore more possibilities with embedded GUI. Topics feature several, such as discussing the best-fitting GUI for your projects, hardware commits to human-computer interaction, skills to simplify GUI development. Also, many examples and projects showcases will be introduced.

⏰ Time: 3/15/2022, 8:00 AM PST
✅ Free & Virtual
✅ The e-certificate is provided to attendees.
👉 Register now: https://bit.ly/3rNzOg6

Halloween Event! What's on your workspace?

Abby — Thu, 21 Oct 2021 03:32:51 +0000

Halloween Event! What's on your workspace?

Take a picture of your workspace
Share the picture below

The most liked comment counted on this Feed and RT-Thread Club Feed will receive a special Halloween Gift.

The winner will be announced on November 1st.

Make sure that you're following the open source RT-Thread Facebook, Twitter, or Linkedin so you'll be updated with the winner announcement!

Happy Dev's Halloween!

Rust for Embedded Development

Abby — Wed, 18 Aug 2021 03:41:02 +0000

What is Rust?

Rust is a language that empowers everyone to build reliable and efficient software. It features

High Performance: Amazing fast speed and high memory utilization
Reliability: Memory errors are able to be eliminated during compilation
Productivity: Great documentation, a friendly compiler with useful error messages, and top-notch tooling — an integrated package manager and build tool, smart multi-editor support with auto-completion and type inspections, an auto-formatter, and more.

Why use RUST on Embedded Development?

Rust is designed to guarantee both security and high performance. The design philosophy is right into what embedded development requires.
While embedded software has running problems that are mostly due to its memory. The Rust language can be regarded as a compiler-oriented language, so you can be sure that you are using memory safely while compiling. Here are some of the benefits of Rust developing on embedded devices:

Powerful static analysis
Flexible memory
Fearless concurrency
Interoperability
Portability
Community driven

Now, let's get it on the Open Source RT-Thread operating system to demonstrate how rust can be used for embedded development.

Call Rust in C

When we're calling the Rust code in C code, requires us to package the Rust source code as a static library file. When the C code compiles, link it in.

Create lib Library

1.Use cargo init --lib rust_to_c to build a lib library in Clion. Add the following code to the lib.rs. The following function evaluates the sum of two values of type i32 and returns the result :

#![no_std]
use core::panic::PanicInfo;

#[no_mangle]
pub extern "C" fn sum(a: i32, b: i32) -> i32 {
    a + b
}

#[panic_handler]
fn panic(_info:&PanicInfo) -> !{
    loop{}
}

2.Add the following code to the Cargo.toml file to tell Rustc what type of library to generate.

[lib]
name = "sum"
crate-type = ["staticlib"]
path = "src/lib.rs"

Cross-compilation

1.Install armv7 target:

   rustup target add armv7a-none-eabi

2.Generate static library file:

   PS C:\Users\LiuKang\Desktop\RUST\rust_to_c> cargo build --target=armv7a-none-eabi --release --verbose
          Fresh rust_to_c v0.1.0 (C:\Users\LiuKang\Desktop\RUST\rust_to_c)
       Finished release [optimized] target(s) in 0.01s

Generate Header File

1.Install cbindgen, cbindgen generates C/C++11 header file from the rust library:

   cargo install --force cbindgen

2.Create a new cbindgen.toml file under the project folder:

3.Generate header file:

   cbindgen --config cbindgen.toml --crate rust_to_c --output sum.h

Call Rust Library File

1.Put the generated sum.h and sum.a files into the rt-thread\bsp\qemu-vexpress-a9\applications directory

2.Modify the SConscript file and add static library:

   from building import *

   cwd     = GetCurrentDir()
   src     = Glob('*.c') + Glob('*.cpp')
   CPPPATH = [cwd]

   LIBS = ["libsum.a"]
   LIBPATH = [GetCurrentDir()]

   group = DefineGroup('Applications', src, depend = [''], CPPPATH = CPPPATH, LIBS = LIBS, LIBPATH = LIBPATH)

   Return('group')

3.Call the sum function in the main function and get the return value and printf the value.

   #include <stdint.h>
   #include <stdio.h>
   #include <stdlib.h>
   #include <rtthread.h>
   #include "sum.h"

   int main(void)
   {
       int32_t tmp;

       tmp = sum(1, 2);
       printf("call rust sum(1, 2) = %d\n", tmp);

       return 0;
   }

4.In RT-Thread Env environment, use scons to compile the project and run:

      LiuKang@DESKTOP-538H6DE D:\repo\github\rt-thread\bsp\qemu-vexpress-a9
      $ scons -j6
      scons: Reading SConscript files ...
      scons: done reading SConscript files.

      scons: warning: you do not seem to have the pywin32 extensions installed;
      parallel (-j) builds may not work reliably with open Python files.
      File "D:\software\env_released_1.2.0\env\tools\Python27\Scripts\scons.py", line 204, in <module>
      scons: Building targets ...
      scons: building associated VariantDir targets: build
      LINK rtthread.elf
      arm-none-eabi-objcopy -O binary rtthread.elf rtthread.bin
      arm-none-eabi-size rtthread.elf
     text    data     bss     dec     hex filename
   628220    2148   86700  717068   af10c rtthread.elf
      scons: done building targets.

      LiuKang@DESKTOP-538H6DE D:\repo\github\rt-thread\bsp\qemu-vexpress-a9
      $ qemu.bat
      WARNING: Image format was not specified for 'sd.bin' and probing guessed raw.
   Automatically detecting the format is dangerous for raw images, write operations on block 0 will be restricted.
   Specify the 'raw' format explicitly to remove the restrictions.

   \ | /
      - RT -     Thread Operating System
   / | \     4.0.4 build Jul 28 2021
   2006 - 2021 Copyright by rt-thread team
      lwIP-2.1.2 initialized!
      [I/sal.skt] Socket Abstraction Layer initialize success.
      [I/SDIO] SD card capacity 65536 KB.
      [I/SDIO] switching card to high speed failed!
      call rust sum(1, 2) = 3
      msh />

Add, subtract, multiply and divide

1.We can implement some complicated math in rust. In the lib.rs file, use the rust language to implement add, subtract, multiply and divide:

     #![no_std]
     use core::panic::PanicInfo;


     #[no_mangle]
     pub extern "C" fn add(a: i32, b: i32) -> i32 {
         a + b
     }

     #[no_mangle]
     pub extern "C" fn subtract(a: i32, b: i32) -> i32 {
         a - b
     }

     #[no_mangle]
     pub extern "C" fn multiply(a: i32, b: i32) -> i32 {
         a * b
     }

     #[no_mangle]
     pub extern "C" fn divide(a: i32, b: i32) -> i32 {
         a / b
     }

     #[panic_handler]
     fn panic(_info:&PanicInfo) -> !{
         loop{}
     }

2.Build library files and header files and place them in the application directory

3.Use scons to compile, if errors jumped on link up, find the solution on its official Github.

      LINK rtthread.elf
      d:/software/env_released_1.2.0/env/tools/gnu_gcc/arm_gcc/mingw/bin/../lib/gcc/arm-none-eabi/5.4.1/armv7-ar/thumb\libgcc.a(_arm_addsubdf3.o): In function `__aeabi_ul2d':
      (.text+0x304): multiple definition of `__aeabi_ul2d'
      applications\libsum.a(compiler_builtins-9b744f6fddf5e719.compiler_builtins.20m0qzjq-cgu.117.rcgu.o):/cargo/registry/src/github.com-1ecc6299db9ec823/compiler_builtins-0.1.35/src/float/conv.rs:143: first defined here
      collect2.exe: error: ld returned 1 exit status
      scons: *** [rtthread.elf] Error 1
      scons: building terminated because of errors.

4.Modify rtconfig.py file, add the link parameter --allow-multiple-definition:

       DEVICE = ' -march=armv7-a -marm -msoft-float'
       CFLAGS = DEVICE + ' -Wall'
       AFLAGS = ' -c' + DEVICE + ' -x assembler-with-cpp -D__ASSEMBLY__ -I.'
       LINK_SCRIPT = 'link.lds'
       LFLAGS = DEVICE + ' -nostartfiles -Wl,--gc-sections,-Map=rtthread.map,-cref,-u,system_vectors,--allow-multiple-definition'+\
                         ' -T %s' % LINK_SCRIPT

       CPATH = ''
       LPATH = ''

5.Compile and run QEMU:

      LiuKang@DESKTOP-538H6DE D:\repo\github\rt-thread\bsp\qemu-vexpress-a9
      $ scons -j6
      scons: Reading SConscript files ...
      scons: done reading SConscript files.

      scons: warning: you do not seem to have the pywin32 extensions installed;
      parallel (-j) builds may not work reliably with open Python files.
      File "D:\software\env_released_1.2.0\env\tools\Python27\Scripts\scons.py", line 204, in <module>
      scons: Building targets ...
      scons: building associated VariantDir targets: build
      LINK rtthread.elf
      arm-none-eabi-objcopy -O binary rtthread.elf rtthread.bin
      arm-none-eabi-size rtthread.elf
     text    data     bss     dec     hex filename
   628756    2148   86700  717604   af324 rtthread.elf
      scons: done building targets.

      LiuKang@DESKTOP-538H6DE D:\repo\github\rt-thread\bsp\qemu-vexpress-a9
      $ qemu.bat
      WARNING: Image format was not specified for 'sd.bin' and probing guessed raw.
       Automatically detecting the format is dangerous for raw images, write operations on block 0 will be restricted.
       Specify the 'raw' format explicitly to remove the restrictions.

   \ | /
      - RT -     Thread Operating System
   / | \     4.0.4 build Jul 28 2021
   2006 - 2021 Copyright by rt-thread team
      lwIP-2.1.2 initialized!
      [I/sal.skt] Socket Abstraction Layer initialize success.
      [I/SDIO] SD card capacity 65536 KB.
      [I/SDIO] switching card to high speed failed!
      call rust sum(1, 2) = 3
      call rust subtract(2, 1) = 1
      call rust multiply(2, 2) = 4
      call rust divide(4, 2) = 2

Call C in Rust

Great to know that Rust can be called in C code, let's give a try to call the rt_kprintf function in Rust:

Modify the lib.rs file

    // The imported rt-thread functions list
    extern "C" {
        pub fn rt_kprintf(format: *const u8, ...);
    }

    #[no_mangle]
    pub extern "C" fn add(a: i32, b: i32) -> i32 {
        unsafe {
            rt_kprintf(b"this is from rust\n" as *const u8);
        }
        a + b
    }

Generate Library File

    cargo build --target=armv7a-none-eabi --release --verbose
       Compiling rust_to_c v0.1.0 (C:\Users\LiuKang\Desktop\RUST\rust_to_c)
         Running `rustc --crate-name sum --edition=2018 src/lib.rs --error-format=json --json=diagnostic-rendered-ansi --crate-type staticlib --emit=dep-info,link -C opt-level=3 -C embed-bitcode=no -C metadata=a
    0723fa112c78339 -C extra-filename=-a0723fa112c78339 --out-dir C:\Users\LiuKang\Desktop\RUST\rust_to_c\target\armv7a-none-eabi\release\deps --target armv7a-none-eabi -L dependency=C:\Users\LiuKang\Desktop\RUS
    T\rust_to_c\target\armv7a-none-eabi\release\deps -L dependency=C:\Users\LiuKang\Desktop\RUST\rust_to_c\target\release\deps`
        Finished release [optimized] target(s) in 0.11s

Run

Copy the library files that generated by rust into the application directory.

    LiuKang@DESKTOP-538H6DE D:\repo\github\rt-thread\bsp\qemu-vexpress-a9                                                       
    $ scons -j6                                                                                                             
    scons: Reading SConscript files ...                                                                                  
    scons: done reading SConscript files.                                                                                                     
    scons: warning: you do not seem to have the pywin32 extensions installed;                                                   
            parallel (-j) builds may not work reliably with open Python files.                                                  
    File "D:\software\env_released_1.2.0\env\tools\Python27\Scripts\scons.py", line 204, in <module>                            
    scons: Building targets ...                                                                                                 
    scons: building associated VariantDir targets: build                                                                        
    LINK rtthread.elf                                                                                                           
    arm-none-eabi-objcopy -O binary rtthread.elf rtthread.bin                                                                   
    arm-none-eabi-size rtthread.elf                                                                                             
       text    data     bss     dec     hex filename                                                                            
     628812    2148   90796  721756   b035c rtthread.elf                                                                        
    scons: done building targets.                                                                                               

    LiuKang@DESKTOP-538H6DE D:\repo\github\rt-thread\bsp\qemu-vexpress-a9                                                       
    $ qemu.bat                                                                                                                  
    WARNING: Image format was not specified for 'sd.bin' and probing guessed raw.                                               
             Automatically detecting the format is dangerous for raw images, write operations on block 0 will be restricted.    
             Specify the 'raw' format explicitly to remove the restrictions.                                                    

     \ | /                                                                                                                      
    - RT -     Thread Operating System                                                                                          
     / | \     4.0.4 build Jul 28 2021                                                                                          
     2006 - 2021 Copyright by rt-thread team                                                                                    
    lwIP-2.1.2 initialized!                                                                                                     
    [I/sal.skt] Socket Abstraction Layer initialize success.                                                                    
    [I/SDIO] SD card capacity 65536 KB.                                                                                         
    [I/SDIO] switching card to high speed failed!                                                                               
    this is from rust                                                                                                           
    call rust sum(1, 2) = 3                                                                                           
    call rust subtract(2, 1) = 1                                                                                                
    call rust multiply(2, 2) = 4                                                                                                
    call rust divide(4, 2) = 2                                                                                     
    msh />

RT-Thread IoT OS Global Tech Conference is open for registration! We welcome developers from different countries to come together to exchange ideas, showcase projects, identify solutions, discuss future strategies, and provide mutual learning opportunities on a wide variety of topics exploring embedded technologies.

Free Register: https://forms.gle/8W1j2ZhCSLKFfyFQ8

RT-Thread IoT OS Tech Conference Virtually on Sep.16–17, 2021.

Abby — Mon, 05 Jul 2021 03:52:58 +0000

The first-ever RT-Thread IoT OS Global Tech Conference will be holding from September 16–17,2021 features embedded technologies, new projects showcase, community contributors track. We welcome embedded developers from across different countries to come together to exchange ideas, showcase projects, identify solutions, discuss future strategies, and provide mutual learning opportunities on a wide variety of topics, let’s exploring embedded technologies.

Free Register: https://forms.gle/8W1j2ZhCSLKFfyFQ8

About RT-Thread:

RT-Thread is an embedded real-time operating system, with its rich middle-tier components and great hardware & software ecosystem delivered great support for the Internet of Things (IoT) industry. Born in 2006, till now, RT-Thread has powered 1 Billion devices, applied in Wearable Devices, Smart Home Appliances, Energy, Automotive Electronics, Medical Electronics, Consumer Electronics, and many other industries.

RT-Thread, a community-powered open source project, we also want to take this time to thank all contributors who shared their time, energy, and talent to help RT-Thread growing! Working alongside the 100K+ community developers strongly inspires RT-Thread to continue exploring and delivering the Best Class of IoT operating system. Let open-source project benefits more people!

Call for Speakers 2021

Submission Link:
https://forms.gle/ZFB3zww5spUWuziY6

Register to Conference:

https://forms.gle/8W1j2ZhCSLKFfyFQ8

How to Port Operating System to Different Chip Architecture?

Abby — Thu, 29 Apr 2021 07:30:10 +0000

There are consolidate steps to transplant the OS onto other hardware platforms, which includes various chips of the same architecture, as well as of different architectures. This article will walk you through how to port OS to many various chips and we learn from open source RT-Thread OS as a case study.

Here are the milestones developers should meet during the porting process:

1.The C-language execution environment is prepared
2.RT-Thread can output characters via a serial port
3.The context switch code works fine
4.Hardware timers are supported by RT-Thread
5.The interrupt routine could handle received data via the serial port

The Execution Model

For most advanced architectures, the operating system and user applications run at different privilege levels, in order to prevent malfunction code affects the integration and safety of OS. For example, In the architecture of ARMv7-A, OS usually runs in the System mode; while in ARMv8-A, OS could run in at the EL2 or EL3 privilege level. Usually, the chip executes the boot-up code at the highest privilege level when powered up. After that, the OS switches the privilege level to its target mode.

Execute C Code

The key action of this step is to set the BSS section to zero and set up the stack pointers.

In the C-language implementations, the uninitialized global variables and static variables are usually stored in the BSS section, which doesn't occupy any space in the storage device. When the program is loaded, the corresponding space is allocated in memory and initialized to zero. When OS boots up, it has to do this work by itself.

On the other hand, the OS has to initialize the stack space and set up the stack pointer as well. Since C-language programs save and restore local variables on the stack when entering and exiting a function, the stack pointer has to be set before invoking any C functions. RT-Thread must do this step for each newly created thread.

At least one serial drive

RT-Thread outputs information and logs via the serial port, which also helps debug the code during the transplantation process. At this step, receiving data via serial ports is not required yet.
If everything works fine, you should see the RT-Thread logo via the serial port.

Context switching logic

The context of a task is its whole execution environment, which contains the generic registers, the program counter, the location of the stack frame, and so on. When a new thread is created, RT-Thread has to allocate and set up its context manually, so that the scheduler could switch to the new thread as it does to others.

There are three things we need to pay attention to. First, When RT-Thread starts up, interrupts are disabled by default. They are enabled when the task scheduler is enabled for the first time, the process of which is implemented in assembly language during the context switch period. Second, the next scheduling starts when a thread exits, by which the resources owned will be reclaimed by the idle thread. Third, the order of pushing data into the stack must be consistent with that of poping data out of the stack.

The sign to improve this function is well working is that you can enter the main function and the msh console normally. However, input control cannot be achieved because serial input interrupts are not implemented, and if serial interrupts have been implemented, msh inputs can be made.

The timer can be normally used

RT-Thread requires a timer to generate interrupts periodically, which is used to count the ticks that elapse since the system startup. The tick number is used not only to provide software interrupt functions but also to instruct the kernel when to start a task scheduling.

Please be careful about setting the value of the time slice, which is usually 10 ms or 1 ms. If a small time slice is chosen on a slow CPU, most of the time will be spent on task switching so that nothing could be done in effect.

Serial port works correctly

In this step, users could interact with RT-Thread msh via the serial port. We input commands and type enter, then msh executes the command and displays results. This process is usually not difficult to implement, however, developers should not forget to clear the interrupt flag on some platforms after the serial port interrupt is handled.

Once the serial port works correctly, the fundamental transplantation process is done.

Conclusion

To port different chip architectures, you should very clear about the architecture of the chip, and very familiar with the underlying code at the most critical point of the Operating System. However, chip manual combines with the actual work experience, you’ll need to learn the chip privilege mode, understand its register and its compilation method.

Now you can give it a try with OpenSource RT-Thread OS. Any questions, feel free to ask for support in RT-Thread Club.

RT-Thread Contact Info:

Website | Github | Twitter | Facebook | Youtube