Modbus —
endüstriyel haberleşme protokolü.

/* 40002 ve 40003 → 32-bit unsigned integer */
uint16_t regs[2];
modbus_read_registers(ctx, 1, 2, regs); /* addr=1 (0-indexed) */

/* Big-endian word order (high word first) */
uint32_t total_flow = ((uint32_t)regs[0] << 16) | regs[1];

/* Little-endian word order (low word first) */
uint32_t total_flow_le = ((uint32_t)regs[1] << 16) | regs[0];

/* IEEE 754 float — libmodbus yardımcı makrosu */
float value = MODBUS_GET_FLOAT_ABCD(regs); /* big-endian */
float value_le = MODBUS_GET_FLOAT_DCBA(regs); /* little-endian */

01       → Slave ID (cihaz adresi 1)
03       → Function Code 3: Read Holding Registers
00 00    → Başlangıç adresi: 0x0000 (register 40001)
00 03    → Okunacak register sayısı: 3
05 CB    → CRC-16 (little-endian)

Yanıt:
01       → Slave ID
03       → Function Code (aynı)
06       → Byte count: 3 register × 2 byte = 6
12 34    → Register 0 değeri: 0x1234 = 4660
00 64    → Register 1 değeri: 0x0064 = 100
00 00    → Register 2 değeri: 0x0000 = 0
XX XX    → CRC-16

01       → Slave ID
83       → FC03 | 0x80 = 0x83 → hata yanıtı
02       → Exception Code: Illegal Data Address
XX XX    → CRC-16

/* 1 karakter = 1 start + 8 data + 1 parity + 1 stop = 11 bit */
/* 3.5 karakter gap hesabı */
int baud = 9600;
double char_time_us = 11.0 * 1e6 / baud;   /* ~1145 µs @ 9600 */
double gap_35_us    = 3.5 * char_time_us;   /* ~4010 µs @ 9600 */

/* Baud rate > 19200 için Modbus spec sabit değer önerir */
/* inter-frame: 1750 µs, inter-character: 750 µs */
double gap_fixed_us = (baud > 19200) ? 1750.0 : gap_35_us;

#include <linux/serial.h>
#include <sys/ioctl.h>
#include <fcntl.h>
#include <termios.h>

int fd = open("/dev/ttyUSB0", O_RDWR | O_NOCTTY);

/* RS-485 modunu yapılandır */
struct serial_rs485 rs485conf = {0};
rs485conf.flags |= SER_RS485_ENABLED;          /* RS-485 etkinleştir */
rs485conf.flags |= SER_RS485_RTS_ON_SEND;      /* TX sırasında RTS yüksek */
rs485conf.flags &= ~SER_RS485_RTS_AFTER_SEND;  /* TX sonrası RTS düşük */
rs485conf.delay_rts_before_send = 0;           /* µs gecikme */
rs485conf.delay_rts_after_send  = 0;

if (ioctl(fd, TIOCSRS485, &rs485conf) < 0) {
    perror("ioctl TIOCSRS485");
    return -1;
}

/* Standart termios ayarları */
struct termios tty = {0};
cfsetispeed(&tty, B115200);
cfsetospeed(&tty, B115200);
tty.c_cflag = CS8 | CLOCAL | CREAD;  /* 8N1 */
tcsetattr(fd, TCSANOW, &tty);

# Cihazı tespit et
dmesg | grep ttyUSB
# usb 1-1.2: ch341-uart converter now attached to ttyUSB0

# İzin ver (kalıcı: kullanıcıyı dialout grubuna ekle)
sudo usermod -aG dialout $USER
ls -la /dev/ttyUSB0

# Manuel test: 9600 baud, raw mod
stty -F /dev/ttyUSB0 9600 raw cs8 -cstopb -parenb

# İlk bağlantı testi: Wireshark veya socat ile yakalama
socat /dev/ttyUSB0,b115200,raw,echo=0 STDOUT | xxd

