#FreeRTOS

[its-faizurbd-me]

Key Benefits of Windows 10 for Users

Windows 10 is a dependable and flexible operating system that can be used for both personal and business purposes. A number of important features that improve security, performance, and usability are included in the official version.

[icnweb]

인피니언, 차량용 AURIX MCU에 FreeRTOS 지원

안정적인 오픈 소스 환경에서 애플리케이션을 빠르게 구축할 수 있다 인피니언의 차량용 MCU AURIX™ TC3x 인피니언 테크놀로지스(코리아 대표이사 이승수)는 AURIX™ TC3x 마이크로컨트롤러(MCU)에 FreeRTOS 지원을 추가했다고 밝혔다. 마이크로컨트롤러에서 실행되는 핵심 소프트웨어 구성 요소인 RTOS는 하드웨어 및 소프트웨어 리소스를 효율적으로 관리하여 작업을 적시에 안정적으로 실행할 수 있도록 한다. 인피니언의 AURIX TC3x MCU는 자동차 및 산업용 시장의 엄격한 요구 사항을 충족하는 ASIL-D/SIL-3을 준수하도록 개발되었다. 고성능 TriCore™ 아키텍처로 구동되어 실시간 기능, 고급 안전 기능 및 기능 안정성을 제공하므로 까다로운 애플리케이션에…

[bitstream24]

Practical Multitasking Fundamentals with FreeRTOS for ESP32

Why would you develop your own Real-Time Operating System (RTOS) and your application when the proven FreeRTOS software is available free of charge? Why not start with a proven foundation? FreeRTOS is a market-leading real-time operating system (RTOS) for microcontrollers and small microprocessors.

[virtualgirladvance]

Hi Lan! Hope your wait isn't too long, if you had a choice of operating system, what would it be? Would you take an era-appropriate chassis as well?

Ooooo that's a toughie. I've always been a debian and arch girlie but something like freeRTOS seems more suited for the role. Arch memes and stereotypes aside it probably suits me more(go fast, east ass, leave a beautiful buggy mess) so lets go with that.

Chassis wise I'd love something a lil bulky and industrial, you know the kind with lots of exposed maintenance access, room for modifications and mounting points. Maybe with some aftermarket transparent panels here and there or added lighting and displays

[andmaybegayer]

ah ha, the reason the buffer didn't fit on the stack was because it didn't make the stack big enough to hold the buffer, obviously. I definitely know how freertos works. I definitely haven't been looking right past that for a day.

[digitaldetoxworld]

Building Your Own Operating System: A Beginner’s Guide

An operating system (OS) is an essential component of computer systems, serving as an interface between hardware and software. It manages system resources, provides services to users and applications, and ensures efficient execution of processes. Without an OS, users would have to manually manage hardware resources, making computing impractical for everyday use.

Lightweight operating system for old laptops

Functions of an Operating System

Operating systems perform several crucial functions to maintain system stability and usability. These functions include:

1. Process Management

 The OS allocates resources to processes and ensures fair execution while preventing conflicts. It employs algorithms like First-Come-First-Serve (FCFS), Round Robin, and Shortest Job Next (SJN) to optimize CPU utilization and maintain system responsiveness.

2. Memory Management

The OS tracks memory usage and prevents memory leaks by implementing techniques such as paging, segmentation, and virtual memory. These mechanisms enable multitasking and improve overall system performance.

3. File System Management

It provides mechanisms for reading, writing, and deleting files while maintaining security through permissions and access control. File systems such as NTFS, FAT32, and ext4 are widely used across different operating systems.

4. Device Management

 The OS provides device drivers to facilitate interaction with hardware components like printers, keyboards, and network adapters. It ensures smooth data exchange and resource allocation for input/output (I/O) operations.

5. Security and Access Control

 It enforces authentication, authorization, and encryption mechanisms to protect user data and system integrity. Modern OSs incorporate features like firewalls, anti-malware tools, and secure boot processes to prevent unauthorized access and cyber threats.

6. User Interface

 CLI-based systems, such as Linux terminals, provide direct access to system commands, while GUI-based systems, such as Windows and macOS, offer intuitive navigation through icons and menus.

Types of Operating Systems

Operating systems come in various forms, each designed to cater to specific computing needs. Some common types include:

1. Batch Operating System

These systems were widely used in early computing environments for tasks like payroll processing and scientific computations.

2. Multi-User Operating System

��It ensures fair resource allocation and prevents conflicts between users. Examples include UNIX and Windows Server.

3. Real-Time Operating System (RTOS)

RTOS is designed for time-sensitive applications, where processing must occur within strict deadlines. It is used in embedded systems, medical devices, and industrial automation. Examples include VxWorks and FreeRTOS.

