NMEA 2000
Deniz Elektroniği CAN Standardı

from typing import Optional

class FastPacketAssembler:
    """NMEA 2000 Fast Packet frame'lerini birleştirir"""

    def __init__(self):
        self.buffers = {}   # (pgn, sa, seq) → {'total': N, 'data': bytearray}

    def feed(self, pgn: int, sa: int, raw: bytes) -> Optional[bytes]:
        header   = raw[0]
        seq_cnt  = (header >> 5) & 0x07
        frame_no = header & 0x1F
        key = (pgn, sa, seq_cnt)

        if frame_no == 0:  # First frame
            total = raw[1]
            data  = bytearray(raw[2:])
            self.buffers[key] = {'total': total, 'data': data}
            return None
        else:               # Subsequent frame
            if key not in self.buffers:
                return None  # first frame kaçırıldı
            buf = self.buffers[key]
            buf['data'].extend(raw[1:])

            if len(buf['data']) >= buf['total']:
                complete = bytes(buf['data'][:buf['total']])
                del self.buffers[key]
                return complete
            return None

import struct, math

def parse_vessel_heading(data: bytes) -> dict:
    """PGN 127250 — 8 byte"""
    if len(data) < 8:
        return {}

    sid        = data[0]
    heading_raw = struct.unpack_from('<H', data, 1)[0]
    deviation  = struct.unpack_from('<h', data, 3)[0]  # signed
    variation  = struct.unpack_from('<h', data, 5)[0]  # signed
    reference  = (data[7] >> 6) & 0x03  # 0=mag, 1=true

    def rad_to_deg(raw, scale=1e-4):
        if raw == 0xFFFF or raw == 0x7FFF:
            return None
        return math.degrees(raw * scale)

    return {
        'sid': sid,
        'heading_deg': rad_to_deg(heading_raw),
        'deviation_deg': rad_to_deg(deviation) if deviation != -32768 else None,
        'variation_deg': rad_to_deg(variation) if variation != -32768 else None,
        'reference': ['Magnetic', 'True', 'Error', 'Null'][reference],
    }

# Test
sample = bytes([0x01, 0x2E, 0x04, 0xFF, 0x7F, 0xFF, 0x7F, 0x40])
result = parse_vessel_heading(sample)
print(ff"Yön: {result['heading_deg']:.1f}° {result['reference']}")

import struct

def parse_position_rapid(data: bytes) -> dict:
    """PGN 129025 — 8 byte: lat + lon"""
    if len(data) < 8:
        return {}
    lat_raw = struct.unpack_from('<i', data, 0)[0]  # signed 32-bit
    lon_raw = struct.unpack_from('<i', data, 4)[0]

    # Çözünürlük: 1e-7 derece / bit
    lat = lat_raw * 1e-7
    lon = lon_raw * 1e-7

    return {'lat': lat, 'lon': lon}

# 41.0082° N, 28.9784° E (İstanbul)
lat_raw = int(41.0082 * 1e7)
lon_raw = int(28.9784 * 1e7)
sample = struct.pack('<ii', lat_raw, lon_raw)
pos = parse_position_rapid(sample)
print(ff"Konum: {pos['lat']:.4f}°N, {pos['lon']:.4f}°E")

import struct, socket

def build_n2k_name(
    manufacturer_code: int,   # 11-bit (0x1ED = Simrad, 0x069 = Garmin...)
    identity_number: int,     # 21-bit (cihaz seri no)
    device_instance: int = 0,
    device_function: int = 60,  # 60 = Navigation (GPS)
    device_class: int = 60,     # 60 = Navigation Systems
    industry_group: int = 4,    # 4 = Marine
    arbitrary: bool = True
) -> int:
    name = (
        (int(arbitrary) << 63) |
        ((industry_group & 0x07) << 60) |
        ((device_class & 0x7F) << 49) |
        ((device_function & 0xFF) << 41) |
        ((device_instance & 0x07) << 38) |
        ((manufacturer_code & 0x7FF) << 21) |
        (identity_number & 0x1FFFFF)
    )
    return name

