ARINC 429
sivil havacılık veri bus'ı.

def bnr_encode(value: float, resolution: float,
               n_data_bits: int = 18) -> int:
    """
    ARINC 429 BNR encode: float deger -> data field bitleri (bits 11-29)
    n_data_bits: isaret biti haric veri bit sayisi (tipik 18)
    resolution: 1 LSB gercek degeri (ornek: 0.25 feet icin)
    Donus: bits 11-29 (19 bit) olarak ham integer
    """
    sign = 1 if value < 0 else 0
    magnitude = int(abs(value) / resolution) & ((1 << n_data_bits) - 1)
    return (sign << n_data_bits) | magnitude

def bnr_decode(raw_field: int, resolution: float,
               n_data_bits: int = 18) -> float:
    """ARINC 429 BNR decode: data field bitleri -> float deger"""
    sign      = (raw_field >> n_data_bits) & 1
    magnitude = (raw_field & ((1 << n_data_bits) - 1)) * resolution
    return -magnitude if sign else magnitude

def calc_odd_parity(word: int) -> int:
    """Bit 32 parity hesapla (odd): 1-31 bitlerin 1 sayisi cift ise 1 don"""
    ones = bin(word & 0x7FFFFFFF).count('1')
    return 0 if ones % 2 != 0 else 1

# Label 203: Baro Corrected Altitude = 35000 ft
LABEL_203_OCT  = 0o203
LABEL_WIRE     = int(f"{LABEL_203_OCT:08b}"[::-1], 2)  # bit-reversed

data_field = bnr_encode(35000.0, resolution=0.25)
sdi        = 0b01      # Left ADC
ssm        = 0b11      # Normal Operation

word32  = LABEL_WIRE
word32 |= (sdi        << 8)
word32 |= (data_field << 10)
word32 |= (ssm        << 29)
word32 |= (calc_odd_parity(word32) << 31)

print(f"Label 203 | 35000 ft: 0x{word32:08X}")

# Decode: gelen word'den altitude oku
rx_word   = word32
rx_label  = rx_word & 0xFF
rx_ssm    = (rx_word >> 29) & 0x3
rx_data   = (rx_word >> 10) & 0x7FFFF

if rx_ssm == 0b11:  # Normal Operation
    altitude = bnr_decode(rx_data, resolution=0.25)
    print(f"Altitude: {altitude:.2f} ft")
else:
    print(f"Veri gecersiz! SSM={rx_ssm:02b}")

def decode_bcd_time(word32: int) -> int:
    """Label 101 (UTC Hours): BCD decode"""
    data    = (word32 >> 10) & 0x7FFFF
    tens    = (data >> 14) & 0xF  # bits 24-27
    units   = (data >> 10) & 0xF  # bits 20-23
    return tens * 10 + units

# Saat 14 -> BCD tens=1, units=4
# word32 ornegi (Label 101, saat 14):
label101_word = (0b10000000) | (0b11 << 29)  # sadelestirilmis
label101_word |= (0x1 << 24) | (0x4 << 20)  # tens=1, units=4
print(f"UTC Hours: {decode_bcd_time(label101_word)}")

def oct_to_wire_byte(octal_str: str) -> int:
    """Octal label string -> wire byte (bit-reversed)"""
    dec  = int(octal_str, 8)
    bits = f"{dec:08b}"
    return int(bits[::-1], 2)

def wire_byte_to_oct(byte_val: int) -> str:
    """Wire byte -> octal label string"""
    bits = f"{byte_val:08b}"
    dec  = int(bits[::-1], 2)
    return oct(dec).replace('0o', '').zfill(3)

# Ornekler:
for lbl in ["203", "206", "311", "101"]:
    wire = oct_to_wire_byte(lbl)
    back = wire_byte_to_oct(wire)
    print(f"Label {lbl}oct ({int(lbl,8)}dec) -> wire: 0x{wire:02X} -> back: {back}oct")

# SPI arayüzü etkinleştir (Raspberry Pi):
sudo raspi-config
# Interface Options -> SPI -> Enable

# SPI kernel modülünü yükle:
sudo modprobe spi-bcm2835

