AUTOSAR Adaptive
POSIX tabanlı dinamik araç yazılım platformu.

// ARXML'den araçlarla otomatik oluşturulan Skeleton sınıfı
#include "ara/temperature/temperature_skeleton.h"
#include "ara/exec/execution_client.h"

using namespace ara::temperature;

class TemperatureServiceImpl : public skeleton::TemperatureServiceSkeleton {
public:
    TemperatureServiceImpl(ara::com::InstanceIdentifier id)
        : TemperatureServiceSkeleton(id) {}

    // Method implementasyonu (blocking Future döner)
    ara::core::Future<GetTemperatureOutput> GetTemperature() override {
        ara::core::Promise<GetTemperatureOutput> promise;
        GetTemperatureOutput output;
        output.temperature = read_sensor();    // hw okuma
        output.unit = TemperatureUnit::Celsius;
        promise.set_value(output);
        return promise.get_future();
    }
};

int main() {
    ara::exec::ExecutionClient exec_client;
    exec_client.ReportExecutionState(
        ara::exec::ExecutionState::kRunning);

    // Instance ID manifest'ten gelir
    ara::com::InstanceIdentifier id("1");
    TemperatureServiceImpl svc(id);
    svc.OfferService();

    // Event periyodik gönder
    while (true) {
        TemperatureChanged::SampleType event_data;
        event_data.value = read_sensor();
        svc.TemperatureChanged.Send(event_data);
        std::this_thread::sleep_for(std::chrono::milliseconds(100));
    }
}

#include "ara/temperature/temperature_proxy.h"

using namespace ara::temperature::proxy;

int main() {
    // Servis bul — async, handle vector döner
    auto handles = TemperatureServiceProxy::FindService(
        ara::com::InstanceIdentifier::Any);

    if (handles.empty()) {
        std::cerr << "Servis bulunamadı\n";
        return 1;
    }

    // İlk bulunan instance ile proxy oluştur
    TemperatureServiceProxy proxy(handles[0]);

    // Event'e abone ol
    proxy.TemperatureChanged.Subscribe(
        ara::com::EventCacheUpdatePolicy::kLastN, 10);
    proxy.TemperatureChanged.SetReceiveHandler([&]() {
        proxy.TemperatureChanged.GetNewSamples(
            [](ara::com::SamplePtr<TemperatureChanged::SampleType> sample) {
                std::cout << "Event: " << sample->value << " °C\n";
            });
    });

    // Method çağır (async Future)
    auto future = proxy.GetTemperature();
    auto result = future.get();  // blocking wait
    std::cout << "Sıcaklık: " << result.temperature << " °C\n";

    // Event subscription sonlandır
    proxy.TemperatureChanged.Unsubscribe();
    return 0;
}

// Servis geldiğinde / gittiğinde bildirim al
TemperatureServiceProxy::StartFindService(
    [](ara::com::ServiceHandleContainer<TemperatureServiceProxy::HandleType> handles,
       ara::com::FindServiceHandle fsh) {
        if (!handles.empty()) {
            std::cout << "Servis aktif\n";
            // proxy oluştur ve kullan
        } else {
            std::cout << "Servis kayboldu\n";
        }
    },
    ara::com::InstanceIdentifier("1"));

<SERVICE-INTERFACE>
  <SHORT-NAME>TemperatureService</SHORT-NAME>
  <NAMESPACE-BLOBS>
    <NAMESPACE-BLOB>
      <SHORT-NAME>ara</SHORT-NAME>
      <SHORT-NAME>temperature</SHORT-NAME>
    </NAMESPACE-BLOB>
  </NAMESPACE-BLOBS>

  <!-- Method tanımı -->
  <METHODS>
    <CLIENT-SERVER-OPERATION>
      <SHORT-NAME>GetTemperature</SHORT-NAME>
      <ARGUMENTS></ARGUMENTS>  <!-- input yok -->
      <POSSIBLE-ERROR-REFS></POSSIBLE-ERROR-REFS>
    </CLIENT-SERVER-OPERATION>
  </METHODS>

  <!-- Event tanımı -->
  <EVENTS>
    <VARIABLE-DATA-PROTOTYPE>
      <SHORT-NAME>TemperatureChanged</SHORT-NAME>
      <TYPE-TREF DEST="IMPLEMENTATION-DATA-TYPE">
        /AUTOSAR/Platform/ImplementationDataTypes/float32
      </TYPE-TREF>
    </VARIABLE-DATA-PROTOTYPE>
  </EVENTS>

  <!-- Field tanımı -->
  <FIELDS>
    <FIELD>
      <SHORT-NAME>CurrentTemperature</SHORT-NAME>
      <HAS-GETTER>true</HAS-GETTER>
      <HAS-SETTER>false</HAS-SETTER>
      <HAS-NOTIFIER>true</HAS-NOTIFIER>
    </FIELD>
  </FIELDS>

