RS-485 / RS-422
diferansiyel seri bus.

/* /usr/include/linux/serial.h veya kernel kaynak kodu: */
struct serial_rs485 {
    __u32  flags;                    /* SER_RS485_ENABLED vb. bayraklar */
    __u32  delay_rts_before_send;    /* TX öncesi RTS gecikmesi (ms) */
    __u32  delay_rts_after_send;     /* TX sonrası RTS gecikmesi (ms) */
    __u32  padding[5];               /* gelecek kullanım için */
};

/* Kullanılabilir bayraklar: */
/* SER_RS485_ENABLED          (1 << 0)  RS-485 modu aktif */
/* SER_RS485_RTS_ON_SEND      (1 << 1)  TX sırasında RTS yüksek */
/* SER_RS485_RTS_AFTER_SEND   (1 << 2)  TX sonrası RTS yüksek */
/* SER_RS485_RX_DURING_TX     (1 << 4)  TX sırasında RX etkin */

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

int rs485_enable(const char *port)
{
    int fd = open(port, O_RDWR | O_NOCTTY);
    if (fd < 0) { perror("open"); return -1; }

    struct serial_rs485 rs485 = {0};

    /* Mevcut yapılandırmayı oku: */
    if (ioctl(fd, TIOCGRS485, &rs485) < 0) {
        perror("TIOCGRS485");
    }

    /* RS-485 half-duplex modunu etkinleştir: */
    rs485.flags |= SER_RS485_ENABLED;
    rs485.flags |= SER_RS485_RTS_ON_SEND;       /* TX sırasında DE=high */
    rs485.flags &= ~SER_RS485_RTS_AFTER_SEND;   /* TX sonrası DE=low */
    rs485.delay_rts_before_send = 1;             /* 1 ms gecikme */
    rs485.delay_rts_after_send  = 1;

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

    return fd;
}

&uart1 {
    status = "okay";
    pinctrl-names = "default";
    pinctrl-0 = <&uart1_pins>;

    linux,rs485-enabled-at-boot-time;       /* boot'ta RS-485 etkin */
    rs485-rts-active-high;                   /* DE pini aktif-yüksek */
    rs485-rx-during-tx;                      /* TX sırasında RX aktif değil */

    /* RTS/DE pini için GPIO belirtme (bazı sürücülerde): */
    rts-gpios = <&gpio0 4 GPIO_ACTIVE_HIGH>;
};

#include <sys/ioctl.h>
#include <termios.h>

/* RTS'yi yüksek yap → DE=HIGH (sürücü aktif) */
static void rts_high(int fd) {
    int flags;
    ioctl(fd, TIOCMGET, &flags);
    flags |= TIOCM_RTS;
    ioctl(fd, TIOCMSET, &flags);
}

/* RTS'yi düşür → DE=LOW (alıcı aktif) */
static void rts_low(int fd) {
    int flags;
    ioctl(fd, TIOCMGET, &flags);
    flags &= ~TIOCM_RTS;
    ioctl(fd, TIOCMSET, &flags);
}

void rs485_write(int fd, const unsigned char *data, int len) {
    rts_high(fd);                          /* DE=HIGH */
    usleep(100);                           /* küçük gecikme */
    write(fd, data, len);
    tcdrain(fd);                           /* TX tamamlanana kadar bekle */
    usleep(100);
    rts_low(fd);                           /* DE=LOW → alıcıya geç */
}

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <fcntl.h>
#include <termios.h>
#include <sys/ioctl.h>
#include <linux/serial.h>
#include <stdint.h>

/* Modbus RTU CRC16 hesabı */
uint16_t modbus_crc16(const uint8_t *buf, int len) {
    uint16_t crc = 0xFFFF;
    for (int i = 0; i < len; i++) {
        crc ^= (uint16_t)buf[i];
        for (int b = 0; b < 8; b++) {
            if (crc & 0x0001) crc = (crc >> 1) ^ 0xA001;
            else              crc >>= 1;
        }
    }
    return crc;
}

