Hands-On: Cross-Platform Vehicle Function

/* Classic gateway SWC runnable — called every 5ms */
FUNC(void, GW_CODE) SpeedGateway_Runnable(void)
{
    uint16 speedRaw;
    Std_ReturnType ret;

    /* Read from COM (filled by CanIf on CAN Rx) */
    ret = Com_ReceiveSignal(COM_SIG_VEHICLE_SPEED, &speedRaw);

    if (ret == E_OK) {
        /* Serialize speed to SOME/IP event payload */
        SomeIP_SpeedEvent_t evt;
        evt.vehicleSpeed = speedRaw;          /* uint16, km/h * 100 */
        evt.timestamp_ms = GetSystemTime_ms();
        evt.valid        = 1;

        /* Write to IPC region (Classic owns write side) */
        HwSemaphore_Acquire(HW_SEM_SPEED);
        memcpy(&ipc_speed_event, &evt, sizeof(evt));
        ipc_speed_new = 1;
        HwSemaphore_Release(HW_SEM_SPEED);
    } else if (ret == COM_E_STOPPED || ret == COM_INVALID) {
        /* CAN bus failure: signal invalid */
        HwSemaphore_Acquire(HW_SEM_SPEED);
        ipc_speed_event.valid = 0;
        ipc_speed_new = 1;
        HwSemaphore_Release(HW_SEM_SPEED);
    }
}

#include "SpeedService_proxy.h"
#include "AudioSkeleton.h"
#include 

class SpeedProcessingApp {
    std::shared_ptr proxy_;
    std::unique_ptr audioSkeleton_;

public:
    void Init() {
        // Find SpeedService on local IPC transport
        auto handles = SpeedService::Proxy::FindService(
            ara::com::InstanceIdentifier("SpeedService_IPC_1"));
        proxy_ = std::make_shared(handles[0]);

        // Subscribe to speed event with 4-sample buffer
        proxy_->SpeedEvent.Subscribe(4);
        proxy_->SpeedEvent.SetReceiveHandler(
            [this]() { OnSpeedEvent(); });

        audioSkeleton_ = std::make_unique(
            ara::com::InstanceIdentifier("AudioService_1"));
        audioSkeleton_->OfferService();
    }

    void OnSpeedEvent() {
        proxy_->SpeedEvent.GetNewSamples([this](auto sample) {
            if (sample.GetE2ECheckStatus() ==
                ara::com::e2e::ProfileCheckStatus::kOk) {
                float speedKph = sample->vehicleSpeed / 100.0f;
                // Volume attenuation: reduce by 0.5 dB per km/h above 80
                float attenDb = std::max(0.0f, (speedKph - 80.0f) * 0.5f);
                audioSkeleton_->VolumeAttenuation.Update(attenDb);
            } else {
                audioSkeleton_->VolumeAttenuation.Update(0.0f); // safe: no attenuation
            }
        }, 4);
    }
};

/* Inject VehicleSpeed on CAN and verify Adaptive volume field update */
variables {
    message VehicleSpeed_Msg msg;
    float expectedAttenDb;
}

on key '1' {
    /* Inject 100 km/h: attenuation should be (100-80)*0.5 = 10.0 dB */
    msg.VehicleSpeed = 10000;  /* raw: 100.00 km/h * 100 */
    output(msg);
    expectedAttenDb = 10.0;
    setTimer(verifyTimer, 100); /* wait 100ms for Adaptive to process */
}

on timer verifyTimer {
    /* Read Adaptive Field value via SOME/IP Get request */
    /* (sent by CANoe SOME/IP tester module) */
    float actualAtten = someip_get_field("AudioService_1", "VolumeAttenuation");
    if (abs(actualAtten - expectedAttenDb) < 0.5) {
        write("PASS: VolumeAttenuation=%.1f dB (expected %.1f)", actualAtten, expectedAttenDb);
    } else {
        write("FAIL: VolumeAttenuation=%.1f dB (expected %.1f)", actualAtten, expectedAttenDb);
    }
}