modbus.h

/*
 * uuid-modbus - Microcontroller asynchronous Modbus library
 * Copyright 2021-2022  Simon Arlott
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
#ifndef UUID_MODBUS_H_
#define UUID_MODBUS_H_
 
#include <Arduino.h>
 
#include <cstdarg>
#include <cstdint>
#include <array>
#include <deque>
#include <memory>
#include <vector>
 
#include <uuid/log.h>
 
namespace uuid {
 
namespace modbus {
 
constexpr uint16_t MAX_MESSAGE_SIZE = 256; 
constexpr uint16_t MESSAGE_HEADER_SIZE = 2; 
constexpr uint16_t MESSAGE_CRC_SIZE = 2; 
constexpr uint32_t INTER_FRAME_TIMEOUT_MS = 5;
constexpr uint16_t DEFAULT_UNICAST_TIMEOUT_MS = 10000; 
constexpr uint16_t DEFAULT_BROADCAST_TIMEOUT_MS = 1000; 
extern const uuid::log::Logger logger; 
using frame_buffer_t = std::array<uint8_t, MAX_MESSAGE_SIZE + 1>; 
enum DeviceAddressType : uint8_t {
    BROADCAST = 0, 
    MIN_UNICAST = 1, 
    MAX_UNICAST = 247, 
};
 
enum FunctionCode : uint8_t {
    READ_HOLDING_REGISTERS = 0x03, 
    READ_INPUT_REGISTERS = 0x04, 
    WRITE_SINGLE_REGISTER = 0x06, 
    READ_EXCEPTION_STATUS = 0x07, 
};
 
enum ResponseStatus : uint8_t {
    QUEUED, 
    TRANSMIT, 
    WAITING, 
    SUCCESS, 
    EXCEPTION, 
    FAILURE_INVALID, 
    FAILURE_CRC, 
    FAILURE_TIMEOUT, 
    FAILURE_TOO_SHORT, 
    FAILURE_TOO_LONG, 
    FAILURE_ADDRESS, 
    FAILURE_FUNCTION, 
    FAILURE_LENGTH, 
    FAILURE_UNEXPECTED, 
};
 
class Response {
public:
    virtual ~Response() = default;
 
    inline bool done() const { return status_ >= ResponseStatus::SUCCESS; }
 
    inline bool pending() const { return status_ < ResponseStatus::SUCCESS; }
 
    bool success() const { return status_ == ResponseStatus::SUCCESS; }
 
    bool exception() const { return status_ == ResponseStatus::EXCEPTION; }
 
    bool failed() const { return status_ > ResponseStatus::EXCEPTION; }
 
    inline ResponseStatus status() const { return status_; }
 
    inline void status(ResponseStatus status) { status_ = status; }
 
    inline uint8_t exception_code() const { return exception_code_; }
 
    inline void exception_code(uint8_t exception_code) { exception_code_ = exception_code; }
 
    virtual ResponseStatus parse(frame_buffer_t &frame, uint16_t len) = 0;
 
protected:
    Response() = default;
 
    bool check_length(frame_buffer_t &frame, uint16_t actual, uint16_t expected);
 
private:
    ResponseStatus status_ = ResponseStatus::QUEUED; 
    uint8_t exception_code_ = 0; 
};
 
class RegisterDataResponse: public Response {
public:
    inline const std::vector<uint16_t>& data() const { return data_; };
 
    ResponseStatus parse(frame_buffer_t &frame, uint16_t len) override;
 
protected:
    std::vector<uint16_t> data_; 
};
 
class RegisterWriteResponse: public RegisterDataResponse {
public:
    ResponseStatus parse(frame_buffer_t &frame, uint16_t len) override;
 
    uint16_t address() const { return address_; }
 
private:
    uint16_t address_; 
};
 
class ExceptionStatusResponse: public Response {
public:
    ResponseStatus parse(frame_buffer_t &frame, uint16_t len) override;
 
    inline uint8_t data() const { return data_; };
 
private:
    uint8_t data_; 
};
 
class Request {
public:
    virtual ~Request() = default;
 
public:
    Request(uint16_t device, uint8_t function_code, uint16_t timeout_ms,
        const std::shared_ptr<Response> &response);
 
    virtual uint16_t encode(frame_buffer_t &frame);
 
    inline uint16_t device() const { return device_; };
 
    inline uint8_t function_code() const { return function_code_; };
 
    inline uint16_t timeout_ms() const { return timeout_ms_; };
 
    inline Response& response() const { return *response_.get(); };
 
private:
    const uint16_t device_; 
    const uint8_t function_code_; 
    const uint16_t timeout_ms_; 
    const std::shared_ptr<Response> response_; 
};
 
class RegisterRequest: public Request {
public:
    RegisterRequest(uint16_t device, uint8_t function_code, uint16_t timeout_ms,
        uint16_t address, uint16_t data,
        const std::shared_ptr<Response> &response);
 
    uint16_t encode(frame_buffer_t &frame) override;
 
    inline uint16_t address() const { return address_; };
 
    inline uint16_t data() const { return data_; };
 
private:
    const uint16_t address_; 
    const uint16_t data_; 
};
 
class SerialClient {
public:
    SerialClient(::HardwareSerial &serial);
 
    ~SerialClient() = default;
 
    void loop();
 
    inline uint16_t default_unicast_timeout_ms() const { return default_unicast_timeout_ms_; }
    inline void default_unicast_timeout_ms(uint16_t timeout_ms) { default_unicast_timeout_ms_ = timeout_ms; }
 
    inline uint16_t default_broadcast_delay_ms() const { return default_broadcast_timeout_ms_; }
    inline void default_broadcast_delay_ms(uint16_t timeout_ms) { default_broadcast_timeout_ms_ = timeout_ms; }
 
    std::shared_ptr<const RegisterDataResponse> read_holding_registers(uint16_t device,
        uint16_t address, uint16_t size, uint16_t timeout_ms = 0);
 
    std::shared_ptr<const RegisterDataResponse> read_input_registers(uint16_t device,
        uint16_t address, uint16_t size, uint16_t timeout_ms = 0);
 
    std::shared_ptr<const RegisterWriteResponse> write_holding_register(uint16_t device,
        uint16_t address, uint16_t value, uint16_t timeout_ms = 0);
 
    std::shared_ptr<const ExceptionStatusResponse> read_exception_status(uint16_t device,
        uint16_t timeout_ms = 0);
 
private:
    void idle();
 
    void encode();
 
    void transmit();
 
    uint32_t input();
 
    void receive();
 
    void complete();
 
    void log_frame(const __FlashStringHelper *prefix);
 
    uint16_t calc_crc() const;
 
    ::HardwareSerial &serial_; 
    std::deque<std::unique_ptr<Request>> requests_; 
    uint16_t default_unicast_timeout_ms_ = DEFAULT_UNICAST_TIMEOUT_MS; 
    uint16_t default_broadcast_timeout_ms_ = DEFAULT_BROADCAST_TIMEOUT_MS; 
    bool idle_frame_ = false; 
    frame_buffer_t frame_; 
    uint16_t frame_pos_ = 0; 
    uint32_t last_rx_ms_ = 0; 
    uint16_t tx_frame_size_ = 0; 
    uint32_t last_tx_ms_ = 0; 
};
 
} // namespace modbus
 
} // namespace uuid
 
#endif