# Debian/Ubuntu
sudo apt install libmodbus-dev

# pkg-config ile derleme
gcc modbus_client.c -o modbus_client $(pkg-config --cflags --libs libmodbus)

#include <stdio.h>
#include <stdlib.h>
#include <errno.h>
#include <modbus.h>

#define SLAVE_ID    1
#define REG_START   0      /* 40001 → 0-indexed */
#define REG_COUNT   10

int main(void)
{
    modbus_t *ctx;
    uint16_t  regs[REG_COUNT];
    int       rc;

    /* RTU context — /dev/ttyUSB0, 115200 baud, No parity, 8 bit, 1 stop */
    ctx = modbus_new_rtu("/dev/ttyUSB0", 115200, 'N', 8, 1);
    if (!ctx) {
        fprintf(stderr, "modbus_new_rtu: %s\n", modbus_strerror(errno));
        return EXIT_FAILURE;
    }

    /* TCP için alternatif:
       ctx = modbus_new_tcp("192.168.1.100", 502); */

    if (modbus_set_slave(ctx, SLAVE_ID) == -1) {
        fprintf(stderr, "set_slave: %s\n", modbus_strerror(errno));
        goto cleanup;
    }

    /* Debug modunu etkinleştir (ham frame'leri basar) */
    modbus_set_debug(ctx, TRUE);

    if (modbus_connect(ctx) == -1) {
        fprintf(stderr, "connect: %s\n", modbus_strerror(errno));
        goto cleanup;
    }

    /* FC03: 10 holding register oku */
    rc = modbus_read_registers(ctx, REG_START, REG_COUNT, regs);
    if (rc == -1) {
        fprintf(stderr, "read_registers: %s\n", modbus_strerror(errno));
        goto disconnect;
    }

    printf("Okunan %d register:\n", rc);
    for (int i = 0; i < rc; i++) {
        printf("  [%d] (addr %d) = %d (0x%04X)\n",
               i, REG_START + i, regs[i], regs[i]);
    }

    /* FC06: tek register yaz — örn. setpoint güncelle */
    rc = modbus_write_register(ctx, 9, 850); /* addr=9, value=850 */
    if (rc == -1) {
        fprintf(stderr, "write_register: %s\n", modbus_strerror(errno));
    } else {
        printf("Register 9 → 850 yazıldı\n");
    }

    /* FC01: 8 coil oku */
    uint8_t coils[8];
    rc = modbus_read_bits(ctx, 0, 8, coils);
    if (rc != -1) {
        printf("Coil durumları:");
        for (int i = 0; i < 8; i++) printf(" %d", coils[i]);
        printf("\n");
    }

disconnect:
    modbus_close(ctx);
cleanup:
    modbus_free(ctx);
    return EXIT_SUCCESS;
}

/* Response timeout: 500 ms */
modbus_set_response_timeout(ctx, 0, 500000); /* sec, usec */

/* Byte timeout: birbirini izleyen byte'lar arası max süre */
modbus_set_byte_timeout(ctx, 0, 100000); /* 100 ms */

/* modbus_mapping_new(nb_bits, nb_input_bits, nb_registers, nb_input_registers) */
modbus_mapping_t *mb_mapping = modbus_mapping_new(
    8,    /* coil sayısı */
    8,    /* discrete input sayısı */
    100,  /* holding register sayısı */
    50    /* input register sayısı */
);

if (!mb_mapping) {
    fprintf(stderr, "mapping_new: %s\n", modbus_strerror(errno));
    exit(EXIT_FAILURE);
}

/* Dizi erişimi */
mb_mapping->tab_bits[0]           = 1;       /* coil 0 = ON */
mb_mapping->tab_input_bits[0]     = 0;       /* discrete input 0 = OFF */
mb_mapping->tab_registers[0]      = 1234;    /* holding register 0 */
mb_mapping->tab_input_registers[0] = 2345;    /* input register 0 */

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
#include <unistd.h>
#include <sys/select.h>
#include <modbus.h>