/* Serial port aç ve termios ayarla */
int uart_open(const char *device, speed_t baud) {
    int fd = open(device, O_RDWR | O_NOCTTY | O_NDELAY);
    if (fd < 0) { perror("open"); return -1; }

    struct termios tty;
    memset(&tty, 0, sizeof(tty));
    tcgetattr(fd, &tty);

    cfsetispeed(&tty, baud);
    cfsetospeed(&tty, baud);

    tty.c_cflag  = (tty.c_cflag & ~CSIZE) | CS8;  /* 8 data bit */
    tty.c_cflag &= ~PARENB;                         /* parity yok */
    tty.c_cflag &= ~CSTOPB;                         /* 1 stop bit */
    tty.c_cflag &= ~CRTSCTS;                        /* hw flow ctrl yok */
    tty.c_cflag |= CREAD | CLOCAL;
    tty.c_lflag  = 0;
    tty.c_iflag  = 0;
    tty.c_oflag  = 0;
    tty.c_cc[VMIN]  = 0;
    tty.c_cc[VTIME] = 20;                           /* 2 saniyelik zaman aşımı */

    tcflush(fd, TCIFLUSH);
    tcsetattr(fd, TCSANOW, &tty);

    /* RS-485 modunu etkinleştir */
    struct serial_rs485 rs485 = {0};
    rs485.flags = SER_RS485_ENABLED | SER_RS485_RTS_ON_SEND;
    rs485.delay_rts_before_send = 1;
    rs485.delay_rts_after_send  = 1;
    ioctl(fd, TIOCSRS485, &rs485);

    fcntl(fd, F_SETFL, 0);
    return fd;
}

/* Modbus RTU Read Holding Registers (FC03) */
int modbus_read_regs(int fd, uint8_t slave_addr,
                     uint16_t start_reg, uint16_t count,
                     uint16_t *out)
{
    uint8_t req[8];
    req[0] = slave_addr;
    req[1] = 0x03;                          /* FC03: Read Holding Registers */
    req[2] = (start_reg >> 8) & 0xFF;
    req[3] =  start_reg       & 0xFF;
    req[4] = (count    >> 8) & 0xFF;
    req[5] =  count          & 0xFF;
    uint16_t crc = modbus_crc16(req, 6);
    req[6] = crc & 0xFF;
    req[7] = (crc >> 8) & 0xFF;

    write(fd, req, 8);
    tcdrain(fd);

    uint8_t resp[5 + count * 2];
    int n = read(fd, resp, sizeof(resp));
    if (n < 5 || resp[0] != slave_addr || resp[1] != 0x03) {
        fprintf(stderr, "Modbus yanıt hatası\n");
        return -1;
    }

    for (int i = 0; i < count; i++)
        out[i] = ((uint16_t)resp[3 + i*2] << 8) | resp[4 + i*2];

    return count;
}

int main(void)
{
    int fd = uart_open("/dev/ttyS1", B9600);
    if (fd < 0) return 1;

    uint16_t regs[10];
    if (modbus_read_regs(fd, 1, 0x0000, 10, regs) == 10) {
        for (int i = 0; i < 10; i++)
            printf("Reg[%d] = 0x%04X (%d)\n", i, regs[i], regs[i]);
    }

    close(fd);
    return 0;
}

gcc -o rs485_modbus rs485_modbus.c
sudo ./rs485_modbus
# Reg[0] = 0x0215 (533)
# Reg[1] = 0x00C8 (200)  ← sıcaklık: 20.0°C (×0.1)

pip install pyserial pymodbus

import serial
import serial.rs485

# RS-485 half-duplex portunu aç
ser = serial.Serial(
    port='/dev/ttyUSB0',
    baudrate=9600,
    bytesize=serial.EIGHTBITS,
    parity=serial.PARITY_NONE,
    stopbits=serial.STOPBITS_ONE,
    timeout=1.0
)

