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

slideserve.com

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:

  1. Initiator: generates transactions, such as a processor or DMA controller.
  2. Interconnect: routes transactions to their destinations.
  3. Target: responds to transactions, such as memory or a peripheral.
  4. Payload: carries transaction information.
  5. 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

my.avnet.com

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

Sensores industriales para monitoreo de vibraciones en equipos rotativos: tecnologías clave para mantenimiento predictivo - Revista Tecnología Minera

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:

  1. Smart inverter system architecture and functional requirements.
  2. ARM processor, FPGA, DSP and MCU hardware partitioning.
  3. SystemC TLM modeling of ADC, PWM, DMA, memory and communication interfaces.
  4. RTOS and embedded Linux software architecture.
  5. Grid synchronization, PLL, MPPT and inverter control algorithms.
  6. Volt-VAR, Volt-Watt, frequency-Watt and power-factor control.
  7. PV, battery energy storage and bidirectional inverter applications.
  8. MATLAB/Simulink and PSCAD integration for system-level and power-system studies.
  9. IEEE 1547, IEEE 2030.5 and SunSpec communication considerations.
  10. Hardware-in-the-loop testing, verification and validation.
  11. 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.