SOME/IP
servis tabanlı araç middleware'i.

# Service ID: 0x1234, Method ID: 0x0001, Length: 0x0000000C
# Client ID:  0x0001, Session ID: 0x0003
# Proto Ver:  0x01,   Iface Ver: 0x01
# Msg Type:   0x00 (REQUEST), Return Code: 0x00 (E_OK)
# Payload:    0xDEAD BEEF

12 34 00 01   # Message ID
00 00 00 0C   # Length (8 byte header tail + 4 byte payload)
00 01 00 03   # Request ID
01 01 00 00   # PV IV MType RC
DE AD BE EF   # Payload

# Length: 0x0009 (9 byte)
# Type:   0x04 (IPv4 Endpoint Option)
# Reserved: 0x00
# IPv4:   192.168.1.10 → C0 A8 01 0A
# Reserved: 0x00
# L4-Proto: 0x11 (UDP) / 0x06 (TCP)
# Port:   50001 → C3 51

00 09  04  00  C0 A8 01 0A  00  11  C3 51

# Bağımlılıklar
sudo apt-get install -y \
    libboost-system-dev libboost-thread-dev libboost-log-dev \
    cmake g++ git

# vsomeip kaynak kodu
git clone https://github.com/COVESA/vsomeip.git
cd vsomeip
mkdir build && cd build
cmake .. -DENABLE_SIGNAL_HANDLING=1
make -j$(nproc)
sudo make install

{
  "unicast": "192.168.1.10",          // bu ECU'nun IP adresi
  "logging": {
    "level": "debug",
    "console": true
  },
  "applications": [
    {
      "name": "body-control",
      "id": "0x1111"                // Client ID
    }
  ],
  "services": [
    {
      "service": "0x1234",         // Service ID
      "instance": "0x0001",
      "unreliable": "30501",      // UDP port
      "reliable": {
        "port": "30500",           // TCP port
        "enable-magic-cookies": "false"
      }
    }
  ],
  "routing": "body-control",       // routing manager bu app'ta
  "service-discovery": {
    "enable": "true",
    "multicast": "239.192.255.251",
    "port": "30490",
    "protocol": "udp",
    "initial_delay_min": "10",
    "initial_delay_max": "100",
    "repetitions_max": "3",
    "ttl": "3"
  }
}

// Service ID: 0x1234, Event ID: 0x8001, EventGroup: 0x0001
const vsomeip::service_t  SERVICE  = 0x1234;
const vsomeip::instance_t INSTANCE = 0x0001;
const vsomeip::event_t    EVENT_ID = 0x8001;
const vsomeip::eventgroup_t EG_ID  = 0x0001;

// Event'i tanımla ve event group'a ekle
std::set<vsomeip::eventgroup_t> its_groups;
its_groups.insert(EG_ID);

app->offer_event(
    SERVICE, INSTANCE, EVENT_ID,
    its_groups,
    vsomeip::event_type_e::ET_FIELD,   // ET_EVENT veya ET_FIELD
    std::chrono::milliseconds::zero(), // cycle time (0 = on-change)
    false,                             // change_resets_cycle
    true,                              // update_on_change
    nullptr,                           // payload filter
    vsomeip::reliability_type_e::RT_UNRELIABLE
);

// Servisi duyur
app->offer_service(SERVICE, INSTANCE);

// Payload gönder (event tetiklendiğinde)
auto its_payload = vsomeip::runtime::get()->create_payload();
std::vector<vsomeip::byte_t> data = { 0x01, 0x02, 0x03 };
its_payload->set_data(data);
app->notify(SERVICE, INSTANCE, EVENT_ID, its_payload);

// Servisi talep et
app->request_service(SERVICE, INSTANCE);

// Event group'a abone ol
app->request_event(SERVICE, INSTANCE, EVENT_ID,
    its_groups, vsomeip::event_type_e::ET_FIELD);
app->subscribe(SERVICE, INSTANCE, EG_ID);

// Bildirim handler'ı kaydet
app->register_message_handler(
    SERVICE, INSTANCE, EVENT_ID,
    [](std::shared_ptr<vsomeip::message> msg) {
        auto payload = msg->get_payload();
        std::cout << "Event alındı, uzunluk: "
                  << payload->get_length() << std::endl;
        // payload->get_data() ile bayt erişimi
    }
);

// g++ service_server.cpp -lvsomeip3 -lboost_system -lboost_thread -o server
#include <vsomeip/vsomeip.hpp>
#include <iostream>
#include <thread>
#include <chrono>

static const vsomeip::service_t  SVC  = 0x1234;
static const vsomeip::instance_t INST = 0x0001;
static const vsomeip::method_t   MTH  = 0x0001; // get_temperature
static const vsomeip::event_t    EVT  = 0x8001; // temperature_update
static const vsomeip::eventgroup_t EG  = 0x0001;

std::shared_ptr<vsomeip::application> app;