# HI-3593 ornek surucu:
git clone https://github.com/avionics/hi3593-linux-driver.git
cd hi3593-linux-driver
make && sudo make install

# Device tree overlay ekle:
sudo nano /boot/config.txt
# dtoverlay=hi3593,speed=12500000

# Cihaz dosyaları:
ls /dev/arinc429_*
# /dev/arinc429_0  (TX)   /dev/arinc429_1 (RX1)   /dev/arinc429_2 (RX2)

#include <fcntl.h>
#include <unistd.h>
#include <stdint.h>
#include <stdio.h>

static uint32_t calc_odd_parity(uint32_t w) {
    int ones = __builtin_popcount(w & 0x7FFFFFFF);
    return (ones % 2 == 0) ? (1u << 31) : 0;
}

int main(void) {
    int fd = open("/dev/arinc429_0", O_WRONLY);
    if (fd < 0) { perror("open"); return 1; }

    /* Label 203 (oct) bit-reversed: 0b11000100 = 0xC4 */
    uint32_t word = 0xC4;

    /* SDI = 01 (Left ADC), bits 9-10 */
    word |= (0x1u << 8);

    /* BNR: 35000 ft, resolution=0.25 -> 140000 = 0x22360, bits 11-28 */
    word |= ((uint32_t)140000 << 10);

    /* SSM = 11 (Normal Op), bits 30-31 */
    word |= (0x3u << 29);

    /* Parity bit 32 */
    word |= calc_odd_parity(word);

    write(fd, &word, sizeof(uint32_t));
    printf("Gonderildi: 0x%08X\n", word);
    close(fd);
    return 0;
}

# AIM kart tespiti:
lspci | grep -i aim
# 04:00.0 Signal processing controller: AIM GmbH ARINC429 PCIe

# AIM Linux surucusu:
sudo modprobe aim_arinc429

# Kanal yapılandırma:
aim_config --card 0 --ch 1 --mode TX --speed high
aim_config --card 0 --ch 2 --mode RX --speed high --filter 203,206,311

import struct

class Arinc429Word:
    """32-bit ARINC 429 word encode / decode yardimci sinifi"""

    SSM_FAILURE      = 0b00
    SSM_NO_COMPUTED  = 0b01
    SSM_FUNC_TEST    = 0b10
    SSM_NORMAL       = 0b11

    def __init__(self, label_oct: int, sdi: int = 0,
                 ssm: int = 0b11):
        self.label_oct  = label_oct   # octal integer, orn. 0o203
        self.sdi        = sdi & 0x3
        self.ssm        = ssm & 0x3
        self._data_bits = 0

    def _label_wire(self) -> int:
        """Label byte bit-reversed"""
        bits = f"{self.label_oct:08b}"
        return int(bits[::-1], 2)

    def set_bnr(self, value: float, resolution: float) -> None:
        sign = 1 if value < 0 else 0
        mag  = int(abs(value) / resolution) & 0x3FFFF  # 18 bit
        self._data_bits = (sign << 18) | mag

    def get_bnr(self, resolution: float) -> float:
        sign = (self._data_bits >> 18) & 1
        mag  = (self._data_bits & 0x3FFFF) * resolution
        return -mag if sign else mag

    def to_uint32(self) -> int:
        w  = self._label_wire()
        w |= (self.sdi          << 8)
        w |= (self._data_bits   << 10)
        w |= (self.ssm          << 29)
        ones = bin(w & 0x7FFFFFFF).count('1')
        if ones % 2 == 0:
            w |= (1 << 31)
        return w

    @classmethod
    def from_uint32(cls, raw: int) -> 'Arinc429Word':
        label_wire = raw & 0xFF
        label_oct  = int(f"{label_wire:08b}"[::-1], 2)
        sdi        = (raw >> 8)  & 0x3
        ssm        = (raw >> 29) & 0x3
        obj = cls(label_oct, sdi, ssm)
        obj._data_bits = (raw >> 10) & 0x7FFFF
        return obj

# Kullanim ornekleri:
w = Arinc429Word(0o203, sdi=1, ssm=Arinc429Word.SSM_NORMAL)
w.set_bnr(35000.0, resolution=0.25)
raw = w.to_uint32()
print(f"Altitude 35000 ft  : 0x{raw:08X}")

