tiny_fd.h

Go to the documentation of this file.

/*
    Copyright 2019-2025 (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

#ifdef __cplusplus
extern "C"
{
#endif

#include <stdint.h>
#include "proto/crc/tiny_crc.h"
#include "hal/tiny_types.h"

    #define TINY_FD_PRIMARY_ADDR (0)

    enum
    {
        TINY_FD_MODE_ABM = 0x00,

        TINY_FD_MODE_NRM = 0x01,

        TINY_FD_MODE_ARM = 0x02,
    };

    struct tiny_fd_data_t;

    typedef struct tiny_fd_data_t *tiny_fd_handle_t;

    typedef enum
    {
        TINY_FD_FRAME_TYPE_I = 0x00, 
        TINY_FD_FRAME_TYPE_S = 0x01, 
        TINY_FD_FRAME_TYPE_U = 0x02, 
    } tiny_fd_frame_type_t;

    typedef enum
    {
        TINY_FD_FRAME_SUBTYPE_RR = 0x00, 
        TINY_FD_FRAME_SUBTYPE_RNR = 0x04, 
        TINY_FD_FRAME_SUBTYPE_REJ = 0x08, 
        TINY_FD_FRAME_SUBTYPE_SREJ = 0x0C, 

        TINY_FD_FRAME_SUBTYPE_UA = 0x60, 
        TINY_FD_FRAME_SUBTYPE_DM = 0x0C, 
        TINY_FD_FRAME_SUBTYPE_FRMR = 0x84, 
        TINY_FD_FRAME_SUBTYPE_RSET = 0x8C, 
        TINY_FD_FRAME_SUBTYPE_SABM = 0x2C, 
        TINY_FD_FRAME_SUBTYPE_SNRM = 0x80, 
        TINY_FD_FRAME_SUBTYPE_DISC = 0x40, 
        TINY_FD_FRAME_SUBTYPE_UI = 0x00, 
    } tiny_fd_frame_subtype_t;

    typedef enum
    {
        TINY_FD_FRAME_DIRECTION_IN = 0x00, 
        TINY_FD_FRAME_DIRECTION_OUT = 0x01, 
    } tiny_fd_frame_direction_t;

    typedef void (*tiny_fd_log_frame_cb_t)(void *udata,
                       tiny_fd_handle_t handle,
                       tiny_fd_frame_direction_t direction,
                       tiny_fd_frame_type_t frame_type,
                       tiny_fd_frame_subtype_t frame_subtype,
                       uint8_t ns,
                       uint8_t nr,
                       const uint8_t *data,
                       int len);
   
    typedef struct tiny_fd_init_t_
    {
        void *pdata;

        on_frame_read_cb_t on_read_cb;

        on_frame_send_cb_t on_send_cb;

        void *buffer;

        uint16_t buffer_size;

        uint16_t send_timeout;

        uint16_t retry_timeout;

        uint8_t retries;

        hdlc_crc_t crc_type;

        uint8_t window_frames;

        int mtu;

        on_connect_event_cb_t on_connect_event_cb;

        tiny_fd_log_frame_cb_t log_frame_cb;

        uint8_t addr;

        uint8_t peers_count;

        uint8_t mode;

        on_frame_read_cb_t on_read_ui_cb;

    } tiny_fd_init_t;

    extern int tiny_fd_init(tiny_fd_handle_t *handle, tiny_fd_init_t *init);

    extern int tiny_fd_get_status(tiny_fd_handle_t handle);

    extern int tiny_fd_disconnect(tiny_fd_handle_t handle);

    extern void tiny_fd_close(tiny_fd_handle_t handle);

    extern int tiny_fd_get_tx_data(tiny_fd_handle_t handle, void *data, int len, uint32_t timeout);

    extern int tiny_fd_run_tx(tiny_fd_handle_t handle, write_block_cb_t write_func);

    extern int tiny_fd_on_rx_data(tiny_fd_handle_t handle, const void *data, int len);

    extern int tiny_fd_run_rx(tiny_fd_handle_t handle, read_block_cb_t read_func);

    extern int tiny_fd_send_packet_to(tiny_fd_handle_t handle, uint8_t address, const void *buf, int len, uint32_t timeout);

    extern int tiny_fd_buffer_size_by_mtu(int mtu, int window);

    extern int tiny_fd_buffer_size_by_mtu_ex(uint8_t peers_count, int mtu, int tx_window, hdlc_crc_t crc_type, int rx_window);

    extern int tiny_fd_get_mtu(tiny_fd_handle_t handle);

    extern int tiny_fd_send_to(tiny_fd_handle_t handle, uint8_t address, const void *buf, int len, uint32_t timeout);

    extern void tiny_fd_set_ka_timeout(tiny_fd_handle_t handle, uint32_t keep_alive);

    extern int tiny_fd_register_peer(tiny_fd_handle_t handle, uint8_t address);

    extern int tiny_fd_send(tiny_fd_handle_t handle, const void *buf, int len, uint32_t timeout);

    extern int tiny_fd_send_packet(tiny_fd_handle_t handle, const void *buf, int len, uint32_t timeout);

    extern int tiny_fd_send_ui_packet_to(tiny_fd_handle_t handle, uint8_t address, const void *buf, int len);

    extern int tiny_fd_send_ui_packet(tiny_fd_handle_t handle, const void *buf, int len);

#ifdef __cplusplus
}
#endif