/*FUNCTION********************************************************************** * * Function Name : TSI_DRV_ChangeMode * Description : The function change the current mode. * *END**************************************************************************/ tsi_status_t TSI_DRV_ChangeMode(uint32_t instance, const tsi_modes_t mode) { assert(instance < TSI_INSTANCE_COUNT); TSI_Type * base = g_tsiBase[instance]; tsi_state_t * tsiState = g_tsiStatePtr[instance]; if((mode == tsiState->opMode) || (mode == tsi_OpModeNoChange)) { return kStatus_TSI_Success; } if(mode >= tsi_OpModeCnt) { return kStatus_TSI_InvalidMode; } /* Critical section. Access to global variable */ if (kStatus_OSA_Success != OSA_MutexLock(&tsiState->lockChangeMode, OSA_WAIT_FOREVER)) { return kStatus_TSI_Error; } if (tsiState->status != kStatus_TSI_Initialized) { /* End of critical section. */ OSA_MutexUnlock(&tsiState->lockChangeMode); return tsiState->status; } if(mode == tsi_OpModeNoise) { if(!tsiState->opModesData[mode].config.mode) { /* End of critical section. */ OSA_MutexUnlock(&tsiState->lockChangeMode); return kStatus_TSI_InvalidMode; } }else { if(tsiState->opModesData[mode].config.mode) { /* End of critical section. */ OSA_MutexUnlock(&tsiState->lockChangeMode); return kStatus_TSI_InvalidMode; } } tsiState->opMode = mode; TSI_HAL_SetConfiguration(base, &tsiState->opModesData[mode].config); /* End of critical section. */ OSA_MutexUnlock(&tsiState->lockChangeMode); return kStatus_TSI_Success; }
/*FUNCTION********************************************************************** * * Function Name : TSI_DRV_LoadConfiguration * Description : The function load the configuration for one mode of operation. * *END**************************************************************************/ tsi_status_t TSI_DRV_LoadConfiguration(uint32_t instance, const tsi_modes_t mode, const tsi_operation_mode_t * operationMode) { assert(instance < TSI_INSTANCE_COUNT); assert(operationMode); TSI_Type * base; tsi_state_t * tsiState = g_tsiStatePtr[instance]; if(mode >= tsi_OpModeCnt) { return kStatus_TSI_InvalidMode; } /* Critical section. Access to global variable */ if (kStatus_OSA_Success != OSA_MutexLock(&tsiState->lock, OSA_WAIT_FOREVER)) { return kStatus_TSI_Error; } tsiState->opModesData[mode] = *operationMode; /* In case that the loaded configuration is active one, update the HW also. */ if(mode == tsiState->opMode) { base = g_tsiBase[instance]; TSI_HAL_SetConfiguration(base, &tsiState->opModesData[mode].config); TSI_HAL_EnableInterrupt(base); TSI_HAL_EnableEndOfScanInterrupt(base); } /* End of critical section. */ OSA_MutexUnlock(&tsiState->lock); return kStatus_TSI_Success; }
/*FUNCTION********************************************************************** * * Function Name : TSI_DRV_ChangeMode * Description : The function change the current mode. * *END**************************************************************************/ tsi_status_t TSI_DRV_ChangeMode(uint32_t instance, const tsi_modes_t mode) { assert(instance < TSI_INSTANCE_COUNT); TSI_Type * base = g_tsiBase[instance]; tsi_state_t * tsiState = g_tsiStatePtr[instance]; if((mode == tsiState->opMode) || (mode == tsi_OpModeNoChange)) { return kStatus_TSI_Success; } if(mode >= tsi_OpModeNoise) /* Neither the noise mode is not supported in TSIv1&2 revision. */ { return kStatus_TSI_InvalidMode; } /* Critical section. Access to global variable */ if (kStatus_OSA_Success != OSA_MutexLock(&tsiState->lockChangeMode, OSA_WAIT_FOREVER)) { return kStatus_TSI_Error; } if (tsiState->status != kStatus_TSI_Initialized) { /* End of critical section. */ OSA_MutexUnlock(&tsiState->lockChangeMode); return tsiState->status; } tsiState->opMode = mode; TSI_HAL_SetConfiguration(base, &tsiState->opModesData[mode].config); /* Disable all electrodes */ TSI_HAL_DisableChannels(base, 0xffff); /* Enable the set electrodes for current operation mode */ TSI_HAL_EnableChannels(base, tsiState->opModesData[mode].enabledElectrodes); /* End of critical section. */ OSA_MutexUnlock(&tsiState->lockChangeMode); return kStatus_TSI_Success; }
/*FUNCTION********************************************************************** * * Function Name : TSI_DRV_Init * Description : Initialize whole the TSI peripheral to be ready to read capacitance changes * To initialize the TSI driver, the configuration structure should be handled. * *END**************************************************************************/ tsi_status_t TSI_DRV_Init(uint32_t instance, tsi_state_t * tsiState, const tsi_user_config_t * tsiUserConfig) { assert(instance < TSI_INSTANCE_COUNT); TSI_Type * base = g_tsiBase[instance]; tsi_state_t * tsiSt = g_tsiStatePtr[instance]; /* Critical section. */ OSA_EnterCritical(kCriticalDisableInt); /* Exit if current instance is already initialized. */ if(tsiSt) { /* End of critical section. */ OSA_ExitCritical(kCriticalDisableInt); return kStatus_TSI_Initialized; } /* Save runtime structure pointer.*/ tsiSt = g_tsiStatePtr[instance] = tsiState; /* Clear the state structure for this instance. */ memset(tsiSt, 0, sizeof(tsi_state_t)); /* Create the mutex used by whole driver. */ OSA_MutexCreate(&tsiSt->lock); /* Create the mutex used by change mode function. */ OSA_MutexCreate(&tsiSt->lockChangeMode); /* Critical section. Access to global variable */ if (kStatus_OSA_Success != OSA_MutexLock(&tsiSt->lock, OSA_WAIT_FOREVER)) { /* End of critical section. */ OSA_ExitCritical(kCriticalDisableInt); return kStatus_TSI_Error; } /* End of critical section. */ OSA_ExitCritical(kCriticalDisableInt); tsiSt->opMode = tsi_OpModeNormal; tsiSt->opModesData[tsiSt->opMode].config = *tsiUserConfig->config; /* Store the hardware configuration. */ tsiSt->pCallBackFunc = tsiUserConfig->pCallBackFunc; tsiSt->usrData = tsiUserConfig->usrData; tsiSt->isBlockingMeasure = false; /* Un-gate TSI module clock */ CLOCK_SYS_EnableTsiClock(instance); /* Initialize the interrupt sync object. */ OSA_SemaCreate(&tsiSt->irqSync, 0); TSI_HAL_Init(base); TSI_HAL_SetConfiguration(base, &tsiSt->opModesData[tsiSt->opMode].config); TSI_HAL_EnableInterrupt(base); TSI_HAL_EnableEndOfScanInterrupt(base); TSI_HAL_EnableSoftwareTriggerScan(base); /* Disable all electrodes */ tsiState->opModesData[tsiState->opMode].enabledElectrodes = 0; /* Enable TSI interrupt on NVIC level. */ INT_SYS_EnableIRQ(g_tsiIrqId[instance]); tsiSt->status = kStatus_TSI_Initialized; /* End of critical section. */ OSA_MutexUnlock(&tsiSt->lock); return kStatus_TSI_Success; }
uint32_t TSI_HAL_Recalibrate(TSI_Type * base, tsi_config_t *config, const uint32_t electrodes, const tsi_parameter_limits_t *parLimits) { assert(config != NULL); uint32_t is_enabled = TSI_HAL_IsModuleEnabled(base); uint32_t is_int_enabled = TSI_HAL_IsInterruptEnabled(base); uint32_t lowest_signal = TSI_RECALIBRATE_MAX_SIGNAL_VAL; if(electrodes == 0) { return 0; } if (is_enabled) { TSI_HAL_DisableModule(base); } if (is_int_enabled) { TSI_HAL_DisableInterrupt(base); } if(parLimits == NULL) /* If NOISE mode calibration*/ { /* parLimits are not used in NOISE mode so this is calibration of noise mode. */ TSI_HAL_SetConfiguration(base, config); lowest_signal = 1; }else { // Normal capacitive mode calibration TSI_HAL_SetNumberOfScans(base, config->nscn); TSI_HAL_SetPrescaler(base, config->ps); TSI_HAL_SetElectrodeChargeCurrent(base, config->extchrg); TSI_HAL_SetReferenceChargeCurrent(base, config->refchrg); TSI_HAL_EnableModule(base); for (uint32_t i = 0U; i < 16U; i++) { if ((uint32_t)(1 << i) & electrodes) { int32_t counter = TSI_HAL_MeasurementBlocking(base, i, 0); if (counter < lowest_signal) { lowest_signal = counter; } } } } if (!is_enabled) { TSI_HAL_EnableModule(base); } if (is_int_enabled) { TSI_HAL_EnableInterrupt(base); } if (lowest_signal == TSI_RECALIBRATE_MAX_SIGNAL_VAL) { lowest_signal = 0U; /* not valid */ } return lowest_signal; }