</SERVICE-INTERFACE>

<SOMEIP-SERVICE-INTERFACE-DEPLOYMENT>
  <SHORT-NAME>TemperatureService_SOMEIP</SHORT-NAME>
  <SERVICE-INTERFACE-REF>/Services/TemperatureService</SERVICE-INTERFACE-REF>

  <SERVICE-ID>0x1234</SERVICE-ID>

  <METHOD-DEPLOYMENTS>
    <SOMEIP-METHOD-DEPLOYMENT>
      <SHORT-NAME>GetTemperature_Deploy</SHORT-NAME>
      <METHOD-REF>/Services/TemperatureService/GetTemperature</METHOD-REF>
      <METHOD-ID>0x0001</METHOD-ID>
    </SOMEIP-METHOD-DEPLOYMENT>
  </METHOD-DEPLOYMENTS>

  <EVENT-DEPLOYMENTS>
    <SOMEIP-EVENT-DEPLOYMENT>
      <SHORT-NAME>TemperatureChanged_Deploy</SHORT-NAME>
      <EVENT-REF>/Services/TemperatureService/TemperatureChanged</EVENT-REF>
      <EVENT-ID>0x8001</EVENT-ID>
      <TRANSPORT-PROTOCOL>UDP</TRANSPORT-PROTOCOL>
    </SOMEIP-EVENT-DEPLOYMENT>
  </EVENT-DEPLOYMENTS>

</SOMEIP-SERVICE-INTERFACE-DEPLOYMENT>

#include "ara/exec/execution_client.h"
#include <csignal>

static volatile std::atomic<bool> running{true};

void signal_handler(int sig) {
    running = false;
}

int main() {
    std::signal(SIGTERM, signal_handler);

    // Execution Management'e durum bildir
    ara::exec::ExecutionClient exec_client;

    // Başlatma tamamlandı, çalışmaya hazır
    auto result = exec_client.ReportExecutionState(
        ara::exec::ExecutionState::kRunning);

    if (result.HasValue()) {
        // uygulama ana döngüsü
        while (running) {
            do_work();
            std::this_thread::sleep_for(std::chrono::milliseconds(10));
        }
    } else {
        // EM izin vermedi — graceful exit
        return 1;
    }

    // Shutdown başlatıldı — temizle ve çık
    cleanup();
    return 0;
    // Process'in kendiliğinden sonlanması kShuttingDown anlamına gelir
}

<ADAPTIVE-APPLICATION-SW-COMPONENT-TYPE>
  <SHORT-NAME>TemperatureSensorApp</SHORT-NAME>

  <PROCESS>
    <SHORT-NAME>TemperatureProcess</SHORT-NAME>
    <EXECUTABLE-REF>/executables/temp_sensor</EXECUTABLE-REF>
    <STARTUP-CONFIGS>
      <STARTUP-CONFIG>
        <ARGUMENTS>--config=/etc/temp_sensor.json</ARGUMENTS>
        <ENVIRONMENT-VARIABLES>
          <ENVIRONMENT-VARIABLE>
            <KEY>VSOMEIP_CONFIGURATION</KEY>
            <VALUE>/etc/vsomeip/temp.json</VALUE>
          </ENVIRONMENT-VARIABLE>
        </ENVIRONMENT-VARIABLES>
      </STARTUP-CONFIG>
    </STARTUP-CONFIGS>
  </PROCESS>

</ADAPTIVE-APPLICATION-SW-COMPONENT-TYPE>

git clone https://github.com/eclipse-openadaptive/openadaptive.git
cd openadaptive

# Docker ile hızlı başlangıç
docker build -t openaa .
docker run -it openaa bash

# Örnek uygulamayı çalıştır
./examples/hello_adaptive/run.sh

# Ubuntu/Debian
sudo add-apt-repository ppa:ecal/ecal-latest
sudo apt-get update
sudo apt-get install ecal

# Python bağlantısı
pip install ecal5

import ecal.core.core as ecal_core
from ecal.core.publisher import StringPublisher
import time, json

ecal_core.initialize([], "temperature_sensor")

pub = StringPublisher("temperature/engine")

