SpaceWire
uzay araçları veri ağı.

import struct

def rmap_crc8(data: bytes) -> int:
    """RMAP CRC-8 (CCITT polynomial 0x07)"""
    crc = 0
    for byte in data:
        for _ in range(8):
            xor_val = (crc ^ byte) & 0x80
            crc = (crc << 1) & 0xFF
            if xor_val:
                crc ^= 0x07
            byte = (byte << 1) & 0xFF
    return crc

def rmap_write_cmd(target_logical_addr: int,
                    initiator_logical_addr: int,
                    key: int,
                    transaction_id: int,
                    mem_addr: int,
                    data: bytes) -> bytes:
    """
    RMAP Write Command paketi oluştur (Verified, Reply, Increment).
    Donus: SpaceWire payload olarak gönderilecek bytes
    """
    # Instruction byte: 0x6C = Write | Verify | Reply | Increment
    instruction = 0b01101100

    header = bytearray()
    header += bytes([target_logical_addr])  # Dest. logical addr
    header += bytes([0x01])               # Protocol ID (RMAP=1)
    header += bytes([instruction])
    header += bytes([key])
    header += bytes([initiator_logical_addr])  # Reply addr (1 byte)
    header += struct.pack(">H", transaction_id)  # Tx ID (2 bytes)
    header += bytes([0x00])               # Extended addr
    header += struct.pack(">I", mem_addr)[0:4]  # Memory addr (4 bytes)
    header += struct.pack(">I", len(data))[1:4]  # Data length (3 bytes)

    header_crc = rmap_crc8(bytes(header))
    header += bytes([header_crc])

    data_crc = rmap_crc8(data)
    packet = bytes(header) + data + bytes([data_crc])
    return packet

# Örnek: OBC (addr=0xFE) target instrument'a (addr=0x20) yaz
payload_data = bytes([0x01, 0x02, 0x03, 0x04])
pkt = rmap_write_cmd(
    target_logical_addr=0x20,
    initiator_logical_addr=0xFE,
    key=0xD1,
    transaction_id=42,
    mem_addr=0x40001000,
    data=payload_data
)
print(f"RMAP Write pkt ({len(pkt)} bytes): {pkt.hex()}")

/* GRLIB SpaceWire router konfigurasyonu */
#include "grspwrouter.h"

void configure_router(void) {
    spwrouter_dev_t *router = grspwrouter_open(0);

    /* Logical address routing table:
       Addr 0x20 -> Port 1 (Kamera)
       Addr 0x21 -> Port 2 (Spektrometre)
       Addr 0xFE -> Port 0 (OBC)              */
    spwrouter_set_route(router, 0x20, 1);  /* camera port */
    spwrouter_set_route(router, 0x21, 2);  /* spectro port */
    spwrouter_set_route(router, 0xFE, 0);  /* OBC port */

    /* Port hız ayarı: 100 Mbps */
    for (int i = 0; i < 6; i++) {
        spwrouter_set_link_speed(router, i, 100000000);
    }

    /* Time code yayinlama: port 0'dan gelen time code
       tüm aktif portlara ilet */
    spwrouter_timecode_enable(router, 0x3F);  /* tüm portlar */

    printf("SpaceWire router yapılandırıldı.\n");
}

# GRLIB Linux sürücü paketi (Cobham tarafından sağlanır):
tar -xzf grlib-linux-driver-v3.x.tar.gz
cd grlib-linux-driver/
make KERNEL_DIR=/lib/modules/$(uname -r)/build
sudo make install

# Modülleri yükle:
sudo modprobe grspw
sudo modprobe grspwrouter

# SpaceWire cihazlarını kontrol et:
dmesg | grep spw
# [ 2.14] grspw 0: SpaceWire link, ports: 4, DMA channels: 4
# [ 2.15] grspwrouter 0: SpaceWire router, 6 ports

# Cihaz dosyaları:
ls /dev/spw*
# /dev/spw0  /dev/spw1  /dev/spw2  /dev/spw3

#include <fcntl.h>
#include <unistd.h>
#include <sys/ioctl.h>
#include "grspw.h"   /* GRLIB sürücü başlığı */

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

    /* Link hızını ayarla: 100 Mbps */
    spw_ioctl_speed_t speed = { .speed = 100000000 };
    ioctl(fd, GRSPW_IOCTL_SET_SPEED, &speed);

    /* Link'i başlat */
    ioctl(fd, GRSPW_IOCTL_LINK_START, NULL);

    /* Paket gönder: Logical Address=0x20, data */
    uint8_t pkt[] = { 0x20, 0xDE, 0xAD, 0xBE, 0xEF };
    ssize_t n = write(fd, pkt, sizeof(pkt));
    printf("Gönderildi: %zd byte\n", n);

    /* Paket al (blocking): */
    uint8_t rxbuf[1024];
    ssize_t rcv = read(fd, rxbuf, sizeof(rxbuf));
    printf("Alındı: %zd byte, ilk byte: 0x%02X\n", rcv, rxbuf[0]);

    close(fd);
    return 0;
}

