TinyProtocolHdlc.h

Go to the documentation of this file.

/*
    Copyright 2020,2022 (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/hdlc/high_level/hdlc.h"

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

namespace tinyproto
{

class Hdlc
{
public:
    Hdlc(void *buffer, int bufferSize)
        : m_buffer(buffer)
        , m_bufferSize(bufferSize)
    {
    }

    virtual ~Hdlc() = default;

    void begin(write_block_cb_t writecb, read_block_cb_t readcb);

    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_tx(void *data, int max_len);

    void disableCrc();

    void enableCrc(hdlc_crc_t crc);

    bool enableCheckSum();

    bool enableCrc16();

    bool enableCrc32();

    void setReceiveCallback(void (*on_receive)(IPacket &pkt) = nullptr)
    {
        m_onReceive = on_receive;
    };

    void setSendCallback(void (*on_send)(IPacket &pkt) = nullptr)
    {
        m_onSend = on_send;
    };

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

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

private:
    hdlc_handle_t m_handle = nullptr;

    hdlc_struct_t m_data{};

    void *m_buffer = nullptr;

    int m_bufferSize = 0;

    hdlc_crc_t m_crc = HDLC_CRC_DEFAULT;

    void (*m_onReceive)(IPacket &pkt) = nullptr;

    void (*m_onSend)(IPacket &pkt) = nullptr;

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

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

} // namespace tinyproto