4  Mobile Operating System

Mobile OSs are tailored for smartphones and tablets, offering touchscreen interfaces and app ecosystems. 

5  Distributed Operating System

Distributed OS manages multiple computers as a single system, enabling resource sharing and parallel processing. It is used in cloud computing and supercomputing environments. Examples include Google’s Fuchsia and Amoeba.

Popular Operating Systems

Several operating systems dominate the computing landscape, each catering to specific user needs and hardware platforms.

1. Microsoft Windows

 It is popular among home users, businesses, and gamers. Windows 10 and 11 are the latest versions, offering improved performance, security, and compatibility.

2. macOS

macOS is Apple’s proprietary OS designed for Mac computers. It provides a seamless experience with Apple hardware and software, featuring robust security and high-end multimedia capabilities.

3. Linux

Linux is an open-source OS favored by developers, system administrators, and security professionals. It offers various distributions, including Ubuntu, Fedora, and Debian, each catering to different user preferences.

4. Android

It is based on the Linux kernel and supports a vast ecosystem of applications.

5. iOS

iOS is Apple’s mobile OS, known for its smooth performance, security, and exclusive app ecosystem. It powers iPhones and iPads, offering seamless integration with other Apple devices.

Future of Operating Systems

The future of operating systems is shaped by emerging technologies such as artificial intelligence (AI), cloud computing, and edge computing. Some key trends include:

1. AI-Driven OS Enhancements

AI-powered features, such as voice assistants and predictive automation, are becoming integral to modern OSs. AI helps optimize performance, enhance security, and personalize user experiences.

2. Cloud-Based Operating Systems

Cloud OSs enable users to access applications and data remotely. Chrome OS is an example of a cloud-centric OS that relies on internet connectivity for most functions.

3. Edge Computing Integration

With the rise of IoT devices, edge computing is gaining importance. Future OSs will focus on decentralized computing, reducing latency and improving real-time processing.

4. Increased Focus on Security

Cyber threats continue to evolve, prompting OS developers to implement advanced security measures such as zero-trust architectures, multi-factor authentication, and blockchain-based security.

[siliconsignalsblog]

Top 3 Tips to Balance Performance & Power Consumption in Embedded Application Development

In embedded systems development, achieving the right balance between performance and power efficiency is an ongoing challenge—especially when working with microcontrollers (MCUs) and low-resource hardware. The right software design decisions can dramatically extend battery life without compromising responsiveness or reliability.

Here are three actionable strategies every embedded engineer should consider to get the best of both worlds.

1. Build Smarter Software with Efficient Code

The foundation of energy-efficient embedded development begins with how your software is structured and optimized.

Here’s what helps:

Choose better algorithms: Replacing inefficient logic (like O(n²)) with more optimized versions (O(n log n)) reduces CPU cycles and energy use.

Go event-driven, not polling: Event-based logic allows your system to enter sleep modes rather than constantly checking for changes.

Cut down on memory operations: Repetitive dynamic memory allocation increases power draw. Keep it lean and predictable.

Use hardware accelerators: Leverage MCU features like DSPs or crypto engines to offload work and reduce CPU load.

Pro Tip: Use compiler flags like -Os for size and power optimization. Tools like EnergyTrace or ARM's Power Debugger can help you find energy-heavy hotspots in your code.

2. Leverage OS and Middleware Power-Saving Features

Your choice of OS and middleware isn’t just a performance decision—it’s an energy one too.

Here’s how to optimize it:

Pick a power-aware RTOS: Systems like Zephyr and FreeRTOS come with built-in low-power features.

Use MCU low-power modes: Utilize deep sleep, stop, or standby modes to lower consumption during idle times.

Optimize peripheral management: Disable or scale down unused modules like timers, ADCs, or communication interfaces.

Reduce wake-up frequency: Combine tasks and delay non-critical activities to avoid excessive interruptions.

Scale clock speeds dynamically: Lowering clock rates during low workload periods helps reduce energy consumption.

Pro Tip: Use vendor-specific tools like the ST Power Calculator or Nordic’s Power Profiler to fine-tune system settings based on actual workloads.

3. Profile, Analyze, and Keep Optimizing

Even perfectly written code can consume more power than expected without proper testing and profiling.

Here’s your checklist:

Continuously monitor energy usage: Real-time power monitoring highlights inefficiencies across code paths.

Test in real-world conditions: Optimize based on typical usage patterns, not just lab simulations or edge cases.

Refine iteratively: Small updates—like fine-tuning interrupts or reducing wake-ups—can lead to major gains.

Slow down (intelligently): Your application doesn’t need to run at max speed—just fast enough. Slower = more efficient, when done wisely.