# RS-485 modunu etkinleştir
ser.rs485_mode = serial.rs485.RS485Settings(
    rts_level_for_tx=True,         # TX sırasında RTS=HIGH
    rts_level_for_rx=False,        # RX sırasında RTS=LOW
    delay_before_tx=0.001,          # 1ms gecikme
    delay_before_rx=0.001
)

# Modbus RTU frame gönder (slave 1, FC03, reg 0-9)
frame = bytes([0x01, 0x03, 0x00, 0x00, 0x00, 0x0A, 0xC5, 0xCD])
ser.write(frame)

# Yanıtı oku
response = ser.read(25)
print('Yanıt:', response.hex())

from pymodbus.client import ModbusSerialClient

# RTU master bağlantısı
client = ModbusSerialClient(
    port='/dev/ttyUSB0',
    baudrate=9600,
    bytesize=8,
    parity='N',
    stopbits=1,
    timeout=1
)

if client.connect():
    # Slave 1'den 10 holding register oku (adres 0x0000)
    result = client.read_holding_registers(address=0, count=10, slave=1)

    if not result.isError():
        for i, val in enumerate(result.registers):
            print(f'Reg[{i}] = {val} (0x{val:04X})')
    else:
        print('Hata:', result)

    client.close()
else:
    print('Bağlanamadı')

import time
from pymodbus.client import ModbusSerialClient

client = ModbusSerialClient(port='/dev/ttyUSB0', baudrate=9600, timeout=1)
client.connect()

try:
    while True:
        result = client.read_holding_registers(address=0, count=2, slave=1)
        if not result.isError():
            temp = result.registers[0] / 10.0   # ×0.1 ölçek faktörü
            hum  = result.registers[1] / 10.0
            print(f'Sıcaklık: {temp:.1f}°C  Nem: {hum:.1f}%')
        time.sleep(1.0)
except KeyboardInterrupt:
    client.close()

# BeagleBone Black UART1 pinleri: P9_24 (TX), P9_26 (RX), P9_19 (RTS/DE)
# MAX485 transceiver bağlantısı:
#   TXD → MAX485 DI    (pin 4)
#   RXD → MAX485 RO    (pin 1)
#   RTS → MAX485 DE+RE (pin 2+3, birleştir)
#   MAX485 A/B → RS-485 bus

# UART1 aktifleştirme:
sudo config-pin P9_24 uart
sudo config-pin P9_26 uart

# Terminasyon dirençleri (120Ω) bus uçlarına
# Bias dirençleri (560Ω): A → 3.3V, B → GND

# Port kontrolü:
ls /dev/ttyS1
dmesg | grep tty

from pymodbus.client import ModbusSerialClient

client = ModbusSerialClient(port='/dev/ttyS1', baudrate=9600, timeout=0.5)
client.connect()

online_nodes = []
for slave_id in range(1, 33):   # 1–32 arası tara
    result = client.read_holding_registers(0, 1, slave=slave_id)
    if not result.isError():
        online_nodes.append(slave_id)
        print(f'[OK] Slave {slave_id}: reg[0] = {result.registers[0]}')
    else:
        print(f'[--] Slave {slave_id}: yanıt yok')

print(f'\nToplamda {len(online_nodes)} node bulundu: {online_nodes}')
client.close()

import serial, time

# DMX512: 250 kbps, 8N2
dmx = serial.Serial('/dev/ttyUSB0', baudrate=250000,
                    bytesize=8, parity='N', stopbits=2)

def dmx_send(channels: list):
    """512 kanallık DMX frame gönder."""
    # BREAK: 88µs dominant (port'u geçici 100kbps'e al)
    dmx.break_condition = True
    time.sleep(0.0001)               # 100µs break
    dmx.break_condition = False
    time.sleep(0.000012)             # 12µs MAB (Mark After Break)
    # Start code + 512 kanal
    frame = bytes([0x00]) + bytes(channels[:512]).ljust(512, b'\x00')
    dmx.write(frame)

# Kanal 1-3: RGB LED (kırmızı=200, yeşil=100, mavi=50)
while True:
    dmx_send([200, 100, 50] + [0] * 509)
    time.sleep(0.025)   # ~40 fps