#define NB_CONNECTIONS  5
#define PORT            502

int main(void)
{
    modbus_t         *ctx;
    modbus_mapping_t *mb_mapping;
    int               server_socket;
    fd_set            refset, rdset;
    int               fdmax;
    uint8_t           query[MODBUS_TCP_MAX_ADU_LENGTH];

    ctx = modbus_new_tcp("0.0.0.0", PORT);
    modbus_set_debug(ctx, FALSE);

    mb_mapping = modbus_mapping_new(8, 8, 100, 50);
    if (!mb_mapping) { perror("mapping"); return 1; }

    /* Başlangıç değerleri */
    mb_mapping->tab_registers[0] = 2350; /* sıcaklık × 10 */
    mb_mapping->tab_registers[1] = 600;  /* nem × 10 */
    mb_mapping->tab_bits[0]       = 1;    /* çalışma durumu */

    server_socket = modbus_tcp_listen(ctx, NB_CONNECTIONS);
    if (server_socket == -1) {
        fprintf(stderr, "listen: %s\n", modbus_strerror(errno));
        return 1;
    }

    printf("Modbus TCP sunucusu port %d'de dinliyor...\n", PORT);

    FD_ZERO(&refset);
    FD_SET(server_socket, &refset);
    fdmax = server_socket;

    int client_sockets[NB_CONNECTIONS];
    for (int i = 0; i < NB_CONNECTIONS; i++) client_sockets[i] = -1;

    for (;;) {
        rdset = refset;
        if (select(fdmax + 1, &rdset, NULL, NULL, NULL) == -1) break;

        for (int fd = 0; fd <= fdmax; fd++) {
            if (!FD_ISSET(fd, &rdset)) continue;

            if (fd == server_socket) {
                /* Yeni client bağlantısı */
                int new_fd = modbus_tcp_accept(ctx, &server_socket);
                if (new_fd != -1) {
                    FD_SET(new_fd, &refset);
                    if (new_fd > fdmax) fdmax = new_fd;
                    printf("Yeni bağlantı: fd=%d\n", new_fd);
                }
            } else {
                /* Mevcut client'tan istek */
                modbus_set_socket(ctx, fd);
                int rc = modbus_receive(ctx, query);
                if (rc > 0) {
                    modbus_reply(ctx, query, rc, mb_mapping);
                } else {
                    printf("Client fd=%d bağlantıyı kapattı\n", fd);
                    close(fd);
                    FD_CLR(fd, &refset);
                    if (fd == fdmax) fdmax--;
                }
            }
        }
    }

    modbus_mapping_free(mb_mapping);
    close(server_socket);
    modbus_free(ctx);
    return 0;
}

# Port bazlı filtre
tcp.port == 502

# Modbus dissector filtresi (Wireshark otomatik decode eder)
modbus

# Sadece FC03 istekleri
modbus.func_code == 3

# Hata yanıtları
modbus.exception_code

# Komut satırından yakalama
tshark -i eth0 -f "tcp port 502" -T fields \
  -e frame.time -e modbus.func_code -e modbus.reference_num

#include <modbus.h>
#include <unistd.h>

int modbus_connect_with_retry(modbus_t *ctx, int max_retries, int delay_sec)
{
    for (int attempt = 0; attempt < max_retries; attempt++) {
        if (modbus_connect(ctx) == 0) {
            printf("Bağlantı başarılı (deneme %d)\n", attempt + 1);
            return 0;
        }
        fprintf(stderr, "Bağlantı hatası: %s — %d saniye bekleniyor\n",
                modbus_strerror(errno), delay_sec);
        sleep(delay_sec);
        modbus_close(ctx); /* mevcut bağlantıyı temizle */
    }
    return -1;
}

/* Timeout: 1 saniye cevap, 500 ms byte arası */
modbus_set_response_timeout(ctx, 1, 0);
modbus_set_byte_timeout(ctx, 0, 500000);