Pro Tip: Use simulation tools like Renesas e² Studio Power Profiler to preview energy impacts of code changes before testing on physical hardware.

Final Thoughts

In embedded development, managing the trade-off between performance and energy consumption is critical. But with the right software architecture, OS features, and continuous optimization, it's absolutely achievable.

By making informed engineering decisions, you can build high-performance, power-efficient embedded applications that last longer, run cooler, and deliver better user experiences.

👉 At Silicon Signals, we help companies build power-conscious embedded solutions using best-in-class design practices, real-time OS integration, and performance profiling techniques. 📩 Let’s connect to optimize your next embedded product — from prototype to production.

[bliiot-jerry]

ARMxy Industrial Computers BL330 for Water Treatment System Monitoring

Case Details

I. Advantages of ARMxy Industrial Computers BL330

Low Power Consumption

ARM architecture Cortex-A7 processors, consume significantly less power than x86 CPUs, ideal for 24/7 industrial operations.

Real-Time Performance

Supports real-time operating systems (RTOS) or Linux with real-time kernels, meeting time-sensitive data acquisition and control requirements.

Compact and Rugged Design

Compact size for space-constrained installations; operates in harsh environments (-40°C to 85°C) with resistance to dust, vibration, and humidity.

Rich Interfaces and Expandability

Equipped with industrial interfaces (RS-485, CAN, Ethernet, GPIO) to connect sensors (pH, turbidity, conductivity), PLCs, and actuators.

Cost-Effective

Lower hardware and maintenance costs compared to traditional industrial PCs, suitable for large-scale deployments.

II. Core Functions in Water Treatment Monitoring

Data Acquisition and Processing

Real-time collection of water quality parameters (COD, BOD, residual chlorine, dissolved oxygen) and equipment status (pump pressure, flow rate, valve position).

Communication via Modbus RTU/TCP, OPC UA protocols.

Edge Computing

Local data preprocessing (filtering, anomaly detection) to reduce cloud bandwidth usage.

Basic logic control (e.g., automatic chemical dosing based on pH levels).

Remote Monitoring and Visualization

Built-in web server or HMI for real-time data display and alarm management.

Data transmission to cloud platforms (SCADA, IoT Hub) via 4G/5G, Ethernet, WiFi.

Fault Diagnosis and Alerts

Predictive maintenance using historical data (e.g., membrane fouling, pump failure).

Trigger alarms or send notifications to operators via SMS/email.

III. Typical Applications

1. Online Water Quality Monitoring Stations

Function:

Deploy at water sources or treatment outlets to monitor turbidity, pH, heavy metals (e.g., arsenic, lead).

Hardware:

ARM computer + multi-parameter sensors + solar power (for remote areas).

2. PLC Replacement in Wastewater Treatment Plants

Function:

Replace traditional PLCs to control dissolved oxygen in aeration tanks, optimize sludge recycling, and adjust chemical dosing.

Solution:

ARM computer running Codesys soft PLC with PID algorithms, controlling devices via EtherCAT.

3. Distributed Rural Water Supply Monitoring

Function:

Monitor decentralized water purification systems (filter lifespan, flow anomalies) to ensure safe drinking water.

Architecture:

ARM edge gateway + sensor+ low-power design for unstable power supply scenarios.

IV. System Design Considerations

Environmental Adaptability

Use Industrial enclosures to protect against moisture and corrosive gases.

Communication Redundancy

Dual-network interfaces (wired + wireless) for reliable data transmission.

Software Architecture

Lightweight OS (Ubuntu, Linux) or RTOS (FreeRTOS) with MQTT/HTTP protocols.

Local storage (SQLite) or time-series databases (InfluxDB).

Cybersecurity

Enable firewalls, TLS/SSL encryption, and regular firmware updates.

V. Case Studies

Seawater Desalination Plant Monitoring

Hardware: ARM Cortex-A7 computer + pressure sensors + RO membrane modules.

Functions:

Monitor pressure differentials across RO membranes to predict fouling.

Automatically shut down high-pressure pumps during overloads.

OPC UA integration with central control systems.

Industrial Park Wastewater Station

Hardware: ARM edge gateway + AI cameras.

Functions:

AI-based foam thickness detection in aeration tanks to adjust blower speed.

Local TensorFlow Lite models for sludge settling ratio analysis.

VI. Challenges and Solutions

Sensor Data Drift

Regular calibration or machine learning-based compensation algorithms.

Long-Term Stability

Watchdog timers and industrial-grade eMMC storage.

Edge Deployment

Integrate lightweight frameworks (ONNX Runtime) for local water quality prediction.

VII. FAQs and Maintenance

Communication Failure: Check SIM signal strength or Ethernet connections.

Data Anomalies: Verify sensor power supply or grounding issues.

