|
ADC_MEASUREMENT_ADV
|
ADC_MEASUREMENT_ADV.c
00001 00078 /*********************************************************************************************************************** 00079 * HEADER FILES 00080 **********************************************************************************************************************/ 00081 #include "adc_measurement_adv.h" 00082 00083 /*********************************************************************************************************************** 00084 * MACROS 00085 **********************************************************************************************************************/ 00086 /* Pointer to the VADC GLOBAL*/ 00087 #define ADC_MEASUREMENT_ADV_GLOBAL_PTR ((XMC_VADC_GLOBAL_t *) (void *) VADC) 00088 00089 /* Max value possible with 10 bit resolution is 1023*/ 00090 #define ADC_MEASUREMENT_ADV_10_BIT_MAX_VALUE ((uint32_t)1023) 00091 00092 #if (XMC_VADC_SHS_AVAILABLE == 1U) 00093 /* Pointer to the SHS unit */ 00094 #define ADC_MEASUREMENT_ADV_SHS_PTR ((XMC_VADC_GLOBAL_SHS_t *) (void *) SHS0) 00095 #endif 00096 00102 #define ADC_MEASUREMENT_ADV_RESERVED_REGISTERS ((uint32_t)2) 00103 00109 #define ADC_MEASUREMENT_ADV_HEAD_RESULT_REG_CONFIG ((uint32_t)0) 00110 00116 #define ADC_MEASUREMENT_ADV_TAIL_RESULT_REG_CONFIG ((uint32_t)1) 00117 00118 /* Configure the slave input class as global input class 1*/ 00119 #define ADC_MEASUREMENT_ADV_GLOBICLASS1 ((uint32_t)1) 00120 00121 00122 /* Since the SCU is different for various devices a macro is defined here to enable check of clock-ungating*/ 00123 #if UC_FAMILY == XMC1 00124 #define ADC_MEASUREMENT_ADV_CHECK_CLOCK_GATING ((uint32_t)1) 00125 #endif 00126 00127 /*********************************************************************************************************************** 00128 * LOCAL DATA 00129 **********************************************************************************************************************/ 00130 /* Array of Group pointers*/ 00131 XMC_VADC_GROUP_t *const group_ptrs[XMC_VADC_MAXIMUM_NUM_GROUPS] = 00132 { 00133 (VADC_G_TypeDef*)(void*) VADC_G0, 00134 (VADC_G_TypeDef*)(void*) VADC_G1 00135 #if (XMC_VADC_MAXIMUM_NUM_GROUPS > 2U) 00136 ,(VADC_G_TypeDef*)(void*) VADC_G2, 00137 (VADC_G_TypeDef*)(void*) VADC_G3 00138 #endif 00139 }; 00140 00141 #ifdef ADC_MEASUREMENT_ADV_FIFO_USED 00142 00145 static const XMC_VADC_RESULT_CONFIG_t ADC_MEASUREMENT_ADV_fifo_intermediate_stage = 00146 { 00147 .data_reduction_control = 0, 00148 .post_processing_mode = 0, 00149 .wait_for_read_mode = 0, 00150 .part_of_fifo = (bool)true, 00151 .event_gen_enable = 0 00152 }; 00153 #endif 00154 00155 /*Anonymous structure/union guard start*/ 00156 #if defined(__CC_ARM) 00157 #pragma push 00158 #pragma anon_unions 00159 #elif defined(__TASKING__) 00160 #pragma warning 586 00161 #endif 00162 00163 /* Private structure to determine the ALIAS*/ 00164 typedef struct ADC_MEASUREMENT_ADV_ALIAS 00165 { 00166 union 00167 { 00168 struct 00169 { 00170 uint32_t alias0 : 5; /* ALIAS for Channel 0*/ 00171 uint32_t : 3; 00172 uint32_t alias1 : 5; /* ALIAS for channel 1*/ 00173 uint32_t : 19; 00174 }; 00175 uint32_t alias; 00176 }; 00177 }ADC_MEASUREMENT_ADV_ALIAS_t; 00178 00179 /*Anonymous structure/union guard end*/ 00180 #if defined(__CC_ARM) 00181 #pragma pop 00182 #elif defined(__TASKING__) 00183 #pragma warning restore 00184 #endif 00185 /*********************************************************************************************************************** 00186 * LOCAL ROUTINES 00187 **********************************************************************************************************************/ 00188 #if defined(ADC_MEASUREMENT_ADV_ADC_QUEUE_USED) || defined (ADC_MEASUREMENT_ADV_ADC_SCAN_USED) 00189 /* Local function to insert an entry into the H/W*/ 00190 __STATIC_INLINE void ADC_MEASUREMENT_ADV_lInsertEntry(const ADC_MEASUREMENT_ADV_t *const handle_ptr, uint8_t ch_num) 00191 { 00192 #if defined( ADC_MEASUREMENT_ADV_SCAN_USED) && defined(ADC_MEASUREMENT_ADV_ADC_SCAN_USED) 00193 #if defined (ADC_MEASUREMENT_ADV_QUEUE_USED) && defined(ADC_MEASUREMENT_ADV_ADC_QUEUE_USED) 00194 if ( ADC_MEASUREMENT_ADV_REQUEST_SOURCE_SCAN == handle_ptr->req_src) 00195 #endif 00196 { 00197 ADC_SCAN_InsertScanEntry(handle_ptr->scan_handle, handle_ptr->scan_entries[ch_num]); 00198 } 00199 #endif 00200 #if defined(ADC_MEASUREMENT_ADV_QUEUE_USED) && defined(ADC_MEASUREMENT_ADV_ADC_QUEUE_USED) 00201 #if defined(ADC_MEASUREMENT_ADV_SCAN_USED) && defined(ADC_MEASUREMENT_ADV_ADC_SCAN_USED) 00202 else 00203 #endif 00204 { 00205 ADC_QUEUE_InsertQueueEntry(handle_ptr->queue_handle, handle_ptr->queue_entries[ch_num]); 00206 } 00207 #endif 00208 } 00209 #endif 00210 00211 /*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/ 00212 XMC_VADC_CHANNEL_CONV_t ADC_MEASUREMENT_ADV_lGetIclass(const ADC_MEASUREMENT_ADV_t *const handle_ptr) 00213 { 00214 XMC_VADC_CHANNEL_CONV_t req_iclass; 00215 00216 #ifdef ADC_MEASUREMENT_ADV_SCAN_USED 00217 #ifdef ADC_MEASUREMENT_ADV_QUEUE_USED 00218 if ( ADC_MEASUREMENT_ADV_REQUEST_SOURCE_LOCAL_SCAN >= handle_ptr->req_src) 00219 #endif 00220 { 00221 #ifdef ADC_MEASUREMENT_ADV_LOCAL_SCAN_USED 00222 #ifdef ADC_MEASUREMENT_ADV_ADC_SCAN_USED 00223 if ( ADC_MEASUREMENT_ADV_REQUEST_SOURCE_SCAN != handle_ptr->req_src) 00224 #endif 00225 { 00226 req_iclass = (XMC_VADC_CHANNEL_CONV_t)handle_ptr->local_scan_handle->iclass_num; 00227 } 00228 #endif 00229 00230 #ifdef ADC_MEASUREMENT_ADV_ADC_SCAN_USED 00231 #ifdef ADC_MEASUREMENT_ADV_LOCAL_SCAN_USED 00232 else 00233 #endif 00234 { 00235 /* Call the function to initialise Clock and ADC global functional units*/ 00236 req_iclass = (XMC_VADC_CHANNEL_CONV_t)handle_ptr->scan_handle->iclass_num; 00237 } 00238 #endif 00239 } 00240 #endif 00241 00242 #ifdef ADC_MEASUREMENT_ADV_QUEUE_USED 00243 #ifdef ADC_MEASUREMENT_ADV_SCAN_USED 00244 else 00245 #endif 00246 { 00247 #ifdef ADC_MEASUREMENT_ADV_LOCAL_QUEUE_USED 00248 #ifdef ADC_MEASUREMENT_ADV_ADC_QUEUE_USED 00249 if ( ADC_MEASUREMENT_ADV_REQUEST_SOURCE_QUEUE != handle_ptr->req_src) 00250 #endif 00251 { 00252 req_iclass = (XMC_VADC_CHANNEL_CONV_t)handle_ptr->local_queue_handle->iclass_num; 00253 } 00254 #endif 00255 00256 #ifdef ADC_MEASUREMENT_ADV_ADC_QUEUE_USED 00257 #ifdef ADC_MEASUREMENT_ADV_LOCAL_QUEUE_USED 00258 else 00259 #endif 00260 { 00261 req_iclass = (XMC_VADC_CHANNEL_CONV_t)handle_ptr->queue_handle->iclass_num; 00262 } 00263 #endif 00264 } 00265 #endif 00266 return (req_iclass); 00267 } 00268 00269 /*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/ 00270 #ifdef ADC_MEASUREMENT_ADV_SYNC_USED 00271 00272 /* Helper function to configure the eval bits in the slave*/ 00273 void ADC_MEASUREMENT_ADV_lSyncEvalConfig(uint32_t master_group, uint32_t slave_selected, 00274 uint32_t sync_group) 00275 { 00276 int8_t group_index; 00277 sync_group |= (1U << master_group); 00278 sync_group &= ~(1U << slave_selected); 00279 for( group_index = XMC_VADC_MAXIMUM_NUM_GROUPS - (int32_t)1; group_index >= (int32_t)0 ; group_index--) 00280 { 00281 if ( (bool)false != (bool)((sync_group >> group_index) & 0x1 )) 00282 { 00283 XMC_VADC_GROUP_SetSyncSlaveReadySignal(group_ptrs[slave_selected], slave_selected, group_index); 00284 } 00285 } 00286 } 00287 00288 /*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/ 00289 /* Helper function to execute the sync init sequence*/ 00290 void ADC_MEASUREMENT_ADV_lSyncSequencer(const ADC_MEASUREMENT_ADV_t *const handle_ptr, 00291 uint32_t sync_group, 00292 ADC_MEASUREMENT_ADV_SYNC_SEQ_t sequence) 00293 { 00294 int8_t group_index; 00295 for( group_index = XMC_VADC_MAXIMUM_NUM_GROUPS - (int32_t)1; group_index >= (int32_t)0 ; group_index--) 00296 { 00297 if ( (bool)false != (bool)((sync_group >> group_index) & 0x1 )) 00298 { 00299 switch( sequence) 00300 { 00301 case ADC_MEASUREMENT_ADV_SYNC_SEQ_POWER_DOWN: 00302 XMC_VADC_GROUP_SetPowerMode(group_ptrs[group_index],XMC_VADC_GROUP_POWERMODE_OFF); 00303 break; 00304 case ADC_MEASUREMENT_ADV_SYNC_SEQ_STSEL_CONFIG: 00305 XMC_VADC_GROUP_SetSyncSlave(group_ptrs[group_index], handle_ptr->group_index, group_index); 00306 XMC_VADC_GROUP_CheckSlaveReadiness(group_ptrs[handle_ptr->group_index],group_index); 00307 break; 00308 case ADC_MEASUREMENT_ADV_SYNC_SEQ_EVAL_CONFIG: 00309 ADC_MEASUREMENT_ADV_lSyncEvalConfig(handle_ptr->group_index, group_index, sync_group); 00310 default: 00311 break; 00312 } 00313 } 00314 } 00315 } 00316 00317 /*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/ 00318 /* Initialization of the all the sync related functions */ 00319 __STATIC_INLINE void ADC_MEASUREMENT_ADV_lSyncInit(const ADC_MEASUREMENT_ADV_t *const handle_ptr) 00320 { 00321 uint8_t sync_group; 00322 00323 /* shift to get the 4 bit position needed to or it with the slave groups */ 00324 sync_group = handle_ptr->sync_slaves | ( 1 << handle_ptr->group_index); 00325 ADC_MEASUREMENT_ADV_lSyncSequencer(handle_ptr, sync_group, ADC_MEASUREMENT_ADV_SYNC_SEQ_POWER_DOWN); 00326 00327 sync_group = handle_ptr->sync_slaves; 00328 ADC_MEASUREMENT_ADV_lSyncSequencer(handle_ptr, sync_group, ADC_MEASUREMENT_ADV_SYNC_SEQ_STSEL_CONFIG); 00329 ADC_MEASUREMENT_ADV_lSyncSequencer(handle_ptr, sync_group, ADC_MEASUREMENT_ADV_SYNC_SEQ_EVAL_CONFIG); 00330 00331 /* Configure the iclass settings needed for the sync slaves*/ 00332 if( (bool) false != handle_ptr->configure_globiclass1) 00333 { 00334 ADC_MEASUREMENT_ADV_SetIclass(handle_ptr); 00335 } 00336 00337 XMC_VADC_GROUP_SetSyncMaster(group_ptrs[handle_ptr->group_index]); 00338 00339 XMC_VADC_GROUP_SetPowerMode(group_ptrs[handle_ptr->group_index],XMC_VADC_GROUP_POWERMODE_NORMAL); 00340 } 00341 #endif 00342 00343 /*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/ 00344 #ifdef ADC_MEASUREMENT_ADV_LOCAL_SCAN_USED 00345 __STATIC_INLINE ADC_MEASUREMENT_ADV_STATUS_t ADC_MEASUREMENT_ADV_lScanInit(ADC_MEASUREMENT_ADV_SCAN_t *const handle_ptr, 00346 uint8_t group_index) 00347 { 00348 ADC_MEASUREMENT_ADV_STATUS_t status; 00349 00350 /*Initialization of APP 'ADCGroup'*/ 00351 status = (ADC_MEASUREMENT_ADV_STATUS_t) GLOBAL_ADC_Init(ADC_MEASUREMENT_ADV_GLOBAL_HANDLE); 00352 00353 XMC_VADC_GROUP_InputClassInit(group_ptrs[group_index], handle_ptr->iclass_config_handle, 00354 XMC_VADC_GROUP_CONV_STD, (uint32_t)handle_ptr->iclass_num); 00355 00356 00357 /*Initialization of scan request source*/ 00358 XMC_VADC_GROUP_ScanInit(group_ptrs[group_index], handle_ptr->scan_config_handle); 00359 00360 /* Configure the gating mode for Scan*/ 00361 XMC_VADC_GROUP_ScanSetGatingMode(group_ptrs[group_index], handle_ptr->gating_mode); 00362 00363 /*Interrupt Configuration*/ 00364 if ((bool)true == handle_ptr->rs_intr_handle.interrupt_enable) 00365 { 00366 #if (UC_FAMILY == XMC1) 00367 NVIC_SetPriority((IRQn_Type)handle_ptr->rs_intr_handle.node_id, handle_ptr->rs_intr_handle.priority); 00368 #else 00369 NVIC_SetPriority((IRQn_Type)handle_ptr->rs_intr_handle.node_id, 00370 NVIC_EncodePriority(NVIC_GetPriorityGrouping(), 00371 handle_ptr->rs_intr_handle.priority,handle_ptr->rs_intr_handle.sub_priority)); 00372 #endif 00373 #ifdef ADC_MEASUREMENT_ADV_NON_DEFAULT_IRQ_SOURCE_SELECTED 00374 XMC_SCU_SetInterruptControl(handle_ptr->rs_intr_handle.node_id, 00375 ((handle_ptr->rs_intr_handle.node_id << 8) | handle_ptr->rs_intr_handle.irqctrl)); 00376 #endif 00377 00378 /* Connect RS Events to NVIC nodes */ 00379 XMC_VADC_GROUP_ScanSetReqSrcEventInterruptNode(group_ptrs[group_index], handle_ptr->srv_req_node); 00380 } 00381 00382 return (status); 00383 } 00384 #endif 00385 /*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/ 00386 #ifdef ADC_MEASUREMENT_ADV_LOCAL_QUEUE_USED 00387 __STATIC_INLINE ADC_MEASUREMENT_ADV_STATUS_t ADC_MEASUREMENT_ADV_lQueueInit(ADC_MEASUREMENT_ADV_QUEUE_t *const handle_ptr, 00388 uint8_t group_index) 00389 { 00390 ADC_MEASUREMENT_ADV_STATUS_t status; 00391 00392 /*Initialization of APP 'GLOBAL_ADC'*/ 00393 status = (ADC_MEASUREMENT_ADV_STATUS_t) GLOBAL_ADC_Init(ADC_MEASUREMENT_ADV_GLOBAL_HANDLE); 00394 00395 /*Class Configuration*/ 00396 XMC_VADC_GROUP_InputClassInit(group_ptrs[group_index],handle_ptr->iclass_config_handle, 00397 XMC_VADC_GROUP_CONV_STD,handle_ptr->iclass_num); 00398 00399 /* Initialize the Queue hardware */ 00400 XMC_VADC_GROUP_QueueInit(group_ptrs[group_index],handle_ptr->queue_config_handle); 00401 00402 /* Configure the gating mode for queue*/ 00403 XMC_VADC_GROUP_QueueSetGatingMode(group_ptrs[group_index], handle_ptr->gating_mode); 00404 00405 /*Interrupt Configuration*/ 00406 if ((bool)true == handle_ptr->rs_intr_handle.interrupt_enable) 00407 { 00408 #if (UC_FAMILY == XMC1) 00409 NVIC_SetPriority((IRQn_Type)handle_ptr->rs_intr_handle.node_id, handle_ptr->rs_intr_handle.priority); 00410 #else 00411 NVIC_SetPriority((IRQn_Type)handle_ptr->rs_intr_handle.node_id, 00412 NVIC_EncodePriority(NVIC_GetPriorityGrouping(), 00413 handle_ptr->rs_intr_handle.priority,handle_ptr->rs_intr_handle.sub_priority)); 00414 #endif 00415 #ifdef ADC_MEASUREMENT_ADV_NON_DEFAULT_IRQ_SOURCE_SELECTED 00416 XMC_SCU_SetInterruptControl(handle_ptr->rs_intr_handle.node_id, 00417 ((handle_ptr->rs_intr_handle.node_id << 8) | handle_ptr->rs_intr_handle.irqctrl)); 00418 #endif 00419 00420 /* Connect RS Events to NVIC nodes */ 00421 XMC_VADC_GROUP_QueueSetReqSrcEventInterruptNode(group_ptrs[group_index], (XMC_VADC_SR_t)handle_ptr->srv_req_node); 00422 } 00423 00424 return (status); 00425 } 00426 #endif 00427 /*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/ 00428 /* Local function to do the request source initialization.*/ 00429 __STATIC_INLINE ADC_MEASUREMENT_ADV_STATUS_t ADC_MEASUREMENT_ADV_lRequestSrcInit(const ADC_MEASUREMENT_ADV_t 00430 *const handle_ptr) 00431 { 00432 ADC_MEASUREMENT_ADV_STATUS_t status; 00433 00434 #ifdef ADC_MEASUREMENT_ADV_SCAN_USED 00435 #ifdef ADC_MEASUREMENT_ADV_QUEUE_USED 00436 if ( ADC_MEASUREMENT_ADV_REQUEST_SOURCE_LOCAL_SCAN >= handle_ptr->req_src) 00437 #endif 00438 { 00439 #ifdef ADC_MEASUREMENT_ADV_LOCAL_SCAN_USED 00440 #ifdef ADC_MEASUREMENT_ADV_ADC_SCAN_USED 00441 if ( ADC_MEASUREMENT_ADV_REQUEST_SOURCE_SCAN != handle_ptr->req_src) 00442 #endif 00443 { 00444 status = ADC_MEASUREMENT_ADV_lScanInit(handle_ptr->local_scan_handle,handle_ptr->group_index); 00445 } 00446 #endif 00447 00448 #ifdef ADC_MEASUREMENT_ADV_ADC_SCAN_USED 00449 #ifdef ADC_MEASUREMENT_ADV_LOCAL_SCAN_USED 00450 else 00451 #endif 00452 { 00453 /* Call the function to initialise Clock and ADC global functional units*/ 00454 status = (ADC_MEASUREMENT_ADV_STATUS_t) ADC_SCAN_Init(handle_ptr->scan_handle); 00455 } 00456 #endif 00457 } 00458 #endif 00459 00460 #ifdef ADC_MEASUREMENT_ADV_QUEUE_USED 00461 #ifdef ADC_MEASUREMENT_ADV_SCAN_USED 00462 else 00463 #endif 00464 { 00465 #ifdef ADC_MEASUREMENT_ADV_LOCAL_QUEUE_USED 00466 #ifdef ADC_MEASUREMENT_ADV_ADC_QUEUE_USED 00467 if ( ADC_MEASUREMENT_ADV_REQUEST_SOURCE_QUEUE != handle_ptr->req_src) 00468 #endif 00469 { 00470 status = ADC_MEASUREMENT_ADV_lQueueInit(handle_ptr->local_queue_handle,handle_ptr->group_index); 00471 } 00472 #endif 00473 00474 #ifdef ADC_MEASUREMENT_ADV_ADC_QUEUE_USED 00475 #ifdef ADC_MEASUREMENT_ADV_LOCAL_QUEUE_USED 00476 else 00477 #endif 00478 { 00479 /* Call the function to initialise Clock and ADC global functional units*/ 00480 status = (ADC_MEASUREMENT_ADV_STATUS_t) ADC_QUEUE_Init(handle_ptr->queue_handle); 00481 } 00482 #endif 00483 } 00484 #endif 00485 return (status); 00486 } 00487 00488 /*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/ 00489 #ifdef ADC_MEASUREMENT_ADV_LOCAL_QUEUE_USED 00490 /* Local function to insert the queue entries into the hardware.*/ 00491 __STATIC_INLINE void ADC_MEASUREMENT_ADV_lQueueInsertEntries(const ADC_MEASUREMENT_ADV_t *const handle_ptr) 00492 { 00493 uint32_t entry_index; 00494 00495 XMC_VADC_GROUP_t *queue_group_ptr = group_ptrs[handle_ptr->group_index]; 00496 const XMC_VADC_QUEUE_ENTRY_t **const entries_array = handle_ptr->local_queue_entries; 00497 00498 for(entry_index = 0; entry_index < handle_ptr->total_number_of_entries; entry_index++) 00499 { 00500 XMC_VADC_GROUP_QueueInsertChannel(queue_group_ptr, *entries_array[entry_index]); 00501 } 00502 } 00503 #endif 00504 00505 /*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/ 00506 __STATIC_INLINE bool ADC_MEASUREMENT_ADV_lArbitrationStatus(const ADC_MEASUREMENT_ADV_t *const handle_ptr) 00507 { 00508 bool clock_reset_check; 00509 bool arbitration_status; 00510 00511 #if !defined(CLOCK_GATING_SUPPORTED) || !defined(ADC_MEASUREMENT_ADV_CHECK_CLOCK_GATING) 00512 clock_reset_check = (bool)false; 00513 #endif 00514 arbitration_status = (bool)false; 00515 00516 /* To check if the arbiter is already enabled. Before checking this ensure that clock and reset states are correct */ 00517 #if defined(CLOCK_GATING_SUPPORTED) && defined(ADC_MEASUREMENT_ADV_CHECK_CLOCK_GATING) 00518 clock_reset_check = !XMC_SCU_CLOCK_IsPeripheralClockGated(XMC_SCU_PERIPHERAL_CLOCK_VADC); 00519 #endif 00520 #ifdef PERIPHERAL_RESET_SUPPORTED 00521 clock_reset_check |= !XMC_SCU_RESET_IsPeripheralResetAsserted(XMC_SCU_PERIPHERAL_RESET_VADC); 00522 #endif 00523 if(clock_reset_check != (bool)false) 00524 { 00525 #ifdef ADC_MEASUREMENT_ADV_SCAN_USED 00526 #ifdef ADC_MEASUREMENT_ADV_QUEUE_USED 00527 if ( ADC_MEASUREMENT_ADV_REQUEST_SOURCE_LOCAL_SCAN >= handle_ptr->req_src) 00528 #endif 00529 { 00530 arbitration_status = XMC_VADC_GROUP_ScanIsArbitrationSlotEnabled(group_ptrs[handle_ptr->group_index]); 00531 } 00532 #endif 00533 00534 #ifdef ADC_MEASUREMENT_ADV_QUEUE_USED 00535 #ifdef ADC_MEASUREMENT_ADV_SCAN_USED 00536 else 00537 #endif 00538 { 00539 arbitration_status = XMC_VADC_GROUP_QueueIsArbitrationSlotEnabled(group_ptrs[handle_ptr->group_index]); 00540 } 00541 #endif 00542 } 00543 return (arbitration_status); 00544 } 00545 00546 /*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/ 00547 __STATIC_INLINE void ADC_MEASUREMENT_ADV_lDisableArbitration(const ADC_MEASUREMENT_ADV_t *const handle_ptr, 00548 bool arbitration_status) 00549 { 00550 if(arbitration_status == (bool)false) 00551 { 00552 #ifdef ADC_MEASUREMENT_ADV_SCAN_USED 00553 #ifdef ADC_MEASUREMENT_ADV_QUEUE_USED 00554 if ( ADC_MEASUREMENT_ADV_REQUEST_SOURCE_LOCAL_SCAN >= handle_ptr->req_src) 00555 #endif 00556 { 00557 XMC_VADC_GROUP_ScanDisableArbitrationSlot(group_ptrs[handle_ptr->group_index]); 00558 } 00559 #endif 00560 00561 #ifdef ADC_MEASUREMENT_ADV_QUEUE_USED 00562 #ifdef ADC_MEASUREMENT_ADV_SCAN_USED 00563 else 00564 #endif 00565 { 00566 XMC_VADC_GROUP_QueueDisableArbitrationSlot(group_ptrs[handle_ptr->group_index]); 00567 } 00568 #endif 00569 } 00570 } 00571 00572 /*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/ 00573 /* Insert channels into the hardware*/ 00574 void ADC_MEASUREMENT_ADV_lInsertChannels(const ADC_MEASUREMENT_ADV_t *const handle_ptr) 00575 { 00576 XMC_ASSERT("ADC_MEASUREMENT_ADV_InsertChannels:Invalid handle_ptr", (handle_ptr != NULL)) 00577 00578 #ifdef ADC_MEASUREMENT_ADV_SCAN_USED 00579 #ifdef ADC_MEASUREMENT_ADV_QUEUE_USED 00580 if ( ADC_MEASUREMENT_ADV_REQUEST_SOURCE_LOCAL_SCAN >= handle_ptr->req_src) 00581 #endif 00582 { 00583 #ifdef ADC_MEASUREMENT_ADV_LOCAL_SCAN_USED 00584 #ifdef ADC_MEASUREMENT_ADV_ADC_SCAN_USED 00585 if ( ADC_MEASUREMENT_ADV_REQUEST_SOURCE_SCAN != handle_ptr->req_src) 00586 #endif 00587 { 00588 XMC_VADC_GROUP_ScanAddMultipleChannels(group_ptrs[handle_ptr->group_index], handle_ptr->local_scan_handle->insert_mask); 00589 } 00590 #endif 00591 00592 #ifdef ADC_MEASUREMENT_ADV_ADC_SCAN_USED 00593 #ifdef ADC_MEASUREMENT_ADV_LOCAL_SCAN_USED 00594 else 00595 #endif 00596 { 00597 ADC_SCAN_AllEntriesInserted(handle_ptr->scan_handle); 00598 } 00599 #endif 00600 } 00601 #endif 00602 00603 #ifdef ADC_MEASUREMENT_ADV_QUEUE_USED 00604 #ifdef ADC_MEASUREMENT_ADV_SCAN_USED 00605 else 00606 #endif 00607 { 00608 #ifdef ADC_MEASUREMENT_ADV_LOCAL_QUEUE_USED 00609 #ifdef ADC_MEASUREMENT_ADV_ADC_QUEUE_USED 00610 if ( ADC_MEASUREMENT_ADV_REQUEST_SOURCE_QUEUE != handle_ptr->req_src) 00611 #endif 00612 { 00613 ADC_MEASUREMENT_ADV_lQueueInsertEntries(handle_ptr); 00614 } 00615 #endif 00616 00617 #ifdef ADC_MEASUREMENT_ADV_ADC_QUEUE_USED 00618 #ifdef ADC_MEASUREMENT_ADV_LOCAL_QUEUE_USED 00619 else 00620 #endif 00621 { 00622 ADC_QUEUE_AllEntriesInserted(handle_ptr->queue_handle); 00623 } 00624 #endif 00625 } 00626 #endif 00627 } 00628 00629 /*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/ 00630 /* Select the boundary for a channel and configure its value as well.*/ 00631 void ADC_MEASUREMENT_ADV_lSetBoundary(const ADC_MEASUREMENT_ADV_CHANNEL_t *const handle_ptr, 00632 XMC_VADC_CHANNEL_BOUNDARY_t boundary_select, 00633 uint32_t boundary_value) 00634 { 00635 XMC_ASSERT("ADC_MEASUREMENT_ADV_SetBoundary:Invalid handle_ptr", (handle_ptr != NULL)) 00636 00637 switch(boundary_select) 00638 { 00639 case XMC_VADC_CHANNEL_BOUNDARY_GROUP_BOUND0: 00640 case XMC_VADC_CHANNEL_BOUNDARY_GROUP_BOUND1: 00641 XMC_VADC_GROUP_SetIndividualBoundary(group_ptrs[handle_ptr->group_index], boundary_select, 00642 (uint16_t)boundary_value); 00643 break; 00644 00645 case XMC_VADC_CHANNEL_BOUNDARY_GLOBAL_BOUND0: 00646 case XMC_VADC_CHANNEL_BOUNDARY_GLOBAL_BOUND1: 00647 XMC_VADC_GLOBAL_SetIndividualBoundary(ADC_MEASUREMENT_ADV_GLOBAL_PTR, 00648 boundary_select, 00649 (uint16_t)boundary_value); 00650 break; 00651 } 00652 } 00653 /*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/ 00654 #ifndef ADC_MEASUREMENT_ADV_SYNC_USED 00655 /* Address the errata for the incorrect conversion.*/ 00656 void ADC_MEASUREMENT_ADV_lSyncADCClocks(void) 00657 { 00658 int32_t group_index; 00659 00660 for (group_index = (int32_t)XMC_VADC_MAXIMUM_NUM_GROUPS - (int32_t)1; group_index >= (int32_t)0 ; group_index--) 00661 { 00662 XMC_VADC_GROUP_SetPowerMode(group_ptrs[group_index],XMC_VADC_GROUP_POWERMODE_OFF); 00663 } 00664 00665 for (group_index = (int32_t)XMC_VADC_MAXIMUM_NUM_GROUPS - (int32_t)1; group_index > (int32_t)0 ; group_index--) 00666 { 00667 XMC_VADC_GROUP_SetSyncSlave(group_ptrs[group_index], (uint32_t)0, (uint32_t)group_index); 00668 00669 XMC_VADC_GROUP_CheckSlaveReadiness(group_ptrs[0U], (uint32_t)group_index); 00670 } 00671 00672 XMC_VADC_GROUP_SetSyncMaster(group_ptrs[0U]); 00673 00674 XMC_VADC_GROUP_SetPowerMode(group_ptrs[0U],XMC_VADC_GROUP_POWERMODE_NORMAL); 00675 } 00676 #endif 00677 /********************************************************************************************************************** 00678 * API IMPLEMENTATION 00679 **********************************************************************************************************************/ 00680 00681 /*This function returns the version of the ADC_MEASUREMENT App*/ 00682 DAVE_APP_VERSION_t ADC_MEASUREMENT_ADV_GetAppVersion(void) 00683 { 00684 DAVE_APP_VERSION_t version; 00685 00686 version.major = (uint8_t) ADC_MEASUREMENT_ADV_MAJOR_VERSION; 00687 version.minor = (uint8_t) ADC_MEASUREMENT_ADV_MINOR_VERSION; 00688 version.patch = (uint8_t) ADC_MEASUREMENT_ADV_PATCH_VERSION; 00689 00690 return version; 00691 } 00692 00693 /*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/ 00694 /* Enables the arbiter of the selected request source*/ 00695 void ADC_MEASUREMENT_ADV_StartADC(const ADC_MEASUREMENT_ADV_t *const handle_ptr) 00696 { 00697 #ifdef ADC_MEASUREMENT_ADV_SCAN_USED 00698 #ifdef ADC_MEASUREMENT_ADV_QUEUE_USED 00699 if ( ADC_MEASUREMENT_ADV_REQUEST_SOURCE_LOCAL_SCAN >= handle_ptr->req_src) 00700 #endif 00701 { 00702 XMC_VADC_GROUP_ScanEnableArbitrationSlot(group_ptrs[handle_ptr->group_index]); 00703 } 00704 #endif 00705 00706 #ifdef ADC_MEASUREMENT_ADV_QUEUE_USED 00707 #ifdef ADC_MEASUREMENT_ADV_SCAN_USED 00708 else 00709 #endif 00710 { 00711 XMC_VADC_GROUP_QueueEnableArbitrationSlot(group_ptrs[handle_ptr->group_index]); 00712 } 00713 #endif 00714 } 00715 00716 /*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/ 00717 /* Starts the ADC conversions by causing a software start of conversion*/ 00718 void ADC_MEASUREMENT_ADV_SoftwareTrigger(const ADC_MEASUREMENT_ADV_t *const handle_ptr) 00719 { 00720 XMC_ASSERT("ADC_MEASUREMENT_ADV_StartConversion:Invalid handle_ptr", (handle_ptr != NULL)) 00721 00722 #ifdef ADC_MEASUREMENT_ADV_SCAN_USED 00723 #ifdef ADC_MEASUREMENT_ADV_QUEUE_USED 00724 if ( ADC_MEASUREMENT_ADV_REQUEST_SOURCE_LOCAL_SCAN >= handle_ptr->req_src) 00725 #endif 00726 { 00727 XMC_VADC_GROUP_ScanTriggerConversion(group_ptrs[handle_ptr->group_index]); 00728 } 00729 #endif 00730 #ifdef ADC_MEASUREMENT_ADV_QUEUE_USED 00731 #ifdef ADC_MEASUREMENT_ADV_SCAN_USED 00732 else 00733 #endif 00734 { 00735 XMC_VADC_GROUP_QueueTriggerConversion(group_ptrs[handle_ptr->group_index]); 00736 } 00737 #endif 00738 } 00739 00740 00741 /*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/ 00742 /* Enables the NVIC(if needed) when scan/queue request source is consumed internally in the APP. */ 00743 void ADC_MEASUREMENT_ADC_lNvicEnable(const ADC_MEASUREMENT_ADV_t *const handle_ptr) 00744 { 00745 #ifdef ADC_MEASUREMENT_ADV_LOCAL_SCAN_USED 00746 if (((bool)true == handle_ptr->local_scan_handle->rs_intr_handle.interrupt_enable) && 00747 (ADC_MEASUREMENT_ADV_REQUEST_SOURCE_LOCAL_SCAN == handle_ptr->req_src)) 00748 { 00749 NVIC_EnableIRQ((IRQn_Type)handle_ptr->local_scan_handle->rs_intr_handle.node_id); 00750 } 00751 #endif 00752 #ifdef ADC_MEASUREMENT_ADV_LOCAL_QUEUE_USED 00753 if (((bool)true == handle_ptr->local_queue_handle->rs_intr_handle.interrupt_enable) && 00754 (ADC_MEASUREMENT_ADV_REQUEST_SOURCE_LOCAL_QUEUE == handle_ptr->req_src)) 00755 { 00756 NVIC_EnableIRQ((IRQn_Type)handle_ptr->local_queue_handle->rs_intr_handle.node_id); 00757 } 00758 #endif 00759 } 00760 00761 /*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/ 00762 /* Configures the result results . */ 00763 __STATIC_INLINE void ADC_MEASUREMENT_ADC_lResultInit(const ADC_MEASUREMENT_ADV_CHANNEL_t *indexed) 00764 { 00765 #ifdef ADC_MEASUREMENT_ADV_FIFO_USED 00766 uint8_t fifo_num_of_intermediate_stages; 00767 uint8_t fifo_index; 00768 uint8_t fifo_head; 00769 #endif 00770 #ifdef ADC_MEASUREMENT_ADV_FIFO_USED 00771 /* If FIFO is selected for the particular channel then do the FIFO initializations*/ 00772 if ( (uint32_t)0 != indexed->max_fifo_required) 00773 { 00774 /*Excluding the head and tail from the total number of FIFO elements needed*/ 00775 fifo_num_of_intermediate_stages = indexed->max_fifo_required - ADC_MEASUREMENT_ADV_RESERVED_REGISTERS; 00776 00777 fifo_head = (uint8_t)indexed->ch_handle->result_reg_number; 00778 for (fifo_index = 1; fifo_index <= fifo_num_of_intermediate_stages; fifo_index++) 00779 { 00780 XMC_VADC_GROUP_ResultInit(group_ptrs[indexed->group_index], (uint32_t)fifo_head - fifo_index, 00781 &ADC_MEASUREMENT_ADV_fifo_intermediate_stage); 00782 } 00783 00784 /* For the FIFO Tail configuration*/ 00785 XMC_VADC_GROUP_ResultInit(group_ptrs[indexed->group_index], (uint32_t)indexed->result_fifo_tail_number, 00786 indexed->res_handle[ADC_MEASUREMENT_ADV_TAIL_RESULT_REG_CONFIG]); 00787 } 00788 #endif 00789 /* Initialize for configured result registers For FIFO Head configuration*/ 00790 XMC_VADC_GROUP_ResultInit(group_ptrs[indexed->group_index], (uint32_t)indexed->ch_handle->result_reg_number, 00791 indexed->res_handle[ADC_MEASUREMENT_ADV_HEAD_RESULT_REG_CONFIG]); 00792 } 00793 00794 /*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/ 00795 /* Initialization routine to call ADC LLD API's */ 00796 ADC_MEASUREMENT_ADV_STATUS_t ADC_MEASUREMENT_ADV_Init(const ADC_MEASUREMENT_ADV_t *const handle_ptr) 00797 { 00798 XMC_ASSERT("ADC_MEASUREMENT_ADV_Init:Invalid handle_ptr", (handle_ptr != NULL)) 00799 00800 const ADC_MEASUREMENT_ADV_CHANNEL_t *indexed; 00801 uint8_t ch_num; 00802 uint8_t total_number_of_channels; 00803 ADC_MEASUREMENT_ADV_STATUS_t status; 00804 #ifdef ADC_MEASUREMENT_ADV_SHS_GAIN_NON_DEFAULT 00805 uint8_t channel_number; 00806 #endif 00807 bool arbitration_status = (bool)false; 00808 00809 if (ADC_MEASUREMENT_ADV_STATUS_UNINITIALIZED == *handle_ptr->init_state) 00810 { 00811 00812 arbitration_status = ADC_MEASUREMENT_ADV_lArbitrationStatus(handle_ptr); 00813 00814 /* Initialize the scan/queue request source.*/ 00815 status = ADC_MEASUREMENT_ADV_lRequestSrcInit(handle_ptr); 00816 00817 /* Disable the Arbitration if no other instance has enabled it*/ 00818 ADC_MEASUREMENT_ADV_lDisableArbitration(handle_ptr,arbitration_status); 00819 00820 #ifdef ADC_MEASUREMENT_ADV_SYNC_USED 00821 #ifdef ADC_MEASUREMENT_ADV_SYNC_NOT_ALL_USED 00822 if ((uint32_t)0 != handle_ptr->sync_slaves) 00823 #endif 00824 { 00825 /* Configure the Sync conversion operation */ 00826 ADC_MEASUREMENT_ADV_lSyncInit(handle_ptr); 00827 } 00828 #else 00829 ADC_MEASUREMENT_ADV_lSyncADCClocks(); 00830 #endif 00831 00832 /* Initialize the SR lines for the Channel event and the Result event, if required*/ 00833 #ifdef ADC_MEASUREMENT_ADV_MUX_USED 00834 #ifdef ADC_MEASUREMENT_ADV_MUX_NOT_ALL_USED 00835 if (handle_ptr->event_config != NULL) 00836 #endif 00837 { 00838 (handle_ptr->event_config)(); 00839 } 00840 #endif 00841 00842 total_number_of_channels = (uint8_t)handle_ptr->total_number_of_channels; 00843 for (ch_num = (uint8_t)0; ch_num < (uint8_t)total_number_of_channels; ch_num++) 00844 { 00845 indexed = handle_ptr->channel_array[ch_num]; 00846 00847 /* Initialize for configured channels*/ 00848 XMC_VADC_GROUP_ChannelInit(group_ptrs[indexed->group_index],(uint32_t)indexed->ch_num, indexed->ch_handle); 00849 00850 #if (XMC_VADC_SHS_AVAILABLE == 1U) 00851 #ifdef ADC_MEASUREMENT_ADV_SHS_GAIN_NON_DEFAULT 00852 channel_number = indexed->ch_num; 00853 #ifdef ADC_MEASUREMENT_ADV_SHS_GAIN_ALIAS 00854 if (indexed->ch_handle->alias_channel != XMC_VADC_CHANNEL_ALIAS_DISABLED) 00855 { 00856 channel_number = indexed->ch_handle->alias_channel; 00857 } 00858 #endif 00859 XMC_VADC_GLOBAL_SHS_SetGainFactor(ADC_MEASUREMENT_ADV_SHS_PTR, 00860 (uint8_t)indexed->shs_gain_factor, 00861 (XMC_VADC_GROUP_INDEX_t)indexed->group_index, 00862 channel_number); 00863 #endif 00864 #endif 00865 00866 /* Result Init both with and without FIFO */ 00867 ADC_MEASUREMENT_ADC_lResultInit(indexed); 00868 00869 #ifdef ADC_MEASUREMENT_ADV_ANALOG_IO_USED 00870 /* ANALOG_IO initialization for the channel*/ 00871 #ifndef ADC_MEASUREMENT_ADV_ANALOG_IO_ALL_CHANNELS_USED 00872 if(indexed->analog_io_config != NULL) 00873 #endif 00874 { 00875 status |= (ADC_MEASUREMENT_ADV_STATUS_t) ANALOG_IO_Init(indexed->analog_io_config); 00876 } 00877 #endif 00878 } 00879 00880 #if defined(ADC_MEASUREMENT_ADV_ADC_SCAN_USED) || defined(ADC_MEASUREMENT_ADV_ADC_QUEUE_USED) 00881 /* Load the queue/scan entries into ADC_QUEUE/ADC_SCAN. 00882 * This would load the scan/ queue entries into the software buffers in the ADC_SCAN/ADC_QUEUE APPs. 00883 * A call to this API would only configure the ADC_SCAN/ADC_QUEUE software buffers and will not be 00884 * programmed into the Hardware. The programming into the hardware is taken care by another API. 00885 */ 00886 #if defined(ADC_MEASUREMENT_ADV_LOCAL_SCAN_USED) || defined(ADC_MEASUREMENT_ADV_LOCAL_QUEUE_USED) 00887 if( (ADC_MEASUREMENT_ADV_REQUEST_SOURCE_SCAN == handle_ptr->req_src) || 00888 (ADC_MEASUREMENT_ADV_REQUEST_SOURCE_QUEUE == handle_ptr->req_src)) 00889 #endif 00890 { 00891 for (ch_num = (uint8_t)0; ch_num < (uint8_t)handle_ptr->total_number_of_entries; ch_num++) 00892 { 00893 ADC_MEASUREMENT_ADV_lInsertEntry(handle_ptr,ch_num); 00894 } 00895 } 00896 #endif 00897 00898 /* Enables the NVIC node if NVIC node is consumed inside the APP*/ 00899 ADC_MEASUREMENT_ADC_lNvicEnable(handle_ptr); 00900 00901 /* Load the queue/scan entries into the hardware */ 00902 ADC_MEASUREMENT_ADV_lInsertChannels(handle_ptr); 00903 00904 /*Start the arbiter of the ADC request source after the initialization. */ 00905 #ifdef ADC_MEASUREMENT_ADV_START_ADC 00906 #ifdef ADC_MEASUREMENT_ADV_NOT_ALL_REQ_START 00907 if ((bool)false != handle_ptr->start_at_initialization) 00908 #endif 00909 { 00910 ADC_MEASUREMENT_ADV_StartADC(handle_ptr); 00911 } 00912 #endif 00913 00914 *handle_ptr->init_state = status; 00915 } 00916 return (*handle_ptr->init_state); 00917 } 00918 00919 /*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/ 00920 /* Set the Fast compare value*/ 00921 ADC_MEASUREMENT_ADV_STATUS_t ADC_MEASUREMENT_ADV_SetFastCompareValue(const ADC_MEASUREMENT_ADV_CHANNEL_t 00922 *const handle_ptr, uint16_t compare_value) 00923 { 00924 ADC_MEASUREMENT_ADV_STATUS_t status; 00925 XMC_ASSERT("ADC_MEASUREMENT_ADV_SetFastCompareValue:Invalid handle_ptr", (handle_ptr != NULL)) 00926 00927 status = ADC_MEASUREMENT_ADV_STATUS_FAILURE; 00928 00929 if ( (uint32_t)compare_value <= ADC_MEASUREMENT_ADV_10_BIT_MAX_VALUE) 00930 { 00931 XMC_VADC_GROUP_SetResultFastCompareValue(group_ptrs[handle_ptr->group_index], 00932 (uint32_t) handle_ptr->ch_handle->result_reg_number, 00933 (XMC_VADC_RESULT_SIZE_t)compare_value); 00934 status = ADC_MEASUREMENT_ADV_STATUS_SUCCESS; 00935 } 00936 return (status); 00937 } 00938 00939 /*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/ 00940 /* Set the Subtraction value */ 00941 void ADC_MEASUREMENT_ADV_SetSubtractionValue(const ADC_MEASUREMENT_ADV_t *const handle_ptr, 00942 ADC_MEASUREMENT_ADV_SUBTRATION_t subtraction_alignment, 00943 uint16_t subtraction_value) 00944 { 00945 uint32_t groups; 00946 uint8_t i; 00947 XMC_ASSERT("ADC_MEASUREMENT_ADV_SetSubtractionValue:Invalid handle_ptr", (handle_ptr != NULL)) 00948 00949 #ifdef ADC_MEASUREMENT_ADV_SYNC_USED 00950 groups = handle_ptr->sync_slaves; 00951 #else 00952 groups = (uint32_t)0; 00953 #endif 00954 groups |= (uint32_t)((uint32_t)1 << (uint32_t)handle_ptr->group_index); 00955 for ( i = (uint8_t)0; i < (uint8_t)XMC_VADC_MAXIMUM_NUM_GROUPS ; i++) 00956 { 00957 if ( (bool)false != (bool)((groups >> i) & (uint32_t)0x1 )) 00958 { 00959 XMC_VADC_GROUP_SetResultSubtractionValue(group_ptrs[i], (uint16_t)(subtraction_value 00960 << (uint32_t)subtraction_alignment)); 00961 } 00962 } 00963 00964 } 00965 00966 /*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/ 00967 /* Configure the resolution and sampling time in an iclass */ 00968 void ADC_MEASUREMENT_ADV_ConfigureChannelClass(const ADC_MEASUREMENT_ADV_CHANNEL_t *const handle_ptr, 00969 const XMC_VADC_GROUP_CLASS_t *config) 00970 { 00971 XMC_ASSERT("ADC_MEASUREMENT_ADV_ConfigureChannelClass:Invalid class configuration", (config != NULL)) 00972 00973 XMC_VADC_GROUP_InputClassInit(group_ptrs[handle_ptr->group_index], *config, XMC_VADC_GROUP_CONV_STD, 00974 (uint32_t)handle_ptr->ch_handle->input_class); 00975 } 00976 00977 /*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/ 00978 /* Sets the alternate reference for a particular channel*/ 00979 void ADC_MEASUREMENT_ADV_SetAlternateReference(const ADC_MEASUREMENT_ADV_CHANNEL_t *const handle_ptr, 00980 const XMC_VADC_CHANNEL_REF_t reference_select) 00981 { 00982 XMC_ASSERT("ADC_MEASUREMENT_ADV_SetAlternateReference:Invalid handle_ptr", (handle_ptr != NULL)) 00983 00984 XMC_VADC_GROUP_ChannelSetInputReference(group_ptrs[handle_ptr->group_index], (uint32_t)handle_ptr->ch_num, 00985 reference_select); 00986 00987 } 00988 00989 #if (XMC_VADC_SHS_AVAILABLE == 1U) 00990 /*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/ 00991 /* Sets the gain ratio for a particular channel*/ 00992 void ADC_MEASUREMENT_ADV_SetChannelGain(const ADC_MEASUREMENT_ADV_CHANNEL_t *const handle_ptr, 00993 const ADC_MEASUREMENT_ADV_GAIN_t gain_factor) 00994 { 00995 uint8_t channel_number; 00996 XMC_ASSERT("ADC_MEASUREMENT_ADV_SetChannelGain:Invalid handle_ptr", (handle_ptr != NULL)) 00997 00998 channel_number = handle_ptr->ch_num; 00999 #ifdef ADC_MEASUREMENT_ADV_SHS_GAIN_ALIAS 01000 if (handle_ptr->ch_handle->alias_channel != XMC_VADC_CHANNEL_ALIAS_DISABLED) 01001 { 01002 channel_number = (uint8_t) handle_ptr->ch_handle->alias_channel; 01003 } 01004 #endif 01005 XMC_VADC_GLOBAL_SHS_SetGainFactor(ADC_MEASUREMENT_ADV_SHS_PTR, 01006 (uint8_t)gain_factor, 01007 (XMC_VADC_GROUP_INDEX_t)handle_ptr->group_index, 01008 (uint32_t)channel_number); 01009 } 01010 #endif 01011 01012 /*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/ 01013 /* Select the boundary for the channel*/ 01014 void ADC_MEASUREMENT_ADV_SelectBoundary(const ADC_MEASUREMENT_ADV_CHANNEL_t *const handle_ptr, 01015 XMC_VADC_BOUNDARY_SELECT_t boundary, 01016 XMC_VADC_CHANNEL_BOUNDARY_t boundary_selection) 01017 { 01018 XMC_ASSERT("ADC_MEASUREMENT_ADV_SelectBoundary:Invalid handle_ptr", (handle_ptr != NULL)) 01019 01020 XMC_VADC_GROUP_ChannelSetBoundarySelection(group_ptrs[handle_ptr->group_index], (uint32_t)handle_ptr->ch_num, 01021 boundary, boundary_selection); 01022 01023 } 01024 01025 /*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/ 01026 /* configure the upper boundary for a channel.*/ 01027 void ADC_MEASUREMENT_ADV_SetBoundaryUpper(const ADC_MEASUREMENT_ADV_CHANNEL_t *const handle_ptr, 01028 uint32_t boundary_value) 01029 { 01030 uint32_t boundary_select; 01031 XMC_ASSERT("ADC_MEASUREMENT_ADV_SetBoundary:Invalid handle_ptr", (handle_ptr != NULL)) 01032 01033 boundary_select = handle_ptr->ch_handle->upper_boundary_select; 01034 01035 ADC_MEASUREMENT_ADV_lSetBoundary(handle_ptr, (XMC_VADC_CHANNEL_BOUNDARY_t)boundary_select, boundary_value); 01036 } 01037 01038 /*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/ 01039 /* configure the lower boundary for a channel.*/ 01040 void ADC_MEASUREMENT_ADV_SetBoundaryLower(const ADC_MEASUREMENT_ADV_CHANNEL_t *const handle_ptr, 01041 uint32_t boundary_value) 01042 { 01043 uint32_t boundary_select; 01044 XMC_ASSERT("ADC_MEASUREMENT_ADV_SetBoundary:Invalid handle_ptr", (handle_ptr != NULL)) 01045 01046 boundary_select = handle_ptr->ch_handle->lower_boundary_select; 01047 01048 ADC_MEASUREMENT_ADV_lSetBoundary(handle_ptr, (XMC_VADC_CHANNEL_BOUNDARY_t)boundary_select, boundary_value); 01049 } 01050 01051 01052 /*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/ 01053 /* Aliased channel number is returned if the channel has alias enabled */ 01054 XMC_VADC_CHANNEL_ALIAS_t ADC_MEASUREMENT_ADV_GetAliasValue(const ADC_MEASUREMENT_ADV_CHANNEL_t *const handle_ptr) 01055 { 01056 XMC_VADC_CHANNEL_ALIAS_t return_value; 01057 ADC_MEASUREMENT_ADV_ALIAS_t alias_value; 01058 01059 XMC_ASSERT("ADC_MEASUREMENT_ADV_GetAliasValue:Invalid handle_ptr", (handle_ptr != NULL)) 01060 01061 alias_value.alias = XMC_VADC_GROUP_GetAlias(group_ptrs[handle_ptr->group_index]); 01062 if ((uint8_t)0 == handle_ptr->ch_num ) 01063 { 01064 return_value = (XMC_VADC_CHANNEL_ALIAS_t)alias_value.alias0; 01065 if ((uint32_t)0 == alias_value.alias0) 01066 { 01067 return_value = XMC_VADC_CHANNEL_ALIAS_DISABLED; 01068 } 01069 } 01070 else if ((uint8_t)1 == handle_ptr->ch_num ) 01071 { 01072 return_value = (XMC_VADC_CHANNEL_ALIAS_t)alias_value.alias1; 01073 if ((uint32_t)1 == alias_value.alias1) 01074 { 01075 return_value = XMC_VADC_CHANNEL_ALIAS_DISABLED; 01076 } 01077 } 01078 else 01079 { 01080 return_value = XMC_VADC_CHANNEL_ALIAS_DISABLED; 01081 } 01082 01083 return(return_value); 01084 01085 } 01086 /*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/ 01087 01088 #ifdef ADC_MEASUREMENT_ADV_SYNC_USED 01089 /* Enables uniform conversion configurations across slaves*/ 01090 void ADC_MEASUREMENT_ADV_SetIclass(const ADC_MEASUREMENT_ADV_t *const handle_ptr) 01091 { 01092 XMC_VADC_CHANNEL_CONV_t req_iclass; 01093 XMC_VADC_GROUP_CLASS_t conv_class; 01094 XMC_VADC_GLOBAL_CLASS_t conv_class_global; 01095 01096 XMC_ASSERT("ADC_MEASUREMENT_ADV_SetIclass:Invalid handle_ptr", (handle_ptr != NULL)) 01097 01098 req_iclass = ADC_MEASUREMENT_ADV_lGetIclass(handle_ptr); 01099 conv_class = XMC_VADC_GROUP_GetInputClass(group_ptrs[handle_ptr->group_index], req_iclass); 01100 conv_class_global.globiclass = conv_class.g_iclass0; 01101 XMC_VADC_GLOBAL_InputClassInit(ADC_MEASUREMENT_ADV_GLOBAL_PTR, conv_class_global, 01102 XMC_VADC_GROUP_CONV_STD, (uint32_t)ADC_MEASUREMENT_ADV_GLOBICLASS1); 01103 01104 } 01105 #endif