Integrated Embedded Systems Engineering for Intelligent Automotive Diagnostics
SystemC TLM, QEMU, RTOS, CAN Bus, TinyML and Model-Based Systems Engineering
IAS-Research.com | Research, Architecture and Engineering Division
November 2026
|
ENGINEERING FOCUS |
Contents
If the table of contents is not populated automatically, update fields in Microsoft Word or LibreOffice.
Abstract
The increasing software content of modern vehicles creates an opportunity to combine embedded systems engineering, automotive communications, edge artificial intelligence and model-based development in a unified diagnostic platform. This white paper proposes an integrated engineering architecture for the OBD-AI Puck: a compact automotive diagnostic device that acquires vehicle data through OBD-II and Controller Area Network (CAN), executes deterministic embedded firmware, performs selected machine-learning inference locally, and exchanges diagnostic context with higher-level AI services when connectivity is available.
The proposed development environment combines SystemC Transaction-Level Modeling (TLM-2.0) for architecture and peripheral modelling; QEMU for processor and machine emulation; an RTOS such as Zephyr or FreeRTOS for embedded execution; SocketCAN, virtual CAN and simulated electronic control units (ECUs) for communication testing; and TinyML runtimes for resource-constrained inference. Model-Based Systems Engineering (MBSE) provides requirements traceability, interface control, verification planning and lifecycle governance. The paper also defines IAS-Research.com’s strategic role in architecture, research, prototyping, consulting, onsite training, implementation and technology transfer.
The target microcontroller or system-on-chip has not yet been fixed. Consequently, the architecture is presented as a technology-neutral reference model, with board-specific decisions deferred until processor, memory, CAN peripheral, power, security and product-cost requirements are baselined. The proposal emphasizes staged simulation before hardware procurement, separation of safety-critical acquisition from probabilistic AI functions, and measurable acceptance criteria for timing, reliability, model accuracy and diagnostic integrity.
Keywords
Embedded systems; SystemC; TLM-2.0; QEMU; Zephyr; FreeRTOS; CAN; CAN FD; OBD-II; ISO-TP; UDS; TinyML; edge AI; MBSE; automotive diagnostics; co-simulation.
Executive Summary
OBD-AI should be engineered as a complete embedded system rather than as a machine-learning application attached to a CAN adapter. The platform must acquire vehicle signals reliably, interpret diagnostic protocols correctly, manage time-sensitive tasks, preserve data integrity, and provide useful diagnostic reasoning under constrained compute, memory and power budgets.
The recommended approach is a model-first engineering workflow. First, define use cases, requirements and interfaces. Next, construct a SystemC TLM platform containing the processor-facing bus, memory map, CAN controller abstraction, diagnostic memory and optional AI accelerator. In parallel, use QEMU to execute target software on a supported processor or board model. Connect the environments through a documented co-simulation boundary where required. Build and test the RTOS application against simulated peripherals and a virtual ECU before connecting physical hardware.
TinyML should be introduced after data acquisition and deterministic firmware are stable. Initial edge models should focus on bounded, explainable tasks such as signal-quality classification, anomaly screening, operating-state recognition or prioritization of diagnostic evidence. Full diagnostic interpretation, service-manual retrieval and conversational explanation can remain in a companion application or server-side retrieval-augmented generation (RAG) service. This hybrid division avoids forcing large language models onto a small microcontroller and keeps the embedded device useful when disconnected.
IAS-Research.com should lead the system architecture, MBSE, simulation strategy, AI research, technical risk management and independent verification. KeenComputer.com can support implementation, integration, deployment and managed engineering services. KeenDirect.com can support productization, component sourcing, packaged hardware/software offerings and the future commercial channel. The three roles should be governed by clear deliverables and acceptance gates.
1. Introduction and Problem Statement
Vehicle diagnostics increasingly involves multiple interacting domains: electronic control units, sensors, actuators, in-vehicle networks, diagnostic services, embedded software, cloud-connected tools and increasingly data-driven maintenance workflows. A diagnostic product must bridge these domains while remaining reliable, secure and maintainable.
The OBD-AI Puck concept is intended to collect standardized diagnostic information and selected vehicle data, associate that data with diagnostic knowledge, and assist a technician or vehicle owner in understanding faults and possible next steps. A credible implementation requires more than decoding diagnostic trouble codes (DTCs). It must manage protocol timing, ECU responses, incomplete or noisy data, vehicle-specific variation, firmware updates, hardware constraints and the distinction between measured facts and AI-generated hypotheses.
The supplied three-page learning guide proposes a practical chain: learn TLM-2.0, study QEMU/SystemC co-simulation, bring up Zephyr, use QEMU CAN and host SocketCAN, create a simulated ECU, then add AIAccelerator and DTCMemory. It also notes that the exact target MCU/SoC is an open design decision and that the Xilinx QEMU/SystemC flow is tied to particular Xilinx platforms rather than automatically matching a small MCU [1]. This paper preserves that staged approach while adding RTOS comparison, TinyML, MBSE, test strategy and delivery governance.
The central engineering problem is therefore: how can IAS-Research design and validate a reusable, low-risk embedded diagnostic platform before committing to a specific hardware implementation, while preserving a path to edge intelligence and commercial deployment?
2. Objectives, Scope and Design Principles
The programme has six objectives: (1) establish a traceable system architecture; (2) develop executable hardware and communication models; (3) validate RTOS firmware using emulation and simulation; (4) implement robust CAN and diagnostic protocol handling; (5) select and deploy suitable TinyML functions; and (6) create a repeatable verification and commercialization process.
The initial scope includes read-oriented OBD-II acquisition, selected CAN/CAN FD interfaces where supported, ISO-TP transport, UDS diagnostic service handling where legally and technically appropriate, DTC and parameter data management, local event detection, and a companion diagnostic knowledge service. ECU reprogramming, actuator control, immobilizer operations, safety-critical vehicle control and unrestricted diagnostic write services are outside the initial product scope.
Design principles are: model before hardware; separate deterministic acquisition from AI inference; keep protocol handling standards-aware; use hardware abstraction and portable interfaces; measure resource consumption early; treat diagnostic outputs as evidence-based assistance rather than guaranteed diagnoses; secure the data path; and retain human review for consequential repair decisions.
3. Reference System Architecture
The reference architecture is divided into five interacting layers.
Layer A — Vehicle interface: OBD-II connector, protected power input, CAN transceiver, CAN controller, optional CAN FD support and electrical protection. The physical interface must be designed against the applicable vehicle electrical environment and product safety requirements. A development vCAN interface is not a substitute for electrical validation.
Layer B — Embedded platform: MCU/SoC, flash, RAM, clock, watchdog, timers, DMA, communication interfaces and optional hardware security or cryptographic support. The final MCU selection must be based on worst-case execution time, memory, CAN peripheral capability, power, temperature, lifecycle, toolchain and bill-of-materials constraints.
Layer C — Real-time firmware: RTOS kernel, board support package, device drivers, CAN receive/transmit services, ISO-TP, diagnostic state machine, data logger, fault handling, secure update mechanism and telemetry interface. Acquisition and protocol tasks should have explicit priorities, bounded queues, timeout policies and overload behavior.
Layer D — Edge intelligence: signal conditioning, feature extraction, compact inference model, confidence and out-of-distribution checks, model versioning and result reporting. The AI subsystem must not block CAN reception or compromise deterministic protocol tasks.
Layer E — Companion intelligence and knowledge: mobile/desktop interface, diagnostic history, vehicle profile, service-manual retrieval, DTC knowledge graph and RAG-based explanation. This layer can use larger models and curated technical documents, while the Puck provides trusted measurements and compact local inference.
A practical data path is: vehicle ECU → CAN controller/transceiver → RTOS driver and receive queue → protocol decoder/ISO-TP → normalized signal and DTC records → local rules/TinyML → diagnostic event store → companion application/RAG service. Each transformation should retain timestamps, source identifiers, units, scaling, protocol context and data-quality flags.
4. SystemC TLM-2.0 for System-Level Modelling
SystemC is a C++-based modelling framework standardized through IEEE 1666. TLM-2.0 provides transaction-level interfaces and structures for modelling memory-mapped communication, including initiator and target sockets, generic payloads, transport interfaces, direct memory interface and timing abstractions [2]. It enables architecture exploration before detailed RTL or physical hardware is available.
For OBD-AI, the first SystemC platform should contain a processor initiator or software-facing transaction source, SimpleBus/interconnect, RAM, ROM/flash abstraction, register-mapped CAN controller, interrupt controller, timer/watchdog, DTCMemory and AIAccelerator placeholder. The CAN peripheral model should expose realistic register behavior, interrupt events, transmit completion, receive buffering, error states and configurable timing. A socket or host-vCAN bridge can connect the model to external ECU simulations.
Modelling fidelity should increase in stages. At the architecture stage, loosely timed transactions are sufficient to explore address maps, register interfaces and data flow. At the performance stage, annotated delays and arbitration assumptions can estimate latency and throughput. At the detailed verification stage, protocol-specific behavior, interrupt timing, buffer limits and error conditions need explicit models. The model should not claim cycle accuracy unless it is actually implemented and validated at that level.
The initial learning path in the supplied guide recommends Doulos TLM-2.0 material, an Embecosm application note, and a DVCon hands-on UART exercise using VCML [1]. The UART exercise is useful because register-mapped peripheral design patterns transfer to a CAN controller, although CAN requires additional bus arbitration, frame filtering, error handling and protocol behavior.
Recommended deliverables are a SystemC platform diagram, address map, TLM interface specification, peripheral register model, timing assumptions, testbench, regression suite and model-to-requirement traceability matrix.
5. QEMU and Hardware/Software Co-Simulation
QEMU provides system emulation and user-mode emulation across multiple processor architectures. In system mode it can emulate a machine containing a CPU, memory and devices; device models expose guest-visible interfaces and may connect to host back ends [3]. QEMU also documents CAN bus emulation and a SocketCAN host connection, including virtual CAN interfaces for host-only testing [4].
The QEMU role is to execute compiled firmware or an operating system in a processor/machine environment that is sufficiently close to the intended target. It is particularly valuable for early boot, driver, RTOS, integration and automated regression work. It does not automatically emulate every MCU or custom peripheral. If the selected Puck MCU is unsupported, possible strategies include a compatible QEMU machine, a custom QEMU device model, a SystemC-only CPU/peripheral platform, or a hybrid setup in which QEMU executes the software and SystemC models selected peripherals.
A co-simulation bridge should define ownership of time, reset, interrupts, register transactions, data queues and error propagation. Avoid two independent simulators silently advancing time without a synchronization contract. A socket-based bridge is practical for initial functional co-simulation; tighter temporal coupling may require a dedicated synchronization mechanism.
The uploaded guide identifies the UT Austin QEMU/SystemC lab and Xilinx libsystemctlm-soc as useful references, while warning that the Xilinx flow is centered on Xilinx QEMU forks and Zynq/ZynqMP/Versal wrappers [1]. Those examples should be treated as learning references, not as proof that the same platform directly supports the eventual Puck MCU.
A sensible sequence is: first run QEMU independently; next run the SystemC platform independently; then exchange CAN frames through SocketCAN/vcan; finally introduce a controlled co-simulation bridge for custom register-level or interrupt-driven peripheral behavior.
6. RTOS Engineering: Zephyr and FreeRTOS
The RTOS is responsible for deterministic task scheduling, synchronization, timers, driver integration, memory management and fault containment. The choice should follow the target hardware and product constraints rather than personal preference.
Zephyr is a strong candidate for the first OBD-AI prototype because it offers a broad embedded subsystem architecture, device model, devicetree configuration and documented CAN and ISO-TP facilities. Its documentation lists support across multiple architectures, including Arm Cortex-M and RISC-V families [5]. The Zephyr CAN documentation covers controller and transceiver interfaces [6], and its ISO-TP subsystem implements the transport protocol used for diagnostic communication over CAN [7]. The availability of a feature in the RTOS does not remove the need to verify the exact driver, board, protocol version and configuration used by the product.
FreeRTOS is a credible alternative where a smaller kernel footprint, existing vendor SDK integration, team familiarity or a specific MCU ecosystem is decisive. Its kernel provides task scheduling, synchronization primitives, software timers and static allocation options [8]. However, protocol stacks, drivers, update services, diagnostics and security components may need to be selected and integrated separately.
A preliminary task model is: (1) CAN RX interrupt/driver service; (2) CAN frame processing; (3) ISO-TP transport; (4) OBD/UDS diagnostic state machine; (5) signal normalization and timestamping; (6) persistent logging; (7) TinyML inference; (8) communications/UI service; and (9) health monitoring/watchdog. High-priority acquisition and protocol work must never wait on model inference, file writes or network activity.
RTOS engineering outputs should include task priority rationale, stack sizing, queue sizing, interrupt-to-task handoff design, worst-case execution-time measurements, watchdog strategy, memory map, fault recovery behavior and a reproducible build configuration.
7. Automotive Communications: CAN, OBD-II, ISO-TP and UDS
CAN is the communication foundation for many vehicle networks, but a diagnostic tool must distinguish the physical/data-link layer from higher-level diagnostic services. OBD-II defines legislated emissions-related diagnostic functionality in applicable markets; vehicle-specific diagnostics may expose additional services and data. The Puck should begin with clearly scoped, read-oriented services and a vehicle compatibility strategy.
The QEMU documentation describes CAN controller emulation and bridging to Linux SocketCAN, including virtual CAN interfaces for local test environments [4]. SocketCAN and can-utils provide a practical host-side development workflow. A virtual ECU can be implemented with python-can and an ISO-TP library to respond to selected requests, supply controlled sensor values and inject fault scenarios.
ISO 15765-2:2024 defines transport and network-layer services for diagnostic communication over CAN and supports diagnostic applications including OBD and UDS [9]. ISO-TP segments payloads larger than a single CAN frame and uses flow-control behavior. Zephyr’s ISO-TP documentation explains single-frame, first-frame, consecutive-frame and flow-control operation [7]. UDS application-layer services are specified separately; ISO 14229-1:2026 is the current published edition identified by ISO at the time of this paper [10]. Standards editions and regional OBD requirements must be checked during product requirements baselining.
The software should implement explicit protocol state machines with bounded timeouts, retry policies, flow-control handling, addressing configuration, negative-response interpretation and malformed-frame rejection. Vehicle profiles should record supported protocols, addressing modes, parameter identifiers and known limitations. Do not assume all vehicles expose the same PIDs, DTC semantics or ECU topology.
Initial test cases should cover valid and invalid frames, missing ECU responses, bus-off/recovery, arbitration load, fragmented ISO-TP payloads, flow-control errors, timeouts, multiple ECUs, duplicate messages, malformed diagnostic payloads and disconnection during a transaction.
8. TinyML and Edge AI Architecture
TinyML refers to machine-learning inference deployed on highly resource-constrained devices such as microcontrollers and DSPs. TensorFlow Lite for Microcontrollers (TFLM) is designed for low-memory embedded targets and supports a constrained operator set; model design and conversion must account for RAM, flash and available kernels [11]. Arm Cortex-M deployments may use CMSIS-NN optimized kernels where supported [12].
TinyML should complement, not replace, deterministic diagnostic logic. The first models should solve narrow problems for which representative labelled data can be collected and performance can be measured. Candidate functions include sensor-pattern anomaly screening, engine operating-state classification, misfire-like event pattern screening where appropriate sensor data is available, battery/charging trend classification, sensor plausibility checks and prioritization of diagnostic evidence. These are research candidates, not claims of validated capability.
The proposed pipeline is: data acquisition → data quality validation → windowing and feature extraction → model training and evaluation → quantization → embedded conversion → target profiling → shadow-mode deployment → controlled release → drift monitoring and retraining. Model selection should be based on accuracy, precision/recall, false-alarm rate, inference latency, peak RAM, flash size, energy per inference, robustness across vehicle types and behavior under missing or corrupted inputs.
A compact int8 model is a sensible first deployment candidate, but quantization can affect accuracy and must be evaluated against a held-out dataset. TFLM supports a limited operator subset and requires the model to fit the target’s memory and compute limits [11]. QEMU can help run cross-compiled software tests; the TFLM project documents QEMU-based execution for some Cortex-M unit-test workflows [13]. Emulation is not a substitute for measuring latency, energy and numerical behavior on the physical target.
A two-tier AI architecture is recommended. On the Puck, run small deterministic rules and TinyML models that produce compact evidence records, confidence values and anomaly indicators. In a companion application or server, use a larger RAG/LLM system to retrieve service-manual passages, correlate DTCs, compare historical observations and generate technician-facing explanations. The large model must cite its evidence and distinguish observed facts from inferred possibilities.
The AI output contract should include model identifier and version, input feature window, timestamp, output class or score, calibrated confidence where available, data-quality status and a statement that the result is advisory. If inputs are outside the training distribution, the model should abstain or downgrade confidence rather than invent a diagnosis.
9. Integrated OBD-AI Puck Software and Data Model
The firmware should expose stable internal interfaces between acquisition, protocol, data normalization, storage and inference. A normalized observation record should include vehicle/session identifier, ECU/source address, timestamp, signal identifier, raw value, engineering value, unit, scaling metadata, protocol context and quality flags. A DTC record should preserve the raw code, ECU, status bits where available, protocol source, occurrence context and time of retrieval.
DTCMemory should be designed as a bounded, versioned data store rather than an unstructured collection of codes. It should support event correlation, session history, data provenance and retention policies. AIAccelerator should initially be a software abstraction with a stable API; a hardware accelerator can be integrated later if measurements justify its cost and complexity.
The companion service may connect normalized observations to a vehicle-specific knowledge base containing service manuals, wiring diagrams, technical service bulletins where licensed, repair procedures and curated diagnostic rules. Retrieval results should include source document, page/section and version. The system must not present an unverified RAG answer as a manufacturer-approved repair instruction.
10. MBSE: Requirements, Architecture and Traceability
MBSE provides a disciplined way to connect stakeholder needs, system requirements, architecture, interfaces, behavior, verification and lifecycle change. INCOSE describes systems engineering as an interdisciplinary approach for conceiving, developing and supporting complex systems, and its handbook aligns with lifecycle processes including ISO/IEC/IEEE 15288 [14].
For OBD-AI, the system model should capture stakeholders and use cases; operational scenarios; functional and non-functional requirements; hardware/software allocation; interface control; task and state behavior; data flows; fault responses; verification cases; and deployment configuration. UML/SysML or a compatible modelling environment can be used, provided model ownership and traceability are maintained.
Example requirement groups include: diagnostic protocol compliance; CAN reception throughput; timestamp accuracy; maximum response latency; supported vehicle coverage; model false-positive rate; boot time; power consumption; secure update behavior; log integrity; operating temperature; and recovery from bus faults. Numerical values must be derived from intended use, selected hardware and measured prototypes rather than invented at the concept stage.
Each requirement should have a unique identifier, rationale, source, verification method, acceptance threshold, owner and status. Every architecture element should trace to requirements, and every verification result should trace back to one or more requirements. This is particularly important when the MCU, RTOS, CAN controller or TinyML model changes.
11. Verification, Validation and Test Strategy
Verification asks whether the implementation meets its specified requirements; validation asks whether the system solves the intended user problem in its operational context. The programme should use a verification pyramid.
Level 1 — Unit tests: parsers, scaling, state machines, queues, storage, feature extraction and model wrappers. Level 2 — Component tests: CAN driver, ISO-TP, diagnostic service layer, DTCMemory and TinyML runtime. Level 3 — Model and co-simulation tests: SystemC register/peripheral behavior, QEMU firmware execution, interrupt paths and SocketCAN integration. Level 4 — Hardware-in-the-loop tests: physical Puck prototype connected to a CAN interface and controlled ECU simulator. Level 5 — Vehicle validation: authorized vehicles, documented procedures, controlled test conditions and technician review.
Test data should include nominal operation, edge cases, rare faults, environmental variation and negative examples. AI evaluation must avoid leakage between training and test sets, and should consider vehicle-level separation so that performance is not overstated by near-duplicate samples. Track false positives and false negatives separately; in diagnostics, a confident but incorrect recommendation can be more harmful than an explicit no-result.
The initial product should operate in a read-only diagnostic mode. Any future write-capable diagnostic function should require a separate hazard, security and regulatory review, explicit authorization, strict service conditions and independent verification. The Puck should not issue commands that control vehicle motion or safety-critical functions.
12. Cybersecurity, Safety and Data Governance
The device is connected to an environment in which malformed messages, compromised diagnostic equipment, unauthorized access and unsafe firmware updates can create risks. Security controls should include secure boot where supported, signed firmware, protected debug interfaces, authenticated update packages, least-privilege interfaces, input validation, bounded buffers, cryptographic identity where justified and auditable release records.
CAN itself should not be treated as an authenticated or confidential channel. The Puck should parse defensively, constrain diagnostic services, avoid unrestricted message injection, and isolate vehicle-facing functions from companion connectivity. Firmware update and data export paths should be designed as explicit trust boundaries.
Vehicle and diagnostic data may contain identifiers or usage patterns. Data collection should be minimized, retention should be defined, and consent and privacy requirements should be assessed for each target market. Technical logs should distinguish vehicle-derived data, technician-entered observations, external knowledge sources and model-generated inferences.
A formal hazard analysis should be conducted before field deployment. This paper is an engineering proposal, not a claim of automotive functional-safety certification, cybersecurity certification or regulatory approval.
13. Development Roadmap and Work Packages
Phase 0 — Requirements and target selection (Weeks 1–3): confirm product use cases, vehicle coverage, diagnostic scope, target MCU/SoC candidates, memory/power budgets, interfaces, security posture and acceptance criteria. Deliverables: system requirements baseline, target trade study, risk register and MBSE context model.
Phase 1 — Host simulation and protocol foundation (Weeks 3–6): configure Kubuntu development environment, build virtual CAN interfaces, implement a simulated ECU, create OBD-II request/response tests and validate ISO-TP behavior. Deliverables: repeatable scripts, protocol test vectors, simulated ECU and automated regression.
Phase 2 — SystemC TLM platform (Weeks 5–9): create bus, memory, CAN controller, interrupt, timer, DTCMemory and AIAccelerator models. Deliverables: TLM platform, address map, register specification, peripheral tests and timing assumptions.
Phase 3 — QEMU and RTOS integration (Weeks 8–13): select a supported QEMU target or define an alternative strategy; bring up Zephyr or FreeRTOS; integrate drivers and protocol services; run firmware against virtual peripherals. Deliverables: RTOS image, board configuration, task model, CI tests and integration report.
Phase 4 — TinyML data and inference (Weeks 12–18): establish data governance, collect or curate labelled signals, build baseline models, evaluate quantization, deploy a software inference wrapper and profile on candidate hardware. Deliverables: dataset card, model card, benchmark report, model artifact and shadow-mode demo.
Phase 5 — Prototype and hardware-in-the-loop (Weeks 17–24): implement the first physical prototype, validate electrical and CAN behavior, compare hardware results with simulation and complete failure-mode tests. Deliverables: prototype, HIL test suite, verification matrix and field-trial plan.
Phase 6 — Productization and pilot (Weeks 24+): complete design reviews, secure update process, documentation, service workflow, support model, pilot feedback and commercialization plan. Deliverables: release candidate, installation guide, technician training, support procedures and product roadmap.
These durations are planning estimates for a small focused team, not guaranteed delivery commitments. They should be revised after target hardware and team availability are known.
14. IAS-Research.com Strategic Role
IAS-Research.com should act as the technical research and systems-engineering lead. Its value is not limited to producing a prototype; it should establish the architecture, evidence base, reusable engineering methods and technology roadmap that reduce development risk and create intellectual and commercial value.
Research and architecture leadership: define the reference architecture, evaluate MCU/SoC candidates, compare RTOS choices, establish SystemC/QEMU co-simulation strategy, define CAN and diagnostic protocol boundaries, and specify the TinyML/companion-AI split.
MBSE and systems assurance: develop stakeholder models, requirements, interface-control documents, architecture views, verification plans, risk registers and change-control processes. Maintain traceability from use cases to tests and release evidence.
Embedded AI research: develop diagnostic feature engineering, dataset strategy, TinyML baselines, model compression and quantization studies, edge profiling, uncertainty handling and RAG/knowledge-graph integration. Publish technical reports and white papers where appropriate, while protecting proprietary implementation details.
Consulting and implementation: provide architecture reviews, technical feasibility studies, RTOS selection, simulation environment setup, embedded firmware design, protocol integration, AI model evaluation, cybersecurity review coordination and independent design assurance.
Onsite training and knowledge transfer: deliver practical workshops in SystemC TLM, QEMU, Zephyr/FreeRTOS, CAN/SocketCAN, ISO-TP, TinyML, MBSE and hardware-in-the-loop testing. Training should use a shared reference platform and measurable exercises rather than slide-only instruction.
Commercialization and partnership: prepare proof-of-concept packages, pilot proposals, technical documentation, funding/partner materials and licensing options. IAS-Research should retain ownership or clearly defined rights over reusable research assets, models, software modules and documentation according to written agreements.
15. Roles of KeenComputer.com and KeenDirect.com
KeenComputer.com can serve as the implementation and deployment arm: development environment engineering, Linux and embedded integration, application and dashboard development, cloud/RAG infrastructure, secure hosting, field installation, support and managed services. It can package IAS-Research architecture into practical solutions for SMEs, repair shops, fleet operators and technical service organizations.
KeenDirect.com can support product operations and commercialization: sourcing development boards and interfaces, component and accessory catalogues, prototype kits, product bundles, documentation distribution, ecommerce, order fulfilment and future channel partnerships. Product claims and compatibility statements must be based on tested configurations.
A clear operating model is recommended: IAS-Research defines and validates the engineering architecture; KeenComputer implements and operates the software and integration services; KeenDirect supports product packaging, sourcing and sales operations. Joint governance should define IP ownership, customer data responsibilities, support obligations, warranty boundaries and release approval.
16. Skills, Training and Consulting Programme
A modular training programme can build internal capability and create a service offering. Module 1: embedded architecture and requirements engineering. Module 2: SystemC and TLM-2.0 peripheral modelling. Module 3: QEMU system emulation and debugging. Module 4: RTOS task design and device drivers. Module 5: CAN, SocketCAN, OBD-II and ISO-TP. Module 6: TinyML data preparation, quantization and deployment. Module 7: MBSE and verification. Module 8: HIL integration and product security.
Each module should include a lecture, guided lab, individual exercise, code review and assessment. A capstone exercise should implement a virtual ECU, receive diagnostic data through an RTOS application, store normalized records and run a compact anomaly model. Onsite training can be supplemented by remote mentoring, architecture reviews and implementation sprints.
Consulting packages may include a two-week feasibility and architecture assessment; a four-to-six-week simulation proof of concept; an RTOS and CAN integration engagement; a TinyML feasibility study; and a prototype/HIL validation programme. Scope, assumptions, deliverables, customer responsibilities and acceptance criteria should be explicit in each statement of work.
17. Risks, Dependencies and Open Decisions
The most important unresolved decision is the target MCU or SoC. It determines QEMU fit, RTOS support, available CAN drivers, memory budgets, TinyML runtime options, accelerator support and production cost. A target selection matrix should compare Cortex-M, Cortex-A, RISC-V and other candidate families only where they satisfy the product's power, cost and software requirements.
Other risks include insufficient representative vehicle data; variation in OEM diagnostic behavior; timing differences between simulation and hardware; incomplete peripheral models; RTOS driver maturity; model drift; false-positive AI recommendations; security vulnerabilities; supply-chain changes; and underestimated verification effort.
Mitigations include early target trade studies, staged fidelity, explicit simulation assumptions, multi-vehicle datasets, read-only scope, shadow-mode AI, hardware profiling, protocol conformance tests, versioned dependencies, secure build pipelines and independent review. No hardware-specific performance claim should be published until measured on the selected board.
18. Conclusion and Recommendations
A robust OBD-AI platform can be developed more efficiently by integrating system-level modelling, processor emulation, RTOS engineering, automotive protocol simulation, TinyML and MBSE into one traceable workflow. SystemC TLM provides a reusable way to model the hardware architecture and peripherals; QEMU enables early software execution on supported processor/machine models; Zephyr or FreeRTOS provides the real-time firmware foundation; SocketCAN and virtual ECUs enable repeatable protocol testing; and TinyML enables carefully bounded local intelligence.
The recommended first milestone is not a production device. It is a reproducible host-based demonstration: a virtual ECU sends OBD-II/ISO-TP data over vcan; an RTOS application processes the messages; a SystemC CAN peripheral model exposes a defined register interface; QEMU executes the software where the chosen target is supported; and a compact edge model classifies a narrowly defined signal pattern. This milestone will expose architecture gaps before hardware cost is incurred.
IAS-Research.com should own the architecture, MBSE, simulation, embedded AI research and verification strategy. KeenComputer.com should lead implementation and deployment services. KeenDirect.com should support sourcing, packaging and commercial distribution. The next decision required to convert this reference architecture into a board-specific engineering plan is selection of the target MCU/SoC and its CAN interface.
Appendix A — Initial Engineering Work Breakdown
A1. Requirements: use cases, vehicle coverage, OBD/UDS scope, latency, power, memory, environmental and security requirements. A2. Architecture: context diagram, block diagram, interface-control document, address map, data model and task model. A3. Simulation: vcan, simulated ECU, SystemC bus/peripheral models, QEMU target evaluation and co-simulation interface. A4. Firmware: RTOS configuration, CAN driver, ISO-TP, diagnostic services, storage, logging and update mechanism. A5. AI: dataset, feature pipeline, baseline model, quantization, inference wrapper, profiling and model governance. A6. Verification: unit, component, co-simulation, HIL, vehicle and acceptance tests. A7. Productization: enclosure/electrical design, manufacturing test, documentation, security maintenance, support and release process.
Appendix B — Initial Acceptance Evidence
The first proof-of-concept should demonstrate: repeatable build and test setup; simulated ECU request/response exchange; valid ISO-TP segmentation and flow control; deterministic handling of timeouts and malformed messages; RTOS task and stack measurements; traceable SystemC peripheral transactions; documented QEMU compatibility limitations; model inference with measured RAM/flash/latency on target hardware when available; AI abstention on invalid inputs; and a requirement-to-test evidence matrix.
References
[1] IAS-Research / OBD-AI project source, “Getting Started with SystemC TLM, QEMU, RTOS and CAN Bus for OBD-AI,” user-provided project guide, 3 pp., supplied with this assignment.
[2] Accellera Systems Initiative, “SystemC Standards & Implementations,” including IEEE Std 1666-2023 and SystemC reference implementations. https://systemc.org/resources/standards/ ; Accellera, “OSCI TLM-2.0 Language Reference Manual.” https://www.accellera.org/images/downloads/standards/systemc/TLM_2_0_LRM.pdf
[3] QEMU Project, “System Emulation” and “Device Emulation” documentation. https://www.qemu.org/docs/master/system/ ; https://www.qemu.org/docs/master/system/device-emulation.html
[4] QEMU Project, “CAN Bus Emulation Support.” https://www.qemu.org/docs/master/system/devices/can.html
[5] Zephyr Project, “Introduction.” https://docs.zephyrproject.org/latest/introduction
[6] Zephyr Project, “Controller Area Network (CAN).” https://docs.zephyrproject.org/latest/hardware/peripherals/can/index.html
[7] Zephyr Project, “ISO-TP Transport Protocol.” https://docs.zephyrproject.org/latest/connectivity/canbus/isotp.html
[8] Amazon Web Services, “FreeRTOS Kernel Fundamentals.” https://docs.aws.amazon.com/freertos/latest/userguide/dev-guide-freertos-kernel.html
[9] International Organization for Standardization, ISO 15765-2:2024, “Road vehicles — Diagnostic communication over Controller Area Network (DoCAN) — Part 2: Transport protocol and network layer services.” https://www.iso.org/standard/84211.html
[10] International Organization for Standardization, ISO 14229-1:2026, “Road vehicles — Unified diagnostic services (UDS) — Part 1: Application layer.” https://www.iso.org/standard/87962.html
[11] TensorFlow, “TensorFlow Lite for Microcontrollers” project documentation and repository. https://github.com/tensorflow/tflite-micro ; see also “Build and convert models.” https://github.com/tensorflow/tensorflow/blob/master/tensorflow/lite/g3doc/microcontrollers/build_convert.md
[12] TensorFlow Lite for Microcontrollers, “Arm IP Support,” including CMSIS-NN and Cortex-M integration. https://github.com/tensorflow/tflite-micro/blob/main/docs/arm.md
[13] TensorFlow Lite for Microcontrollers, “Software Emulation with QEMU.” https://github.com/tensorflow/tflite-micro/blob/main/tensorflow/lite/micro/docs/qemu.md
[14] International Council on Systems Engineering (INCOSE), “Systems Engineering Handbook.” https://www.incose.org/resources-publications/technical-publications/se-handbook/
[15] Edge Impulse, “Edge AI FAQ” and deployment documentation, for embedded C++ deployment and target-aware model profiling. https://www.edgeimpulse.com/faqs ; https://docs.edgeimpulse.com/
Research and Standards Note
This paper combines the supplied project guide with current public technical documentation and engineering recommendations. Standards abstracts and vendor documentation are not substitutes for licensed full standards, detailed datasheets or target-specific conformance testing. ISO 14229-1:2026 and ISO 15765-2:2024 are cited as identified at the paper's preparation date; applicable regional OBD regulations and later revisions must be reviewed before product release. The architecture is a research proposal, not a certified reference design.