# iptables: sadece belirli IP'den port 502'ye izin ver
sudo iptables -A INPUT -p tcp --dport 502 \
  -s 192.168.1.0/24 -j ACCEPT
sudo iptables -A INPUT -p tcp --dport 502 -j DROP

# nftables alternatifi
nft add rule ip filter input ip saddr 192.168.1.0/24 \
    tcp dport 502 accept

# Port 1502 kullan (1024 altı root gerektirir)
# libmodbus: modbus_new_tcp("0.0.0.0", 1502)

pip install pymodbus

# Sürüm doğrulama
python3 -c "import pymodbus; print(pymodbus.__version__)"

from pymodbus.client import ModbusTcpClient
from pymodbus.exceptions import ModbusException

client = ModbusTcpClient(host="192.168.1.100", port=502, timeout=3)

if not client.connect():
    raise ConnectionError("Sunucuya bağlanılamadı")

try:
    # FC03: holding register oku
    response = client.read_holding_registers(address=0, count=10, slave=1)
    if response.isError():
        print(f"Hata: {response}")
    else:
        print(f"Registers: {response.registers}")
        # [4660, 100, 0, 2350, 600, 0, 0, 0, 0, 850]

    # FC04: input register oku
    rr = client.read_input_registers(address=0, count=5, slave=1)
    if not rr.isError():
        print(f"Input registers: {rr.registers}")

    # FC06: tek holding register yaz
    wr = client.write_register(address=9, value=1234, slave=1)
    if wr.isError():
        print(f"Yazma hatası: {wr}")
    else:
        print("Register 9 → 1234 yazıldı")

    # FC16: birden fazla register yaz
    values = [100, 200, 300]
    wrs = client.write_registers(address=0, values=values, slave=1)

except ModbusException as exc:
    print(f"Modbus hatası: {exc}")
finally:
    client.close()

from pymodbus.client import ModbusSerialClient

client = ModbusSerialClient(
    port="/dev/ttyUSB0",
    baudrate=115200,
    bytesize=8,
    parity="N",
    stopbits=1,
    timeout=1
)

client.connect()
rr = client.read_holding_registers(address=0, count=5, slave=1)
print(rr.registers)
client.close()

import asyncio
import logging
import time
from pymodbus.client import AsyncModbusTcpClient
from pymodbus.exceptions import ModbusException

logging.basicConfig(level=logging.WARNING)

SLAVE_ID = 1
POLL_INTERVAL = 5.0   # saniye
MAX_READINGS  = 20

async def read_sensor(client: AsyncModbusTcpClient) -> dict:
    """Holding register 0–4'ü oku, sözlük döndür."""
    rr = await client.read_holding_registers(address=0, count=5, slave=SLAVE_ID)
    if rr.isError():
        raise ModbusException(f"Register okuma hatası: {rr}")
    regs = rr.registers
    return {
        "temperature": regs[0] / 10.0,   # °C × 10
        "humidity"   : regs[1] / 10.0,   # % × 10
        "pressure"   : regs[2],           # hPa
        "flow_rate"  : regs[3] / 10.0,   # L/min × 10
        "status_bits": regs[4],
    }

async def main():
    async with AsyncModbusTcpClient(
        host="192.168.1.100", port=502, timeout=2
    ) as client:
        print("Bağlandı. Sensör verileri okunuyor...\n")
        for i in range(MAX_READINGS):
            try:
                data = await read_sensor(client)
                ts = time.strftime("%H:%M:%S")
                print(
                    f"[{ts}] #{i+1:04d}  "
                    f"T={data['temperature']:.1f}°C  "
                    f"H={data['humidity']:.1f}%  "
                    f"P={data['pressure']} hPa  "
                    f"F={data['flow_rate']:.1f} L/min"
                )
            except ModbusException as exc:
                print(f"[{time.strftime('%H:%M:%S')}] Hata: {exc}")
            await asyncio.sleep(POLL_INTERVAL)