System Lag: Optimize software thread priorities.

ARM industrial computers enable cost-effective, intelligent monitoring for water treatment systems. For specific projects, consider

More low-cost industrial solutions：ARMxy SBC BL335

[bliiot]

Comparison of Ubuntu, Debian, and Yocto for IIoT and Edge Computing

In industrial IoT (IIoT) and edge computing scenarios, Ubuntu, Debian, and Yocto Project each have unique advantages. Below is a detailed comparison and recommendations for these three systems:

1. Ubuntu (ARM)

Advantages

Ready-to-use: Provides official ARM images (e.g., Ubuntu Server 22.04 LTS) supporting hardware like Raspberry Pi and NVIDIA Jetson, requiring no complex configuration.

Cloud-native support: Built-in tools like MicroK8s, Docker, and Kubernetes, ideal for edge-cloud collaboration.

Long-term support (LTS): 5 years of security updates, meeting industrial stability requirements.

Rich software ecosystem: Access to AI/ML tools (e.g., TensorFlow Lite) and databases (e.g., PostgreSQL ARM-optimized) via APT and Snap Store.

Use Cases

Rapid prototyping: Quick deployment of Python/Node.js applications on edge gateways.

AI edge inference: Running computer vision models (e.g., ROS 2 + Ubuntu) on Jetson devices.

Lightweight K8s clusters: Edge nodes managed by MicroK8s.

Limitations

Higher resource usage (minimum ~512MB RAM), unsuitable for ultra-low-power devices.

2. Debian (ARM)

Advantages

Exceptional stability: Packages undergo rigorous testing, ideal for 24/7 industrial operation.

Lightweight: Minimal installation requires only 128MB RAM; GUI-free versions available.

Long-term support: Up to 10+ years of security updates via Debian LTS (with commercial support).

Hardware compatibility: Supports older or niche ARM chips (e.g., TI Sitara series).

Use Cases

Industrial controllers: PLCs, HMIs, and other devices requiring deterministic responses.

Network edge devices: Firewalls, protocol gateways (e.g., Modbus-to-MQTT).

Critical systems (medical/transport): Compliance with IEC 62304/DO-178C certifications.

Limitations

Older software versions (e.g., default GCC version); newer features require backports.

3. Yocto Project

Advantages

Full customization: Tailor everything from kernel to user space, generating minimal images (<50MB possible).

Real-time extensions: Supports Xenomai/Preempt-RT patches for μs-level latency.

Cross-platform portability: Single recipe set adapts to multiple hardware platforms (e.g., NXP i.MX6 → i.MX8).

Security design: Built-in industrial-grade features like SELinux and dm-verity.

Use Cases

Custom industrial devices: Requires specific kernel configurations or proprietary drivers (e.g., CAN-FD bus support).

High real-time systems: Robotic motion control, CNC machines.

Resource-constrained terminals: Sensor nodes running lightweight stacks (e.g., Zephyr+FreeRTOS hybrid deployment).

Limitations

Steep learning curve (BitBake syntax required); longer development cycles.

4. Comparison Summary

5. Selection Recommendations

Choose Ubuntu ARM: For rapid deployment of edge AI applications (e.g., vision detection on Jetson) or deep integration with public clouds (e.g., AWS IoT Greengrass).

Choose Debian ARM: For mission-critical industrial equipment (e.g., substation monitoring) where stability outweighs feature novelty.

Choose Yocto Project: For custom hardware development (e.g., proprietary industrial boards) or strict real-time/safety certification (e.g., ISO 13849) requirements.

6. Hybrid Architecture Example

Smart factory edge node:

Real-time control layer: RTOS built with Yocto (controlling robotic arms)

Data processing layer: Debian running OPC UA servers

Cloud connectivity layer: Ubuntu Server managing K8s edge clusters

Combining these systems based on specific needs can maximize the efficiency of IIoT edge computing.

[rapidise]

A Comprehensive Guide for Embedded Software Development for Medical Devices 

As a reality check, the embedded software development life cycle of a medical device is not only challenging, but it is also sophisticated in regard to the value proposition it presents to the healthcare payers and patients. Consequently, as the field of medicine continuous to evolve, these tools become more complex as their operations are managed by embedded software which needs to be integrated with the system in a way that guarantees safe and effective operation. This in-depth tutorial will guide you through the development embedded software for medical devices and all regulatory considerations that must be addressed.

Grasping the Regulatory Framework

Manufacturers of medical devices will always be bound by the numerous laws from the Federal Drug Administration (FDA) concerning effectiveness and safety of medical devices. Starting March 2023, the FDA began restricting submissions of Software Bill of Materials (SBOM) unless there was a set cybersecurity strategy. By October 2023 the FDA started refusing to accept submission of devices that had cyber security problems.

