486 lines
15 KiB
C
486 lines
15 KiB
C
/**
|
|
****************************************************************************************
|
|
*
|
|
* @file prf_otas.c
|
|
*
|
|
* @brief OTA Service - Server Role Implementation.
|
|
*
|
|
* < If want to modify it, recommend to copy the file to 'user porject'/src >
|
|
****************************************************************************************
|
|
*/
|
|
|
|
#if (PRF_OTAS)
|
|
|
|
/*
|
|
* INCLUDE FILES
|
|
****************************************************************************************
|
|
*/
|
|
|
|
#include "prf.h"
|
|
#include "prf_otas.h"
|
|
|
|
#if (DBG_OTAS)
|
|
#include "dbg.h"
|
|
#define DEBUG(format, ...) debug("<%s,%d>" format "\r\n", __MODULE__, __LINE__, ##__VA_ARGS__)
|
|
#else
|
|
#define DEBUG(format, ...)
|
|
#define debugHex(dat, len)
|
|
#endif
|
|
|
|
|
|
/*
|
|
* DEFINITIONS
|
|
****************************************************************************************
|
|
*/
|
|
|
|
/// Max length of received once
|
|
#if !defined(OTA_RXD_MAX_LEN)
|
|
#define OTA_RXD_MAX_LEN (20)
|
|
#endif
|
|
|
|
/// Max number of notify/indicate pkt
|
|
#if !defined(OTA_NB_PKT_MAX)
|
|
#define OTA_NB_PKT_MAX (5)
|
|
#endif
|
|
|
|
/// Version String for OTA_IDX_READ_VAL Read
|
|
#define OTA_VERS_STR ("bleOTA v1.0")
|
|
#define OTA_VERS_STR_LEN (sizeof(OTA_VERS_STR) - 1)
|
|
|
|
/// Macro for Client Config value operation
|
|
#define OTA_NTF_CFG_GET(conidx) \
|
|
((otas_env.ntf_bits >> (conidx*2)) & (PRF_CLI_START_NTF | PRF_CLI_START_IND))
|
|
|
|
#define OTA_NTF_CFG_CLR(conidx) \
|
|
otas_env.ntf_bits &= ~((PRF_CLI_START_NTF | PRF_CLI_START_IND) << (conidx*2))
|
|
|
|
#define OTA_NTF_CFG_SET(conidx, conf) \
|
|
otas_env.ntf_bits = (otas_env.ntf_bits & ~((PRF_CLI_START_NTF | PRF_CLI_START_IND) << (conidx*2))) | ((conf) << (conidx*2))
|
|
|
|
|
|
/**
|
|
****************************************************************************************
|
|
* @section ENVIRONMENT DEFINITION
|
|
****************************************************************************************
|
|
*/
|
|
|
|
/// Server Environment Variable
|
|
typedef struct otas_env_tag
|
|
{
|
|
// Service Start Handle
|
|
uint16_t start_hdl;
|
|
// Client Config of peer devices - each 2Bits(NTF & IND), so max_peer=8.
|
|
uint16_t ntf_bits;
|
|
// Number of notify pkt
|
|
uint8_t nb_pkt;
|
|
} otas_env_t;
|
|
|
|
/// Global Variable Declarations
|
|
otas_env_t otas_env;
|
|
|
|
|
|
/**
|
|
****************************************************************************************
|
|
* @section ATTRIBUTES DEFINITION
|
|
****************************************************************************************
|
|
*/
|
|
|
|
/// Attributes Index
|
|
enum ota_att_idx
|
|
{
|
|
// Service Declaration, *MUST* Start at 0
|
|
OTA_IDX_SVC,
|
|
|
|
// Serial TXD Char.
|
|
OTA_IDX_TXD_CHAR,
|
|
OTA_IDX_TXD_VAL,
|
|
OTA_IDX_TXD_NTF_CFG,
|
|
|
|
// Serial RXD Char.
|
|
OTA_IDX_RXD_CHAR,
|
|
OTA_IDX_RXD_VAL, //5
|
|
|
|
#if (OTA_READ_SUP)
|
|
// Serial READ Char.
|
|
OTA_IDX_READ_CHAR,
|
|
OTA_IDX_READ_VAL,
|
|
#endif
|
|
|
|
// Max Index, *NOTE* Minus 1(Svc Decl) is .nb_att
|
|
OTA_IDX_NB,
|
|
};
|
|
|
|
#if (OTA_UUID_128)
|
|
/// Characteristic Base UUID128 (User Customize)
|
|
#define OTA_ATT_UUID128(uuid) { 0xFC, 0x12, 0x41, 0x2A, 0xD2, 0xDE, 0x7E, 0x1D, \
|
|
0x4D, 0x47, 0xA2, 0x09, (uuid) & 0xFF, (uuid >> 8) & 0xFF, 0x00, 0x00 }
|
|
|
|
/// Serial Service UUID128
|
|
const uint8_t ota_svc_uuid[] = OTA_ATT_UUID128(0xFF50);
|
|
/// Serial Notify UUID128
|
|
const uint8_t ota_char_txd_notify[] = OTA_ATT_UUID128(0xFF51);
|
|
/// Serial Write Command UUID128
|
|
const uint8_t ota_char_rxd_write[] = OTA_ATT_UUID128(0xFF52);
|
|
/// Serial Read Command UUID128
|
|
const uint8_t ota_char_val_read[] = OTA_ATT_UUID128(0xFF53);
|
|
|
|
/// Attributes Description
|
|
const att_decl_t ota_atts[] =
|
|
{
|
|
// Serial Notify Char. Declaration and Value and Client Char. Configuration Descriptor
|
|
ATT_ELMT_DECL_CHAR( OTA_IDX_TXD_CHAR ),
|
|
ATT_ELMT128( OTA_IDX_TXD_VAL, ota_char_txd_notify, PROP_NTF | PROP_IND, 0 ),
|
|
ATT_ELMT_DESC_CLI_CHAR_CFG( OTA_IDX_TXD_NTF_CFG ),
|
|
|
|
// Serial Write Command Char. Declaration and Value
|
|
ATT_ELMT_DECL_CHAR( OTA_IDX_RXD_CHAR ),
|
|
ATT_ELMT128( OTA_IDX_RXD_VAL, ota_char_rxd_write, PROP_WC | PROP_WR, OTA_RXD_MAX_LEN ),
|
|
|
|
#if (OTA_READ_SUP)
|
|
// Serial Read Command Char. Declaration and Value
|
|
ATT_ELMT_DECL_CHAR( OTA_IDX_READ_CHAR ),
|
|
ATT_ELMT128( OTA_IDX_READ_VAL, ota_char_val_read, PROP_RD, 0 ),
|
|
#endif //(OTA_READ_SUP)
|
|
};
|
|
|
|
/// Service Description
|
|
const struct svc_decl ota_svc_db =
|
|
{
|
|
.uuid128 = ota_svc_uuid,
|
|
.info = SVC_UUID(128),
|
|
.atts = ota_atts,
|
|
.nb_att = OTA_IDX_NB - 1,
|
|
};
|
|
|
|
#else //(OTAS_UUID16)
|
|
|
|
/// Serial Service UUID
|
|
#define OTA_SVC_UUID ATT_UUID16(0xFF50)
|
|
/// Serial Notify UUID
|
|
#define OTA_CHAR_TXD_NOTIFY ATT_UUID16(0xFF51)
|
|
/// Serial Write Command UUID
|
|
#define OTA_CHAR_RXD_WRITE ATT_UUID16(0xFF52)
|
|
/// Serial Read Command UUID
|
|
#define OTA_CHAR_VAL_READ ATT_UUID16(0xFF53)
|
|
|
|
/// Attributes Description
|
|
const att_decl_t ota_atts[] =
|
|
{
|
|
// Serial Notify Char. Declaration and Value and CCC Descriptor
|
|
ATT_ELMT_DECL_CHAR( OTA_IDX_TXD_CHAR ),
|
|
ATT_ELMT( OTA_IDX_TXD_VAL, OTA_CHAR_TXD_NOTIFY, PROP_NTF | PROP_IND, 0 ),
|
|
ATT_ELMT_DESC_CLI_CHAR_CFG( OTA_IDX_TXD_NTF_CFG ),
|
|
|
|
// Serial Write Command Char. Declaration and Value
|
|
ATT_ELMT_DECL_CHAR( OTA_IDX_RXD_CHAR ),
|
|
ATT_ELMT( OTA_IDX_RXD_VAL, OTA_CHAR_RXD_WRITE, PROP_WC | PROP_WR, OTA_RXD_MAX_LEN ),
|
|
|
|
#if (OTA_READ_SUP)
|
|
// Serial Read Command Char. Declaration and Value
|
|
ATT_ELMT_DECL_CHAR( OTA_IDX_READ_CHAR ),
|
|
ATT_ELMT( OTA_IDX_READ_VAL, OTA_CHAR_VAL_READ, PROP_RD, 0 ),
|
|
#endif //(OTA_READ_SUP)
|
|
};
|
|
|
|
/// Service Description
|
|
const struct svc_decl ota_svc_db =
|
|
{
|
|
.uuid = OTA_SVC_UUID,
|
|
.info = SVC_UUID(16),
|
|
.atts = ota_atts,
|
|
.nb_att = OTA_IDX_NB - 1,
|
|
};
|
|
#endif
|
|
|
|
|
|
/*
|
|
* FUNCTION DECLARATIONS
|
|
****************************************************************************************
|
|
*/
|
|
|
|
/**
|
|
****************************************************************************************
|
|
* @section SVC FUNCTIONS
|
|
****************************************************************************************
|
|
*/
|
|
|
|
/// Retrieve attribute handle from index (@see ota_att_idx)
|
|
static uint16_t otas_get_att_handle(uint8_t att_idx)
|
|
{
|
|
ASSERT_ERR(att_idx < OTA_IDX_NB);
|
|
|
|
return att_idx + otas_env.start_hdl;
|
|
}
|
|
|
|
/// Retrieve attribute index form handle
|
|
static uint8_t otas_get_att_idx(uint16_t handle)
|
|
{
|
|
ASSERT_ERR((handle >= otas_env.start_hdl) && (handle < otas_env.start_hdl + OTA_IDX_NB));
|
|
|
|
return handle - otas_env.start_hdl;
|
|
}
|
|
|
|
/// Handles reception of the atts request from peer device
|
|
static void otas_svc_func(uint8_t conidx, uint8_t opcode, uint16_t handle, const void *param)
|
|
{
|
|
uint8_t att_idx = otas_get_att_idx(handle);
|
|
|
|
DEBUG("svc_func(cid:%d,op:0x%x,hdl:0x%x,att:%d)", conidx, opcode, handle, att_idx);
|
|
|
|
switch (opcode)
|
|
{
|
|
case ATTS_READ_REQ:
|
|
{
|
|
if (att_idx == OTA_IDX_TXD_NTF_CFG)
|
|
{
|
|
// retrieve notification config
|
|
uint16_t cli_cfg = OTA_NTF_CFG_GET(conidx);
|
|
|
|
DEBUG(" read_cfm(txd_ntf:%d)", cli_cfg);
|
|
gatt_read_cfm(conidx, LE_SUCCESS, handle, sizeof(uint16_t), (uint8_t *)&cli_cfg);
|
|
break;
|
|
}
|
|
|
|
#if (OTA_READ_SUP)
|
|
if (att_idx == OTA_IDX_READ_VAL)
|
|
{
|
|
otas_cb_rdv(conidx, att_idx, handle);
|
|
break;
|
|
}
|
|
#endif //(OTA_READ_SUP)
|
|
|
|
// Send error response
|
|
gatt_read_cfm(conidx, PRF_ERR_APP_ERROR, handle, 0, NULL);
|
|
} break;
|
|
|
|
case ATTS_WRITE_REQ:
|
|
{
|
|
const struct atts_write_ind *ind = param;
|
|
|
|
DEBUG(" write_req(hdl:0x%x,att:%d,wr:0x%x,len:%d)", handle, att_idx, ind->wrcode, ind->length);
|
|
|
|
if (att_idx == OTA_IDX_RXD_VAL)
|
|
{
|
|
// Send write conform first!
|
|
if (!ind->more) gatt_write_cfm(conidx, LE_SUCCESS, handle);
|
|
|
|
// Next to process data received
|
|
otas_cb_rxd(conidx, ind->length, ind->value);
|
|
break;
|
|
}
|
|
|
|
if (att_idx == OTA_IDX_TXD_NTF_CFG)
|
|
{
|
|
if ((!ind->more) && (ind->length == sizeof(uint16_t)))
|
|
{
|
|
uint16_t cli_cfg = read16p(ind->value);
|
|
|
|
// update configuration if value for stop or NTF/IND start
|
|
if (cli_cfg <= PRF_CLI_START_IND)
|
|
{
|
|
DEBUG(" set txd_ntf(cid:%d,cfg:%d)", conidx, cli_cfg);
|
|
|
|
OTA_NTF_CFG_SET(conidx, cli_cfg);
|
|
// Send write conform quickly!
|
|
gatt_write_cfm(conidx, LE_SUCCESS, handle);
|
|
|
|
#if (OTA_CLI_CFG)
|
|
// Next to process cli_cfg changed
|
|
otas_cb_ccc(conidx, cli_cfg);
|
|
#endif //(OTA_CLI_CFG)
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
// Send write conform with error!
|
|
gatt_write_cfm(conidx, PRF_ERR_APP_ERROR, handle);
|
|
} break;
|
|
|
|
case ATTS_INFO_REQ:
|
|
{
|
|
uint8_t status = LE_SUCCESS;
|
|
uint16_t length = 0;
|
|
|
|
if (att_idx == OTA_IDX_RXD_VAL)
|
|
{
|
|
length = OTA_RXD_MAX_LEN; // accepted length
|
|
}
|
|
else if (att_idx == OTA_IDX_TXD_NTF_CFG)
|
|
{
|
|
length = sizeof(uint16_t); // CCC attribute
|
|
}
|
|
else
|
|
{
|
|
status = ATT_ERR_WRITE_NOT_PERMITTED;
|
|
}
|
|
|
|
// Send length-info confirm for prepWR judging.
|
|
DEBUG(" info_cfm(hdl:0x%x,att:%d,sta:0x%X,len:%d)", handle, att_idx, status, length);
|
|
gatt_info_cfm(conidx, status, handle, length);
|
|
} break;
|
|
|
|
case ATTS_CMP_EVT:
|
|
{
|
|
const struct atts_cmp_evt *evt = param;
|
|
|
|
otas_env.nb_pkt++; // release
|
|
|
|
DEBUG(" cmp_evt(op:0x%x,sta:0x%x,nb:%d)", evt->operation, evt->status, otas_env.nb_pkt);
|
|
// add 'if' to avoid warning #117-D: "evt" never referenced
|
|
if (evt->operation == GATT_NOTIFY)
|
|
{
|
|
// Notify result
|
|
}
|
|
} break;
|
|
|
|
default:
|
|
{
|
|
// nothing to do
|
|
} break;
|
|
}
|
|
}
|
|
|
|
|
|
/**
|
|
****************************************************************************************
|
|
* @section API FUNCTIONS
|
|
****************************************************************************************
|
|
*/
|
|
|
|
/**
|
|
****************************************************************************************
|
|
* @brief Add Serial Service Profile in the DB.
|
|
* Customize via pre-define @see OTA_START_HDL
|
|
*
|
|
* @return Result status, LE_SUCCESS or Error Reason
|
|
****************************************************************************************
|
|
*/
|
|
uint8_t otas_svc_init(void)
|
|
{
|
|
uint8_t status = LE_SUCCESS;
|
|
|
|
// Init Environment
|
|
otas_env.start_hdl = OTA_START_HDL;
|
|
otas_env.nb_pkt = OTA_NB_PKT_MAX;
|
|
otas_env.ntf_bits = 0;
|
|
|
|
// Create Service in database
|
|
status = attmdb_svc_create(&otas_env.start_hdl, NULL, &ota_svc_db, otas_svc_func);
|
|
|
|
DEBUG("svc_init(sta:0x%X,shdl:%d,nb_pkt:%d,ntf_bits:0x%X)",
|
|
status, otas_env.start_hdl, otas_env.nb_pkt, otas_env.ntf_bits);
|
|
|
|
return status;
|
|
}
|
|
|
|
/**
|
|
****************************************************************************************
|
|
* @brief Enable setting client configuration characteristics
|
|
*
|
|
* @param[in] conidx Connection index
|
|
* @param[in] cli_cfg Client configuration @see prf_cli_conf
|
|
****************************************************************************************
|
|
*/
|
|
void otas_set_ccc(uint8_t conidx, uint8_t cli_cfg)
|
|
{
|
|
//if (gapc_get_conhdl(conidx) != GAP_INVALID_CONHDL)
|
|
{
|
|
// update configuration
|
|
OTA_NTF_CFG_SET(conidx, cli_cfg);
|
|
}
|
|
}
|
|
|
|
/**
|
|
****************************************************************************************
|
|
* @brief Transmit data to peer device via NTF or IND
|
|
*
|
|
* @param[in] conidx peer device connection index
|
|
* @param[in] len Length of data
|
|
* @param[in] data pointer of buffer
|
|
*
|
|
* @return Status of the operation @see prf_err
|
|
****************************************************************************************
|
|
*/
|
|
uint8_t otas_txd_send(uint8_t conidx, uint16_t len, const uint8_t* data)
|
|
{
|
|
uint8_t status = PRF_ERR_REQ_DISALLOWED;
|
|
|
|
if ((len > 0) && (otas_env.nb_pkt > 0))
|
|
{
|
|
uint8_t ntf_cfg = OTA_NTF_CFG_GET(conidx);
|
|
|
|
if (ntf_cfg != PRF_CLI_STOP_NTFIND)
|
|
{
|
|
status = LE_SUCCESS;
|
|
gatt_ntf_send(conidx, otas_get_att_handle(OTA_IDX_TXD_VAL), len, data);
|
|
|
|
otas_env.nb_pkt--; // allocate
|
|
DEBUG("txd_send(len:%d,nb:%d)", len, otas_env.nb_pkt);
|
|
}
|
|
else
|
|
{
|
|
status = PRF_ERR_NTF_DISABLED;
|
|
}
|
|
}
|
|
|
|
return status;
|
|
}
|
|
|
|
/**
|
|
****************************************************************************************
|
|
* @brief Callback on received data from peer device via WC or WQ (__weak func)
|
|
*
|
|
* @param[in] conidx peer device connection index
|
|
* @param[in] len Length of data
|
|
* @param[in] data pointer of buffer
|
|
****************************************************************************************
|
|
*/
|
|
__weak void otas_cb_rxd(uint8_t conidx, uint16_t len, const uint8_t *data)
|
|
{
|
|
debugHex(data, len);
|
|
|
|
// Loopback to txd, just test.
|
|
//otas_txd_send(conidx, len, data);
|
|
}
|
|
|
|
#if (OTA_READ_SUP)
|
|
/**
|
|
****************************************************************************************
|
|
* @brief Callback to response 'READ' from peer device (__weak func)
|
|
*
|
|
* @param[in] conidx peer device connection index
|
|
* @param[in] attidx SESS attribute index, converted with 'handle'
|
|
* @param[in] handle SESS attribute handle to send read cfm
|
|
*
|
|
* @return Length of value been READ
|
|
****************************************************************************************
|
|
*/
|
|
__weak void otas_cb_rdv(uint8_t conidx, uint8_t attidx, uint16_t handle)
|
|
{
|
|
uint16_t length = OTA_VERS_STR_LEN;
|
|
const uint8_t *p_data = (const uint8_t *)OTA_VERS_STR;
|
|
|
|
DEBUG(" read_cfm(att:%d, len:%d)", attidx, length);
|
|
gatt_read_cfm(conidx, LE_SUCCESS, handle, length, p_data);
|
|
}
|
|
#endif //(OTA_READ_SUP)
|
|
|
|
#if (OTA_CLI_CFG)
|
|
/**
|
|
****************************************************************************************
|
|
* @brief Callback on enabled client config from peer device via WQ (__weak func)
|
|
*
|
|
* @param[in] conidx Connection index
|
|
* @param[in] cli_cfg Client configuration @see prf_cli_conf
|
|
****************************************************************************************
|
|
*/
|
|
__weak void otas_cb_ccc(uint8_t conidx, uint8_t cli_cfg)
|
|
{
|
|
// user override
|
|
}
|
|
#endif //(OTA_CLI_CFG)
|
|
|
|
|
|
#endif //PRF_OTAS
|