Abstract
The Internet of Things (IoT) enables everyday objects to connect and communicate remotely, transforming areas such as smart homes and industrial automation. IoT systems can be standalone or interconnected in a System of Systems, where multiple devices work together towards a common goal. A key application is Energy Monitoring Systems (EMS), which track energy use within communities, using energy production and consumption. Designing this type of IoT systems remains complex and requires careful consideration of heterogeneous devices, their limitations, software, communication protocols, data management, and security. This paper presents a design approach for EMS communities, with a focus on house-level IoT systems. We introduce a model-driven development methodology, a holistic and flexible framework for designing IoT systems across the development and operations lifecycle. Especially, the concept of projectors enables an easy shift between domain assets and provide automation support. The approach is validated with a real-life use case, for which an analysis phase was developed, showing the benefits of using our approach for managing EMS and the automation of the analysis configuration. © 2025 by SCITEPRESS - Science and Technology Publications, Lda.

Abstract
The Constant Bandwidth Server (CBS) is a mechanism used in real-time systems to enable aperiodic soft realtime tasks with unknown execution parameters to run under a dynamic scheduling policy such as Earliest Deadline First (EDF), while still ensuring schedulability by using a bandwidth reservation strategy. This paper proposes an approach to extend the Zephyr open-source real-time operating system, currently maintained by the Linux Foundation, to support aperiodic tasks with CBS. The paper provides the proposed architecture and the design and implementation of the CBS mechanisms in the operating system, which are then evaluated in two test cases in an embedded platform. © 2025 Elsevier B.V., All rights reserved.

Abstract
The performance of time-predictable systems can be improved in multi-core processors using parallel programming models (e.g., OpenMP). However, schedulability analysis of parallel applications is a big challenge due to their sophisticated structure. The common drawbacks of current task-to-thread mapping approaches in OpenMP are that they (i) utilize a global queue in the mapping process, which may increase contention, (ii) do not apply heuristic techniques, which may reduce the predictability and performance of the system, and (iii) use basic analytical techniques, which may cause notable pessimism in the temporal conditions. Accordingly, this paper proposes a task-to-thread mapping method in multi-core processors based on the OpenMP framework. The mapping process is carried out through two phases: allocation and dispatching. Each thread has an allocation queue in order to minimize contention, and the allocation and dispatching processes are performed using several heuristic algorithms to enhance predictability. In the allocation phase, each task-part from the OpenMP DAG is allocated to one of the allocation queues, which includes both sibling and child task-parts. A suitable thread (i.e., allocation queue) is selected using one of the suggested heuristic allocation algorithms. In the dispatching phase, when a thread is idle, a task-part is selected from its allocation queue using one of the suggested heuristic dispatching algorithms and then dispatched to and executed by the thread. The performance of the proposed method is evaluated under different conditions (e.g., varying the number of tasks and the number of threads) in terms of application response time and overhead of the mapping process. The simulation results show that the proposed method surpasses the other methods, especially in the scenario that includes overhead of the mapping. In addition, a prototype implementation of the main heuristics is evaluated using two kernels from real-world applications, showing that the methods work better than LLVM's default scheduler in most of the configurations.

Abstract
Developing real-time systems applications requires programming paradigms that can handle the specification of concurrent activities and timing constraints, and controlling execution on a particular platform. The increasing need for high-performance, and the use of fine-grained parallel execution, makes this an even more challenging task. This paper explores the state-of-the-art and challenges in real-time parallel application development, focusing on two research directions: one from the high- performance domain (using OpenMP) and another from the real-time and critical systems field (based on Ada). The paper reviews the features of each approach and highlights remaining open issues.

Abstract
Developing distributed and scalable Cyber-Physical Systems (CPS) that can handle large amounts of data at high data rates at the edge, remains a challenging task. Also, the limited availability of open-source solutions makes it difficult for developers and researchers to experiment with and deploy CPSs on a larger scale. This work introduces Edge4CPS, an open-source multi-architecture solution built over Kubernetes that aims to enable an easy to use, efficient and scalable solution for the deployment of applications on edge-like distributed computing clusters. To verify the successful real-world implementation of the introduced architecture, the system was tested in a railway scenario, derived from the Ferrovia 4.0 project, which highlights its functionalities.