vance/vos
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

initial commit

Browse Source
This commit is contained in:
vance
2022-10-23 23:45:43 -07:00
commit e190fa5193
6450 changed files with 8626944 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files
ambiq-hal-sys/ambiq-sparkfun-sdk/third_party/exactle/ble-profiles/sources/apps/cycling/cycling_api.h
Vendored
+73
View File
@@ -0,0 +1,73 @@
/*************************************************************************************************/
/*!
* \file
*
* \brief Cycling server sample application.
*
* Copyright (c) 2016-2019 Arm Ltd.
*
* Copyright (c) 2019 Packetcraft, Inc.
*
* 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
*
* http://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 CYCLING_API_H
#define CYCLING_API_H
#include "wsf_os.h"
#ifdef __cplusplus
extern "C" {
#endif
/**************************************************************************************************
Function Declarations
**************************************************************************************************/
/*************************************************************************************************/
/*!
* \brief Start the application.
*
* \return None.
*/
/*************************************************************************************************/
void CyclingStart(void);
/*************************************************************************************************/
/*!
* \brief Application handler init function called during system initialization.
*
* \param handlerID WSF handler ID for App.
*
* \return None.
*/
/*************************************************************************************************/
void CyclingHandlerInit(wsfHandlerId_t handlerId);
/*************************************************************************************************/
/*!
* \brief WSF event handler for the application.
*
* \param event WSF event mask.
* \param pMsg WSF message.
*
* \return None.
*/
/*************************************************************************************************/
void CyclingHandler(wsfEventMask_t event, wsfMsgHdr_t *pMsg);
#ifdef __cplusplus
};
#endif
#endif /* CYCLING_API_H */
ambiq-hal-sys/ambiq-sparkfun-sdk/third_party/exactle/ble-profiles/sources/apps/cycling/cycling_main.c
Vendored
+777
View File
@@ -0,0 +1,777 @@
/*************************************************************************************************/
/*!
* \file
*
* \brief Cycling server sample application.
*
* Copyright (c) 2016-2019 Arm Ltd.
*
* Copyright (c) 2019 Packetcraft, Inc.
*
* 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
*
* http://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.
*/
/*************************************************************************************************/
#include <string.h>
#include "wsf_types.h"
#include "util/bstream.h"
#include "wsf_msg.h"
#include "wsf_trace.h"
#include "wsf_buf.h"
#include "hci_api.h"
#include "dm_api.h"
#include "att_api.h"
#include "app_api.h"
#include "app_main.h"
#include "app_db.h"
#include "app_ui.h"
#include "svc_ch.h"
#include "svc_core.h"
#include "svc_cps.h"
#include "svc_cscs.h"
#include "svc_batt.h"
#include "bas/bas_api.h"
#include "cpp/cpp_api.h"
#include "cscp/cscp_api.h"
#include "gatt/gatt_api.h"
#include "util/calc128.h"
/**************************************************************************************************
Macros
**************************************************************************************************/
/*! Enumeration of client characteristic configuration descriptors */
enum
{
CYCLING_GATT_SC_CCC_IDX, /*! GATT service, service changed characteristic */
CYCLING_CPS_CPM_CCC_IDX, /*! Cycling Power Measurement, service changed characteristic */
CYCLING_CSCS_CSM_CCC_IDX, /*! Cycling Speed Measurement, service changed characteristic */
CYCLING_BATT_LVL_CCC_IDX, /*! Battery service, battery level characteristic */
CYCLING_NUM_CCC_IDX
};
/*! WSF message event starting value */
#define CYCLING_MSG_START 0xA0
/*! WSF message event enumeration */
enum
{
CYCLING_CPP_PM_TIMER_IND = CYCLING_MSG_START, /*! Cycling power measurement timer expired */
CYCLING_CSCP_SM_TIMER_IND, /*! Cycling speed measurement timer expired */
CYCLING_BATT_TIMER_IND /*! Battery measurement timer expired */
};
/* Default Cycling Power Measurement period (seconds) */
#define CYCLING_DEFAULT_CPM_PERIOD 1
/* Default Cycling Speed Measurement period (seconds) */
#define CYCLING_DEFAULT_CSM_PERIOD 1
/* Default MTU */
#define CYCLING_DEFAULT_MTU 50
/**************************************************************************************************
Configurable Parameters
**************************************************************************************************/
/*! configurable parameters for advertising */
static const appAdvCfg_t cyclingAdvCfg =
{
{30000, 0, 0}, /*! Advertising durations in ms */
{ 96, 1600, 0} /*! Advertising intervals in 0.625 ms units */
};
/*! configurable parameters for slave */
static const appSlaveCfg_t cyclingSlaveCfg =
{
1, /*! Maximum connections */
};
/*! configurable parameters for security */
static const appSecCfg_t cyclingSecCfg =
{
DM_AUTH_BOND_FLAG | SMP_AUTH_SC_FLAG, /*! Authentication and bonding flags */
DM_KEY_DIST_IRK, /*! Initiator key distribution flags */
DM_KEY_DIST_LTK | DM_KEY_DIST_IRK, /*! Responder key distribution flags */
FALSE, /*! TRUE if Out-of-band pairing data is present */
TRUE /*! TRUE to initiate security upon connection */
};
/*! configurable parameters for connection parameter update */
static const appUpdateCfg_t cyclingUpdateCfg =
{
0, /*! Connection idle period in ms before attempting
connection parameter update; set to zero to disable */
640, /*! Minimum connection interval in 1.25ms units */
800, /*! Maximum connection interval in 1.25ms units */
3, /*! Connection latency */
600, /*! Supervision timeout in 10ms units */
5 /*! Number of update attempts before giving up */
};
/*! ATT configurable parameters (increase MTU) */
static const attCfg_t cyclingAttCfg =
{
15, /* ATT server service discovery connection idle timeout in seconds */
CYCLING_DEFAULT_MTU, /* desired ATT MTU */
ATT_MAX_TRANS_TIMEOUT, /* transcation timeout in seconds */
4 /* number of queued prepare writes supported by server */
};
/*! local IRK */
static uint8_t localIrk[] =
{
0x95, 0xC8, 0xEE, 0x6F, 0xC5, 0x0D, 0xEF, 0x93, 0x35, 0x4E, 0x7C, 0x57, 0x08, 0xE2, 0xA3, 0x85
};
/**************************************************************************************************
Advertising Data
**************************************************************************************************/
/*! advertising data, discoverable mode */
static const uint8_t cyclingAdvDataDisc[] =
{
/*! flags */
2, /*! length */
DM_ADV_TYPE_FLAGS, /*! AD type */
DM_FLAG_LE_GENERAL_DISC | /*! flags */
DM_FLAG_LE_BREDR_NOT_SUP,
/*! manufacturer specific data */
3, /*! length */
DM_ADV_TYPE_MANUFACTURER, /*! AD type */
UINT16_TO_BYTES(HCI_ID_ARM), /*! company ID */
/*! service UUID list */
9, /*! length */
DM_ADV_TYPE_16_UUID, /*! AD type */
UINT16_TO_BYTES(ATT_UUID_CYCLING_POWER_SERVICE),
UINT16_TO_BYTES(ATT_UUID_CYCLING_SPEED_SERVICE),
UINT16_TO_BYTES(ATT_UUID_DEVICE_INFO_SERVICE),
UINT16_TO_BYTES(ATT_UUID_BATTERY_SERVICE)
};
/*! scan data, discoverable mode */
static const uint8_t cyclingScanDataDisc[] =
{
/*! device name */
8, /*! length */
DM_ADV_TYPE_LOCAL_NAME, /*! AD type */
'C',
'y',
'c',
'l',
'i',
'n',
'g'
};
/**************************************************************************************************
Client Characteristic Configuration Descriptors
**************************************************************************************************/
/*! client characteristic configuration descriptors settings, indexed by above enumeration */
static const attsCccSet_t cyclingCccSet[CYCLING_NUM_CCC_IDX] =
{
/* cccd handle value range security level */
{ GATT_SC_CH_CCC_HDL, ATT_CLIENT_CFG_INDICATE, DM_SEC_LEVEL_NONE }, /* CYCLING_GATT_SC_CCC_IDX */
{ CPS_CPM_CH_CCC_HDL, ATT_CLIENT_CFG_NOTIFY, DM_SEC_LEVEL_NONE }, /* CYCLING_CPS_CPM_CCC_IDX */
{ CSCS_CSM_CH_CCC_HDL, ATT_CLIENT_CFG_NOTIFY, DM_SEC_LEVEL_NONE }, /* CYCLING_CSCS_CSM_CCC_IDX */
{ BATT_LVL_CH_CCC_HDL, ATT_CLIENT_CFG_NOTIFY, DM_SEC_LEVEL_NONE } /* CYCLING_BATT_LVL_CCC_IDX */
};
/**************************************************************************************************
Local Variables
**************************************************************************************************/
/*! application control block */
static struct
{
wsfHandlerId_t handlerId; /* WSF handler ID */
wsfTimer_t cpmTimer; /* WSF Timer to send cycling power measurement data */
wsfTimer_t csmTimer; /* WSF Timer to send cycling speed measurement data */
} cyclingCb;
/* Cycling Power Measurement period - Can be changed at runtime to vary period */
static uint16_t cyclingCpmPeriod = CYCLING_DEFAULT_CPM_PERIOD;
/* Cycling Speed Measurement period - Can be changed at runtime to vary period */
static uint16_t cyclingCsmPeriod = CYCLING_DEFAULT_CSM_PERIOD;
/*************************************************************************************************/
/*!
* \brief Application DM callback.
*
* \param pDmEvt DM callback event
*
* \return None.
*/
/*************************************************************************************************/
static void cyclingDmCback(dmEvt_t *pDmEvt)
{
dmEvt_t *pMsg;
if (pDmEvt->hdr.event == DM_SEC_ECC_KEY_IND)
{
DmSecSetEccKey(&pDmEvt->eccMsg.data.key);
}
else
{
uint16_t len = DmSizeOfEvt(pDmEvt);
if ((pMsg = WsfMsgAlloc(len)) != NULL)
{
memcpy(pMsg, pDmEvt, len);
WsfMsgSend(cyclingCb.handlerId, pMsg);
}
}
}
/*************************************************************************************************/
/*!
* \brief Application ATT callback.
*
* \param pEvt ATT callback event
*
* \return None.
*/
/*************************************************************************************************/
static void cyclingAttCback(attEvt_t *pEvt)
{
attEvt_t *pMsg;
if ((pMsg = WsfMsgAlloc(sizeof(attEvt_t) + pEvt->valueLen)) != NULL)
{
memcpy(pMsg, pEvt, sizeof(attEvt_t));
pMsg->pValue = (uint8_t *)(pMsg + 1);
memcpy(pMsg->pValue, pEvt->pValue, pEvt->valueLen);
WsfMsgSend(cyclingCb.handlerId, pMsg);
}
}
/*************************************************************************************************/
/*!
* \brief Send a Cycling Speed Measurement Notification.
*
* \param connId connection ID
*
* \return None.
*/
/*************************************************************************************************/
static void cyclingSendCyclingSpeedMeasurement(dmConnId_t connId)
{
static uint32_t revolutions = 1;
static uint32_t lastTime = 1;
if (AttsCccEnabled(connId, CYCLING_CSCS_CSM_CCC_IDX))
{
/* TODO: Set Cycle Speed Measurement Parameters */
revolutions++;
lastTime += 100;
CscpsSetParameter(CSCP_SM_PARAM_WHEEL_REVOLUTIONS, revolutions);
CscpsSetParameter(CSCP_SM_PARAM_LAST_WHEEL_EVT_TIME, lastTime);
CscpsSetParameter(CSCP_SM_PARAM_CRANK_REVOLUTIONS, revolutions);
CscpsSetParameter(CSCP_SM_PARAM_LAST_CRANK_TIME, lastTime);
CscpsSendSpeedMeasurement(connId);
}
/* Configure and start timer to send the next measurement */
cyclingCb.csmTimer.msg.event = CYCLING_CSCP_SM_TIMER_IND;
cyclingCb.csmTimer.msg.status = CYCLING_CSCS_CSM_CCC_IDX;
cyclingCb.csmTimer.handlerId = cyclingCb.handlerId;
cyclingCb.csmTimer.msg.param = connId;
WsfTimerStartSec(&cyclingCb.csmTimer, cyclingCsmPeriod);
}
/*************************************************************************************************/
/*!
* \brief Send a Cycling Power Measurement Notification.
*
* \param connId connection ID
*
* \return None.
*/
/*************************************************************************************************/
static void cyclingSendCyclingPowerMeasurement(dmConnId_t connId)
{
static uint32_t revolutions = 1;
static uint32_t lastTime = 1;
if (AttsCccEnabled(connId, CYCLING_CPS_CPM_CCC_IDX))
{
/* TODO: Set Cycle Power Measurement Parameters */
revolutions++;
lastTime += 100;
CppsSetParameter(CPP_PM_PARAM_INSTANTANEOUS_POWER, 1);
CppsSetParameter(CPP_PM_PARAM_PEDAL_POWER, 2);
CppsSetParameter(CPP_PM_PARAM_ACCUMULATED_TORQUE, 4);
CppsSetParameter(CPP_PM_PARAM_WHEEL_REVOLUTIONS, revolutions);
CppsSetParameter(CPP_PM_PARAM_LAST_WHEEL_REV_TIME, lastTime);
CppsSetParameter(CPP_PM_PARAM_CRANK_REVOLUTIONS, revolutions);
CppsSetParameter(CPP_PM_PARAM_LAST_CRANK_TIME, lastTime);
CppsSetParameter(CPP_PM_PARAM_MAX_FORCE_MAGNITUDE, 9);
CppsSetParameter(CPP_PM_PARAM_MIN_FORCE_MAGNITUDE, 10);
CppsSetParameter(CPP_PM_PARAM_MAX_TORQUE_MAGNITUDE, 11);
CppsSetParameter(CPP_PM_PARAM_MIN_TORQUE_MAGNITUDE, 12);
CppsSetParameter(CPP_PM_PARAM_MAX_EXTREME_ANGLE, 13);
CppsSetParameter(CPP_PM_PARAM_MIN_EXTREME_ANGLE, 14);
CppsSetParameter(CPP_PM_PARAM_TOP_DEAD_SPOT, 15);
CppsSetParameter(CPP_PM_PARAM_BOTTOM_DEAD_SPOT, 16);
CppsSetParameter(CPP_PM_PARAM_ACCUMULATED_ENERGY, 17);
CppsSendPowerMeasurement(connId);
}
/* Configure and start timer to send the next measurement */
cyclingCb.cpmTimer.msg.event = CYCLING_CPP_PM_TIMER_IND;
cyclingCb.cpmTimer.msg.status = CYCLING_CPS_CPM_CCC_IDX;
cyclingCb.cpmTimer.handlerId = cyclingCb.handlerId;
cyclingCb.cpmTimer.msg.param = connId;
WsfTimerStartSec(&cyclingCb.cpmTimer, cyclingCpmPeriod);
}
/*************************************************************************************************/
/*!
* \brief Application ATTS client characteristic configuration callback.
*
* \param pDmEvt DM callback event
*
* \return None.
*/
/*************************************************************************************************/
static void cyclingProcCccState(attsCccEvt_t *pMsg)
{
APP_TRACE_INFO3("ccc state ind value:%d handle:%d idx:%d", pMsg->value, pMsg->handle, pMsg->idx);
/* handle cycling power measurement CCC */
if (pMsg->idx == CYCLING_CPS_CPM_CCC_IDX)
{
if (pMsg->value == ATT_CLIENT_CFG_NOTIFY)
{
cyclingSendCyclingPowerMeasurement((dmConnId_t)pMsg->hdr.param);
}
else
{
WsfTimerStop(&cyclingCb.cpmTimer);
}
return;
}
/* handle cycling speed measurement CCC */
if (pMsg->idx == CYCLING_CSCS_CSM_CCC_IDX)
{
if (pMsg->value == ATT_CLIENT_CFG_NOTIFY)
{
cyclingSendCyclingSpeedMeasurement((dmConnId_t)pMsg->hdr.param);
}
else
{
WsfTimerStop(&cyclingCb.csmTimer);
}
return;
}
/* handle battery level CCC */
if (pMsg->idx == CYCLING_BATT_LVL_CCC_IDX)
{
if (pMsg->value == ATT_CLIENT_CFG_NOTIFY)
{
BasMeasBattStart((dmConnId_t)pMsg->hdr.param, CYCLING_BATT_TIMER_IND, CYCLING_BATT_LVL_CCC_IDX);
}
else
{
BasMeasBattStop((dmConnId_t)pMsg->hdr.param);
}
return;
}
}
/*************************************************************************************************/
/*!
* \brief Application ATTS client characteristic configuration callback.
*
* \param pDmEvt DM callback event
*
* \return None.
*/
/*************************************************************************************************/
static void cyclingCccCback(attsCccEvt_t *pEvt)
{
attsCccEvt_t *pMsg;
appDbHdl_t dbHdl;
/* If CCC not set from initialization and there's a bond record and currently bonded */
if ((pEvt->handle != ATT_HANDLE_NONE) &&
((dbHdl = AppDbGetHdl((dmConnId_t)pEvt->hdr.param)) != APP_DB_HDL_NONE) &&
AppCheckBonded((dmConnId_t)pEvt->hdr.param))
{
/* Store value in device database. */
AppDbSetCccTblValue(dbHdl, pEvt->idx, pEvt->value);
}
if ((pMsg = WsfMsgAlloc(sizeof(attsCccEvt_t))) != NULL)
{
memcpy(pMsg, pEvt, sizeof(attsCccEvt_t));
WsfMsgSend(cyclingCb.handlerId, pMsg);
}
}
/*************************************************************************************************/
/*!
* \fn cyclingGetPeerKey
*
* \brief Get peer key from a device database record.
*
* \param pMsg Pointer to DM callback event message.
*
* \return Pointer to peer key if key is valid or NULL if not valid.
*/
/*************************************************************************************************/
static dmSecKey_t *cyclingGetPeerKey(dmEvt_t *pMsg)
{
appDbHdl_t dbHdl;
/* get device database record handle */
dbHdl = AppDbGetHdl((dmConnId_t) pMsg->hdr.param);
/* if database record handle valid */
if (dbHdl != APP_DB_HDL_NONE)
{
return AppDbGetKey(dbHdl, DM_KEY_IRK, NULL);
}
return NULL;
}
/*************************************************************************************************/
/*!
* \fn datsPrivAddDevToResListInd
*
* \brief Handle add device to resolving list indication.
*
* \param pMsg Pointer to DM callback event message.
*
* \return None.
*/
/*************************************************************************************************/
static void cyclingPrivAddDevToResListInd(dmEvt_t *pMsg)
{
dmSecKey_t *pPeerKey;
/* if peer IRK present */
if ((pPeerKey = cyclingGetPeerKey(pMsg)) != NULL)
{
/* set advertising peer address */
AppSetAdvPeerAddr(pPeerKey->irk.addrType, pPeerKey->irk.bdAddr);
}
}
/*************************************************************************************************/
/*!
* \fn cyclingPrivRemDevFromResListInd
*
* \brief Handle remove device from resolving list indication.
*
* \param pMsg Pointer to DM callback event message.
*
* \return None.
*/
/*************************************************************************************************/
static void cyclingPrivRemDevFromResListInd(dmEvt_t *pMsg)
{
if (pMsg->hdr.status == HCI_SUCCESS)
{
if (AppDbGetHdl((dmConnId_t) pMsg->hdr.param) != APP_DB_HDL_NONE)
{
uint8_t addrZeros[BDA_ADDR_LEN] = { 0 };
/* clear advertising peer address and its type */
AppSetAdvPeerAddr(HCI_ADDR_TYPE_PUBLIC, addrZeros);
}
}
}
/*************************************************************************************************/
/*!
* \fn cyclingSetup
*
* \brief Set up advertising and other procedures that need to be performed after
* device reset.
*
* \param pMsg Pointer to message.
*
* \return None.
*/
/*************************************************************************************************/
static void cyclingSetup(dmEvt_t *pMsg)
{
/* set advertising and scan response data for discoverable mode */
AppAdvSetData(APP_ADV_DATA_DISCOVERABLE, sizeof(cyclingAdvDataDisc), (uint8_t *) cyclingAdvDataDisc);
AppAdvSetData(APP_SCAN_DATA_DISCOVERABLE, sizeof(cyclingScanDataDisc), (uint8_t *) cyclingScanDataDisc);
/* set advertising and scan response data for connectable mode */
AppAdvSetData(APP_ADV_DATA_CONNECTABLE, sizeof(cyclingAdvDataDisc), (uint8_t *) cyclingAdvDataDisc);
AppAdvSetData(APP_SCAN_DATA_CONNECTABLE, sizeof(cyclingScanDataDisc), (uint8_t *) cyclingScanDataDisc);
/* start advertising; automatically set connectable/discoverable mode and bondable mode */
AppAdvStart(APP_MODE_AUTO_INIT);
}
/*************************************************************************************************/
/*!
* \brief Process messages from the event handler.
*
* \param pMsg Pointer to message.
*
* \return None.
*/
/*************************************************************************************************/
static void cyclingProcMsg(dmEvt_t *pMsg)
{
uint8_t uiEvent = APP_UI_NONE;
switch(pMsg->hdr.event)
{
case CYCLING_CPP_PM_TIMER_IND:
cyclingSendCyclingPowerMeasurement((dmConnId_t) pMsg->hdr.param);
break;
case CYCLING_CSCP_SM_TIMER_IND:
cyclingSendCyclingSpeedMeasurement((dmConnId_t) pMsg->hdr.param);
break;
case ATTS_CCC_STATE_IND:
cyclingProcCccState((attsCccEvt_t*) pMsg);
break;
case ATT_MTU_UPDATE_IND:
APP_TRACE_INFO1("Negotiated MTU %d", ((attEvt_t *)pMsg)->mtu);
break;
case DM_RESET_CMPL_IND:
AttsCalculateDbHash();
DmSecGenerateEccKeyReq();
cyclingSetup(pMsg);
uiEvent = APP_UI_RESET_CMPL;
break;
case DM_ADV_START_IND:
uiEvent = APP_UI_ADV_START;
break;
case DM_ADV_STOP_IND:
uiEvent = APP_UI_ADV_STOP;
break;
case DM_CONN_OPEN_IND:
CppsConnOpen((dmConnId_t)pMsg->hdr.param);
uiEvent = APP_UI_CONN_OPEN;
break;
case DM_CONN_CLOSE_IND:
WsfTimerStop(&cyclingCb.cpmTimer);
WsfTimerStop(&cyclingCb.csmTimer);
uiEvent = APP_UI_CONN_CLOSE;
break;
case DM_SEC_PAIR_CMPL_IND:
DmSecGenerateEccKeyReq();
uiEvent = APP_UI_SEC_PAIR_CMPL;
break;
case DM_SEC_PAIR_FAIL_IND:
DmSecGenerateEccKeyReq();
uiEvent = APP_UI_SEC_PAIR_FAIL;
break;
case DM_SEC_ENCRYPT_IND:
uiEvent = APP_UI_SEC_ENCRYPT;
break;
case DM_SEC_ENCRYPT_FAIL_IND:
uiEvent = APP_UI_SEC_ENCRYPT_FAIL;
break;
case DM_SEC_AUTH_REQ_IND:
AppHandlePasskey(&pMsg->authReq);
break;
case DM_SEC_COMPARE_IND:
AppHandleNumericComparison(&pMsg->cnfInd);
break;
case DM_PRIV_ADD_DEV_TO_RES_LIST_IND:
cyclingPrivAddDevToResListInd(pMsg);
break;
case DM_PRIV_REM_DEV_FROM_RES_LIST_IND:
cyclingPrivRemDevFromResListInd(pMsg);
break;
case DM_ADV_NEW_ADDR_IND:
break;
case DM_VENDOR_SPEC_CMD_CMPL_IND:
{
#if defined(AM_PART_APOLLO) || defined(AM_PART_APOLLO2)
uint8_t *param_ptr = &pMsg->vendorSpecCmdCmpl.param[0];
switch (pMsg->vendorSpecCmdCmpl.opcode)
{
case 0xFC20: //read at address
{
uint32_t read_value;
BSTREAM_TO_UINT32(read_value, param_ptr);
APP_TRACE_INFO3("VSC 0x%0x complete status %x param %x",
pMsg->vendorSpecCmdCmpl.opcode,
pMsg->hdr.status,
read_value);
}
break;
default:
APP_TRACE_INFO2("VSC 0x%0x complete status %x",
pMsg->vendorSpecCmdCmpl.opcode,
pMsg->hdr.status);
break;
}
#endif
}
break;
default:
break;
}
if (uiEvent != APP_UI_NONE)
{
AppUiAction(uiEvent);
}
}
/*************************************************************************************************/
/*!
* \brief Application handler init function called during system initialization.
*
* \param handlerID WSF handler ID.
*
* \return None.
*/
/*************************************************************************************************/
void CyclingHandlerInit(wsfHandlerId_t handlerId)
{
APP_TRACE_INFO0("CyclingHandlerInit");
/* store handler ID */
cyclingCb.handlerId = handlerId;
/* Set configuration pointers */
pAppSlaveCfg = (appSlaveCfg_t *) &cyclingSlaveCfg;
pAppAdvCfg = (appAdvCfg_t *) &cyclingAdvCfg;
pAppSecCfg = (appSecCfg_t *) &cyclingSecCfg;
pAppUpdateCfg = (appUpdateCfg_t *) &cyclingUpdateCfg;
pAttCfg = (attCfg_t *) &cyclingAttCfg;
/* Initialize application framework */
AppSlaveInit();
AppServerInit();
/* Set IRK for the local device */
DmSecSetLocalIrk(localIrk);
}
/*************************************************************************************************/
/*!
* \brief WSF event handler for application.
*
* \param event WSF event mask.
* \param pMsg WSF message.
*
* \return None.
*/
/*************************************************************************************************/
void CyclingHandler(wsfEventMask_t event, wsfMsgHdr_t *pMsg)
{
if (pMsg != NULL)
{
APP_TRACE_INFO1("Cycling got evt %d", pMsg->event);
/* process ATT messages */
if (pMsg->event >= ATT_CBACK_START && pMsg->event <= ATT_CBACK_END)
{
/* process server-related ATT messages */
AppServerProcAttMsg(pMsg);
}
/* process DM messages */
else if (pMsg->event >= DM_CBACK_START && pMsg->event <= DM_CBACK_END)
{
/* process advertising and connection-related messages */
AppSlaveProcDmMsg((dmEvt_t *) pMsg);
/* process security-related messages */
AppSlaveSecProcDmMsg((dmEvt_t *) pMsg);
}
/* perform profile and user interface-related operations */
cyclingProcMsg((dmEvt_t *) pMsg);
}
}
/*************************************************************************************************/
/*!
* \brief Start the application.
*
* \return None.
*/
/*************************************************************************************************/
void CyclingStart(void)
{
/* Register for stack callbacks */
DmRegister(cyclingDmCback);
DmConnRegister(DM_CLIENT_ID_APP, cyclingDmCback);
AttRegister(cyclingAttCback);
AttConnRegister(AppServerConnCback);
AttsCccRegister(CYCLING_NUM_CCC_IDX, (attsCccSet_t *) cyclingCccSet, cyclingCccCback);
/* Initialize attribute server database */
SvcCoreGattCbackRegister(GattReadCback, GattWriteCback);
SvcCoreAddGroup();
SvcCpsAddGroup();
SvcCscsAddGroup();
SvcBattCbackRegister(BasReadCback, NULL);
SvcBattAddGroup();
/* Set Service Changed CCCD index. */
GattSetSvcChangedIdx(CYCLING_GATT_SC_CCC_IDX);
/* Set the cycling power features */
CppsSetFeatures(CPP_ALL_FEATURES);
/* Set the cycling speed and cadence features */
CscpsSetFeatures(CSCS_ALL_FEATURES);
/* Reset the device */
DmDevReset();
}