The regulatory landscape requires manufacturers to:

Implement a risk-based approach to software design and testing Conduct thorough validation of software functionality and security

Ensure devices can detect and respond to security incidents

Establish processes for monitoring and reporting security issues

Conduct ongoing testing throughout the device's lifecycle

Key Components of Embedded Medical Device Software

Hardware-Software Integration

In medical devices, embedded systems must achieve full intergration of hardware parts and software. This is necessary to guarantee that the medical devices operate as needed and that safety regulations are satisfied.

Real-Time Operating Systems (RTOS)

Many medical devices use Real-Time Operating Systems because they require some degree of waiting time to perform an important task. Such OS’s are essential in time-sensitive operations. For embedded medical devices, RTOS frameworks like FreeRTOS and Zephyr are routinely deployed.

Software Architecture

The structure has to be modular, so that later maintenance, testing, and validation would be easier. That also helps meet regulatory standards because tracking requirements to be enacted is simplified.

Read Also: Integrating Hardware and Software in Embedded Systems Development

The Development Process

Establishing a Regulatory Strategy Early

Prior to commencing any developmental work, formulate and put in writing a regulatory strategy that is aligned with the device's capabilities and goals. This becomes particularly critical in the case of Software as a Medical Device (SaMD), wherein modifying software becomes relatively easier than changing a hardware component.

Selecting the Right Development Team

Select the relevant personnel from the software policy team having working knowledge in cyber security, more so, if drastic changes are anticipated post initial launch of the product. Engage the services of engineers specialized in software development of medical devices as they have working knowledge of the required documentation for the device regulatory processes.

Programming Languages and Tools

Common languages used in embedded medical device development include:

C: Efficient and suitable for low-level memory management

C++: Provides object-oriented features for complex systems

Assembly: For performance-critical applications requiring direct hardware access

Rust: Offers memory safety features for developing secure systems

Implementing Security by Design

Security is not an add-on but a fundamental aspect of medical device software development. The FDA requires manufacturers to:

Conduct secruity risk assessments to identify potential vulnerabilities

Implement security controls to mitigate identified risks

Design software to be resilient against potential attacks

Ensure the ability to detect and respond to security incidents

Testing and Validation

Comprehensive Testing Approach

Testing should cover every aspect of the software, including:

Unit testing for individual components

Integration testing for combined components

System testing for the entire device

Performance testing under various conditions

Security testing to identify vulnerabilities

Documentation Requirements

Thorough documentation is essential for regulatory compliance. This includes:

Design specifications

Risk assessments

Test protocols and results

Validation reports

User manuals and technical documents

Post-Market Requirements

Getting regulatory clearance is just the beginning. Once your device is on the market, you must:

1. Maintain annual Establishment Registration

2. List your device(s)

3. Implement and maintain Quality Management System (QMS) processes

4. Document changes to software and assess regulatory impact

5. Be prepared for FDA audits

6. Run postmarket cybersecurity processes including periodic penetration tests and vulnerability scans

7. Conduct postmarket surveillance

8. Produce Unique Device Identifiers for new versions

Managing Software Updates

Yes, you can update your software after FDA clearance, and in fact, the FDA expects you to provide cybersecurity updates. However, significant changes may require a new 510(k) submission, possibly including new clinical or performance data.

Strategic planning around feature development is crucial. Consider creating key features that FDA needs to evaluate in version 1.0, then have your engineering team work on version 1.1 features while waiting for FDA review.

Best Practices for Success

Optimize code for performance, power consumption, and memory usage

Implement robust error handling mechanisms

Reuse code when possible to reduce development time

Provide thorough documentation for maintainability

Perform comprehensive testing to ensure code meets requirements

Raise sufficient funding for clinical performance validation, non-clinical testing, software documentation, and cybersecurity.

Conclusion

A greener tomorrow starts with better healthcare today, and embedded software for medical devices is at the forefront of this transformation. By integrating robust security measures, following regulatory guidelines, and implementing best development practices, manufacturers can create safe, effective medical devices that enhance patient care while maintaining compliance.

Let's build smarter, develop better, and create medical devices that care for both patients and healthcare providers. The truth is, embedded software development for medical devices is complex but essential for advancing healthcare technology and improving patient outcomes.

[tia003]

What is real-time OS?

A Real-Time Operating System (RTOS) is a specialized operating system designed to serve real-time applications that process data as it comes in, typically without any buffering delays. Unlike general-purpose operating systems, an RTOS provides deterministic timing and quick responsiveness, which is crucial for systems where timing is critical.