# STAR-Dundee açık kaynak Linux sürücüsü:
git clone https://github.com/star-dundee/star-dundee-linux
cd star-dundee-linux/
make && sudo make install

# USB Brick'i bağla ve tespit et:
dmesg | grep -i star
# [ 10.5] usb 1-1.3: STAR-Dundee SpaceWire USB Brick detected

# Cihaz dosyası:
ls /dev/star*
# /dev/starspw0

# RMAP araçları (gr-rmap Python kütüphanesi):
pip install gr-rmap

from grrmap import RMAPInitiator, RMAPTarget

# SpaceWire link aç (/dev/starspw0 veya /dev/spw0)
initiator = RMAPInitiator(device="/dev/starspw0",
                           logical_addr=0xFE,
                           link_speed=100e6)
initiator.start_link()

# Target: Kamera kontrolcüsü, addr=0x20, key=0xD1
target = RMAPTarget(logical_addr=0x20, key=0xD1)

# Memory read: 16 byte, adres 0x40000000
data = initiator.read(target, mem_addr=0x40000000,
                       length=16, timeout_ms=1000)
print(f"Okunan veri: {data.hex()}")

# Memory write: kamera başlatma komutu
cmd_bytes = bytes([0x01, 0x00, 0x00, 0x01])
result = initiator.write(target, mem_addr=0x40001000,
                          data=cmd_bytes, verify=True, reply=True)
print(f"Yazma sonucu: 0x{result.status:02X}")
if result.status == 0x00:
    print("Başarılı!")
else:
    print(f"Hata: {result.status_str}")

initiator.close()

# SpaceWire VHDL IP core (opencores.org):
git clone https://github.com/nicowillis/spw_fpga.git
# Temel dosyalar:
# spw_link.vhd         - Link katmanı FSM
# spw_recv.vhd         - Alici DS-LVDS demodülatör
# spw_send.vhd         - Verici DS-LVDS modülatör
# spw_fifo.vhd         - TX/RX FIFO tamponları
# spw_routerport.vhd   - Router port mantığı

-- SpaceWire fiziksel arayuz: 4 diferansiyel hat
entity spw_top is
  port (
    clk         : in  std_logic;
    rst         : in  std_logic;
    -- SpaceWire fiziksel pinler
    spw_di_p    : in  std_logic;   -- Data In +
    spw_di_n    : in  std_logic;   -- Data In -
    spw_si_p    : in  std_logic;   -- Strobe In +
    spw_si_n    : in  std_logic;   -- Strobe In -
    spw_do_p    : out std_logic;   -- Data Out +
    spw_do_n    : out std_logic;   -- Data Out -
    spw_so_p    : out std_logic;   -- Strobe Out +
    spw_so_n    : out std_logic;   -- Strobe Out -
    -- Kullanici arayuzu (AXI4-Stream)
    tx_data     : in  std_logic_vector(7 downto 0);
    tx_valid    : in  std_logic;
    tx_ready    : out std_logic;
    tx_eop      : in  std_logic;   -- End of Packet
    rx_data     : out std_logic_vector(7 downto 0);
    rx_valid    : out std_logic;
    rx_ready    : in  std_logic;
    rx_eop      : out std_logic;
    -- Status
    link_running : out std_logic
  );
end entity spw_top;

/* RTEMS GRSPW kullanimi */
#include <rtems.h>
#include "grspw.h"

void spw_task(rtems_task_argument arg) {
    void *spw_dev = grspw_open(0);
    if (!spw_dev) { rtems_task_delete(RTEMS_SELF); }

    grspw_set_speed(spw_dev, 100000000);
    grspw_link_start(spw_dev);

    while (1) {
        /* Paket al (50 ms zaman asimi) */
        uint8_t buf[512];
        int n = grspw_recv(spw_dev, buf, sizeof(buf),
                            50 * GRSPW_TICKS_PER_MS);
        if (n > 0) {
            process_packet(buf, n);
        }
    }
}

# STAR-Dundee Python API ile link analizi:
pip install star-dundee-api

# Link istatistiklerini oku:
python3 - <<'EOF'
import star_dundee as sd

brick = sd.open_brick(0)  # USB Brick
brick.set_link_speed(1, 100e6)  # Port 1, 100 Mbps
brick.link_start(1)

stats = brick.get_link_stats(1)
print(f"Packets TX: {stats.tx_count}")
print(f"Packets RX: {stats.rx_count}")
print(f"Error count: {stats.error_count}")
print(f"Disconnect count: {stats.disconnect_count}")
EOF

