FlexRay
deterministik araç bus'ı.

import struct

def parse_flexray_header(header_5bytes: bytes) -> dict:
    """5-byte FlexRay header'ı parse et"""
    assert len(header_5bytes) == 5

    # Tüm 40 biti integer'a dönüştür
    val = int.from_bytes(header_5bytes, byteorder='big')

    reserved   = (val >> 39) & 1
    pp         = (val >> 38) & 1
    nf         = (val >> 37) & 1
    sync       = (val >> 36) & 1
    startup    = (val >> 35) & 1
    frame_id   = (val >> 24) & 0x7FF    # 11 bit
    payload_len= (val >> 17) & 0x7F     # 7 bit (word sayisi)
    header_crc = (val >> 6)  & 0x7FF    # 11 bit
    cycle_cnt  =  val         & 0x3F     # 6 bit

    return {
        "frame_id"     : frame_id,
        "payload_words": payload_len,
        "payload_bytes": payload_len * 2,
        "cycle_count"  : cycle_cnt,
        "sync"         : bool(sync),
        "startup"      : bool(startup),
        "null_frame"   : not bool(nf),
        "payload_preamble": bool(pp),
        "header_crc"   : header_crc,
    }

# Ornek header: Frame ID=5, 4 word payload, cycle=12, sync frame
example_hdr = bytes([0x10, 0x05, 0x04, 0x00, 0x0C])
info = parse_flexray_header(example_hdr)
for k, v in info.items():
    print(f"  {k}: {v}")

<!-- FlexRay Cluster FIBEX tanımı (kısaltılmış) -->
<fx:CLUSTER id="C_FlexRay_1">
  <fx:PROTOCOL>FLEXRAY</fx:PROTOCOL>
  <fx:BAUDRATE>10000000</fx:BAUDRATE>   <!-- 10 Mbps -->

  <fx:TIMING>
    <fx:CYCLE-LENGTH>5000</fx:CYCLE-LENGTH>      <!-- 5 ms -->
    <fx:STATIC-SLOTS>40</fx:STATIC-SLOTS>
    <fx:STATIC-SLOT-LENGTH>100</fx:STATIC-SLOT-LENGTH>  <!-- 100 µs -->
    <fx:MINISLOT-LENGTH>25</fx:MINISLOT-LENGTH>
    <fx:NUMBER-OF-MINISLOTS>20</fx:NUMBER-OF-MINISLOTS>
  </fx:TIMING>

  <fx:CHANNEL-A>active-star</fx:CHANNEL-A>
  <fx:CHANNEL-B>active-star</fx:CHANNEL-B>
</fx:CLUSTER>

<!-- ECU Tanımı: Süspansiyon Kontrol Modülü -->
<fx:ECU id="ECU_SuspensionCtrl">
  <fx:NODE>
    <fx:STATIC-SLOT-ASSIGNMENT>
      <fx:SLOT-ID>5</fx:SLOT-ID>           <!-- Slot 5: CH A+B -->
      <fx:CHANNEL>A_AND_B</fx:CHANNEL>
    </fx:STATIC-SLOT-ASSIGNMENT>
    <fx:STATIC-SLOT-ASSIGNMENT>
      <fx:SLOT-ID>6</fx:SLOT-ID>           <!-- Slot 6: sadece CH A -->
      <fx:CHANNEL>A</fx:CHANNEL>
    </fx:STATIC-SLOT-ASSIGNMENT>
  </fx:NODE>
</fx:ECU>

<!-- Frame tanımı -->
<fx:FRAME id="FRM_SuspensionData">
  <fx:SLOT-ID>5</fx:SLOT-ID>
  <fx:PAYLOAD-LENGTH>8</fx:PAYLOAD-LENGTH>   <!-- 16 byte -->
  <fx:PDU-INSTANCES>
    <fx:PDU ref="PDU_WheelSpeed_FL"/>
    <fx:PDU ref="PDU_WheelSpeed_FR"/>
    <fx:PDU ref="PDU_SuspensionPos"/>
  </fx:PDU-INSTANCES>
</fx:FRAME>

# FlexRay kernel modülü (üretici özel):
sudo modprobe flexray
sudo modprobe flexray_mpc5121  # Freescale MPC5121 FlexRay IP için

# Cihaz listesi:
ip link show | grep fr
# 5: fr0: <NOARP,UP,LOWER_UP> mtu 254 ... state UNKNOWN

# FlexRay arayüzünü yapılandır (araç özel BSP):
ip link set fr0 type flexray speed 10000000
ip link set fr0 up