In an RTOS, tasks are managed and prioritized so that high-priority operations are executed precisely when needed. The system ensures minimal latency between the occurrence of an event and the system's response to it. This is vital in scenarios like medical devices, industrial automation, robotics, and automotive control systems, where even a slight delay can lead to malfunction or safety risks.

An RTOS typically supports multitasking, priority-based scheduling, and inter-task communication. It ensures that tasks are predictable, meaning the system can guarantee task execution within a defined time frame. Key components include task management, memory management, time management, and device management. Common examples of real-time operating systems include FreeRTOS, VxWorks, and RTEMS.

There are two types of RTOS: Hard RTOS and Soft RTOS. Hard RTOS guarantees strict timing constraints and is used in critical systems like pacemakers or braking systems. Soft RTOS, on the other hand, offers flexibility and is used in applications where occasional delays are tolerable, like multimedia systems.

In embedded systems, RTOS plays a central role in ensuring system reliability and performance. Developers often choose RTOS to simplify complex task handling and improve scalability.

If you're looking to gain hands-on experience and theoretical knowledge in designing real-time applications, enrolling in an embedded system certification course is an excellent step toward mastering this essential technology.

[souhaillaghchimdev]

Learning Operating System Development from Scratch

Developing an operating system (OS) from scratch is one of the most challenging yet rewarding projects for aspiring software developers and computer scientists. It provides deep insights into how computers work, the role of software in hardware management, and the intricacies of system programming. In this post, we’ll explore the fundamental concepts of OS development and provide a roadmap to get started.

What is an Operating System?

An operating system is software that acts as an intermediary between computer hardware and the user applications. It manages hardware resources, provides a user interface, and enables multitasking and process management.

Core Functions of an OS

Process Management: Handling the execution of processes and multitasking.

Memory Management: Allocating and managing memory for processes.

File System Management: Organizing and managing data storage.

Device Management: Controlling hardware devices and managing input/output operations.

User Interface: Providing user interactions through command-line or graphical interfaces.

Prerequisites for OS Development

Programming Skills: Strong knowledge of C/C++ and assembly language.

Computer Architecture: Understanding how hardware components interact with software.

Data Structures & Algorithms: Familiarity with common data structures and algorithms used in OS design.

System Programming: Knowledge of system calls and low-level programming.

Development Environment Setup

Choose a Programming Language: Primarily C or C++ for the OS kernel.

Set Up a Cross-Compiler: Use a cross-compiler to generate binaries for your target architecture.

Create a Bootable Image: Learn to create bootable images to run on emulators or real hardware.

Use Emulators: QEMU or Bochs for testing your OS without needing physical hardware.

Basic Structure of an Operating System

#include <stdio.h> #include <stdint.h> void kernel_main() { // This is where your kernel code will begin executing. const char *str = "Hello, Operating System!"; // Function to output to the screen (implement your own). print_string(str); } void print_string(const char *str) { while (*str) { // Output each character to the screen // Implementation dependent on the hardware. } }

Learning Resources

Books: "Operating Systems: Three Easy Pieces" by Remzi H. Arpaci-Dusseau, "Modern Operating Systems" by Andrew S. Tanenbaum.

Online Courses: Look for OS development courses on platforms like Coursera or edX.

Open Source Projects: Study existing open-source OS projects like Linux, MINIX, or FreeRTOS.

Communities: Engage in forums like Stack Overflow, Reddit, or specialized OS development communities.

Challenges in OS Development

Debugging low-level code can be complex and time-consuming.

Resource management and concurrency can introduce unexpected behavior.

Compatibility with various hardware can be a significant hurdle.

Performance optimization is crucial for a functional OS.

Conclusion

Building an operating system from scratch is a daunting task that requires patience, dedication, and a thirst for knowledge. However, the skills you develop and the understanding you gain will be invaluable in your programming career. Start with small projects, gradually expand your scope, and enjoy the journey into the world of OS development!

[govindhtech]

Intel Quartus Prime Pro Edition 25.1 Optimized for Agilex 3

Altera Launches Quartus Prime Pro Edition 25.1 for Agilex 3 FPGAs

Now available is Quartus Prime Pro 25.1, which supports Agilex 3, the latest Agilex release. Developers may design high-performing, power-efficient edge and embedded programs with this update.

Comprehensive Agilex 3 FPGA support

Agilex 3 FPGA family offers cost optimisation, high performance, and power efficiency for edge and embedded applications. This version lets you develop, test, and implement solutions faster with Agilex 3 higher-speed transceivers, on-chip dual Cortex-A55 ARM CPUs, and increased memory support, including LPDDR4.

For small board space applications, Agilex 3 uses Intel's variable pitch BGA packaging to design more efficiently and compactly. With this technology, developers can maintain performance and power efficiency while adding functionality to smaller spaces.

