EtherNet/IP
CIP üzerine endüstriyel Ethernet.

04 EDS dosyası — Electronic Data Sheet

EDS (Electronic Data Sheet), bir CIP cihazının kimliğini, parametrelerini, I/O bağlantı yapılandırmalarını ve desteklenen servisleri tanımlayan ASCII metin dosyasıdır. ODVA'nın tanımladığı bu format, mühendislik yazılımlarının (RSLogix, Studio 5000, RSNetWorx, Sysmac Studio) cihazı otomatik tanımasını ve yapılandırmasını sağlar.

EDS dosyasının temel bölümleri

$ EDS örneği: EmbeddedDeck_DigitalIO.eds

[File]
DescText = "EmbeddedDeck 8DI/8DO Modülü";
CreateDate = 04-12-2026;
CreateTime = 09:00:00;
ModDate    = 04-12-2026;
ModTime    = 09:00:00;
Revision   = 2.1;
HomeURL    = "https://x3beche.github.io/embedded-deck";

[Device]
VendorCode   = 0xFFFF;          $ Test Vendor ID (ODVA'dan alınacak)
VendorName   = "EmbeddedDeck";
ProdType     = 7;               $ 0x07 = Generic Device
ProdTypeStr  = "Generic Device";
ProdCode     = 1;
MajRev       = 2;
MinRev       = 1;
ProdName     = "EDBED-DIO-8x8";
Catalog      = "EDBED-DIO-001";
Icon         = "generic_io.ico";

[Device Classification]
Class1 = EtherNetIP;

[Params]
Param1 =
    0,                          $ reserved
    ,,                          $ path
    0x0004,                     $ Class = Assembly
    0x0064,                     $ Instance = 100 (O→T output)
    0x0003,                     $ Attribute = Data
    0x0000,                     $ access = get/set
    "Dijital Çıkışlar",
    "bitfield",
    "DO7..DO0 bit alanı",
    0, 0xFF, 0,
    1, 1,
    0, ;

Param2 =
    0,,,
    0x0004, 0x0065, 0x0003,
    0x0000,
    "Dijital Girişler",
    "bitfield",
    "DI7..DI0 bit alanı",
    0, 0xFF, 0,
    1, 1,
    0, ;

[Assembly]
Assem100 =                      $ Output Assembly (O→T): PLC → Modül
    0x0000,
    "$PARAM[1]",
    ,
    1, 0;                       $ 1 byte, proxy=0

Assem101 =                      $ Input Assembly (T→O): Modül → PLC
    0x0000,
    "$PARAM[2]",
    ,
    1, 0;

Assem102 =                      $ Configuration Assembly (boş)
    0x0000,
    "",
    ,
    0, 0;

[Connection Manager]
Connection1 =
    0x04010002,                 $ Transport: Class 1, Cyclic, Server
    0x44240305,                 $ Point-to-Point, Exclusive Owner
    0x00002710,                 $ O→T RPI: 10000 µs
    ,,
    0x00002710,                 $ T→O RPI: 10000 µs
    ,,
    ,
    "Exclusive Owner",
    ,
    "20 04 24 64",              $ O→T Path: Assembly 100
    "20 04 24 65",              $ T→O Path: Assembly 101
    "20 04 24 66",;             $ Config Path: Assembly 102

05 Linux'ta EtherNet/IP — OpENer ve açık kaynak yığınlar

Linux üzerinde EtherNet/IP adaptör (device/slave) veya scanner (master/client) geliştirmek için birkaç olgun açık kaynak seçenek mevcuttur. Seçim; rolünüze (adaptör mü, scanner mı), lisans gereksinimlerine ve hedef donanıma bağlıdır.

Açık kaynak EtherNet/IP yığınları

OpENer — Linux üzerinde derleme ve çalıştırma

OpENer, ODVA'nın desteklediği referans uygulamaya en yakın açık kaynak EtherNet/IP adaptör yığınıdır. POSIX platformu için örnek bir "sample application" içerir; bu uygulamayı temel alarak kendi I/O modülünüzü geliştirebilirsiniz.

# Bağımlılıklar
sudo apt update
sudo apt install -y cmake build-essential libpcap-dev git

# Kaynak kodu
git clone https://github.com/EIPStackGroup/OpENer.git
cd OpENer

# POSIX platformu için derleme
mkdir build && cd build
cmake ../source \
    -DOPENER_PLATFORM=POSIX \
    -DCMAKE_BUILD_TYPE=Release \
    -DOPENER_TESTS=OFF

make -j$(nproc)

# Çalıştır (root gereklidir — raw socket için)
# Sözdizimi: OpENer    
sudo ./src/ports/POSIX/OpENer eth0 192.168.1.20 255.255.255.0 192.168.1.1

# Doğrulama: pycomm3 veya cpppo ile Identity oku
python3 -c "
from pycomm3 import CIPDriver
with CIPDriver('192.168.1.20') as d:
    r = d.generic_message(
        service=0x01,        # Get_Attributes_All
        class_code=0x01,     # Identity Object
        instance=1,
        data_type=None,
        name='identity'
    )
    print('OpENer Identity:', r.value)
"

OpENer'da özel Assembly tanımlama

Kendi I/O verilerinizi taşımak için OpENer'ın user_application.c dosyasını düzenler ve CIP_Assembly_CreateAssemblyObject() ile yeni assembly örnekleri eklersiniz. Üretilen/tüketilen veri alanları için global değişkenler tanımlayıp bu assembly'lere bağlarsınız. Her döngüde çağrılan ApplicationRunHook() fonksiyonu donanım okuma/yazma noktanızdır.

/* user_application.c — basit 8DI / 8DO örneği */
#include "opener_api.h"

static uint8_t g_digital_outputs = 0x00;  /* O→T: PLC → biz */
static uint8_t g_digital_inputs  = 0x00;  /* T→O: biz → PLC */

EipStatus ApplicationInitialization(void) {
    /* Output Assembly: Class 0x04, Instance 100, 1 byte */
    CipAssembly *out_asm = CreateAssemblyObject(
        100, (EipByte *)&g_digital_outputs, 1);
    /* Input Assembly: Class 0x04, Instance 101, 1 byte  */
    CipAssembly *in_asm  = CreateAssemblyObject(
        101, (EipByte *)&g_digital_inputs,  1);
    /* Config Assembly: boş */
    CreateAssemblyObject(102, NULL, 0);
    return kEipStatusOk;
}

void RunIdleChanged(EipUint32 run_idle_value) {
    if (run_idle_value & 1) {
        /* PLC Run modunda — çıkışları uygula */
        /* gpio_write(GPIO_PORT_DO, g_digital_outputs); */
    } else {
        /* PLC Idle/Program modunda — çıkışları sıfırla */
        /* gpio_write(GPIO_PORT_DO, 0x00); */
    }
}

EipStatus AfterAssemblyDataReceived(CipAssembly *assembly) {
    /* O→T verisi geldi (g_digital_outputs güncellendi) */
    /* gpio_write(GPIO_PORT_DO, g_digital_outputs); */
    return kEipStatusOk;
}

void BeforeAssemblyDataSend(CipAssembly *assembly) {
    /* T→O göndermeden önce giriş değerlerini tazele */
    /* g_digital_inputs = gpio_read(GPIO_PORT_DI); */
}

06 pycomm3 Python kütüphanesi

pycomm3, Allen-Bradley CompactLogix, ControlLogix ve Micro800 PLC'lerle iletişim için en yaygın kullanılan Python kütüphanesidir. Rockwell'in Logix5000 sembolik tag protokolünü (CIP servisler 0x4C/0x4D) uygular; PLC programının tag adlarına doğrudan erişim sağlar.

pip install pycomm3           # son kararlı sürüm
pip install pycomm3==0.12.4  # belirli sürüm sabitleme (üretim için)

LogixDriver bağlantı parametreleri

Tag okuma: atomic, array ve UDT

from pycomm3 import LogixDriver

with LogixDriver('192.168.1.1/0') as plc:
    # Atomic tag (tek değer)
    speed = plc.read('Motor1.Speed')         # REAL
    running = plc.read('Motor1.Running')     # BOOL
    fault   = plc.read('Motor1.FaultCode')  # DINT
    print(f"Hız: {speed.value:.1f} RPM  "
          f"Çalışıyor: {running.value}  "
          f"Hata: {fault.value}")

    # Çoklu tag — tek TCP round-trip (verimli)
    results = plc.read(
        'Motor1.Speed',
        'Motor1.Current',
        'Motor1.Running',
        'Tank.Temperature',
        'System.CycleCount',
    )
    for r in results:
        if r.error:
            print(f"  HATA [{r.tag}]: {r.error}")
        else:
            print(f"  {r.tag} = {r.value}  ({r.type})")

    # Array dilimi: SensorArray[0]{8} → ilk 8 eleman
    sensors = plc.read('SensorArray[0]{8}')
    print(f"Sensörler: {sensors.value}")  # [12.3, 14.1, ...]

    # UDT (User Defined Type) okuma
    motor = plc.read('MotorData')
    # motor.value örn: {'Speed': 1498.5, 'Current': 4.2,
    #                   'Fault': False, 'Name': 'Pompa1'}
    print(f"UDT Motor: {motor.value}")

    # Program scope tag: Program:ProgramAdı.TagAdı
    p_temp = plc.read('Program:HavuzKontrol.SetNoktasi')
    print(f"Program tag: {p_temp.value}")

Tag yazma

from pycomm3 import LogixDriver

with LogixDriver('192.168.1.1/0') as plc:
    # Tek tag yaz — tuple (tag_adı, değer)
    r = plc.write(('Motor1.SpeedRef', 1500.0))
    print("SpeedRef yazıldı:", r.error or "OK")

    # Çoklu yazma — tek CIP paketiyle (verimli)
    results = plc.write(
        ('Motor1.SpeedRef',    1500.0),    # REAL
        ('Motor1.RunCmd',      True),      # BOOL
        ('Conveyor.TargetPos', 3500),      # DINT
        ('System.Message',     "Hazir"),   # STRING (82 char max)
    )
    for r in results:
        status = "OK" if r.error is None else f"HATA: {r.error}"
        print(f"  {r.tag}: {status}")

    # Array yazma
    plc.write(('RecipeArray[0]{5}', [100.0, 95.0, 88.0, 92.0, 97.0]))

PLC tipine göre farklılıklar

07 Pratik: CompactLogix'ten sıcaklık okuma ve CSV loglama

Bu bölümde Allen-Bradley CompactLogix PLC'den sıcaklık ve proses tag'lerini periyodik olarak okuyup CSV dosyasına kaydeden, yeniden bağlanma mantığı ve alarm kontrolü içeren eksiksiz bir izleme uygulaması geliştirilir. Uygulama systemd servisi olarak arka planda çalışabilir; CSV verisi Grafana ile görselleştirilebilir.

Sistem mimarisi

 Allen-Bradley CompactLogix
 192.168.1.1  Slot 0
 Studio 5000 PLC Programı
       │
       │ EtherNet/IP (TCP 44818)
       │ CIP Read_Tag (0x4C) — sembolik tag
       │
 Linux PC / Raspberry Pi
 pycomm3 → plc_logger.py
       │
       ├─► stdout  (terminal ekranı, gerçek zamanlı)
       ├─► /var/log/plc/plc_data.csv  (CSV dosyası)
       └─► Prometheus Pushgateway (opsiyonel metrik)
              │
              └─► Grafana Dashboard

#!/usr/bin/env python3
"""
plc_logger.py — Allen-Bradley CompactLogix sıcaklık ve proses tag izleme
Gereksinim : pip install pycomm3
Kullanım   : python3 plc_logger.py --ip 192.168.1.1 --slot 0 --interval 1.0
"""
import csv
import time
import signal
import logging
import argparse
from datetime import datetime
from pathlib import Path

from pycomm3 import LogixDriver, RequestError, CommError

# ── Loglama yapılandırması ───────────────────────────────────────────────────
logging.basicConfig(
    level=logging.INFO,
    format="%(asctime)s  %(levelname)-8s  %(message)s",
    datefmt="%Y-%m-%d %H:%M:%S",
)
log = logging.getLogger("plc_logger")

# ── İzlenecek tag listesi ────────────────────────────────────────────────────
TAGS = [
    "Firin.Sicaklik_PV",       # REAL  — fırın proses değeri (°C)
    "Firin.Sicaklik_SP",       # REAL  — fırın set noktası (°C)
    "Firin.Isitici_Cikis",     # REAL  — ısıtıcı çıkış yüzdesi (%)
    "Kazan.Basinc_PV",         # REAL  — kazan basıncı (bar)
    "Kazan.Sicaklik_PV",       # REAL  — kazan sıcaklığı (°C)
    "Pompa1.Hiz",              # REAL  — pompa hızı (RPM)
    "Pompa1.Akis",             # REAL  — debi (L/dak)
    "Pompa1.Calisiyor",        # BOOL  — çalışma durumu
    "Sistem.UretimSayaci",     # DINT  — üretim döngü sayacı
    "Sistem.HataKodu",         # DINT  — aktif hata kodu (0 = yok)
]

# ── Alarm eşikleri: {tag: (min, max)} ───────────────────────────────────────
ALARMLAR = {
    "Firin.Sicaklik_PV":  (50.0,  250.0),  # 50 °C altı / 250 °C üstü
    "Kazan.Basinc_PV":    (0.5,   12.0),   # 0.5 bar altı / 12 bar üstü
    "Kazan.Sicaklik_PV":  (20.0,  180.0),
    "Pompa1.Hiz":         (0.0,   3600.0),
    "Pompa1.Akis":        (2.0,   150.0),
}

_running = True  # SIGINT / SIGTERM ile False yapılır


def _stop(sig, frame):
    global _running
    log.info("Durdurma sinyali alındı, kapatılıyor...")
    _running = False


def alarm_kontrol(tag: str, deger) -> str | None:
    """Değeri eşiklerle karşılaştırır; alarm metni veya None döndürür."""
    if tag not in ALARMLAR or deger is None:
        return None
    try:
        v = float(deger)
        lo, hi = ALARMLAR[tag]
        if v < lo:
            return f"DUSUK({v:.2f}<{lo})"
        if v > hi:
            return f"YUKSEK({v:.2f}>{hi})"
    except (TypeError, ValueError):
        pass
    return None


def toplu_oku(plc: LogixDriver) -> dict:
    """Tüm tag'leri tek bir CIP isteğiyle oku."""
    sonuclar: dict = {}
    try:
        okumalar = plc.read(*TAGS)
        if not isinstance(okumalar, (list, tuple)):
            okumalar = [okumalar]
        for r in okumalar:
            sonuclar[r.tag] = r.value if r.error is None else None
            if r.error:
                log.warning("Tag hatası [%s]: %s", r.tag, r.error)
    except (RequestError, CommError) as e:
        log.error("CIP iletişim hatası: %s", e)
    return sonuclar


def csv_hazirla(yol: Path) -> tuple:
    """CSV dosyasını oluştur/aç; writer ve file nesnelerini döndür."""
    sutunlar = ["zaman"] + TAGS + ["alarmlar"]
    yeni = not yol.exists()
    f = yol.open("a", newline="", encoding="utf-8")
    writer = csv.DictWriter(f, fieldnames=sutunlar)
    if yeni:
        writer.writeheader()
        log.info("CSV oluşturuldu: %s", yol)
    return writer, f


def main() -> None:
    ap = argparse.ArgumentParser(description="CompactLogix PLC Tag Logger")
    ap.add_argument("--ip",       default="192.168.1.1",
                    help="PLC IP adresi")
    ap.add_argument("--slot",     type=int, default=0,
                    help="Backplane slot numarası (CompactLogix=0)")
    ap.add_argument("--interval", type=float, default=1.0,
                    help="Örnekleme periyodu (saniye, varsayılan: 1.0)")
    ap.add_argument("--output",   default="/var/log/plc/plc_data.csv",
                    help="CSV çıkış dosyası yolu")
    ap.add_argument("--prometheus-gw", default="",
                    help="Prometheus Pushgateway URL (opsiyonel)")
    args = ap.parse_args()

    signal.signal(signal.SIGINT,  _stop)
    signal.signal(signal.SIGTERM, _stop)

    csv_yol = Path(args.output)
    csv_yol.parent.mkdir(parents=True, exist_ok=True)
    writer, csv_dosya = csv_hazirla(csv_yol)

    plc_adres      = f"{args.ip}/{args.slot}"
    yeniden_gecikme = 5.0
    plc: LogixDriver | None = None

    log.info("Başlıyor  PLC=%s  interval=%.2f s  csv=%s",
             plc_adres, args.interval, csv_yol)

    try:
        while _running:
            t0 = time.monotonic()

            # ── Bağlantı kur / yeniden bağlan ─────────────────────────────
            if plc is None:
                try:
                    plc = LogixDriver(plc_adres, init_tags=True, init_info=True)
                    plc.open()
                    bilgi = plc.info
                    log.info("Bağlandı: %s  Rev=%s  S/N=%s",
                             bilgi.get("product_name", "?"),
                             bilgi.get("revision", "?"),
                             bilgi.get("serial", "?"))
                except (CommError, Exception) as e:
                    log.error("Bağlantı kurulamadı: %s — %.0f s sonra tekrar",
                              e, yeniden_gecikme)
                    plc = None
                    time.sleep(yeniden_gecikme)
                    continue

            # ── Tag'leri oku ───────────────────────────────────────────────
            veri = toplu_oku(plc)

            if not veri:
                log.warning("Veri yok, bağlantı yenileniyor...")
                try:
                    plc.close()
                except Exception:
                    pass
                plc = None
                time.sleep(yeniden_gecikme)
                continue

            # ── Alarm kontrolü ─────────────────────────────────────────────
            aktif_alarmlar = []
            for tag_adi, deger in veri.items():
                mesaj = alarm_kontrol(tag_adi, deger)
                if mesaj:
                    aktif_alarmlar.append(f"{tag_adi}:{mesaj}")
                    log.warning("ALARM  %s  %s", tag_adi, mesaj)

            # ── Ekran çıktısı ──────────────────────────────────────────────
            simdi = datetime.now()
            print(f"\n{'─'*58}")
            print(f"  {simdi:%Y-%m-%d %H:%M:%S}  |  {len(aktif_alarmlar)} alarm")
            print(f"{'─'*58}")
            for tag_adi in TAGS:
                deger = veri.get(tag_adi)
                if isinstance(deger, float):
                    val_str = f"{deger:>10.3f}"
                elif deger is None:
                    val_str = f"{'N/A':>10}"
                else:
                    val_str = f"{str(deger):>10}"
                alarm_str = " [!]" if any(tag_adi in a
                                          for a in aktif_alarmlar) else ""
                print(f"  {tag_adi:<32} {val_str}{alarm_str}")

            # ── CSV kaydı ──────────────────────────────────────────────────
            satir = {"zaman": simdi.isoformat(),
                     "alarmlar": "|".join(aktif_alarmlar)}
            satir.update({t: veri.get(t, "") for t in TAGS})
            writer.writerow(satir)
            csv_dosya.flush()

            # ── Periyot bekle ──────────────────────────────────────────────
            gecen = time.monotonic() - t0
            bekle = args.interval - gecen
            if bekle > 0:
                time.sleep(bekle)
            else:
                log.warning("Döngü süresi aşıldı: %.3f s", gecen)

    finally:
        csv_dosya.close()
        if plc is not None:
            try:
                plc.close()
            except Exception:
                pass
        log.info("Logger durduruldu. CSV: %s", csv_yol)


if __name__ == "__main__":
    main()

Systemd servisi olarak çalıştırma

# Scripti kopyala
sudo cp plc_logger.py /opt/plc_logger.py
sudo chmod +x /opt/plc_logger.py

# Servis dosyası oluştur
sudo tee /etc/systemd/system/plc-logger.service <<'EOF'
[Unit]
Description=Allen-Bradley CompactLogix Tag Logger
After=network-online.target
Wants=network-online.target

[Service]
Type=simple
User=pi
ExecStart=/usr/bin/python3 /opt/plc_logger.py \
    --ip 192.168.1.1 \
    --slot 0 \
    --interval 1.0 \
    --output /var/log/plc/plc_data.csv
Restart=on-failure
RestartSec=10
StandardOutput=journal
StandardError=journal

[Install]
WantedBy=multi-user.target
EOF

sudo systemctl daemon-reload
sudo systemctl enable --now plc-logger

# Durum kontrol
sudo systemctl status plc-logger
journalctl -u plc-logger -f     # canlı log izleme

Pandas ile CSV analizi

import pandas as pd
import matplotlib.pyplot as plt

# CSV yükle
df = pd.read_csv(
    "/var/log/plc/plc_data.csv",
    index_col="zaman",
    parse_dates=True,
)

# Son 1 saatin verisi
son_1_saat = df.last("1H")

# Temel istatistikler
print(son_1_saat[["Firin.Sicaklik_PV", "Kazan.Basinc_PV"]].describe())

# Alarm sayısı
alarm_satirlari = df[df["alarmlar"] != ""]
print(f"Toplam alarm: {len(alarm_satirlari)}")

# Sıcaklık grafiği
son_1_saat[["Firin.Sicaklik_PV", "Firin.Sicaklik_SP"]].plot(
    title="Fırın Sıcaklığı — Son 1 Saat",
    ylabel="Sıcaklık (°C)",
    figsize=(12, 4),
)
plt.tight_layout()
plt.savefig("/tmp/firin_sicaklik.png", dpi=150)

Grafana entegrasyonu

CSV verilerini Grafana'da görselleştirmenin en kolay yolu Grafana'nın CSV datasource eklentisidir. Alternatif olarak pycomm3 verilerini doğrudan InfluxDB veya Prometheus'a iletebilirsiniz.

pycomm3 → plc_logger.py
    │
    ├── CSV → Grafana CSV Plugin (dosya tabanlı, basit)
    │
    ├── InfluxDB line protocol (HTTP POST)
    │       └── Grafana InfluxDB datasource
    │
    └── Prometheus Pushgateway (push metrik)
            └── Prometheus scrape → Grafana