Skip to content

Latest commit

 

History

History
187 lines (131 loc) · 5.31 KB

README.md

File metadata and controls

187 lines (131 loc) · 5.31 KB
Raw

SuperNano-Task-Switch1

The objective of a super-nano Multi-Platform Nano-sized C++ Task Switching System (currently x64 and cortex-m) is to provide hardware and software that for All access will-free.

Build and revise are under way!

Overview

The Multi-Platform Task Switching System is a lightweight, efficient, and portable implementation of a cooperative multitasking system. It supports x64, Cortex-M4F, and Cortex-M7F architectures, making it suitable for a wide range of applications from desktop software to embedded systems. We try to use modern C++20 features, compatibility, and avoid STD or fat libs.

Key Features

  • Cross-Platform Compatibility: Runs on x64, Cortex-M4F, and Cortex-M7F architectures & next RISC-V in cenetr
  • Lightweight: Minimal overhead, suitable for resource-constrained systems,KEEP arround KB of flash & bytes of RAM !! & arrount 100 cycle of cpu for switch
  • Cooperative Multitasking: Efficient task switching without the need for a full RTOS, in next we ad managment event with high priority time ,but keep Cooperative this balance managment & safety
  • Easy Integration: Simple API for creating and managing tasks
  • Debuggable: Optional debug output for development and troubleshooting, NEXT under KB of code & can dubug & realtime trace with current SWD device
  • Modern Build System: Uses CMake for easy compilation across different platforms

Architecture

The system consists of the following key components:

  1. Task: Base class for defining individual tasks
  2. TaskManager: Manages task creation, scheduling, and switching
  3. Platform-Specific Implementations: Separate implementations for x64, Cortex-M4F, and Cortex-M7F

File Structure

project_root/
├── CMakeLists.txt
├── include/
│   └── task_system.hpp
├── src/
│   ├── task_system.cpp
│   ├── task_system_x64.cpp
│   ├── task_system_cortex_m4f.cpp
│   ├── task_system_cortex_m7f.cpp
│   └── main.cpp
└── linker_script.ld (for ARM builds)

Setup and Installation

Prerequisites

  • CMake (version 3.15 or higher)
  • For x64: A modern C++ compiler (GCC, Clang)
  • For ARM: arm-none-eabi-gcc toolchain

Installation Steps

  1. Clone the repository:

    git clone https://github.com/yourusername/task-switching-system.git
cd task-switching-system

  2. Create a build directory:

    mkdir build && cd build

  3. Configure the project using CMake (see Build Process for platform-specific commands)

  4. Build the project:

    cmake --build .

  5. (Optional) Install the built binaries:

    cmake --install .

Build Process

For x64 Platforms

cmake ..
cmake --build .

For Cortex-M4F

cmake -DCMAKE_SYSTEM_NAME=Generic -DCMAKE_SYSTEM_PROCESSOR=arm -DARM_CPU=cortex-m4f -DCMAKE_TOOLCHAIN_FILE=path/to/arm-none-eabi-gcc.cmake ..
cmake --build .

For Cortex-M7F

cmake -DCMAKE_SYSTEM_NAME=Generic -DCMAKE_SYSTEM_PROCESSOR=arm -DARM_CPU=cortex-m7f -DCMAKE_TOOLCHAIN_FILE=path/to/arm-none-eabi-gcc.cmake ..
cmake --build .

Enabling Debug Output

Add -DENABLE_DEBUG=ON to your CMake configuration command to enable debug output.

Usage

Creating a Task

  1. Include the necessary header:

    #include "task_system.hpp"

  2. Define your task by inheriting from the Task class:

    class MyTask : public Task {
public:
    MyTask() : Task(1) {} // 1 is the task ID

    void run() override {
        while (true) {
            // Your task logic here
            TaskManager::yield();
        }
    }
};

  3. Create an instance of your task:

    MyTask myTask;

Setting Up the Task Manager

In your main function:

int main() {
    TaskManager taskManager;
    taskManager.add_task(&myTask);
    taskManager.start();
    return 0;
}

Yielding Control

Within your task's run() method, use TaskManager::yield() to cooperatively give up control:

TaskManager::yield();

Debugging

When compiled with -DENABLE_DEBUG=ON, the system will output debug information. You can add your own debug statements using the DEBUG_PRINT macro:

DEBUG_PRINT("Task %u is running", task_id);

Performance Considerations

  • The system uses cooperative multitasking, so tasks must yield voluntarily.
  • On ARM platforms, context switching is optimized using assembly code.
  • Avoid long-running operations without yielding to ensure responsive task switching.
  • in next we weork on special mechanism keep Cooperative & also high level managment for tune perfomance & safety on the fly

Troubleshooting

  1. Compilation Errors on ARM: Ensure you're using the correct toolchain file and have the arm-none-eabi-gcc toolchain installed.

  2. Tasks Not Switching: Check that your tasks are calling TaskManager::yield() regularly.

  3. Unexpected Behavior on ARM: Verify that the linker script is correct for your specific microcontroller.

  4. Debug Output Not Showing: Confirm that you've built with -DENABLE_DEBUG=ON.

Contributing

Contributions are welcome! Please fork the repository and submit a pull request with your changes.

License

This project is licensed under the MIT License - see the LICENSE file for details.