Hands-On: Production Build Pipeline

pipeline {
  agent any
  stages {
    stage('Validate ARXML') {
      steps {
        sh 'davinci_cli.exe -project ECU.dpj -validate -strict'
        sh 'python3 ci_bsw_validation.py'  // PduR routes, signal matrix
      }
    }
    stage('Generate BSW + RTE Code') {
      steps {
        sh 'davinci_cli.exe -project ECU.dpj -gen -output GENDATA/'
        sh 'python3 ci_stale_check.py'  // verify GENDATA matches ARXML checksum
      }
    }
    stage('MISRA-C Analysis') {
      steps {
        sh 'polyspace-bug-finder -sources GENDATA/ src/ -misra C2012 -report polyspace_report.pdf'
        sh 'python3 check_misra_deviations.py polyspace_report.pdf approved_deviations.csv'
      }
    }
    stage('Cross-Compile') {
      steps {
        sh 'cmake --build build/ --config Release -j4'
        archiveArtifacts artifacts: 'build/ECU_EPS.elf, build/ECU_EPS.map'
      }
    }
    stage('ROM Budget Gate') {
      steps {
        sh 'python3 ci_map_budget.py --map build/ECU_EPS.map --budgets rom_budgets.yaml'
      }
    }
    stage('Flash to Bench + CAN Validation') {
      steps {
        sh 'trace32_cli -script flash_bench.cmm'
        sh 'python3 canoe_validation.py --dbc ECU.dbc --duration 30'
      }
    }
  }
}

#!/usr/bin/env python3
import re, sys, yaml, argparse

def parse_map(mapfile):
    # Parse arm-none-eabi-ld map file, return {section: size_bytes}
    sections = {}
    with open(mapfile) as f:
        for line in f:
            m = re.match(r'^(\.\S+)\s+0x[0-9a-f]+\s+0x([0-9a-f]+)', line)
            if m:
                sections[m.group(1)] = int(m.group(2), 16)
    return sections

parser = argparse.ArgumentParser()
parser.add_argument('--map', required=True)
parser.add_argument('--budgets', required=True)
args = parser.parse_args()

sections = parse_map(args.map)
budgets = yaml.safe_load(open(args.budgets))

failures = []
for section, budget_bytes in budgets.items():
    actual = sections.get(section, 0)
    status = "PASS" if actual <= budget_bytes else "FAIL"
    print(f"{status}: {section} = {actual:,} / {budget_bytes:,} bytes ({actual/budget_bytes:.0%})")
    if status == "FAIL":
        failures.append(section)

sys.exit(1 if failures else 0)

.text:          196608   # 192 KB total code
.rodata:         65536    # 64 KB const data (COM tables etc.)
.bss:             8192    # 8 KB zero-init data
.os_stacks:      16384    # 16 KB task stacks
.post_build:     32768    # 32 KB post-build config

#!/bin/bash
# Update PduR routing table without recompiling full BSW
# Scenario: OEM adds new CAN signal after BSW freeze

# 1. Update only Com_PBcfg.arxml and PduR_PBcfg.arxml
# 2. Regenerate PBcfg files only
davinci_cli.exe -project ECU.dpj -gen-postbuild -output GENDATA_PB/

# 3. Compile PBcfg only
arm-none-eabi-gcc -c GENDATA_PB/Com_PBcfg.c -o build/Com_PBcfg.o
arm-none-eabi-gcc -c GENDATA_PB/PduR_PBcfg.c -o build/PduR_PBcfg.o

# 4. Link PBcfg binary (self-contained — no BSW code references)
arm-none-eabi-ld -T postbuild.ld build/Com_PBcfg.o build/PduR_PBcfg.o -o ECU_PBcfg.bin

# 5. Flash PBcfg section only (100KB flash, not 2MB full BSW image)
trace32_cli -script flash_postbuild.cmm ECU_PBcfg.bin

echo "Post-build update complete — BSW binary unchanged" 

#!/usr/bin/env python3
# CANoe headless CAN trace comparison against DBC expected values
import canoe_com_api as canoe
import can_dbc_parser as dbc_parser
import sys

# Load DBC expected signal specifications
dbc = dbc_parser.load("ECU.dbc")
expected_cycles = {sig.name: sig.cycle_time_ms for sig in dbc.signals if sig.is_cyclic}

# Connect to CANoe and run 30-second capture
session = canoe.start_headless("CANoe_Config.cfg")
session.start_measurement()
session.wait(30.0)
trace = session.get_trace()
session.stop_measurement()

failures = []
for sig_name, expected_ms in expected_cycles.items():
    actual_ms = trace.measure_average_cycle_time(sig_name)
    if actual_ms is None:
        failures.append(f"{sig_name}: NOT FOUND ON BUS (PDU disabled?)")
    elif abs(actual_ms - expected_ms) > expected_ms * 0.15:  # ±15% tolerance
        failures.append(f"{sig_name}: cycle={actual_ms:.1f}ms expected={expected_ms}ms")

if failures:
    print("CAN VALIDATION FAILED:"); [print(f"  {f}") for f in failures]; sys.exit(1)
print(f"CAN validation PASSED: {len(expected_cycles)} signals verified")