TinyProtocolFd.h

Go to the documentation of this file.

/*
    Copyright 2019-2024 (C) Alexey Dynda

    This file is part of Tiny Protocol Library.

    GNU General Public License Usage

    Protocol Library is free software: you can redistribute it and/or modify
    it under the terms of the GNU Lesser General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.

    Protocol Library 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 Lesser General Public License for more details.

    You should have received a copy of the GNU Lesser General Public License
    along with Protocol Library.  If not, see <http://www.gnu.org/licenses/>.

    Commercial License Usage

    Licensees holding valid commercial Tiny Protocol licenses may use this file in
    accordance with the commercial license agreement provided in accordance with
    the terms contained in a written agreement between you and Alexey Dynda.
    For further information contact via email on github account.
*/

#pragma once

#include "TinyPacket.h"
#include "proto/fd/tiny_fd.h"

#ifdef ARDUINO
#include <HardwareSerial.h>
#else
#include <string.h>
#include <stdlib.h>
#endif

namespace tinyproto
{

class IFd
{
public:
    friend class FdD;
    IFd(void *buffer, int bufferSize)
        : m_buffer((uint8_t *)buffer)
        , m_bufferSize(bufferSize)
    {
    }

    virtual ~IFd() = default;

    void begin();

    void end();

    int write(const char *buf, int size);

    int write(const IPacket &pkt);

    int run_rx(const void *data, int len);

    int run_rx(read_block_cb_t read_func);

    int run_tx(write_block_cb_t write_func);

    int run_tx(void *data, int max_size);

    void disableCrc();

    void enableCrc(hdlc_crc_t crc);

    bool enableCheckSum();

    bool enableCrc16();

    bool enableCrc32();

    void setReceiveCallback(void (*on_receive)(void *userData, uint8_t addr, IPacket &pkt) = nullptr)
    {
        m_onReceive = on_receive;
    };

    void setSendCallback(void (*on_send)(void *userData, uint8_t addr, IPacket &pkt) = nullptr)
    {
        m_onSend = on_send;
    };

    void setConnectEventCallback(void (*on_connect)(void *userData, uint8_t addr, bool connected) = nullptr)
    {
        m_onConnectEvent = on_connect;
    }

    void setWindowSize(uint8_t window)
    {
        m_window = window;
    }

    void setSendTimeout(uint16_t timeout)
    {
        m_sendTimeout = timeout;
    }

    void setUserData(void *userData)
    {
        m_userData = userData;
    }

    tiny_fd_handle_t getHandle()
    {
        return m_handle;
    }

    int getStatus()
    {
        return tiny_fd_get_status(m_handle);
    }

protected:
    virtual void onReceive(uint8_t addr, uint8_t *pdata, int size)
    {
        IPacket pkt((char *)pdata, size);
        pkt.m_len = size;
        if ( m_onReceive )
            m_onReceive(m_userData, addr, pkt);
    }

    virtual void onSend(uint8_t addr, const uint8_t *pdata, int size)
    {
        IPacket pkt((char *)pdata, size);
        pkt.m_len = size;
        if ( m_onSend )
            m_onSend(m_userData, addr, pkt);
    }

    virtual void onConnectEvent(uint8_t addr, bool connected)
    {
        if ( m_onConnectEvent )
            m_onConnectEvent(m_userData, addr, connected);
    }

private:
    tiny_fd_handle_t m_handle = nullptr;

    uint8_t *m_buffer = nullptr;

    hdlc_crc_t m_crc = HDLC_CRC_DEFAULT;

    int m_bufferSize = 0;

    uint16_t m_sendTimeout = 0;

    uint8_t m_window = 3;

    void (*m_onReceive)(void *userData, uint8_t addr, IPacket &pkt) = nullptr;

    void (*m_onSend)(void *userData, uint8_t addr, IPacket &pkt) = nullptr;

    void (*m_onConnectEvent)(void *userData, uint8_t addr, bool connected) = nullptr;

    void *m_userData = nullptr;

    static void onReceiveInternal(void *handle, uint8_t addr, uint8_t *pdata, int size);

    static void onSendInternal(void *handle, uint8_t addr, const uint8_t *pdata, int size);

    static void onConnectEventInternal(void *handle, uint8_t addr, bool connected);
};

template <int S> class Fd: public IFd
{
public:
    Fd()
        : IFd(m_data, S)
    {
    }

private:
    TINY_ALIGNED_STRUCT uint8_t m_data[S]{};
};

class FdD: public IFd
{
public:
    explicit FdD(int size)
        : IFd(reinterpret_cast<uint8_t *>(new uintptr_t[(size + TINY_ALIGN_STRUCT_VALUE - 1) / TINY_ALIGN_STRUCT_VALUE]), size)
        , m_allocated(reinterpret_cast<uintptr_t *>(m_buffer))
    {
    }

    ~FdD()
    {
        end();
        delete[] m_allocated;
    }

private:
    uintptr_t *m_allocated = nullptr;
};

} // namespace tinyproto