Research White Paper
Hardware–Software Co-Design for Intelligent IoT Systems: SystemC TLM-Based Architecture, Simulation, and Engineering Applications
Research, Architecture, Design Methodology, Industrial IoT Use Cases, and Implementation Strategy
Prepared for: IAS-Research.com, KeenComputer.com and KeenDirect.com
Research and Engineering Partner: IAS-Research.com
Author: IASR-KEEN-KEENDIRECT
Date: November 2026
Abstract
The increasing complexity of Internet of Things (IoT), embedded computing, industrial automation, automotive electronics, smart energy systems, and edge-AI applications requires a systematic approach to hardware and software development.
Traditional hardware and software development approaches frequently operate in separate engineering environments. Hardware engineers focus on processors, buses, memory, peripherals, and electronic interfaces, while software engineers develop firmware, device drivers, real-time operating systems (RTOS), communication protocols, and application software. This separation can create integration problems, increase development costs, and delay product commercialization.
Hardware–Software Co-Design (HSCD) provides an integrated engineering methodology in which hardware architecture and software architecture are developed, evaluated, and optimized together.
This paper examines the role of SystemC and Transaction-Level Modeling (TLM) as an architectural simulation and verification framework for hardware–software co-design. It presents a practical engineering methodology for modeling processors, memory systems, interconnects, peripherals, sensors, communication interfaces, embedded software, and IoT applications.
The paper also establishes the strategic role of IAS-Research.com in providing architecture design, system modeling, simulation, verification, embedded software engineering, and IoT research and development services.
The central proposition is that SystemC TLM can help engineering organizations evaluate system architecture before committing to detailed RTL implementation, PCB development, firmware integration, and physical prototyping.
1. Introduction: Why Hardware–Software Co-Design Matters
1.1 The engineering challenge
Consider the development of an industrial IoT controller. It may contain:
- ARM Cortex-A or Cortex-M processors.
- FPGA or ASIC-based hardware accelerators.
- RAM, Flash and memory controllers.
- ADC, DAC, PWM, GPIO and timer peripherals.
- CAN, UART, SPI, I²C, Ethernet and wireless interfaces.
- RTOS or embedded Linux.
- Sensor acquisition and actuator control.
- TinyML inference and anomaly detection.
- MQTT, OPC UA or other industrial communication protocols.
- Cloud connectivity and remote monitoring.
Each component introduces design constraints.
|
Engineering domain |
Important design questions |
|---|---|
|
Processor architecture |
Is computational performance sufficient? |
|
Memory architecture |
Are bandwidth and capacity adequate? |
|
Interconnect |
Will bus contention affect performance? |
|
Hardware interfaces |
Are peripheral transactions correct? |
|
Firmware |
Are drivers and interrupts reliable? |
|
RTOS |
Can tasks meet their deadlines? |
|
AI processing |
Can inference execute within power and memory constraints? |
|
Networking |
Can the system maintain reliable communication? |
|
Security |
Are device identity, communications and updates protected? |
A major problem with conventional sequential engineering is that architectural mistakes may be discovered only after hardware and firmware integration.
For example, an IoT controller might have sufficient CPU processing capacity but inadequate memory bandwidth. Alternatively, an AI algorithm might work in a desktop environment but fail on an embedded processor because of memory, latency or power constraints.
Hardware–Software Co-Design addresses these problems through early architectural modeling and joint evaluation.
1.2 Research proposition
IAS-Research proposes an integrated engineering approach:
Requirements Engineering → System Architecture → SystemC TLM → Hardware–Software Partitioning → Virtual Platform → Firmware → Prototype → Verification.
This allows engineers to investigate alternative architectures before expensive physical implementation.
2. SystemC and Transaction-Level Modeling
2.1 What is SystemC?
SystemC is a C++-based modeling and simulation framework used for system-level design, hardware architecture exploration, performance modeling and verification.
Its standardization is governed through IEEE 1666. The current standard is IEEE 1666-2023, with a 2025 corrigendum listed by the SystemC standards organization. [1][2]
SystemC allows engineers to represent hardware components as communicating modules with defined interfaces and simulation behavior.
A model may represent:
- Processor subsystems.
- Memory and memory controllers.
- Bus and interconnect networks.
- Hardware IP blocks.
- DMA controllers.
- Sensor interfaces.
- Peripheral devices.
- Embedded system components.
2.2 What is Transaction-Level Modeling?
Transaction-Level Modeling represents communication between hardware components at an abstraction level above individual clock cycles and signal transitions.
Instead of modeling every wire and every clock edge, an engineer models operations such as:
- Read a sensor register.
- Write a control register.
- Transfer a data block.
- Access a memory location.
- Send a packet.
- Initiate a DMA operation.
For example, an embedded processor reading an ADC register can be represented as a transaction between an initiator and a target.
PPT - Synthesizing TLM-2.0 Communication Interfaces PowerPoint Presentation - ID:2087246
The principal advantage is that engineers can evaluate system functionality and architecture before implementing detailed RTL.
The SystemC TLM framework provides standard interfaces for virtual prototyping, architectural analysis, software development, performance analysis and hardware verification. [3]
2.3 Loosely Timed and Approximately Timed modeling
TLM 2.0 provides two important modeling styles.
|
Characteristic |
Loosely Timed (LT) |
Approximately Timed (AT) |
|---|---|---|
|
Abstraction |
High |
More detailed |
|
Simulation speed |
Generally faster |
Generally slower |
|
Timing detail |
Coarse |
Detailed transaction phases |
|
Primary application |
Early architecture |
Detailed performance and protocol analysis |
|
Software development |
Particularly useful |
Useful where timing behavior matters |
|
Contention analysis |
Requires additional modeling |
Can model more detailed contention |
Recommended IAS-Research methodology: Start with LT for architecture and functional exploration, then introduce AT modeling for components where timing, arbitration, buffering and transaction ordering are important.
This avoids spending engineering effort on detailed timing models before the system architecture has stabilized. [3][4][5]
2.4 SystemC TLM architecture
A typical TLM-based system consists of:
- Initiator: generates transactions, such as a processor or DMA controller.
- Interconnect: routes transactions to their destinations.
- Target: responds to transactions, such as memory or a peripheral.
- Payload: carries transaction information.
- Timing model: represents transaction delay and synchronization.
The TLM-2.0 generic payload supports standardized transaction information, while sockets provide communication interfaces between modules.
A simplified conceptual transaction is:
tlm_generic_payload trans; trans.set_command(TLM_READ_COMMAND); trans.set_address(0x40000000); trans.set_data_ptr(data); trans.set_data_length(4); sc_time delay = SC_ZERO_TIME; socket->b_transport(trans, delay);
This illustrates a blocking transport transaction. A production model must also validate response status, address mapping, data length, byte enables, access permissions and timing behavior.
3. Proposed IAS-Research Hardware–Software Co-Design Architecture
EBV-IoT Smart Connected Motor Control Solution | EBV Elektronik
The proposed architecture has six engineering layers.
|
Layer |
Engineering responsibility |
|---|---|
|
Physical layer |
Sensors, actuators, power electronics and interfaces |
|
Hardware layer |
ARM SoC, FPGA, memory, buses and peripheral IP |
|
Virtual platform |
SystemC TLM models and simulated hardware |
|
Embedded software |
Bootloader, drivers, RTOS and embedded Linux |
|
Intelligence layer |
Signal processing, TinyML and edge AI |
|
Application layer |
IoT services, dashboards, cloud and digital twins |
The architecture should be supported by a common requirements and verification model.
3.1 Hardware components
IAS-Research can model and evaluate:
- ARM-based embedded processing systems.
- RISC-V processor architectures.
- FPGA-based hardware subsystems.
- Memory and cache hierarchies.
- AXI and other on-chip interconnects.
- DMA and interrupt controllers.
- Sensor and actuator interfaces.
- Communication peripherals.
- Custom hardware accelerators.
3.2 Software components
The software architecture can include:
- Bootloader and board-support packages.
- Device drivers.
- FreeRTOS or other RTOS implementations.
- Embedded Linux.
- Yocto-based embedded Linux distributions.
- CAN and Ethernet communication stacks.
- MQTT and OPC UA clients.
- Edge-AI inference.
- Device management and OTA updates.
3.3 Co-design decisions
The principal objective is to determine which functions should execute in software and which should be implemented in hardware.
For example:
|
Function |
Possible implementation |
|---|---|
|
Sensor acquisition |
ADC peripheral and firmware |
|
Digital filtering |
CPU, DSP or FPGA |
|
Motor control |
MCU/RTOS or dedicated control hardware |
|
Neural-network inference |
CPU, NPU or FPGA accelerator |
|
Protocol handling |
Software |
|
Cryptographic acceleration |
Hardware accelerator or software |
|
High-speed data transfer |
DMA and memory subsystem |
The optimal allocation depends on latency, throughput, power, cost, safety, flexibility and development constraints.
14. Main engineering use cases covered
Industrial IoT and predictive maintenance
Sensor acquisition, DMA, processor loading, anomaly detection and industrial networking.
CoolSiC 1200V G2 MOSFETs - Infineon Technologies | Mouser
Smart inverter and grid-edge systems
ADC, PWM, control processors, communication interfaces and edge analytics.
M2 (Under-the-Dash) | Macchina
OBD-AI automotive diagnostics
CAN transactions, embedded processing, diagnostic algorithms and AI integration.
El sistema de riego inteligente logra un riego automatizado
Smart agriculture
Low-power sensor nodes, wireless communication and automated irrigation.
15. Download the research paper
IAS-Research Hardware–Software Co-Design White Paper
Ready
PDF research document · November 2026
Download the complete research white paper
The paper includes architecture, SystemC TLM examples, IoT applications, implementation methodology, verification metrics, consulting services and technical references.
Important source limitation: The uploaded Patterson Computer Organization and Design, 6th Edition file returned an access-block message, so I could not verify or incorporate its specific chapters. The paper instead uses independently identified SystemC and IEEE references.
The foundational reference is IEEE 1666-2023 SystemC Standard. Additional technical resources include SystemC TLM documentation and Accellera SystemC resources.
My recommendation for IAS-Research: Develop this paper into a practical SystemC TLM engineering demonstration using an ARM-based IoT controller, sensor peripherals, memory, DMA, CAN/Ethernet and an RTOS. That demonstrator can become the foundation for IAS-Research's hardware–software co-design consulting and training services.
The revised paper should incorporate the complete original discussion and a substantially expanded Smart Inverter Hardware–Software Co-Design case study, covering:
- Smart inverter system architecture and functional requirements.
- ARM processor, FPGA, DSP and MCU hardware partitioning.
- SystemC TLM modeling of ADC, PWM, DMA, memory and communication interfaces.
- RTOS and embedded Linux software architecture.
- Grid synchronization, PLL, MPPT and inverter control algorithms.
- Volt-VAR, Volt-Watt, frequency-Watt and power-factor control.
- PV, battery energy storage and bidirectional inverter applications.
- MATLAB/Simulink and PSCAD integration for system-level and power-system studies.
- IEEE 1547, IEEE 2030.5 and SunSpec communication considerations.
- Hardware-in-the-loop testing, verification and validation.
- IAS-Research engineering and commercialization strategy, with KeenComputer and KeenDirect roles.
The deliverable should be a completely recreated professional research white paper, not an addendum to the previous document.