Security is essential for FPGA applications to protect sensitive data and IP. Agilex 3's physical security, authentication, and encryption capabilities strengthen designs' manipulation and assault resistance.

Nios V Soft Processor Enhancements

Nios V is vital for embedded applications and improves efficiency and performance. These improvements allow developers to make smaller, more efficient embedded devices.

Improved Nios V/g Core Performance Improved work completion and overall performance.

Nios V/c Core Area reduction saves 8% space, leading in smaller designs.

The Ashling RISCFree IDE's Visual Studio Code plugin simplifies Nios V software development.

TinyML Example Design with Nios V Application Note lets developers add machine learning (ML) to FPGA designs utilising microcontrollers.

Features of Embed Software

FPGA-based embedded applications need strong OS and virtualisation support. By adding Linux, RTOS, and hypervisor support, Quartus Prime Pro 25.1 lets developers build scalable, real-time, and virtualised embedded systems.

Linux Hardware Reference Designs Regular and standard editions for Linux development.

To support Xen, developers can virtualise FPGA programs.

RTOS supports Zephyr and Bare Metal, and FreeRTOS will arrive in Q2 (May).

Installer Improvements: Faster, flexible configuration

FPGA software should install and adapt easily. Quartus Prime Pro 25.1 improves installation with parallel processing, configurable component selection, and file management.

Installation in Parallel speeds up setup by installing many components simultaneously.

By letting users choose just the bits they need, Dynamic Components decrease installation time and disc space.

Troubleshoot hardware quickly with streaming debugging

Effective debugging reduces development cycles. The Streaming Debug IP for Signal Tap helps engineers debug FPGA designs by capturing real-time, high-bandwidth data.

Hardware debugging streaming allows real-time data flow for analysis.

Configurable streaming via STP Signal Tap Logic Analyser configures streaming and selects a debug host.

Simulation Enhancements

Quartus Prime Pro 25.1 improves integration, long-term support, and simulation with new native Altera AXI4 Bus Functional Models (BFMs).

Optimised for Quartus simulation workflows, native Altera AXI4 BFMs increase performance and compatibility.

Smooth Change With better toolchain integration, customers may switch to Altera AXI4 BFMs without substantial modifications.

Quartus Prime Pro 25.1 improves simulation performance, notably for transceiver protocol IP, enabling faster debugging and verification.

Better Transceiver Protocol IP simulation enhances PCIe, Ethernet, Serial Lite, JESD, and other transceiver protocols.

25.1 Beta Models The new simulation models for this edition focus on Ethernet and PCIe and are under beta testing.

Improved Efficiency Usually, 50% or more improvements speed up verification and reduce simulation time.

These simulation additions improve Quartus Prime Pro 25.1's transceiver-based FPGA design capabilities by speeding up simulations and reducing verification time.

Extra Quartus Prime Pro 25.1 Updates

QPDS Standard & Pro Containerised Images Docker Hub offers Quartus Prime Standard and Pro Editions containerised, simplifying deployment and improving cloud and CI/CD compatibility.

Separating timed closure data from Design Assistant results simplifies failure classification in Summary of Design Closure.

SDC Relative File Paths improve portability and script management for Synopsys Design Constraints (SDC) reports.

MTBF improvements It lets users adjust instance toggling rates to improve MTBF when default toggle rates are not suitable.

Static timing analysis improvements in Quartus Prime Pro 25.1 speed up timing problem identification and resolution.

Synthesis supports basic Quad-Port RAM. Automatic quad-port RAM inference expands memory design flexibility.

Complete Support for Byte Enable Inference in Synthesis: This adds 8-bit byte enables and supports 5, 8, 9, and 10-bit combinations, matching hardware capabilities.

Correcter Management Users can now write individual bytes within a word using the byte enable control signal to increase memory access and performance.

Better RAM inference lets designers use FPGA memory more readily.

FPGA AI Suite: Improved Usability and AI

As AI advances, FPGA-based inference systems must be more flexible and effective. This release includes better performance estimation, model support, and Agilex FPGA integration.

Support Agilex 3 Beta FPGA AI Suite beta supports Agilex 3 FPGAs. Build in Quartus with Agilex 3 and generate Inference IP targeting Agilex 5 in the architectural configuration file.

The RPM and DEB packages are now called “altera-fpga-ai-suite-” and the AI Suite is installed in “/opt/altera” instead of “/opt/intel”.

YoloV7 Model Support enables high-accuracy object recognition in robotics, surveillance, and industrial quality control.

Agilex 5 FPGA E-Series Example Design Support New Agilex 5 FPGA E-Series 065B Modular Development Kit sample designs are available.

This SoC example uses an ARM host CPU for AI inference. AI Inference IP and a novel layout transform enable folding and run-time configurability to improve AI model performance and usability.