# eb tresos Studio Linux kurulumu:
tar -xzf eb_tresos_studio_linux_v28.0.tar.gz
cd eb_tresos_studio/
./install.sh

# FlexRay simülasyon projesi oluştur:
./tresos_studio --project fr_cluster_sim --protocol flexray

# FIBEX dosyasını yükle:
./tresos_studio --import-fibex bmw_x5_suspension.xml

# Simülasyonu başlat:
./tresos_studio --run-sim --duration 1000ms --log fr_trace.bin

# FIBEX'ten AUTOSAR .arxml'e dönüştür (Vector Fibex2arxml):
fibex2arxml --input bmw_x5.fibex --output bmw_x5.arxml

# FlexRay log dosyasını analiz et (Python ile):
python3 - <<'EOF'
import can   # python-can FlexRay eklentisi (Vector sürücüsü ile)
import cantools

db = cantools.db.load_file('bmw_x5_flexray.arxml')
bus = can.interface.Bus(bustype='vector',
                         channel=0, bitrate=10000000,
                         protocol='flexray')
for msg in bus:
    try:
        decoded = db.decode_message(msg.arbitration_id, msg.data)
        print(f"Slot {msg.arbitration_id}: {decoded}")
    except Exception:
        pass
EOF

<!-- AUTOSAR .arxml FlexRay Frame tanımı -->
<FR-CLUSTER>
  <SHORT-NAME>FlexRayCluster_SuspensionDomain</SHORT-NAME>
  <BAUD-RATE>10000000</BAUD-RATE>

  <COMMUNICATION-CYCLE>
    <CYCLE-LENGTH>5000</CYCLE-LENGTH>
    <STATIC-SLOT-LENGTH>100</STATIC-SLOT-LENGTH>
    <NUMBER-OF-STATIC-SLOTS>40</NUMBER-OF-STATIC-SLOTS>
  </COMMUNICATION-CYCLE>
</FR-CLUSTER>

<!-- Frame to PDU mapping -->
<FR-FRAME>
  <SHORT-NAME>SuspensionDataFrame</SHORT-NAME>
  <FRAME-LENGTH>16</FRAME-LENGTH>    <!-- 16 byte payload -->
  <PDU-TO-FRAME-MAPPINGS>
    <PDU-TO-FRAME-MAPPING>
      <PDU-REF>WheelSpeed_FL_PDU</PDU-REF>
      <START-POSITION>0</START-POSITION>
      <PACKED-BYTE-LENGTH>4</PACKED-BYTE-LENGTH>
    </PDU-TO-FRAME-MAPPING>
    <PDU-TO-FRAME-MAPPING>
      <PDU-REF>SuspensionPosition_PDU</PDU-REF>
      <START-POSITION>4</START-POSITION>
      <PACKED-BYTE-LENGTH>8</PACKED-BYTE-LENGTH>
    </PDU-TO-FRAME-MAPPING>
  </PDU-TO-FRAME-MAPPINGS>
</FR-FRAME>

# CANoe komut satırı simülasyonu (CANoeScript):
CANoe /CFG bmw_x5_flexray.cfg /Start /StopAfter 5000 /Log output.blf

# BLF (Binary Logging File) dosyasını Python ile analiz et:
python3 - <<'EOF'
import can
from can.util import load_environment_config

log = can.BLFReader("output.blf")
flexray_msgs = []
for msg in log:
    if msg.channel == "FlexRay":
        flexray_msgs.append({
            "timestamp" : msg.timestamp,
            "slot_id"   : msg.arbitration_id,
            "cycle"     : msg.channel_specific.get("cycle", 0),
            "data"      : msg.data.hex()
        })

print(f"Toplam FlexRay mesaj: {len(flexray_msgs)}")
for m in flexray_msgs[:5]:
    print(f"  Slot {m['slot_id']} Cycle {m['cycle']}: {m['data']}")
EOF

# TRACE32 FlexRay trace komutu (PowerView scripting):
# FlexRay.TRACE.Init <cluster_file> <channel>
FlexRay.TRACE.Init bmw_x5.fibex A+B
FlexRay.TRACE.Start
# ... 5 saniye bekle ...
FlexRay.TRACE.Stop
FlexRay.TRACE.Export CSV fr_trace.csv

pip install python-flexray

from flexray import FlexRayFrame, FlexRayCluster

# Cluster tanımını yükle (FIBEX veya arxml):
cluster = FlexRayCluster.from_fibex("bmw_x5_suspension.fibex")

