/*FUNCTION********************************************************************** * * Function Name : TSI_HAL_MeasurementBlocking * Description : Function do blocking measurement of enabled electrodes * It used just for recalibration process *END**************************************************************************/ static int32_t TSI_HAL_MeasurementBlocking(TSI_Type * base, uint32_t electrode, uint32_t noise_mode) { int32_t result; uint32_t timeout = 1000000; /* measure only if at least one electrode is enabled */ TSI_HAL_EnableSoftwareTriggerScan(base); TSI_HAL_SetMeasuredChannelNumber(base, electrode); TSI_HAL_SetMode(base, TSI_HAL_GetMode(base)); /* force to HW right analog mode. */ TSI_HAL_EnableModule(base); TSI_HAL_StartSoftwareTrigger(base); while((TSI_HAL_GetEndOfScanFlag(base) == 0U) && (--timeout)) { /* Do nothing, just to meet MISRA C 2004 rule 14.3 . */ } if(timeout == 0) { result = 0; }else { if(noise_mode) { result = TSI_HAL_GetNoiseResult(base); }else { result = TSI_HAL_GetCounter(base); } } TSI_HAL_ClearEndOfScanFlag(base); TSI_HAL_DisableModule(base); return result; }
/*! * @brief Interrupt handler for TSI. * This handler uses the tsi State structure to handle the instance depend data. * This is not a public API as it is called whenever an interrupt occurs. */ void TSI_DRV_IRQHandler(uint32_t instance) { TSI_Type * base = g_tsiBase[instance]; tsi_state_t * tsiState = g_tsiStatePtr[instance]; uint32_t channels = tsiState->opModesData[tsiState->opMode].enabledElectrodes; uint32_t curr_channel = TSI_HAL_GetMeasuredChannelNumber(base); uint32_t next_pen, pen; /* Check if a measure is running and wanted. */ TSI_HAL_ClearOutOfRangeFlag(base); TSI_HAL_ClearEndOfScanFlag(base); if((uint32_t)(1 << curr_channel) & channels) { /* Am I in noise mode? */ if(tsiState->opMode == tsi_OpModeNoise) { tsiState->counters[curr_channel] = TSI_HAL_GetMode(base); } else { tsiState->counters[curr_channel] = TSI_HAL_GetCounter(base); } } next_pen = curr_channel + 1; pen = channels; while (((((pen >> next_pen) & 0x1U)) == 0U) && (next_pen < 16)) { next_pen++; } if(next_pen < 16) { /* Measurement must continue on next channel. */ TSI_HAL_SetMeasuredChannelNumber(base, next_pen); TSI_HAL_StartSoftwareTrigger(base); return; } if(tsiState->isBlockingMeasure) { /* Signal the synchronous completion object. */ OSA_SemaPost(&tsiState->irqSync); tsiState->isBlockingMeasure = false; } else if(tsiState->pCallBackFunc) { tsiState->pCallBackFunc(instance, tsiState->usrData); } if(tsiState->status != kStatus_TSI_LowPower) { /* Return status of the driver to initialized state */ tsiState->status = kStatus_TSI_Initialized; } }
/*FUNCTION********************************************************************** * * Function Name : TSI_DRV_Measure * Description : This function gets (measure) capacitance of enabled electrodes * from the TSI module using a non-blocking method. * *END**************************************************************************/ tsi_status_t TSI_DRV_Measure(uint32_t instance) { assert(instance < TSI_INSTANCE_COUNT); TSI_Type * base = g_tsiBase[instance]; tsi_state_t * tsiState = g_tsiStatePtr[instance]; uint32_t first_pen, pen; /* Critical section. Access to global variable */ if (kStatus_OSA_Success != OSA_MutexLock(&tsiState->lock, OSA_WAIT_FOREVER)) { return kStatus_TSI_Error; } if (tsiState->status != kStatus_TSI_Initialized) { /* End of critical section. */ OSA_MutexUnlock(&tsiState->lock); return tsiState->status; } if(!tsiState->opModesData[tsiState->opMode].enabledElectrodes) { /* End of critical section. */ OSA_MutexUnlock(&tsiState->lock); return kStatus_TSI_InvalidChannel; } tsiState->status = kStatus_TSI_Busy; first_pen = 0U; pen = tsiState->opModesData[tsiState->opMode].enabledElectrodes; while (((pen >> first_pen) & 0x1U) == 0U) { first_pen++; } /* End of critical section. */ OSA_MutexUnlock(&tsiState->lock); TSI_HAL_DisableModule(base); TSI_HAL_SetMeasuredChannelNumber(base, first_pen); TSI_HAL_EnableSoftwareTriggerScan(base); TSI_HAL_EnableModule(base); TSI_HAL_StartSoftwareTrigger(base); return kStatus_TSI_Success; }
/*FUNCTION********************************************************************** * * Function Name : TSI_DRV_EnableLowPower * Description : Enables/Disables the low power module. * *END**************************************************************************/ tsi_status_t TSI_DRV_EnableLowPower(uint32_t instance) { assert(instance < TSI_INSTANCE_COUNT); TSI_Type * base = g_tsiBase[instance]; tsi_state_t * tsiState = g_tsiStatePtr[instance]; tsi_status_t status; uint32_t i; int32_t channel = -1; /* Critical section. Access to global variable */ if (kStatus_OSA_Success != OSA_MutexLock(&tsiState->lock, OSA_WAIT_FOREVER)) { return kStatus_TSI_Error; } if((tsiState->opModesData[tsiState->opMode].config.thresl == 0) || (tsiState->opModesData[tsiState->opMode].config.thresh == 0)) { /* End of critical section. */ OSA_MutexUnlock(&tsiState->lock); return kStatus_TSI_Error; } if ((status = TSI_DRV_ChangeMode(instance, tsi_OpModeLowPower)) != kStatus_TSI_Success) { /* End of critical section. */ OSA_MutexUnlock(&tsiState->lock); return status; } if(tsiState->opModesData[tsiState->opMode].enabledElectrodes == 0) { /* End of critical section. */ OSA_MutexUnlock(&tsiState->lock); return kStatus_TSI_InvalidChannel; } /* Configurate the peripheral for next use */ TSI_HAL_EnableOutOfRangeInterrupt(base); TSI_HAL_EnableHardwareTriggerScan(base); for(i = 0; i < FSL_FEATURE_TSI_CHANNEL_COUNT; i++) { if((uint32_t)(1 << i) & tsiState->opModesData[tsiState->opMode].enabledElectrodes) { channel = i; break; } } if(channel == -1) { /* End of critical section. */ OSA_MutexUnlock(&tsiState->lock); return kStatus_TSI_InvalidChannel; } tsiState->status = kStatus_TSI_LowPower; TSI_HAL_EnableLowPower(base); TSI_HAL_SetMeasuredChannelNumber(base, channel); TSI_HAL_EnableInterrupt(base); TSI_HAL_EnableModule(base); /* End of critical section. */ OSA_MutexUnlock(&tsiState->lock); return kStatus_TSI_Success; }