import star_dundee as sd
import time

def loopback_test(brick, port: int = 1,
                   n_packets: int = 1000) -> dict:
    """SpaceWire loopback testi: n_packets gönder ve al"""
    errors = 0
    latencies = []

    for i in range(n_packets):
        payload = bytes([i & 0xFF] * 64)  # 64-byte test paketi
        t0 = time.perf_counter()
        brick.send_packet(port, payload + b'\x00')  # EOP
        rcv = brick.recv_packet(port, timeout_ms=100)
        t1 = time.perf_counter()

        if rcv is None or rcv != payload:
            errors += 1
        else:
            latencies.append((t1 - t0) * 1e6)  # µs

    avg_lat = sum(latencies) / len(latencies) if latencies else float('inf')
    return {
        "total"   : n_packets,
        "errors"  : errors,
        "ber"     : errors / n_packets,
        "avg_lat_us": avg_lat,
        "min_lat_us": min(latencies, default=0),
        "max_lat_us": max(latencies, default=0),
    }

brick = sd.open_brick(0)
brick.set_loopback_mode(1, enable=True)  # dahili loopback
result = loopback_test(brick, n_packets=10000)
print(f"BER: {result['ber']:.2e}  Avg latency: {result['avg_lat_us']:.1f} µs")

pip install spacewire-tools

# SpaceWire link analizi komut satırı:
spw-link-test --device /dev/starspw0 --speed 100M --loopback \
              --packets 10000 --size 256

# RMAP bellek dökümü:
spw-rmap-dump --device /dev/starspw0 --target 0x20 --key 0xD1 \
              --addr 0x40000000 --length 256 --output memory.bin

/*
 * Örnek uydu On-Board Software (OBSW) — SpaceWire payload arayüzü
 * Platform: GR712RC, RTEMS 5.x
 *
 * Topoloji:
 *   Port 0: Yer istasyonu uplink (telekomanda) / downlink (telemetri)
 *   Port 1: Kamera payload (RMAP okuma)
 *   Port 2: Spektrometre payload (RMAP okuma/yazma)
 *   Port 3-5: Rezerv
 */

#include <rtems.h>
#include "grspw.h"
#include "rmap.h"
#include "pus.h"       /* ESA Packet Utilisation Standard */

#define SPW_PORT_GS      0   /* Yer istasyonu */
#define SPW_PORT_CAM     1   /* Kamera */
#define SPW_PORT_SPECT   2   /* Spektrometre */

#define ADDR_OBC         0xFE
#define ADDR_CAMERA      0x20
#define ADDR_SPECTRO     0x21

#define CAM_CTRL_REG     0x40001000   /* Kamera kontrol register */
#define CAM_DATA_REG     0x40002000   /* Kamera veri tamponu */

static void *spw_port[3];
static rmap_ctx_t rmap;

void obsw_spw_init(void) {
    int i;
    for (i = 0; i < 3; i++) {
        spw_port[i] = grspw_open(i);
        grspw_set_speed(spw_port[i], 100000000); /* 100 Mbps */
        grspw_set_addr(spw_port[i], ADDR_OBC);
        grspw_link_start(spw_port[i]);
        rtems_task_wake_after(100);             /* link init bekle */
    }
    rmap_init(&rmap, spw_port[SPW_PORT_CAM], ADDR_OBC);
    printf("OBSW SpaceWire başlatıldı.\n");
}

/* Kamera başlatma: RMAP write ile kontrol register'ı set et */
rtems_status_code obsw_camera_init(void) {
    uint32_t ctrl_val = 0x00000001;  /* ENABLE bit */
    rmap_status_t st  = rmap_write(&rmap,
                                    ADDR_CAMERA, 0xD1,   /* key */
                                    CAM_CTRL_REG,
                                    (uint8_t *)&ctrl_val, 4,
                                    500);               /* 500 ms timeout */
    if (st.status != 0) {
        printf("Kamera başlatma HATA: 0x%02X\n", st.status);
        return RTEMS_IO_ERROR;
    }
    printf("Kamera başlatıldı.\n");
    return RTEMS_SUCCESSFUL;
}

/* Kameradan veri al: RMAP read */
int obsw_camera_read_frame(uint8_t *frame_buf, uint32_t max_len) {
    rmap_status_t st = rmap_read(&rmap,
                                  ADDR_CAMERA, 0xD1,
                                  CAM_DATA_REG,
                                  frame_buf, max_len,
                                  2000);  /* 2 sn timeout */
    if (st.status == 0) {
        printf("Frame alındı: %u byte\n", st.data_length);
        return (int)st.data_length;
    }
    printf("Frame okuma HATA: 0x%02X\n", st.status);
    return -1;
}