# Raspberry Pi gateway için NAME
name = build_n2k_name(
    manufacturer_code=0x001,  # özel/test
    identity_number=0x00001,
    device_function=10,       # System Tools
    device_class=10,
    industry_group=4          # Marine
)
print(ff"N2K NAME: 0x{name:016X}")
print(ff"Bytes: {struct.pack('<Q', name).hex()}")

# Bağımlılıklar
sudo apt install build-essential git

# Kaynak kodu indir ve derle
git clone https://github.com/canboat/canboat.git
cd canboat
make
sudo make install

# Kurulu araçlar:
# analyzer — PGN decode ve JSON çıktı
# n2kd     — N2K daemon (TCP ile paylaşım)
# candump2analyzer — candump log → analyzer pipeline
# actisense-serial — Actisense NGT-1 USB adaptörü desteği

# candump çıktısını analyzer'a pipe et
candump can0 | analyzer

# JSON formatında çıktı
candump can0 | analyzer -json
# Çıktı örneği:
# {"timestamp":"2026-04-12T10:30:00.123Z","prio":2,
#  "src":5,"dst":255,"pgn":129025,
#  "description":"Position Rapid Update",
#  "fields":{"Latitude":41.0082,"Longitude":28.9784}}

# Belirli PGN'i filtrele (bash ile)
candump can0 | analyzer -json | grep '"pgn":129025'

# candump log dosyasından analiz
candump2analyzer < candump_log.txt | analyzer -json

# Tüm bilinen PGN listesi
analyzer -explain

# n2kd: N2K verilerini TCP üzerinden paylaş
# can0 → TCP 2597 (analyzer JSON) + TCP 2598 (raw)
candump can0 | analyzer -json | n2kd -s 2597

# İstemci bağlantısı (başka cihazdan)
nc 192.168.1.100 2597
# JSON stream başlar

# N2K 250 kbit/s
sudo ip link set can0 type can bitrate 250000 restart-ms 200
sudo ip link set can0 up

# Ham frame'leri izle (29-bit EFF → -e flag)
candump can0

# Örnek N2K çıktı:
# (1716890123.456) can0  09F80105   [8]  2E 04 FF 7F FF 7F 40 FF
#  → 0x09F80105 = Priority=2, PGN=0x1F801=129025(pos), SA=0x05

# CANBOAT pipeline ile decode
candump can0 | analyzer -json | python3 -c "
import sys, json
for line in sys.stdin:
    try:
        msg = json.loads(line)
        if msg.get('pgn') in [129025, 127250, 128259]:
            print(json.dumps(msg['fields'], indent=2))
    except: pass
"

import socket, struct

# J1939 socket ile N2K okuma
s = socket.socket(socket.AF_CAN, socket.SOCK_RAW, socket.CAN_RAW)
s.bind(('can0',))

def decode_pgn_from_eff(can_id: int) -> tuple:
    """29-bit CAN ID'den PGN ve SA çıkar"""
    can_id &= 0x1FFFFFFF   # EFF flag temizle
    priority = (can_id >> 26) & 0x07
    dp  = (can_id >> 24) & 0x01
    pf  = (can_id >> 16) & 0xFF
    ps  = (can_id >>  8) & 0xFF
    sa  = (can_id >>  0) & 0xFF
    if pf < 0xF0:
        pgn = (dp << 16) | (pf << 8)
    else:
        pgn = (dp << 16) | (pf << 8) | ps
    return pgn, sa, priority

INTERESTING_PGNS = {129025, 127250, 128259, 127488, 130306}

while True:
    frame = s.recv(16)
    can_id, dlc = struct.unpack_from('<IB', frame, 0)
    data = frame[8:8+dlc]

    pgn, sa, prio = decode_pgn_from_eff(can_id)

    if pgn in INTERESTING_PGNS:
        print(ff"PGN={pgn:6d} SA={sa:#04x} prio={prio} data={data.hex()}")

# Node.js gereklidir
curl -fsSL https://deb.nodesource.com/setup_20.x | sudo bash -
sudo apt install -y nodejs

# Signal K Server kurulumu
sudo npm install -g @signalk/server

# Başlat
signalk-server