w2 = Arinc429Word(0o311, sdi=0, ssm=Arinc429Word.SSM_NORMAL)
w2.set_bnr(274.5, resolution=0.0055)
print(f"Heading 274.5 deg  : 0x{w2.to_uint32():08X}")

# Decode:
received = Arinc429Word.from_uint32(raw)
print(f"Decoded altitude   : {received.get_bnr(resolution=0.25):.2f} ft")
print(f"SSM                : {received.ssm:02b}")

# Kanal 1'de 100 kbps RX, label 203 ve 206'yı izle (30 sn):
altaview_429 --card 0 --ch 1 --mode RX --speed high \
             --filter-labels 203,206,311 --duration 30 \
             --output adc_capture.a429

# Kaydı CSV'ye çevir:
altaview_decode --input adc_capture.a429 --format csv \
                --output adc_data.csv

# Hata raporu:
altaview_stats --input adc_capture.a429
# Total words:        12450
# Parity errors:          0
# Bit format errors:      2
# Label 203 count:     3780  (19.1 ms rate)
# Label 206 count:     3780  (19.1 ms rate)
# Label 311 count:     1890  (38.2 ms rate)

import spidev, time, struct
import smbus2  # BMP280 basinc sensörü için

# ─── ARINC 429 word yardımcıları ──────────────────────────────
def label_wire(octal: int) -> int:
    return int(f"{octal:08b}"[::-1], 2)

def bnr_data(value: float, resolution: float) -> int:
    sign = 1 if value < 0 else 0
    mag  = int(abs(value) / resolution) & 0x3FFFF
    return (sign << 18) | mag

def build_word(label_oct: int, sdi: int, ssm: int,
               data_19: int) -> int:
    w  = label_wire(label_oct)
    w |= (sdi    << 8)
    w |= (data_19 << 10)
    w |= (ssm    << 29)
    ones = bin(w & 0x7FFFFFFF).count('1')
    if ones % 2 == 0:
        w |= (1 << 31)
    return w

# ─── HI-3593 SPI TX fonksiyonu ────────────────────────────────
def hi3593_transmit(spi: spidev.SpiDev, word32: int) -> None:
    """HI-3593 TX1: 32-bit ARINC word SPI ile gönder (MSB first)"""
    # HI-3593 TX komutu: 0xA0 + 4 byte data
    cmd  = [0xA0]
    cmd += list(struct.pack(">I", word32))  # big-endian
    spi.xfer2(cmd)

# ─── BMP280 basınçtan irtifa hesabı ───────────────────────────
def pressure_to_altitude_ft(pressure_pa: float,
                              baro_setting_pa: float = 101325.0) -> float:
    """ISA modeli: basınçtan irtifa (feet)"""
    ratio    = pressure_pa / baro_setting_pa
    alt_m    = 44330.0 * (1.0 - ratio ** 0.1903)
    return alt_m * 3.28084  # metre -> feet

# ─── Ana döngü ────────────────────────────────────────────────
spi = spidev.SpiDev()
spi.open(0, 0)   # SPI0, CE0
spi.max_speed_hz = 1_000_000
spi.mode = 0

i2c = smbus2.SMBus(1)  # BMP280 I2C bus

print("ADC simülasyonu başlıyor — ARINC 429 Label 203 yayını...")
try:
    while True:
        # BMP280'den ham basıncı oku (sadelestirilmis)
        raw_p = i2c.read_i2c_block_data(0x77, 0xF7, 3)
        p_pa  = ((raw_p[0] << 12) | (raw_p[1] << 4) | (raw_p[2] >> 4)) * 0.25

        # Basınçtan irtifa (feet, ISA)
        alt_ft = pressure_to_altitude_ft(p_pa)

        # Label 203: Baro Corrected Altitude
        data = bnr_data(alt_ft, resolution=0.25)
        word = build_word(label_oct=0o203, sdi=1, ssm=0b11,
                          data_19=data)

        hi3593_transmit(spi, word)
        print(f"TX Label 203: {alt_ft:.1f} ft  | 0x{word:08X}")
        time.sleep(0.05)  # 50 ms = 20 Hz
except KeyboardInterrupt:
    spi.close()
    print("Durduruldu.")