# Ham frame verisi (header + payload):
raw_frame = bytes([
    0x10, 0x05, 0x08, 0x00, 0x0C,  # 5-byte header
    0x13, 0x88, 0x27, 0x10,          # 4 byte: FL hız = 5000, FR hız = 10000
    0x01, 0xF4, 0x02, 0x58,          # süspansiyon pozisyonları
    0x00, 0x00, 0x00, 0x00,
    0xA3, 0xB2, 0xC1,               # 3-byte Frame CRC
])

frame = FlexRayFrame.from_bytes(raw_frame)
print(f"Slot ID: {frame.slot_id}")
print(f"Cycle:   {frame.cycle_count}")
print(f"Sync:    {frame.sync_frame}")

# PDU decode (cluster tanımından):
decoded = cluster.decode_frame(frame)
for signal_name, value in decoded.items():
    print(f"  {signal_name}: {value}")

# Beklenen çıktı:
# WheelSpeed_FL: 5000 rpm
# WheelSpeed_FR: 10000 rpm
# SuspensionPos_FL: 500 mm
# SuspensionPos_FR: 600 mm

/*
 * AUTOSAR SWC: EHC (Electro-Hydraulic Control) — aktif damper
 * Platform: TriCore TC1797, AUTOSAR CP 4.3
 * Periyot: 5 ms (FlexRay static segment Slot 5 ile tetiklenir)
 */

#include "Rte_EHC_SuspensionCtrl.h"   /* AUTOSAR RTE başlığı */

/* Sinyal tanımları (FIBEX'ten ARXML'e, arxml'den RTE'ye üretildi) */
#define YAW_RATE_MAX_DEG_S   150.0f
#define LATERAL_G_MAX        1.5f

/* SWC RunEntity: her 5 ms'de FlexRay frame alımında tetiklenir */
FUNC(void, EHC_CODE) EHC_SuspensionCtrl_5ms(void) {
    float32 yaw_rate_deg_s   = 0.0f;
    float32 lateral_accel_g  = 0.0f;
    float32 roll_angle_deg   = 0.0f;

    /* Slot 1'den (VDM): araç dinamik verileri al */
    Rte_Read_SRVehicleDynamics_YawRate(&yaw_rate_deg_s);
    Rte_Read_SRVehicleDynamics_LateralAccel(&lateral_accel_g);
    Rte_Read_SRVehicleDynamics_RollAngle(&roll_angle_deg);

    /* Süspansiyon kuvvet talebi hesapla */
    float32 anti_roll_force_Nm = lateral_accel_g * 9.81f * 450.0f;
    /* 450 = araç sprung mass * roll moment kolu */

    /* Damper kuvvetini sınırla */
    if (anti_roll_force_Nm > EHCA_MAX_FORCE_NM)
        anti_roll_force_Nm = EHCA_MAX_FORCE_NM;
    if (anti_roll_force_Nm < -EHCA_MAX_FORCE_NM)
        anti_roll_force_Nm = -EHCA_MAX_FORCE_NM;

    /* Slot 5'e (EHC çıkış): amortisör valf komutu yaz */
    Rte_Write_SRDamperControl_AntiRollForce(anti_roll_force_Nm);
    Rte_Write_SRDamperControl_DamperMode(DAMPER_MODE_COMFORT);
}

/*
 * AUTOSAR PduR (PDU Router) — FlexRay to CAN routing tablosu
 * Bu konfigürasyon AUTOSAR Configurator'da üretilir.
 */

/* Araç hızı: FlexRay Slot 1 → CAN ID 0x1A0 (body network) */
const PduR_RoutingPathType PduR_RoutingTable[] = {
    {
        .src_pdu_id   = FR_PDU_VEHICLE_SPEED,   /* FlexRay kaynak */
        .dst_pdu_id   = CAN_PDU_VEHICLE_SPEED,  /* CAN hedef */
        .scaling      = 1.0f,                   /* birim dönüşümü yok */
        .gateway_type = PDUGATEWAY_FLEXRAY_TO_CAN
    },
    {
        .src_pdu_id   = FR_PDU_YAW_RATE,
        .dst_pdu_id   = CAN_PDU_YAW_RATE,
        .scaling      = 1.0f,
        .gateway_type = PDUGATEWAY_FLEXRAY_TO_CAN
    },
};

void PduR_FrIfRxIndication(PduIdType pduId,
                             const PduInfoType* pduInfo) {
    /* FlexRay'den gelen PDU'yu CAN'a yönlendir */
    for (int i = 0; i < PDUR_ROUTING_TABLE_SIZE; i++) {
        if (PduR_RoutingTable[i].src_pdu_id == pduId) {
            CanIf_Transmit(PduR_RoutingTable[i].dst_pdu_id, pduInfo);
        }
    }
}