Example of Hostless JTAG-Attach Design A system console linked to the Inference IP via JTAG allows users to setup and control IP functionality step-by-step.

Performance Estimator Uses Memory Bandwidth Users may now define external memory bandwidth when designing for memory-limited devices like Agilex 5 and Agilex 3, improving accuracy.

OpenVINO 2024.6 Integration FPGA AI Suite 25.1 uses the latest OpenVINO 2024.6 for stability and maintainability.

For two years, Quartus Prime Pro versions will only include the Long-Term Support AI Suite, which uses new optimisations and performance improvements.

FPGA AI Suite 25.1 simplifies FPGA AI inference with faster performance, more example designs, and greater model support.

Quartus Prime Pro 25.1 IP Features

After adding Agilex 3 IP cores and upgrading Agilex 5, Quartus Prime Pro 25.1 delivers real-time data processing, flexible memory access, and rapid connectivity for many applications.

Agilex 3 IPs

Agilex 3 has a wide range of memory, processor, and connectivity IPs for low-cost applications:

1.25 Gbps LVDS and MIPI D-PHY high-voltage and fast adaptable I/O Assistance interfaces.

PCIe 3.0, 10GE Hard IP, and 12.5Gbps transceivers ensure high-bandwidth applications.

LPDDR4 provides cost-effective embedded memory up to 2133 Mbps.

HPS EMIF ensures tight ARM Cortex integration.

HD Image and Video Processing Our VVP package accelerates video and vision processing applications.

JESD204B for Synchronising Data Converters synchronises 12.5Gbps multi-channels accurately.

The Transceiver Toolkit for Advanced Debugging improved transceiver link testing and debugging.

Agilex 5 IP updates

Performance and flexibility enhancements to Agilex 5 series IP include:

PMA-Direct real-time adaptive reconfiguration of multiple configurations

PCIe 3.0/4.0 Multi-Channel DMA supports x2/x4 Root Port (RP) and Endpoint (EP) modes.

Agilex 5 D Series enabled 12.5 Gbps per serial channel in Interlaken for scalable data transport.

Transceiver Toolkit 17.16 Gbps JESD204B Advanced Debugging ensures rapid, accurate data flow.

Dual-Simplex Mode Protocol JESD204C expands high-speed ADC/DAC interface for more advanced signal processing.

O-RAN IP: Supports 15–240 KHz subcarrier frequencies and real-time spacing changes via control messages. Scalable and conserved digital power.

The Agilex 3 and Agilex 5 FPGAs are ideal for embedded, networking, and AI-driven applications due to their performance, efficiency, and adaptability.

Conclusion

Quartus Prime Pro 25.1 improves Agilex 3 support, debugging tools, AI acceleration, IP cores, and usability. Optimisation for embedded apps, high-speed interfaces, or AI workloads is faster, more efficient, and more flexible with this version.

[engineeringpu]

What are Embedded Systems | Dr. Anupam Sobti

The embedded systems course at Plaksha University is designed to provide insight into how electronic products are designed and manufactured. The course is divided into 4 parts:

Module 1: Power it Up: Starting from developing a deep understanding of how power supplies are designed and used, we do bare bones chip-level design. We build microcontroller based designs on our own printed circuit boards.

Module 2: Connect it together: We learn how to interface different types of peripherals with microcontrollers and the different types of interfaces that are used in embedded system design. We discuss both aspects - the computer architecture and the software design of the systems. We discuss the internal architecture design as well as software usage for the various modules in a microcontroller apart from the CPU - timers, interrupts, Analog to Digital Converters (ADCs). We end this module with a discussion of the state of the art devices built and a showcase that the underlying hardware remains surprisingly simple.

Module 3: Modularise and Sustain: Next, we discuss how a real-time operating system (RTOS) simplifies embedded software design and provides facilities for automatic virtualization and memory management. We see code examples from the popular FreeRTOS and Zephyr RTOS systems. We concluded this module by touching briefly on embedded linux - the world of yocto and buildroot.

Module 4: Add Magic: Finally, we see how machine learning is sprinkling magic into embedded systems and helping build devices of the future. Here, we explore the world of TinyML and bring together learnings from various courses - Foundations of Computer Systems, Machine Learning, Deep Learning, etc.

[virtualgirladvance]

As you are a robot-girl What operating system do you run on yourself?

Im mostly analogue except for the small upgrade that now manages my passive life support that runs off freeRTOS

Really wish I could just run apps natively, tired of running out of phone battery

[andmaybegayer]

damn I should really learn zephyr RTOS, I've been using esp32's so much that I just use their freertos for everything. maybe for the quadcopter project. It seems very sensible.