// -----------------------------------------------------------------------------
//! \brief This is a HWI function handler for the MRDY pin. Some MRDY
//! functionality can execute from this HWI context. Others
//! must be executed from task context hence the taskCBs.remRdyCB()
//!
//! \param[in] hPin - PIN Handle
//! \param[in] pinId - ID of pin that triggered HWI
//!
//! \return void
// -----------------------------------------------------------------------------
static void NPITL_remRdyPINHwiFxn(PIN_Handle hPin, PIN_Id pinId)
{
// The pin driver does not currently support returning whether the int
// was neg or pos edge so we must use a variable to keep track of state.
remRdy_state ^= 1;
if (remRdy_state == 0)
{
mrdyPktStamp = txPktCount;
NPITL_setPM();
}
else
{
transportStopTransfer();
npiRxActive = FALSE;
}
// Signal to registered task that Rem Ready signal has changed state
if (taskCBs.remRdyCB)
{
taskCBs.remRdyCB(remRdy_state);
}
// Check the physical state of the pin to see if it matches the variable
// state. If not trigger another task call back
if (remRdy_state != PIN_getInputValue(remRdyPIN))
{
remRdy_state = PIN_getInputValue(remRdyPIN);
if (taskCBs.remRdyCB)
{
taskCBs.remRdyCB(remRdy_state);
}
}
}
/*********************************************************************
* @fn Board_keyCallback
*
* @brief Interrupt handler for Keys
*
* @param none
*
* @return none
*/
static void Board_keyCallback(PIN_Handle hPin, PIN_Id pinId)
{
keysPressed = 0;
if ( PIN_getInputValue(Board_BTN1) == 0 )
{
keysPressed |= KEY_BTN1;
}
if ( PIN_getInputValue(Board_BTN2) == 0 )
{
keysPressed |= KEY_BTN2;
}
Util_startClock(&keyChangeClock);
}
// -----------------------------------------------------------------------------
//! \brief Initialization for the LCD Thread
//!
//! \return void
// -----------------------------------------------------------------------------
static void LCDTask_inititializeTask(void)
{
LCDTask_events = 0;
LCDTask_State = LCDTASK_OFF_STATE;
delay_ms(4000);
// Handling of buttons, relay and MPU interrupt
hlGpioPin = PIN_open(&pinGpioState, lcdMotionPinsCfg);
// if (hGpioPin == 0) {
// //HWREGB(GPIO_BASE+GPIO_O_DOUT3_0+Board_LCD_PWR) = 1;
// //HWREGB(GPIO_BASE+GPIO_O_DOUT3_0+Board_LCD_PWR) = 0;
// } else {
motion_state = PIN_getInputValue(Board_LCD_MOTION);
PIN_registerIntCb(hlGpioPin, LCD_WakeupPinHwiFxn);
//
// // Enable IRQ
PIN_setConfig(hlGpioPin, PIN_BM_IRQ, Board_LCD_MOTION | PIN_IRQ_BOTHEDGES);
// // Enable wakeup
//PIN_setConfig(hlGpioPin, PINCC26XX_BM_WAKEUP, Board_LCD_MOTION | PINCC26XX_WAKEUP_POSEDGE);
// // Init SPI Bus
// bspSpiOpen();
// Init LCD Variables
ILI9341_init(hGpioPin);
// }
}
// -----------------------------------------------------------------------------
//! \brief This routine initializes the transport layer and opens the port
//! of the device. Note that based on project defines, either the
//! UART, or SPI driver can be used.
//!
//! \param[in] npiCBTx - Call back function for TX complete event
//! \param[in] npiCBRx - Call back function for RX event
//! \param[in] npiCBMrdy - Call back function for MRDY event
//!
//! \return void
// -----------------------------------------------------------------------------
void NPITL_initTL(npiRtosCB_t npiCBTx, npiRtosCB_t npiCBRx, npiRtosCB_t npiCBMrdy)
{
ICall_CSState key;
key = ICall_enterCriticalSection();
taskTxCB = npiCBTx;
taskRxCB = npiCBRx;
#if (NPI_FLOW_CTRL == 1)
taskMrdyCB = npiCBMrdy;
#endif // NPI_FLOW_CTRL = 1
transportInit(npiRxBuf,npiTxBuf, NPITL_transmissionCallBack);
#if (NPI_FLOW_CTRL == 1)
SRDY_DISABLE();
// Initialize SRDY/MRDY. Enable int after callback registered
hNpiHandshakePins = PIN_open(&npiHandshakePins, npiHandshakePinsCfg);
PIN_registerIntCb(hNpiHandshakePins, NPITL_MRDYPinHwiFxn);
PIN_setConfig(hNpiHandshakePins, PIN_BM_IRQ, MRDY_PIN | PIN_IRQ_BOTHEDGES);
// Enable wakeup
PIN_setConfig(hNpiHandshakePins, PINCC26XX_BM_WAKEUP, MRDY_PIN | PINCC26XX_WAKEUP_NEGEDGE);
mrdy_state = PIN_getInputValue(MRDY_PIN);
#endif // NPI_FLOW_CTRL = 1
ICall_leaveCriticalSection(key);
return;
}
static void rightKeyEvent_Handler(void) {
if (PIN_getInputValue(Board_KEY_RIGHT) == 0) {
longPressedButtonCheck |= KEY_RIGHT_EVT;
longPressNotiSent = 0;
if(Util_isActive(&longPressCheckClock)){
Util_startClock(&longPressCheckClock);
}else{
Util_startClock(&longPressCheckClock);
}
} else {
longPressedButtonCheck &= ~KEY_RIGHT_EVT;
if(longPressedButtonCheck == 0){
Util_stopClock(&longPressCheckClock);
}
if (Keys_AppCGs && longPressNotiSent == 0) {
Keys_AppCGs->pfnKeysNotification(RIGHT_SHORT);
}
}
}
// -----------------------------------------------------------------------------
//! \brief This is a HWI function handler for the MRDY pin. Some MRDY
//! functionality can execute from this HWI context. Others
//! must be executed from task context hence the taskMrdyCB()
//!
//! \param[in] hPin - PIN Handle
//! \param[in] pinId - ID of pin that triggered HWI
//!
//! \return void
// -----------------------------------------------------------------------------
static void NPITL_MRDYPinHwiFxn(PIN_Handle hPin, PIN_Id pinId)
{
// The pin driver does not currently support returning whether the int
// was neg or pos edge so we must use a variable to keep track of state.
// If the physical state of the pin was used then a very quick toggle of
// of MRDY could be missed.
mrdy_state ^= 1;
if (mrdy_state == 0)
{
mrdyPktStamp = txPktCount;
NPITL_setPM();
if ( taskMrdyCB )
{
taskMrdyCB();
}
}
else
{
transportStopTransfer();
}
// Check the physical state of the pin to see if it matches the variable
// state. If not then edge has been missed
if (mrdy_state != PIN_getInputValue(MRDY_PIN))
{
mrdy_state = PIN_getInputValue(MRDY_PIN);
if (mrdy_state == 0)
{
mrdyPktStamp = txPktCount;
NPITL_setPM();
if (taskMrdyCB)
{
taskMrdyCB();
}
}
else
{
transportStopTransfer();
}
}
}
static void longPress_Handler(void){
if (longPressedButtonCheck == KEY_LEFT_EVT) { //pressione lunga solo del tasto sinistro
longPressedButtonCheck = 0;
if (PIN_getInputValue(Board_KEY_LEFT) == 0) {
Keys_AppCGs->pfnKeysNotification(LEFT_LONG);
}
}
if (longPressedButtonCheck == KEY_RIGHT_EVT) { //pressione lunga solo del tasto destra
longPressedButtonCheck = 0;
if (PIN_getInputValue(Board_KEY_RIGHT) == 0) {
Keys_AppCGs->pfnKeysNotification(RIGHT_LONG);
}
}
if (longPressedButtonCheck == KEY_RIGHT_EVT | KEY_LEFT_EVT) { //pressione lunga di entrambi
longPressedButtonCheck = 0;
if (PIN_getInputValue(Board_KEY_RIGHT) == 0 && PIN_getInputValue(Board_KEY_LEFT) == 0) {
while((PIN_getInputValue(Board_KEY_RIGHT) == 0 || PIN_getInputValue(Board_KEY_LEFT) == 0)){
delay_ms(100);
}
Keys_AppCGs->pfnKeysNotification(BOTH);
//HCI_EXT_ResetSystemCmd(HCI_EXT_RESET_SYSTEM_HARD);
}
}
longPressNotiSent = 1;
}
/*********************************************************************
* @fn SensorTagKeys_processKeyRight
*
* @brief Interrupt handler for BUTTON 1(right)
*
* @param none
*
* @return none
*/
void SensorTagKeys_processButton(void)
{
if (PIN_getInputValue(Board_BUTTON))
{
keys &= ~SK_KEY_RIGHT;
}
else
{
keys |= SK_KEY_RIGHT;
}
// Wake up the application thread
Semaphore_post(sem);
}
// -----------------------------------------------------------------------------
//! \brief This routine is used to handle an MRDY transition from a task
//! context. Certain operations such as UART_read() cannot be
//! performed from a HWI context
//!
//! \return void
// -----------------------------------------------------------------------------
void NPITL_handleMrdyEvent(void)
{
ICall_CSState key;
key = ICall_enterCriticalSection();
// Check to make sure this event is not occurring during the next packet
// transmission
if ( PIN_getInputValue(MRDY_PIN) == 0 ||
(npiTxActive && mrdyPktStamp == txPktCount ) )
{
transportMrdyEvent();
SRDY_ENABLE();
}
ICall_leaveCriticalSection(key);
}
// -----------------------------------------------------------------------------
//! \brief This routine is used to handle an MRDY transition from a task
//! context. Certain operations such as UART_read() cannot be
//! performed from a HWI context
//!
//! \return void
// -----------------------------------------------------------------------------
void NPITL_handleRemRdyEvent(void)
{
_npiCSKey_t key;
key = NPIUtil_EnterCS();
// Check to make sure this event is not occurring during the next packet
// transmission
if (PIN_getInputValue(remRdyPIN) == 0 ||
(npiTxActive && mrdyPktStamp == txPktCount))
{
transportRemRdyEvent();
npiRxActive = TRUE;
LocRDY_ENABLE();
}
NPIUtil_ExitCS(key);
}
// -----------------------------------------------------------------------------
//! \brief This callback is invoked on the completion of one transmission
//! to/from the host MCU. Any bytes receives will be [0,Rxlen) in
//! npiRxBuf.
//! If bytes were receives or transmitted, this function notifies
//! the NPI task via registered call backs
//!
//! \param[in] Rxlen - lenth of the data received
//! \param[in] Txlen - length of the data transferred
//!
//! \return void
// -----------------------------------------------------------------------------
static void NPITL_transmissionCallBack(uint16 Rxlen, uint16 Txlen)
{
npiRxBufHead = 0;
npiRxBufTail = Rxlen;
if(Rxlen)
{
if ( taskRxCB )
{
taskRxCB(Rxlen);
}
}
if(Txlen)
{
npiTxActive = FALSE;
// Only perform call back if NPI Task has been registered
// and if there is not another fragment to send of this message
if ( taskTxCB && !msgFragLen )
{
taskTxCB(Txlen);
}
}
#if (NPI_FLOW_CTRL == 1)
// Reset mrdy state in case of missed HWI
mrdy_state = PIN_getInputValue(MRDY_PIN);
NPITL_relPM();
SRDY_DISABLE();
#endif // NPI_FLOW_CTRL = 1
// If there is another fragment to send, begin write without notifying
// higher level tasks
if ( msgFragLen )
{
NPITL_writeTL(msgFrag,msgFragLen);
}
}
// -----------------------------------------------------------------------------
//! \brief This routine initializes the transport layer and opens the port
//! of the device. Note that based on project defines, either the
//! UART, or SPI driver can be used.
//!
//! \param[in] params - Transport Layer parameters
//!
//! \return void
// -----------------------------------------------------------------------------
void NPITL_openTL(NPITL_Params *params)
{
_npiCSKey_t key;
key = NPIUtil_EnterCS();
// Set NPI Task Call backs
memcpy(&taskCBs, ¶ms->npiCallBacks, sizeof(params->npiCallBacks));
// Allocate memory for Transport Layer Tx/Rx buffers
npiBufSize = params->npiTLBufSize;
npiRxBuf = NPIUTIL_MALLOC(params->npiTLBufSize);
memset(npiRxBuf, 0, npiBufSize);
npiTxBuf = NPIUTIL_MALLOC(params->npiTLBufSize);
memset(npiTxBuf, 0, npiBufSize);
// This will be updated to be able to select SPI/UART TL at runtime
// Now only compile time with the NPI_USE_[UART,SPI] flag
#if defined(NPI_USE_UART)
transportOpen(params->portBoardID,
¶ms->portParams.uartParams,
NPITL_transmissionCallBack);
#elif defined(NPI_USE_SPI)
transportOpen(params->portBoardID,
¶ms->portParams.spiParams,
NPITL_transmissionCallBack);
#endif //NPI_USE_UART
#if (NPI_FLOW_CTRL == 1)
// Assign PIN IDs to remRdy and locRrdy
#ifdef NPI_MASTER
remRdyPIN = (params->srdyPinID & IOC_IOID_MASK);
locRdyPIN = (params->mrdyPinID & IOC_IOID_MASK);
#else
remRdyPIN = (params->mrdyPinID & IOC_IOID_MASK);
locRdyPIN = (params->srdyPinID & IOC_IOID_MASK);
#endif //NPI_MASTER
// Add PIN IDs to PIN Configuration
npiHandshakePinsCfg[REM_RDY_PIN_IDX] |= remRdyPIN;
npiHandshakePinsCfg[LOC_RDY_PIN_IDX] |= locRdyPIN;
// Initialize LOCRDY/REMRDY. Enable int after callback registered
hNpiHandshakePins = PIN_open(&npiHandshakePins, npiHandshakePinsCfg);
PIN_registerIntCb(hNpiHandshakePins, NPITL_remRdyPINHwiFxn);
PIN_setConfig(hNpiHandshakePins,
PIN_BM_IRQ,
remRdyPIN | PIN_IRQ_BOTHEDGES);
// Enable wakeup
PIN_setConfig(hNpiHandshakePins,
PINCC26XX_BM_WAKEUP,
remRdyPIN | PINCC26XX_WAKEUP_NEGEDGE);
remRdy_state = PIN_getInputValue(remRdyPIN);
// If MRDY is already low then we must initiate a read because there was
// a prior MRDY negedge that was missed
if (!remRdy_state)
{
NPITL_setPM();
if (taskCBs.remRdyCB)
{
transportRemRdyEvent();
LocRDY_ENABLE();
}
}
#endif // NPI_FLOW_CTRL = 1
#if (NPI_FLOW_CTRL == 0)
// This call will start repeated Uart Reads when Power Savings is disabled
transportRead();
#endif // NPI_FLOW_CTRL = 0
NPIUtil_ExitCS(key);
}
