FlProg

Код: Выделить всё

/**
 * Супер-минимальный Modbus Slave для STM8S103F3
 * Только функция 0x03 (чтение регистров)
 */

#include <Arduino.h>

// Конфигурация
#define MB_ADDR     1
#define MB_BAUD     9600
#define MB_BUF_SIZE 32
#define MB_REG_CNT  10

// Переменные
static uint16_t mb_regs[MB_REG_CNT];
static uint8_t mb_buf[MB_BUF_SIZE];
static uint8_t mb_idx = 0;
static uint32_t mb_time = 0;

// CRC16 функция
static uint16_t mb_crc(uint8_t *d, uint8_t n) {
    uint16_t c = 0xFFFF;
    uint8_t i, j;
    
    for (i = 0; i < n; i++) {
        c ^= d[i];
        for (j = 0; j < 8; j++) {
            if (c & 1) {
                c = (c >> 1) ^ 0xA001;
            } else {
                c >>= 1;
            }
        }
    }
    return c;
}

void setup() {
    Serial_begin(MB_BAUD);
    pinMode(LED_BUILTIN, OUTPUT);
    
    // Инициализация регистров
    uint8_t k;
    for (k = 0; k < MB_REG_CNT; k++) {
        mb_regs[k] = k * 100;
    }
}

void loop() {
    // Прием данных
    if (Serial_available()) {
        int c = Serial_read();
        if (c >= 0) {
            mb_buf[mb_idx++] = (uint8_t)c;
            mb_time = millis();
            
            if (mb_idx >= MB_BUF_SIZE) {
                mb_idx = 0;
            }
        }
    }
    
    // Обработка фрейма
    if (mb_idx > 0 && (millis() - mb_time) > 5) {
        // Проверка адреса
        if (mb_buf[0] == MB_ADDR && mb_idx >= 8) {
            // Проверка CRC
            uint16_t crc_rx = (mb_buf[mb_idx-1] << 8) | mb_buf[mb_idx-2];
            uint16_t crc_calc = mb_crc(mb_buf, mb_idx - 2);
            
            if (crc_rx == crc_calc) {
                // Проверка функции 0x03
                if (mb_buf[1] == 0x03) {
                    uint16_t addr = (mb_buf[2] << 8) | mb_buf[3];
                    uint16_t cnt = (mb_buf[4] << 8) | mb_buf[5];
                    
                    if (addr < MB_REG_CNT && cnt > 0 && (addr + cnt) <= MB_REG_CNT) {
                        // Формирование ответа
                        uint8_t tx[MB_BUF_SIZE];
                        uint8_t tx_idx = 0;
                        uint16_t i;
                        
                        tx[tx_idx++] = MB_ADDR;
                        tx[tx_idx++] = 0x03;
                        tx[tx_idx++] = cnt * 2;
                        
                        for (i = 0; i < cnt; i++) {
                            uint16_t val = mb_regs[addr + i];
                            tx[tx_idx++] = val >> 8;
                            tx[tx_idx++] = val & 0xFF;
                        }
                        
                        uint16_t crc = mb_crc(tx, tx_idx);
                        tx[tx_idx++] = crc & 0xFF;
                        tx[tx_idx++] = crc >> 8;
                        
                        // Отправка
                        for (i = 0; i < tx_idx; i++) {
                            Serial_write(tx[i]);
                        }
                        
                        // Индикация
                        digitalWrite(LED_BUILTIN, HIGH);
                        delay(2);
                        digitalWrite(LED_BUILTIN, LOW);
                    }
                }
            }
            mb_idx = 0;
        } else if (mb_buf[0] != MB_ADDR) {
            mb_idx = 0;
        }
    }
    
    // Фоновые задачи
    static uint32_t last = 0;
    if (millis() - last > 1000) {
        last = millis();
        mb_regs[0] = (mb_regs[0] + 1) & 0xFFFF;
        digitalWrite(LED_BUILTIN, HIGH);
        delay(1);
        digitalWrite(LED_BUILTIN, LOW);
    }
}