# Web arayüzü: http://raspberrypi:3000
# Admin: http://raspberrypi:3000/@signalk/server-admin-ui

# Server data bağlantısı için settings.json'a eklenir:
# Pipedeprovider: candump → analyzer -json → signal k

# Alternatif: canboat-to-signalk paketi
sudo npm install -g @canboat/canboatjs

# candump çıktısını SignalK'ya pipe et (manuel)
candump can0 | analyzer -json | \
  node /usr/local/lib/node_modules/@canboat/canboatjs/tools/fromPgn.js | \
  nc localhost 3000

import requests, json

SIGNALK_URL = "http://localhost:3000/signalk/v1/api/vessels/self"

def get_vessel_data():
    resp = requests.get(SIGNALK_URL, timeout=2)
    data = resp.json()

    # Konum
    nav = data.get('navigation', {})
    pos = nav.get('position', {}).get('value', {})
    lat = pos.get('latitude')
    lon = pos.get('longitude')

    # Yön
    heading = nav.get('headingMagnetic', {}).get('value')
    if heading:
        import math
        heading = math.degrees(heading)

    # Hız
    sog = nav.get('speedOverGround', {}).get('value')
    if sog:
        sog_kn = sog * 1.944   # m/s → knot

    print(ff"Konum: {lat:.4f}°N, {lon:.4f}°E")
    print(ff"Yön: {heading:.1f}°  SOG: {sog_kn:.1f} kn")

get_vessel_data()

# OpenCPN kurulumu
sudo apt install opencpn

# OpenCPN içinden: Options → Connections → Add Signal K
# Host: localhost, Port: 3000
# Veya NMEA 0183 TCP → Signal K NMEA0183 output aktif et

# NMEA 0183 çıktısı için Signal K'ya NMEA 0183 output eklenir
# Settings → Signal paths → Enable NMEA 0183 output → port 10110
# OpenCPN: Options → Connections → TCP, localhost:10110

#!/bin/bash
# NMEA 2000 → WiFi Gateway kurulum scripti

# 1. CAN interface başlat (Actisense NGT-1 veya MCP2515 sonrası)
sudo ip link set can0 type can bitrate 250000 restart-ms 200
sudo ip link set can0 up
echo "CAN arayüzü açıldı"

# 2. CANBOAT kontrolü
which analyzer || { echo "CANBOAT yok, kuruluyor..."; sudo apt install -y canboat; }

# 3. Signal K başlat (systemd servis olarak)
sudo systemctl start signalk.service
sudo systemctl enable signalk.service

# 4. N2K veri akışını test et
timeout 5 candump can0 | analyzer -json | head -20

echo "Gateway hazır — http://$(hostname -I | awk '{print $1}'):3000"

import subprocess, json, math, os, time

def clear(): os.system('clear')

data = {'lat': None, 'lon': None,
        'heading': None, 'sog': None, 'depth': None}

proc = subprocess.Popen(
    ['bash', '-c', 'candump can0 | analyzer -json'],
    stdout=subprocess.PIPE, text=True
)

for line in proc.stdout:
    try:
        msg = json.loads(line)
        pgn = msg.get('pgn')
        fields = msg.get('fields', {})

        if pgn == 129025:
            data['lat'] = fields.get('Latitude')
            data['lon'] = fields.get('Longitude')
        elif pgn == 127250:
            h = fields.get('Heading')
            if h: data['heading'] = math.degrees(h)
        elif pgn == 129026:
            sog = fields.get('SOG')
            if sog: data['sog'] = sog * 1.944
        elif pgn == 128267:
            data['depth'] = fields.get('Depth')

        clear()
        print("=== NMEA 2000 Dashboard ===")
        print(ff"Konum: {data['lat']:.4f}°N  {data['lon']:.4f}°E" if data['lat'] else "Konum: ---")
        print(ff"Yön:   {data['heading']:.1f}°" if data['heading'] else "Yön:   ---")
        print(ff"SOG:   {data['sog']:.1f} kn" if data['sog'] else "SOG:   ---")
        print(ff"Derinlik: {data['depth']:.1f} m" if data['depth'] else "Derinlik: ---")
    except (json.JSONDecodeError, KeyError):
        continue