Andrey Perminov
a8bf0d4d76
Combined BM-Lite SDK and examples for Raspberry Pi and nRF52840 MCU into one project
146 lines
4.8 KiB
C
146 lines
4.8 KiB
C
/*
|
|
* Copyright (c) 2020 Andrey Perminov <andrey.ppp@gmail.com>
|
|
*
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
* you may not use this file except in compliance with the License.
|
|
* You may obtain a copy of the License at
|
|
*
|
|
* https://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*/
|
|
|
|
#ifndef HCP_H
|
|
#define HCP_H
|
|
|
|
#include "fpc_bep_types.h"
|
|
#include "fpc_hcp_common.h"
|
|
|
|
/** MTU for HCP physical layer */
|
|
#define MTU 256
|
|
|
|
/** Communication acknowledge definition */
|
|
#define FPC_BEP_ACK 0x7f01ff7f
|
|
|
|
typedef struct {
|
|
uint32_t size;
|
|
uint8_t *data;
|
|
} HCP_arg_t;
|
|
|
|
typedef struct {
|
|
/** Send data to BM-Lite */
|
|
fpc_bep_result_t (*write) (uint16_t, const uint8_t *, uint32_t, void *);
|
|
/** Receive data from BM-Lite */
|
|
fpc_bep_result_t (*read)(uint16_t, uint8_t *, uint32_t, void *);
|
|
/** Receive timeout (msec). Applys ONLY to receiving packet from BM-Lite on physical layer */
|
|
uint32_t phy_rx_timeout;
|
|
/** Data buffer for application layer */
|
|
uint8_t *pkt_buffer;
|
|
/** Size of data buffer */
|
|
uint32_t pkt_size_max;
|
|
/** Current size of incoming or outcoming command packet */
|
|
uint32_t pkt_size;
|
|
/** Buffer of MTU size for transport layer */
|
|
uint8_t *txrx_buffer;
|
|
/** Values of last argument pulled by bmlite_get_arg
|
|
Values are valid only right after bmlite_get_arg() call */
|
|
HCP_arg_t arg;
|
|
/** Result of execution command on BM-Lite */
|
|
fpc_bep_result_t bep_result;
|
|
} HCP_comm_t;
|
|
|
|
/**
|
|
* @brief Send prepared command packet to FPC BM-LIte
|
|
*
|
|
* @param[in] hcp_comm - pointer to HCP_comm struct
|
|
*
|
|
* @return ::fpc_bep_result_t
|
|
*/
|
|
fpc_bep_result_t bmlite_send(HCP_comm_t *hcp_comm);
|
|
|
|
/**
|
|
* @brief Receive answer from FPC BM-LIte
|
|
*
|
|
* @param[in] hcp_comm - pointer to HCP_comm struct
|
|
*
|
|
* @return ::fpc_bep_result_t
|
|
*/
|
|
fpc_bep_result_t bmlite_receive(HCP_comm_t *hcp_comm);
|
|
|
|
/**
|
|
* @brief Send prepared command packet to FPC BM-LIte and receive answer
|
|
*
|
|
* @param[in] hcp_comm - pointer to HCP_comm struct
|
|
*
|
|
* Returns result of executing command in BM-LIte in hcp_comm->bep_result
|
|
* if communication with BM-Lite was successful.
|
|
* Please not that some BM-Lite command does not return result in ARG_RESULT.
|
|
* They return data with some other argument instead.
|
|
*
|
|
* @return ::fpc_bep_result_t
|
|
*/
|
|
fpc_bep_result_t bmlite_tranceive(HCP_comm_t *hcp_comm);
|
|
|
|
/**
|
|
* @brief Initialize new command for BM-Lite
|
|
*
|
|
* @param[in] hcp_comm - pointer to HCP_comm struct
|
|
* @param[in] cmd - command to send
|
|
* @param[in] arg - Argument for the command without parameterd
|
|
* Use ARG_NONE and add arguments by bmlite_add_arg() if
|
|
* you need to add argument with parameter
|
|
*
|
|
* @return ::fpc_bep_result_t
|
|
*/
|
|
fpc_bep_result_t bmlite_init_cmd(HCP_comm_t *hcp_comm, uint16_t cmd, uint16_t arg);
|
|
|
|
/**
|
|
* @brief Add argument to command.
|
|
* Must be used only after command buffer is initialized by bmlite_init_cmd()
|
|
*
|
|
* @param[in] hcp_comm - pointer to HCP_comm struct
|
|
* @param[in] arg_type - argument key
|
|
* @param[in] arg_data - argument data
|
|
* @param[in] arg_size - argument data length
|
|
*
|
|
* @return ::fpc_bep_result_t
|
|
*/
|
|
fpc_bep_result_t bmlite_add_arg(HCP_comm_t *hcp_comm, uint16_t arg_type, void *arg_data, uint16_t arg_size);
|
|
|
|
/**
|
|
* @brief Search for argument in received answer.
|
|
*
|
|
* @param[in] hcp_comm - pointer to HCP_comm struct
|
|
* @param[in] arg_type - argument key
|
|
*
|
|
* If found, place pointer to argument data in receiving buffer to hcp_comm->arg.data
|
|
* and size of the argument in hcp_comm->arg.size
|
|
*
|
|
* @return ::fpc_bep_result_t
|
|
*/
|
|
fpc_bep_result_t bmlite_get_arg(HCP_comm_t *hcp_comm, uint16_t arg_type);
|
|
|
|
/**
|
|
* @brief Search for argument in received answer and copy argument's data
|
|
* to arg_data
|
|
*
|
|
* @param[in] hcp_comm - pointer to HCP_comm struct
|
|
* @param[in] arg_type - argument key
|
|
* @param[out] arg_data - pointer for memory to copy argument value
|
|
* @param[out] arg_data_size - size of data area for copying argument value
|
|
*
|
|
* If found, argument's data will be copyed to arg_data
|
|
* If received argument's size greater that arg_data_size, the copyed data will be
|
|
* truncated to arg_data_size.
|
|
* Still hcp_comm->arg.data will be pointed to argument's data in receiving buffer
|
|
* and real size of the argument will be hcp_comm->arg.size
|
|
*
|
|
* @return ::fpc_bep_result_t
|
|
*/
|
|
fpc_bep_result_t bmlite_copy_arg(HCP_comm_t *hcp_comm, uint16_t arg_key, void *arg_data, uint16_t arg_data_size);
|
|
|
|
#endif |