asyncio.run(main())

import struct

def regs_to_float32(high: int, low: int) -> float:
    """İki 16-bit register'dan IEEE 754 float32 oluştur (big-endian word order)."""
    packed = struct.pack(">HH", high, low)  # big-endian, 2×uint16
    return struct.unpack(">f", packed)[0]     # big-endian float32

# Örnek: register 0x0000=0x4349, 0x0001=0x8000 → 201.5 V
voltage = regs_to_float32(0x4349, 0x8000)
print(f"Voltaj: {voltage:.2f} V")  # 201.50 V

# Little-endian word order için (bazı cihazlar)
def regs_to_float32_le(low: int, high: int) -> float:
    packed = struct.pack(">HH", high, low)
    return struct.unpack(">f", packed)[0]

import struct
import time
import csv
import sys
from datetime import datetime
from pymodbus.client import ModbusSerialClient
from pymodbus.exceptions import ModbusException

# Bağlantı parametreleri
PORT      = "/dev/ttyUSB0"
BAUD      = 9600
SLAVE_ID  = 1
POLL_SEC  = 10
CSV_FILE  = "energy_log.csv"
MAX_RETRY = 3

# SDM630 register adresleri (0-indexed input registers)
REG_MAP = {
    "v_l1"       : 0x0000,
    "v_l2"       : 0x0002,
    "v_l3"       : 0x0004,
    "i_l1"       : 0x0006,
    "i_l2"       : 0x0008,
    "i_l3"       : 0x000A,
    "p_total"    : 0x0034,
    "freq"       : 0x0048,
    "energy_kwh" : 0x0156,
}

def regs_to_float32(high: int, low: int) -> float:
    return struct.unpack(">f", struct.pack(">HH", high, low))[0]

def read_float(client, address: int, retries: int = MAX_RETRY) -> float:
    """2 input register oku, float32'e dönüştür. Hata durumunda retry."""
    for attempt in range(retries):
        try:
            rr = client.read_input_registers(address=address, count=2, slave=SLAVE_ID)
            if not rr.isError():
                return regs_to_float32(rr.registers[0], rr.registers[1])
            print(f"  Hata @ 0x{address:04X} (deneme {attempt+1}): {rr}", file=sys.stderr)
        except ModbusException as exc:
            print(f"  ModbusException @ 0x{address:04X}: {exc}", file=sys.stderr)
        time.sleep(0.2)
    return float("nan")

def read_all_registers(client) -> dict:
    data = {}
    for name, addr in REG_MAP.items():
        data[name] = read_float(client, addr)
        time.sleep(0.05)  # frame'ler arası boşluk
    return data

def main():
    client = ModbusSerialClient(
        port=PORT, baudrate=BAUD, bytesize=8, parity="N", stopbits=1, timeout=2
    )
    if not client.connect():
        print("Seri porta bağlanılamadı!", file=sys.stderr)
        sys.exit(1)

    fieldnames = ["timestamp"] + list(REG_MAP.keys())
    with open(CSV_FILE, "w", newline="") as f:
        writer = csv.DictWriter(f, fieldnames=fieldnames)
        writer.writeheader()

        print(f"Loglama başladı → {CSV_FILE}  (Ctrl+C ile durdur)")
        try:
            while True:
                data = read_all_registers(client)
                data["timestamp"] = datetime.now().isoformat(timespec="seconds")
                writer.writerow(data)
                f.flush()
                print(
                    f"[{data['timestamp']}] "
                    f"V={data['v_l1']:.1f}V  "
                    f"I={data['i_l1']:.2f}A  "
                    f"P={data['p_total']:.1f}W  "
                    f"E={data['energy_kwh']:.3f}kWh"
                )
                time.sleep(POLL_SEC)
        except KeyboardInterrupt:
            print("\nDurduruldu.")
        finally:
            client.close()

if __name__ == "__main__":
    main()