void on_message(std::shared_ptr<vsomeip::message> request) {
    // Method isteğini yanıtla
    auto response = vsomeip::runtime::get()->create_response(request);
    std::vector<vsomeip::byte_t> data = { 0x00, 0x50 }; // 80°C (örnek)
    auto payload = vsomeip::runtime::get()->create_payload();
    payload->set_data(data);
    response->set_payload(payload);
    app->send(response);
    std::cout << "Method çağrısı yanıtlandı\n";
}

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

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

    // Method handler
    app->register_message_handler(SVC, INST, MTH, on_message);

    app->offer_service(SVC, INST);

    // Periyodik notification thread
    std::thread notifier([&]() {
        uint16_t temp = 70;
        while (true) {
            std::this_thread::sleep_for(std::chrono::seconds(1));
            auto pl = vsomeip::runtime::get()->create_payload();
            pl->set_data({ (vsomeip::byte_t)(temp >> 8),
                           (vsomeip::byte_t)(temp & 0xFF) });
            app->notify(SVC, INST, EVT, pl);
            temp++;
        }
    });

    app->start(); // blocking
    notifier.join();
    return 0;
}

#include <vsomeip/vsomeip.hpp>
#include <iostream>

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

std::shared_ptr<vsomeip::application> app;

void on_availability(vsomeip::service_t s, vsomeip::instance_t i, bool available) {
    if (available) {
        std::cout << "Servis bulundu, method çağrılıyor...\n";
        // Method isteği oluştur
        auto req = vsomeip::runtime::get()->create_request();
        req->set_service(s);
        req->set_instance(i);
        req->set_method(MTH);
        app->send(req);

        // Event group'a abone ol
        std::set<vsomeip::eventgroup_t> groups = { EG };
        app->request_event(s, i, EVT, groups,
            vsomeip::event_type_e::ET_FIELD);
        app->subscribe(s, i, EG);
    }
}

void on_message(std::shared_ptr<vsomeip::message> msg) {
    auto data = msg->get_payload()->get_data();
    uint16_t temp = (data[0] << 8) | data[1];
    std::cout << "Sıcaklık: " << temp << " °C\n";
}

int main() {
    app = vsomeip::runtime::get()->create_application("temperature-client");
    app->init();
    app->register_availability_handler(SVC, INST, on_availability);
    app->register_message_handler(SVC, INST, MTH, on_message);  // response
    app->register_message_handler(SVC, INST, EVT, on_message);  // notification
    app->request_service(SVC, INST);
    app->start();
    return 0;
}

g++ service_server.cpp -lvsomeip3 -lboost_system -lboost_thread -o server
g++ service_client.cpp -lvsomeip3 -lboost_system -lboost_thread -o client

# Terminal 1 — sunucu başlat
VSOMEIP_CONFIGURATION=./vsomeip-server.json ./server

# Terminal 2 — istemci başlat
VSOMEIP_CONFIGURATION=./vsomeip-client.json ./client

{
  "security": {
    "check_credentials": true,
    "allow_remote_clients": false
  },
  "tls": {
    "enabled": true,
    "certificate": "/etc/vsomeip/certs/ecu.crt",
    "private_key": "/etc/vsomeip/certs/ecu.key",
    "ca_certificate": "/etc/vsomeip/certs/ca.crt"
  }
}

{
  "policies": [
    {
      "credentials": { "uid": 1001, "gid": 1001 },
      "allow": {
        "offers": [
          { "service": "0x1234", "instance": "0x0001" }
        ]
      }
    },
    {
      "credentials": { "uid": 1002, "gid": 1002 },
      "allow": {
        "requests": [
          { "service": "0x1234", "instance": "0x0001" }
        ]
      }
    }
  ]
}

# Loopback interface ile test (tek makine)
sudo ip addr add 192.168.1.10/24 dev lo label lo:gw
sudo ip addr add 192.168.1.11/24 dev lo label lo:bcm

# Ya da iki sanal Ethernet interface oluştur
sudo ip link add veth-gw type veth peer name veth-bcm
sudo ip addr add 192.168.1.10/24 dev veth-gw
sudo ip addr add 192.168.1.11/24 dev veth-bcm
sudo ip link set veth-gw up
sudo ip link set veth-bcm up

# Multicast route ekle (SD için)
sudo ip route add 239.192.255.251/32 dev veth-gw

# Wireshark >= 2.0 SOME/IP desteği yerleşiktir
# Dissector etkinleştirme: Analyze → Decode As
# UDP port 30490 → SOMEIP-SD
# UDP/TCP port 30500/30501 → SOMEIP

# Komut satırından tshark ile yakalama
tshark -i lo \
    -d 'udp.port==30490,someipsd' \
    -d 'udp.port==30501,someip' \
    -T fields \
    -e someip.serviceid \
    -e someip.methodid \
    -e someip.msgtype

# SOME/IP-SD Offer mesajlarını filtrele
tshark -r capture.pcap -Y 'someipsd.type == 1'

# Terminal 1 — BCM (sunucu)
VSOMEIP_CONFIGURATION=./bcm-config.json \
VSOMEIP_APPLICATION_NAME=bcm-ecu \
    ./bcm_server

# Terminal 2 — Gateway (istemci)
VSOMEIP_CONFIGURATION=./gw-config.json \
VSOMEIP_APPLICATION_NAME=gateway-ecu \
    ./gw_client

# Beklenen çıktı (Gateway):
# [info] BCM servisi bulundu: 0x1234/0x0001
# [info] Kapı durumu event alındı: LOCKED
# [info] unlock() methodu yanıtlandı: E_OK
# [info] Kapı durumu event alındı: UNLOCKED