while ecal_core.ok():
    data = json.dumps({"temperature": 85.5, "unit": "Celsius"})
    pub.send(data)
    time.sleep(0.1)

ecal_core.finalize()

# Temel build araçları
sudo apt-get install -y \
    build-essential cmake ninja-build \
    libboost-all-dev libssl-dev \
    git python3 python3-pip

# C++17 derleyicisi (GCC 11+)
g++ --version   # >= 11 olmalı

# vsomeip (SOME/IP binding için)
git clone https://github.com/COVESA/vsomeip.git
cd vsomeip && mkdir build && cd build
cmake .. -DCMAKE_BUILD_TYPE=Release
make -j$(nproc) && sudo make install

# DLT daemon (ara::log için)
sudo apt-get install -y dlt-daemon dlt-tools

cmake_minimum_required(VERSION 3.16)
project(adaptive_app CXX)

set(CMAKE_CXX_STANDARD 17)
set(CMAKE_CXX_STANDARD_REQUIRED ON)

# Bağımlılıklar
find_package(Boost REQUIRED COMPONENTS system thread log)
find_package(vsomeip3 REQUIRED)

# Uygulama
add_executable(temperature_server
    src/temperature_server.cpp
    src/temperature_skeleton.cpp)

target_include_directories(temperature_server PRIVATE
    ${CMAKE_SOURCE_DIR}/include
    ${vsomeip3_INCLUDE_DIRS})

target_link_libraries(temperature_server
    vsomeip3
    Boost::system Boost::thread Boost::log
    pthread)

# vsomeip routing manager (ara::com altyapısı)
VSOMEIP_CONFIGURATION=/etc/vsomeip/routing.json \
    vsomeipd &

# DLT daemon (ara::log altyapısı)
dlt-daemon -c /etc/dlt.conf &

# Execution Manager (simüle edilmiş — gerçekte platform sağlar)
# Adaptive Application'ları systemd veya EM başlatır
systemctl start adaptive-execution-manager

# Uygulama başlat
VSOMEIP_CONFIGURATION=/etc/vsomeip/temp.json \
    ./temperature_server &

# Log izle
dlt-receive -a localhost

speed_demo/
├── CMakeLists.txt
├── include/
│   ├── speed_service_skeleton.h   # ARXML'den üretilmiş
│   └── speed_service_proxy.h      # ARXML'den üretilmiş
├── src/
│   ├── speed_sensor_server.cpp    # Sensör (Skeleton)
│   └── dashboard_client.cpp      # Dashboard (Proxy)
└── config/
    ├── sensor-vsomeip.json        # vsomeip konfigürasyonu
    └── dashboard-vsomeip.json

#include "speed_service_skeleton.h"
#include <vsomeip/vsomeip.hpp>

static const vsomeip::service_t  SVC  = 0x5100;
static const vsomeip::instance_t INST = 0x0001;
static const vsomeip::event_t    EVT  = 0x8001;
static const vsomeip::eventgroup_t EG  = 0x0001;

int main() {
    auto app = vsomeip::runtime::get()->create_application("SpeedSensor");
    app->init();

    std::set<vsomeip::eventgroup_t> groups = { EG };
    app->offer_event(SVC, INST, EVT, groups,
        vsomeip::event_type_e::ET_FIELD);
    app->offer_service(SVC, INST);

    float speed = 0.0f;
    std::thread sensor_thread([&]() {
        while (true) {
            speed = simulate_speed_sensor();
            auto pl = vsomeip::runtime::get()->create_payload();
            std::vector<uint8_t> data(sizeof(float));
            std::memcpy(data.data(), &speed, sizeof(float));
            pl->set_data(data);
            app->notify(SVC, INST, EVT, pl);
            std::this_thread::sleep_for(std::chrono::milliseconds(50));
        }
    });

    app->start();
    sensor_thread.join();
}

mkdir build && cd build
cmake .. -DCMAKE_BUILD_TYPE=Debug
make -j4

# Terminal 1 — Sensör başlat
VSOMEIP_CONFIGURATION=../config/sensor-vsomeip.json \
    ./speed_sensor_server

# Terminal 2 — Dashboard başlat
VSOMEIP_CONFIGURATION=../config/dashboard-vsomeip.json \
    ./dashboard_client

# Beklenen dashboard çıktısı:
# [ara::com] SpeedService bulundu: 0x5100/0x0001
# Hız: 0.0 km/h
# Hız: 12.5 km/h
# Hız: 25.0 km/h
# ...