+++ /dev/null
-/*******************************************************************************\r
- * (c) Copyright 2009 Actel Corporation. All rights reserved.\r
- * \r
- * SVN $Revision: 2840 $\r
- * SVN $Date: 2010-07-20 17:00:32 +0100 (Tue, 20 Jul 2010) $\r
- */\r
-#include "mss_ace.h"\r
-#include "mss_ace_configurator.h"\r
-#include "../../CMSIS/a2fxxxm3.h"\r
-#include "../../CMSIS/mss_assert.h"\r
-#include "../../drivers_config/mss_ace/ace_handles.h"\r
-#include "../../drivers_config/mss_ace/ace_config.h"\r
-#include <string.h>\r
-\r
-#ifdef __cplusplus\r
-extern "C" {\r
-#endif \r
-\r
-#define MAX_FULL_FLAG_NAME_LENGTH (MAX_CHANNEL_NAME_LENGTH + MAX_FLAG_NAME_LENGTH + 1)\r
-\r
-/*-------------------------------------------------------------------------*//**\r
- * Number of flag types supported.\r
- * the supported flag types are:\r
- * - BASIC_THRESHOLD_OVER\r
- * - BASIC_THRESHOLD_UNDER\r
- * - STATE_FILTERED_OVER\r
- * - STATE_FILTERED_UNDER\r
- * - DUAL_HYSTERESIS_OVER\r
- * - DUAL_HYSTERESIS_UNDER\r
- * - IPMI_HYSTERESIS_OVER\r
- * - IPMI_HYSTERESIS_UNDER\r
- */\r
-#define NB_OF_FLAG_TYPES 8\r
-\r
-/*-------------------------------------------------------------------------*//**\r
- *\r
- */\r
-#define THRESHOLD_FLAG0 0u\r
-#define THRESHOLD_FLAG1 1u\r
-#define THRESHOLD_FLAG2 2u\r
-#define THRESHOLD_FLAG3 3u\r
-#define THRESHOLD_FLAG4 4u\r
-#define THRESHOLD_FLAG5 5u\r
-#define THRESHOLD_FLAG6 6u\r
-#define THRESHOLD_FLAG7 7u\r
-#define THRESHOLD_FLAG8 8u\r
-#define THRESHOLD_FLAG9 9u\r
-#define THRESHOLD_FLAG10 10u\r
-#define THRESHOLD_FLAG11 11u\r
-#define THRESHOLD_FLAG12 12u\r
-#define THRESHOLD_FLAG13 13u\r
-#define THRESHOLD_FLAG14 14u\r
-#define THRESHOLD_FLAG15 15u\r
-#define THRESHOLD_FLAG16 16u\r
-#define THRESHOLD_FLAG17 17u\r
-#define THRESHOLD_FLAG18 18u\r
-#define THRESHOLD_FLAG19 19u\r
-#define THRESHOLD_FLAG20 20u\r
-#define THRESHOLD_FLAG21 21u\r
-#define THRESHOLD_FLAG22 22u\r
-#define THRESHOLD_FLAG23 23u\r
-#define THRESHOLD_FLAG24 24u\r
-#define THRESHOLD_FLAG25 25u\r
-#define THRESHOLD_FLAG26 26u\r
-#define THRESHOLD_FLAG27 27u\r
-#define THRESHOLD_FLAG28 28u\r
-#define THRESHOLD_FLAG29 29u\r
-#define THRESHOLD_FLAG30 30u\r
-#define THRESHOLD_FLAG31 31u\r
-#define NB_OF_THRESHOLD_IRQ 32u\r
-\r
-/*-------------------------------------------------------------------------*//**\r
- *\r
- */\r
-void ace_init_flags( void );\r
-\r
-/*-------------------------------------------------------------------------*//**\r
- * Flag interrupots routines function prototypes\r
- */\r
-#if defined(__GNUC__)\r
-__attribute__((__interrupt__)) void ACE_PPE_Flag0_IRQHandler( void );\r
-#else\r
-void ACE_PPE_Flag0_IRQHandler( void );\r
-#endif\r
-\r
-#if defined(__GNUC__)\r
-__attribute__((__interrupt__)) void ACE_PPE_Flag1_IRQHandler( void );\r
-#else\r
-void ACE_PPE_Flag1_IRQHandler( void );\r
-#endif\r
-\r
-#if defined(__GNUC__)\r
-__attribute__((__interrupt__)) void ACE_PPE_Flag2_IRQHandler( void );\r
-#else\r
-void ACE_PPE_Flag2_IRQHandler( void );\r
-#endif\r
-\r
-#if defined(__GNUC__)\r
-__attribute__((__interrupt__)) void ACE_PPE_Flag3_IRQHandler( void );\r
-#else\r
-void ACE_PPE_Flag3_IRQHandler( void );\r
-#endif\r
-\r
-#if defined(__GNUC__)\r
-__attribute__((__interrupt__)) void ACE_PPE_Flag4_IRQHandler( void );\r
-#else\r
-void ACE_PPE_Flag4_IRQHandler( void );\r
-#endif\r
-\r
-#if defined(__GNUC__)\r
-__attribute__((__interrupt__)) void ACE_PPE_Flag5_IRQHandler( void );\r
-#else\r
-void ACE_PPE_Flag5_IRQHandler( void );\r
-#endif\r
-\r
-#if defined(__GNUC__)\r
-__attribute__((__interrupt__)) void ACE_PPE_Flag6_IRQHandler( void );\r
-#else\r
-void ACE_PPE_Flag6_IRQHandler( void );\r
-#endif\r
-\r
-#if defined(__GNUC__)\r
-__attribute__((__interrupt__)) void ACE_PPE_Flag7_IRQHandler( void );\r
-#else\r
-void ACE_PPE_Flag7_IRQHandler( void );\r
-#endif\r
-\r
-#if defined(__GNUC__)\r
-__attribute__((__interrupt__)) void ACE_PPE_Flag8_IRQHandler( void );\r
-#else\r
-void ACE_PPE_Flag8_IRQHandler( void );\r
-#endif\r
-\r
-#if defined(__GNUC__)\r
-__attribute__((__interrupt__)) void ACE_PPE_Flag9_IRQHandler( void );\r
-#else\r
-void ACE_PPE_Flag9_IRQHandler( void );\r
-#endif\r
-\r
-#if defined(__GNUC__)\r
-__attribute__((__interrupt__)) void ACE_PPE_Flag10_IRQHandler( void );\r
-#else\r
-void ACE_PPE_Flag10_IRQHandler( void );\r
-#endif\r
-\r
-#if defined(__GNUC__)\r
-__attribute__((__interrupt__)) void ACE_PPE_Flag11_IRQHandler( void );\r
-#else\r
-void ACE_PPE_Flag11_IRQHandler( void );\r
-#endif\r
-\r
-#if defined(__GNUC__)\r
-__attribute__((__interrupt__)) void ACE_PPE_Flag12_IRQHandler( void );\r
-#else\r
-void ACE_PPE_Flag12_IRQHandler( void );\r
-#endif\r
-\r
-#if defined(__GNUC__)\r
-__attribute__((__interrupt__)) void ACE_PPE_Flag13_IRQHandler( void );\r
-#else\r
-void ACE_PPE_Flag13_IRQHandler( void );\r
-#endif\r
-\r
-#if defined(__GNUC__)\r
-__attribute__((__interrupt__)) void ACE_PPE_Flag14_IRQHandler( void );\r
-#else\r
-void ACE_PPE_Flag14_IRQHandler( void );\r
-#endif\r
-\r
-#if defined(__GNUC__)\r
-__attribute__((__interrupt__)) void ACE_PPE_Flag15_IRQHandler( void );\r
-#else\r
-void ACE_PPE_Flag15_IRQHandler( void );\r
-#endif\r
-\r
-#if defined(__GNUC__)\r
-__attribute__((__interrupt__)) void ACE_PPE_Flag16_IRQHandler( void );\r
-#else\r
-void ACE_PPE_Flag16_IRQHandler( void );\r
-#endif\r
-\r
-#if defined(__GNUC__)\r
-__attribute__((__interrupt__)) void ACE_PPE_Flag17_IRQHandler( void );\r
-#else\r
-void ACE_PPE_Flag17_IRQHandler( void );\r
-#endif\r
-\r
-#if defined(__GNUC__)\r
-__attribute__((__interrupt__)) void ACE_PPE_Flag18_IRQHandler( void );\r
-#else\r
-void ACE_PPE_Flag18_IRQHandler( void );\r
-#endif\r
-\r
-#if defined(__GNUC__)\r
-__attribute__((__interrupt__)) void ACE_PPE_Flag19_IRQHandler( void );\r
-#else\r
-void ACE_PPE_Flag19_IRQHandler( void );\r
-#endif\r
-\r
-#if defined(__GNUC__)\r
-__attribute__((__interrupt__)) void ACE_PPE_Flag20_IRQHandler( void );\r
-#else\r
-void ACE_PPE_Flag20_IRQHandler( void );\r
-#endif\r
-\r
-#if defined(__GNUC__)\r
-__attribute__((__interrupt__)) void ACE_PPE_Flag21_IRQHandler( void );\r
-#else\r
-void ACE_PPE_Flag21_IRQHandler( void );\r
-#endif\r
-\r
-#if defined(__GNUC__)\r
-__attribute__((__interrupt__)) void ACE_PPE_Flag22_IRQHandler( void );\r
-#else\r
-void ACE_PPE_Flag22_IRQHandler( void );\r
-#endif\r
-\r
-#if defined(__GNUC__)\r
-__attribute__((__interrupt__)) void ACE_PPE_Flag23_IRQHandler( void );\r
-#else\r
-void ACE_PPE_Flag23_IRQHandler( void );\r
-#endif\r
-\r
-#if defined(__GNUC__)\r
-__attribute__((__interrupt__)) void ACE_PPE_Flag24_IRQHandler( void );\r
-#else\r
-void ACE_PPE_Flag24_IRQHandler( void );\r
-#endif\r
-\r
-#if defined(__GNUC__)\r
-__attribute__((__interrupt__)) void ACE_PPE_Flag25_IRQHandler( void );\r
-#else\r
-void ACE_PPE_Flag25_IRQHandler( void );\r
-#endif\r
-\r
-#if defined(__GNUC__)\r
-__attribute__((__interrupt__)) void ACE_PPE_Flag26_IRQHandler( void );\r
-#else\r
-void ACE_PPE_Flag26_IRQHandler( void );\r
-#endif\r
-\r
-#if defined(__GNUC__)\r
-__attribute__((__interrupt__)) void ACE_PPE_Flag27_IRQHandler( void );\r
-#else\r
-void ACE_PPE_Flag27_IRQHandler( void );\r
-#endif\r
-\r
-#if defined(__GNUC__)\r
-__attribute__((__interrupt__)) void ACE_PPE_Flag28_IRQHandler( void );\r
-#else\r
-void ACE_PPE_Flag28_IRQHandler( void );\r
-#endif\r
-\r
-#if defined(__GNUC__)\r
-__attribute__((__interrupt__)) void ACE_PPE_Flag29_IRQHandler( void );\r
-#else\r
-void ACE_PPE_Flag29_IRQHandler( void );\r
-#endif\r
-\r
-#if defined(__GNUC__)\r
-__attribute__((__interrupt__)) void ACE_PPE_Flag30_IRQHandler( void );\r
-#else\r
-void ACE_PPE_Flag30_IRQHandler( void );\r
-#endif\r
-\r
-#if defined(__GNUC__)\r
-__attribute__((__interrupt__)) void ACE_PPE_Flag31_IRQHandler( void );\r
-#else\r
-void ACE_PPE_Flag31_IRQHandler( void );\r
-#endif\r
-\r
-/*-------------------------------------------------------------------------*//**\r
- *\r
- */\r
-#if (ACE_NB_OF_PPE_FLAGS > 0)\r
-extern ppe_flag_desc_t g_ppe_flags_desc_table[ACE_NB_OF_PPE_FLAGS];\r
-#endif\r
-\r
-extern ace_channel_desc_t g_ace_channel_desc_table[ACE_NB_OF_INPUT_CHANNELS];\r
-\r
-extern ace_adc_config_t g_ace_adc_config[ACE_NB_OF_ADC];\r
-\r
-#if (ACE_NB_OF_PPE_FLAGS > 0)\r
-/*-------------------------------------------------------------------------*//**\r
- Lookup table indexed on flag_id_t of the index of the flag's descriptor index\r
- in the flag descriptors table g_ppe_flags_desc_table[]\r
- */\r
-static ace_flag_handle_t g_ppe_flag_handles_lut[NB_OF_PPE_FLAGS];\r
-\r
-/*-------------------------------------------------------------------------*//**\r
- *\r
- */\r
-static flag_isr_t g_ppe_flags_isr_lut[NB_OF_PPE_FLAGS];\r
-\r
-/*-------------------------------------------------------------------------*//**\r
- *\r
- */\r
-static global_flag_isr_t g_ppe_global_flags_isr;\r
-\r
-/*-------------------------------------------------------------------------*//**\r
- *\r
- */\r
-static channel_flag_isr_t g_ppe_channel_flags_isr_lut[ACE_NB_OF_INPUT_CHANNELS];\r
-#endif\r
-\r
-/*-------------------------------------------------------------------------*//**\r
- Intialise the ACE driver's internal data structures used by flag control\r
- functions.\r
- */\r
-void ace_init_flags( void )\r
-{\r
- /* Ensure the generated ACE configuration files are consistent. */\r
- ASSERT(NB_OF_ACE_FLAG_HANDLES == ACE_NB_OF_PPE_FLAGS);\r
- \r
-#if (ACE_NB_OF_PPE_FLAGS > 0) \r
- {\r
- uint8_t flag_idx;\r
- uint8_t channel_idx;\r
- \r
- for ( flag_idx = 0u; flag_idx < (uint8_t)NB_OF_PPE_FLAGS; ++flag_idx )\r
- {\r
- g_ppe_flags_isr_lut[flag_idx] = 0;\r
- g_ppe_flag_handles_lut[flag_idx] = INVALID_FLAG_HANDLE;\r
- }\r
- \r
- for ( flag_idx = 0u; flag_idx < (uint8_t)ACE_NB_OF_PPE_FLAGS; ++flag_idx )\r
- {\r
- ASSERT( g_ppe_flags_desc_table[flag_idx].flag_id < NB_OF_PPE_FLAGS );\r
- g_ppe_flag_handles_lut[g_ppe_flags_desc_table[flag_idx].flag_id] = (ace_flag_handle_t)flag_idx;\r
- }\r
- \r
- for ( channel_idx = 0u; channel_idx < (uint8_t)ACE_NB_OF_INPUT_CHANNELS; ++channel_idx )\r
- {\r
- g_ppe_channel_flags_isr_lut[channel_idx] = 0;\r
- }\r
- \r
- g_ppe_global_flags_isr = 0u;\r
- }\r
-#endif\r
-}\r
-\r
-/*-------------------------------------------------------------------------*//**\r
- *\r
- */\r
-uint32_t ACE_is_hysteresis_flag( ace_flag_handle_t flag_handle )\r
-{\r
- uint32_t hysteresis = 0u;\r
- \r
-#if (ACE_NB_OF_PPE_FLAGS > 0)\r
- ASSERT( flag_handle < NB_OF_ACE_FLAG_HANDLES );\r
- \r
- if ( g_ppe_flags_desc_table[flag_handle].flag_type >= DUAL_HYSTERESIS_OVER )\r
- {\r
- hysteresis = 1u;\r
- }\r
-#endif\r
- return hysteresis;\r
-}\r
-\r
-/*-------------------------------------------------------------------------*//**\r
- *\r
- */\r
-uint32_t ACE_is_under_flag\r
-(\r
- ace_flag_handle_t flag_handle\r
-)\r
-{\r
- uint32_t is_under = 0;\r
- \r
-#if (ACE_NB_OF_PPE_FLAGS > 0)\r
- const uint32_t flag_type_lut[NB_OF_FLAG_TYPES] =\r
- {\r
- 0, /* BASIC_THRESHOLD_OVER */\r
- 1, /* BASIC_THRESHOLD_UNDER */\r
- 0, /* STATE_FILTERED_OVER */\r
- 1, /* STATE_FILTERED_UNDER */\r
- 0, /* DUAL_HYSTERESIS_OVER */\r
- 1, /* DUAL_HYSTERESIS_UNDER */\r
- 0, /* IPMI_HYSTERESIS_OVER */\r
- 1, /* IPMI_HYSTERESIS_UNDER */\r
- };\r
- \r
- ASSERT(flag_handle < ACE_NB_OF_PPE_FLAGS);\r
- if (flag_handle < ACE_NB_OF_PPE_FLAGS)\r
- {\r
- uint8_t flag_type;\r
- flag_type = g_ppe_flags_desc_table[flag_handle].flag_type;\r
- ASSERT(flag_type < NB_OF_FLAG_TYPES);\r
- if (flag_type < NB_OF_FLAG_TYPES)\r
- {\r
- is_under = flag_type_lut[flag_type];\r
- }\r
- }\r
-#endif\r
- return is_under;\r
-}\r
-\r
-/*-------------------------------------------------------------------------*//**\r
- Mask of the threshold value bits within a PPE RAM meory location holding the\r
- threshold value for a flag.\r
- */\r
-#define PPE_RAM_THRESHOLD_MASK 0x0000FFFFuL\r
-\r
-/*-------------------------------------------------------------------------*//**\r
- * TODO: handle IPMI hysteresis flags\r
- */\r
-void ACE_set_flag_threshold\r
-(\r
- ace_flag_handle_t flag_handle,\r
- uint16_t new_threshold\r
-)\r
-{\r
-#if (ACE_NB_OF_PPE_FLAGS > 0)\r
- uint16_t ppe_offset;\r
- \r
- ASSERT( flag_handle < NB_OF_ACE_FLAG_HANDLES );\r
- \r
- if ( flag_handle < NB_OF_ACE_FLAG_HANDLES )\r
- {\r
- \r
- ppe_offset = g_ppe_flags_desc_table[flag_handle].threshold_ppe_offset;\r
- \r
- if ( ACE_is_hysteresis_flag( flag_handle ) == 0u )\r
- {\r
- ACE->PPE_RAM_DATA[ppe_offset] = (ACE->PPE_RAM_DATA[ppe_offset] & (uint32_t)~PPE_RAM_THRESHOLD_MASK) + new_threshold;\r
- }\r
- else\r
- {\r
- uint16_t high_threshold;\r
- uint16_t low_threshold;\r
- ace_channel_handle_t channel_handle;\r
- uint16_t hysteresis;\r
- uint32_t adc_id;\r
- uint16_t adc_resolution;\r
- \r
- high_threshold = (uint16_t)(ACE->PPE_RAM_DATA[ppe_offset] & PPE_RAM_THRESHOLD_MASK);\r
- low_threshold = (uint16_t)(ACE->PPE_RAM_DATA[ppe_offset + 1u] & PPE_RAM_THRESHOLD_MASK);\r
- ASSERT(high_threshold > low_threshold);\r
- hysteresis = (uint16_t)(high_threshold - low_threshold) / 2u;\r
- \r
- channel_handle = g_ppe_flags_desc_table[flag_handle].channel_handle;\r
- adc_id = (uint32_t)(g_ace_channel_desc_table[channel_handle].signal_id) >> 4u;\r
- ASSERT( adc_id < (uint32_t)ACE_NB_OF_ADC );\r
- \r
- if ( adc_id < (uint32_t)ACE_NB_OF_ADC )\r
- {\r
- adc_resolution = g_ace_adc_config[adc_id].adc_resolution - 1u;\r
- \r
- high_threshold = new_threshold + hysteresis;\r
- if ( high_threshold > adc_resolution )\r
- {\r
- high_threshold = adc_resolution;\r
- }\r
- \r
- if ( hysteresis > new_threshold )\r
- {\r
- low_threshold = 1u;\r
- }\r
- else\r
- {\r
- low_threshold = new_threshold - hysteresis;\r
- }\r
- \r
- ACE->PPE_RAM_DATA[ppe_offset] = (ACE->PPE_RAM_DATA[ppe_offset] & ~PPE_RAM_THRESHOLD_MASK) + high_threshold;\r
- ACE->PPE_RAM_DATA[ppe_offset + 1u] = (ACE->PPE_RAM_DATA[ppe_offset + 1u] & (uint32_t)~PPE_RAM_THRESHOLD_MASK) + low_threshold;\r
- }\r
- }\r
- }\r
-#endif\r
-}\r
-\r
-\r
-/*-------------------------------------------------------------------------*//**\r
- *\r
- */\r
-#define FLAG_OVER_UNDER_MASK 0x01u\r
-#define FLAG_OVER 0x00u\r
-#define FLAF_UNDER 0x01\r
-\r
-void ACE_set_flag_assertion\r
-(\r
- ace_flag_handle_t flag_handle,\r
- uint16_t assertion_value\r
-)\r
-{\r
-#if (ACE_NB_OF_PPE_FLAGS > 0)\r
- uint16_t ppe_offset;\r
- \r
- ASSERT( flag_handle < NB_OF_ACE_FLAG_HANDLES );\r
- \r
- if ( flag_handle < NB_OF_ACE_FLAG_HANDLES )\r
- {\r
- if (ACE_is_hysteresis_flag(flag_handle))\r
- {\r
- uint8_t flag_direction;\r
- flag_direction = g_ppe_flags_desc_table[flag_handle].flag_type & FLAG_OVER_UNDER_MASK;\r
- \r
- if ( FLAG_OVER == flag_direction )\r
- {\r
- ppe_offset = g_ppe_flags_desc_table[flag_handle].threshold_ppe_offset;\r
- }\r
- else\r
- {\r
- ppe_offset = g_ppe_flags_desc_table[flag_handle].threshold_ppe_offset + 1u;\r
- }\r
- }\r
- else\r
- {\r
- ppe_offset = g_ppe_flags_desc_table[flag_handle].threshold_ppe_offset;\r
- }\r
- ACE->PPE_RAM_DATA[ppe_offset] = (ACE->PPE_RAM_DATA[ppe_offset] & ~PPE_RAM_THRESHOLD_MASK) + assertion_value;\r
- }\r
-#endif\r
-}\r
-\r
-/*-------------------------------------------------------------------------*//**\r
- *\r
- */\r
-void ACE_set_flag_deassertion\r
-(\r
- ace_flag_handle_t flag_handle,\r
- uint16_t assertion_value\r
-)\r
-{\r
-#if (ACE_NB_OF_PPE_FLAGS > 0)\r
- uint16_t ppe_offset;\r
- \r
- ASSERT( flag_handle < NB_OF_ACE_FLAG_HANDLES );\r
- ASSERT(ACE_is_hysteresis_flag(flag_handle));\r
- \r
- if ((flag_handle < NB_OF_ACE_FLAG_HANDLES) && (ACE_is_hysteresis_flag(flag_handle)))\r
- {\r
- uint8_t flag_direction;\r
- flag_direction = g_ppe_flags_desc_table[flag_handle].flag_type & FLAG_OVER_UNDER_MASK;\r
- \r
- if ( FLAG_OVER == flag_direction )\r
- {\r
- ppe_offset = g_ppe_flags_desc_table[flag_handle].threshold_ppe_offset + 1u;\r
- }\r
- else\r
- {\r
- ppe_offset = g_ppe_flags_desc_table[flag_handle].threshold_ppe_offset;\r
- }\r
- \r
- ACE->PPE_RAM_DATA[ppe_offset] = (ACE->PPE_RAM_DATA[ppe_offset] & ~PPE_RAM_THRESHOLD_MASK) + assertion_value;\r
- }\r
-#endif\r
-}\r
-\r
-/*-------------------------------------------------------------------------*//**\r
- *\r
- */\r
-void\r
-ACE_set_flag_hysteresis\r
-(\r
- ace_flag_handle_t flag_handle,\r
- uint16_t adc_hysteresis\r
-)\r
-{\r
-#if (ACE_NB_OF_PPE_FLAGS > 0)\r
- uint16_t ppe_offset;\r
- uint32_t high_threshold;\r
- uint32_t low_threshold;\r
- uint32_t nominal_threshold;\r
- uint16_t adc_resolution;\r
- uint32_t adc_id;\r
- \r
- ASSERT( flag_handle < NB_OF_ACE_FLAG_HANDLES );\r
- ASSERT(ACE_is_hysteresis_flag(flag_handle));\r
- \r
- if ( ( flag_handle < NB_OF_ACE_FLAG_HANDLES ) && ( ACE_is_hysteresis_flag( flag_handle ) ) )\r
- {\r
- ace_channel_handle_t channel_handle;\r
- \r
- ppe_offset = g_ppe_flags_desc_table[flag_handle].threshold_ppe_offset;\r
- \r
- high_threshold = ACE->PPE_RAM_DATA[ppe_offset] & PPE_RAM_THRESHOLD_MASK;\r
- low_threshold = ACE->PPE_RAM_DATA[ppe_offset + 1u] & PPE_RAM_THRESHOLD_MASK;\r
- ASSERT(high_threshold > low_threshold);\r
- nominal_threshold = (low_threshold + ((high_threshold - low_threshold) / 2u));\r
- \r
- channel_handle = g_ppe_flags_desc_table[flag_handle].channel_handle;\r
- adc_id = (uint32_t)((uint32_t)g_ace_channel_desc_table[channel_handle].signal_id >> 4u);\r
- ASSERT( adc_id < (uint32_t)ACE_NB_OF_ADC );\r
- \r
- if ( adc_id < (uint32_t)ACE_NB_OF_ADC )\r
- {\r
- adc_resolution = g_ace_adc_config[adc_id].adc_resolution;\r
- \r
- high_threshold = nominal_threshold + adc_hysteresis;\r
- if ( high_threshold > adc_resolution )\r
- {\r
- high_threshold = (uint32_t)adc_resolution - 1u;\r
- }\r
- \r
- if ( adc_hysteresis > nominal_threshold )\r
- {\r
- low_threshold = 1u;\r
- }\r
- else\r
- {\r
- low_threshold = nominal_threshold - adc_hysteresis;\r
- }\r
- \r
- ACE->PPE_RAM_DATA[ppe_offset] = (ACE->PPE_RAM_DATA[ppe_offset] & ~PPE_RAM_THRESHOLD_MASK) + high_threshold;\r
- ACE->PPE_RAM_DATA[ppe_offset + 1u] = (ACE->PPE_RAM_DATA[ppe_offset + 1u] & ~PPE_RAM_THRESHOLD_MASK) + low_threshold;\r
- }\r
- }\r
-#endif\r
-}\r
-\r
-\r
-/*-------------------------------------------------------------------------*//**\r
- *\r
- */\r
-void\r
-ACE_set_channel_hysteresis\r
-(\r
- ace_channel_handle_t channel_handle,\r
- uint16_t adc_hysteresis\r
-)\r
-{\r
-#if (ACE_NB_OF_PPE_FLAGS > 0)\r
- ace_flag_handle_t flag_handle;\r
- \r
- ASSERT( channel_handle < NB_OF_ACE_CHANNEL_HANDLES );\r
- \r
- if ( channel_handle < NB_OF_ACE_CHANNEL_HANDLES )\r
- {\r
- uint16_t i;\r
- \r
- for( i = 0u; i < g_ace_channel_desc_table[channel_handle].nb_of_flags; ++i )\r
- {\r
- flag_handle = (ace_flag_handle_t)g_ace_channel_desc_table[channel_handle].p_flags_array[i];\r
- ACE_set_flag_hysteresis( flag_handle, adc_hysteresis );\r
- }\r
- }\r
-#endif\r
-}\r
-\r
-/*==============================================================================\r
- *\r
- */\r
-\r
-/*-------------------------------------------------------------------------*//**\r
- Masking a flag_id with FLAG_BIT_OFFSET_MASK results in the offset of the \r
- flag bit within a PPE__FLAGSn register.\r
- */\r
-#define FLAG_BIT_OFFSET_MASK 0x0000001FuL\r
-\r
-/*-------------------------------------------------------------------------*//**\r
- Shifting right a flag_id by FLAG_PPE_REG_SHIFT results in identifying the\r
- PPE_FLAGSn or PPE_SFFLAGS the flags belongs to.\r
- */\r
-#define FLAG_PPE_REG_SHIFT 5u\r
-\r
-/*-------------------------------------------------------------------------*//**\r
- There is a set of 5 PPE flag registers to control and report status of the PPE\r
- flags resulting in the PPE flags being grouped into 5 separate flag groups at\r
- the register level. Each register provides status or control for 32 flags.\r
- */\r
-#define NB_OF_FLAG_GROUPS 5u\r
-#define NB_OF_FLAGS_PER_GROUP 32u\r
-\r
-#if (ACE_NB_OF_PPE_FLAGS > 0)\r
-/*-------------------------------------------------------------------------*//**\r
- Lookup table of the address PPE_FLAGSn registers for fast reading of PPE\r
- status.\r
- */\r
-static volatile uint32_t * const g_ppe_flags_regs_lut[NB_OF_FLAG_GROUPS] =\r
-{\r
- &ACE->PPE_FLAGS0,\r
- &ACE->PPE_FLAGS1,\r
- &ACE->PPE_FLAGS2,\r
- &ACE->PPE_FLAGS3,\r
- &ACE->PPE_SFFLAGS\r
-};\r
-\r
-/*-------------------------------------------------------------------------*//**\r
- Lookup table of the address of the PPE flags interrupt enable registers.\r
- */\r
-static uint32_t volatile * const flags_irq_enable_regs_lut[NB_OF_FLAG_GROUPS] =\r
-{\r
- &ACE->PPE_FLAGS0_IRQ_EN,\r
- &ACE->PPE_FLAGS1_IRQ_EN,\r
- &ACE->PPE_FLAGS2_IRQ_EN,\r
- &ACE->PPE_FLAGS3_IRQ_EN,\r
- &ACE->PPE_SFFLAGS_IRQ_EN\r
-};\r
-\r
-/*-------------------------------------------------------------------------*//**\r
- Lookup table of the address of the PPE flags interrupt status registers.\r
- */\r
-static uint32_t volatile const * const flags_irq_status_regs_lut[NB_OF_FLAG_GROUPS] =\r
-{\r
- &ACE->PPE_FLAGS0_IRQ,\r
- &ACE->PPE_FLAGS1_IRQ,\r
- &ACE->PPE_FLAGS2_IRQ,\r
- &ACE->PPE_FLAGS3_IRQ,\r
- &ACE->PPE_SFFLAGS_IRQ\r
-};\r
-\r
-/*-------------------------------------------------------------------------*//**\r
- Lookup table of the address of the PPE flags interrupt clearing registers.\r
- */\r
-static uint32_t volatile * const flags_irq_clear_regs_lut[NB_OF_FLAG_GROUPS] =\r
-{\r
- &ACE->PPE_FLAGS0_IRQ_CLR,\r
- &ACE->PPE_FLAGS1_IRQ_CLR,\r
- &ACE->PPE_FLAGS2_IRQ_CLR,\r
- &ACE->PPE_FLAGS3_IRQ_CLR,\r
- &ACE->PPE_SFFLAGS_IRQ_CLR\r
-};\r
-\r
-/*-------------------------------------------------------------------------*//**\r
- *\r
- */\r
-static const IRQn_Type threshold_irqn_lut[NB_OF_THRESHOLD_IRQ] =\r
-{\r
- ACE_PPE_Flag0_IRQn,\r
- ACE_PPE_Flag1_IRQn,\r
- ACE_PPE_Flag2_IRQn,\r
- ACE_PPE_Flag3_IRQn,\r
- ACE_PPE_Flag4_IRQn,\r
- ACE_PPE_Flag5_IRQn,\r
- ACE_PPE_Flag6_IRQn,\r
- ACE_PPE_Flag7_IRQn,\r
- ACE_PPE_Flag8_IRQn,\r
- ACE_PPE_Flag9_IRQn,\r
- ACE_PPE_Flag10_IRQn,\r
- ACE_PPE_Flag11_IRQn,\r
- ACE_PPE_Flag12_IRQn,\r
- ACE_PPE_Flag13_IRQn,\r
- ACE_PPE_Flag14_IRQn,\r
- ACE_PPE_Flag15_IRQn,\r
- ACE_PPE_Flag16_IRQn,\r
- ACE_PPE_Flag17_IRQn,\r
- ACE_PPE_Flag18_IRQn,\r
- ACE_PPE_Flag19_IRQn,\r
- ACE_PPE_Flag20_IRQn,\r
- ACE_PPE_Flag21_IRQn,\r
- ACE_PPE_Flag22_IRQn,\r
- ACE_PPE_Flag23_IRQn,\r
- ACE_PPE_Flag24_IRQn,\r
- ACE_PPE_Flag25_IRQn,\r
- ACE_PPE_Flag26_IRQn,\r
- ACE_PPE_Flag27_IRQn,\r
- ACE_PPE_Flag28_IRQn,\r
- ACE_PPE_Flag29_IRQn,\r
- ACE_PPE_Flag30_IRQn,\r
- ACE_PPE_Flag31_IRQn\r
-};\r
-#endif\r
-\r
-/*-------------------------------------------------------------------------*//**\r
- */\r
-ace_flag_handle_t\r
-ACE_get_flag_handle\r
-(\r
- const uint8_t * p_sz_full_flag_name\r
-)\r
-{\r
- ace_flag_handle_t flag_handle = INVALID_FLAG_HANDLE;\r
-#if (ACE_NB_OF_PPE_FLAGS > 0)\r
- ace_flag_handle_t flag_idx;\r
- \r
- for ( flag_idx = (ace_flag_handle_t)0; flag_idx < NB_OF_ACE_FLAG_HANDLES; ++flag_idx )\r
- {\r
- if ( g_ppe_flags_desc_table[flag_idx].p_sz_flag_name != 0 )\r
- {\r
- int32_t diff;\r
- diff = strncmp( (const char *)p_sz_full_flag_name, (const char *)g_ppe_flags_desc_table[flag_idx].p_sz_flag_name, (size_t)MAX_FULL_FLAG_NAME_LENGTH );\r
- if ( 0 == diff )\r
- {\r
- /* flag name found. */\r
- flag_handle = (ace_flag_handle_t)flag_idx;\r
- break;\r
- }\r
- }\r
- }\r
-#endif\r
- return flag_handle;\r
-}\r
-\r
-/*-------------------------------------------------------------------------*//**\r
- */\r
-int32_t\r
-ACE_get_flag_status\r
-(\r
- ace_flag_handle_t flag_handle\r
-)\r
-{\r
- int32_t flag_state = UNKNOWN_FLAG;\r
-#if (ACE_NB_OF_PPE_FLAGS > 0) \r
- ppe_flag_id_t flag_id;\r
- \r
- ASSERT( flag_handle < NB_OF_ACE_FLAG_HANDLES );\r
- \r
- if ( flag_handle < NB_OF_ACE_FLAG_HANDLES )\r
- {\r
- uint32_t flag_bit_offset;\r
- uint32_t ppe_flag_group;\r
- uint32_t flag_id_mask;\r
- uint32_t flag_status;\r
-\r
- flag_id = g_ppe_flags_desc_table[flag_handle].flag_id;\r
- \r
- if ( flag_id < NB_OF_PPE_FLAGS )\r
- {\r
- flag_bit_offset = ((uint32_t)flag_id & FLAG_BIT_OFFSET_MASK);\r
- ppe_flag_group = ((uint32_t)flag_id >> FLAG_PPE_REG_SHIFT);\r
- flag_id_mask = 1uL << flag_bit_offset;\r
- flag_status = *(g_ppe_flags_regs_lut[ppe_flag_group]) & flag_id_mask;\r
- if ( flag_status > 0u )\r
- {\r
- flag_state = FLAG_ASSERTED;\r
- }\r
- else\r
- {\r
- flag_state = FLAG_NOT_ASSERTED;\r
- }\r
- }\r
-\r
- }\r
-#endif\r
- return flag_state;\r
-}\r
-\r
-\r
-/*-------------------------------------------------------------------------*//**\r
- */\r
-const uint8_t *\r
-ACE_get_flag_name\r
-(\r
- ace_flag_handle_t flag_handle\r
-)\r
-{\r
- const uint8_t * psz_flag_name = 0;\r
-#if (ACE_NB_OF_PPE_FLAGS > 0) \r
- ASSERT( flag_handle < NB_OF_ACE_FLAG_HANDLES );\r
- \r
- if ( flag_handle < NB_OF_ACE_FLAG_HANDLES )\r
- {\r
- psz_flag_name = g_ppe_flags_desc_table[flag_handle].p_sz_flag_name;\r
- }\r
-#endif\r
- return psz_flag_name;\r
-}\r
-\r
-/*-------------------------------------------------------------------------*//**\r
- */\r
-ace_channel_handle_t\r
-ACE_get_flag_channel\r
-(\r
- ace_flag_handle_t flag_handle\r
-)\r
-{\r
- ace_channel_handle_t channel_handle = INVALID_CHANNEL_HANDLE;\r
-#if (ACE_NB_OF_PPE_FLAGS > 0)\r
- ASSERT( flag_handle < NB_OF_ACE_FLAG_HANDLES );\r
- \r
- if ( flag_handle < NB_OF_ACE_FLAG_HANDLES )\r
- {\r
- channel_handle = g_ppe_flags_desc_table[flag_handle].channel_handle;\r
- }\r
-#endif\r
- return channel_handle;\r
-}\r
-\r
-/*-------------------------------------------------------------------------*//**\r
- */\r
-uint32_t\r
-ACE_get_channel_flag_count\r
-(\r
- ace_channel_handle_t channel_handle\r
-)\r
-{\r
- uint32_t flag_count = 0;\r
-#if (ACE_NB_OF_PPE_FLAGS > 0)\r
- ASSERT( channel_handle < ACE_NB_OF_INPUT_CHANNELS );\r
- if (channel_handle < ACE_NB_OF_INPUT_CHANNELS)\r
- {\r
- flag_count = g_ace_channel_desc_table[channel_handle].nb_of_flags;\r
- }\r
-#endif\r
- return flag_count;\r
-}\r
-\r
-/*-------------------------------------------------------------------------*//**\r
- \r
- */\r
-ace_flag_handle_t\r
-ACE_get_channel_first_flag\r
-(\r
- ace_channel_handle_t channel_handle,\r
- uint16_t * iterator\r
-)\r
-{\r
- ace_flag_handle_t flag_handle = INVALID_FLAG_HANDLE;\r
-#if (ACE_NB_OF_PPE_FLAGS > 0)\r
- ASSERT( channel_handle < NB_OF_ACE_CHANNEL_HANDLES);\r
- \r
- *iterator = 0u;\r
- \r
- if ( channel_handle < NB_OF_ACE_CHANNEL_HANDLES)\r
- {\r
- if ( g_ace_channel_desc_table[channel_handle].nb_of_flags > 0u )\r
- {\r
- flag_handle = (ace_flag_handle_t)g_ace_channel_desc_table[channel_handle].p_flags_array[*iterator];\r
- }\r
- }\r
-#endif \r
- return flag_handle;\r
-}\r
-\r
-/*-------------------------------------------------------------------------*//**\r
- \r
- */\r
-ace_flag_handle_t\r
-ACE_get_channel_next_flag\r
-(\r
- ace_channel_handle_t channel_handle,\r
- uint16_t * iterator\r
-)\r
-{\r
- ace_flag_handle_t flag_handle = INVALID_FLAG_HANDLE;\r
-#if (ACE_NB_OF_PPE_FLAGS > 0) \r
- ASSERT( channel_handle < NB_OF_ACE_CHANNEL_HANDLES);\r
-\r
- if ( channel_handle < NB_OF_ACE_CHANNEL_HANDLES)\r
- {\r
- ++(*iterator);\r
- \r
- if ( *iterator >= g_ace_channel_desc_table[channel_handle].nb_of_flags )\r
- {\r
- *iterator = 0u;\r
- }\r
- \r
- if ( g_ace_channel_desc_table[channel_handle].nb_of_flags > 0u )\r
- {\r
- flag_handle = (ace_flag_handle_t)g_ace_channel_desc_table[channel_handle].p_flags_array[*iterator];\r
- }\r
- }\r
-#endif\r
- return flag_handle;\r
-}\r
-\r
-\r
-/*-------------------------------------------------------------------------*//**\r
- *\r
- */\r
-void ACE_enable_channel_flags_irq\r
-(\r
- ace_channel_handle_t channel_handle\r
-)\r
-{\r
-#if (ACE_NB_OF_PPE_FLAGS > 0)\r
- uint32_t flag_idx;\r
- ace_flag_handle_t flag_handle;\r
- \r
- ASSERT( channel_handle < NB_OF_ACE_CHANNEL_HANDLES );\r
- \r
- if ( channel_handle < NB_OF_ACE_CHANNEL_HANDLES )\r
- {\r
- for ( flag_idx = 0u; flag_idx < g_ace_channel_desc_table[channel_handle].nb_of_flags; ++flag_idx )\r
- {\r
- flag_handle = (ace_flag_handle_t)g_ace_channel_desc_table[channel_handle].p_flags_array[flag_idx];\r
- ACE_enable_flag_irq( flag_handle );\r
- }\r
- }\r
-#endif\r
-}\r
-\r
-/*-------------------------------------------------------------------------*//**\r
- *\r
- */\r
-void ACE_disable_channel_flags_irq\r
-(\r
- ace_channel_handle_t channel_handle\r
-)\r
-{\r
-#if (ACE_NB_OF_PPE_FLAGS > 0)\r
- uint32_t flag_idx;\r
- ace_flag_handle_t flag_handle;\r
- \r
- ASSERT( channel_handle < NB_OF_ACE_CHANNEL_HANDLES );\r
- \r
- if ( channel_handle < NB_OF_ACE_CHANNEL_HANDLES )\r
- {\r
- for ( flag_idx = 0u; flag_idx < g_ace_channel_desc_table[channel_handle].nb_of_flags; ++flag_idx )\r
- {\r
- flag_handle = (ace_flag_handle_t)g_ace_channel_desc_table[channel_handle].p_flags_array[flag_idx];\r
- ACE_disable_flag_irq( flag_handle );\r
- }\r
- }\r
-#endif\r
-}\r
-\r
-/*-------------------------------------------------------------------------*//**\r
- *\r
- */\r
-void ACE_clear_channel_flags_irq\r
-(\r
- ace_channel_handle_t channel_handle\r
-)\r
-{\r
-#if (ACE_NB_OF_PPE_FLAGS > 0)\r
- uint32_t flag_idx;\r
- ace_flag_handle_t flag_handle;\r
- \r
- ASSERT( channel_handle < NB_OF_ACE_CHANNEL_HANDLES );\r
- \r
- if ( channel_handle < NB_OF_ACE_CHANNEL_HANDLES )\r
- {\r
- for ( flag_idx = 0u; flag_idx < g_ace_channel_desc_table[channel_handle].nb_of_flags; ++flag_idx )\r
- {\r
- flag_handle = (ace_flag_handle_t)g_ace_channel_desc_table[channel_handle].p_flags_array[flag_idx];\r
- ACE_clear_flag_irq( flag_handle );\r
- }\r
- }\r
-#endif\r
-}\r
-\r
-/*-------------------------------------------------------------------------*//**\r
- *\r
- */\r
-void ACE_enable_flag_irq\r
-(\r
- ace_flag_handle_t flag_handle\r
-)\r
-{\r
-#if (ACE_NB_OF_PPE_FLAGS > 0)\r
- ASSERT( flag_handle < NB_OF_ACE_FLAG_HANDLES );\r
- \r
- if ( flag_handle < NB_OF_ACE_FLAG_HANDLES )\r
- {\r
- ppe_flag_id_t flag_id;\r
- uint32_t flag_bit_offset;\r
- uint32_t ppe_flag_group;\r
- uint32_t flag_id_mask;\r
- \r
- flag_id = g_ppe_flags_desc_table[flag_handle].flag_id;\r
- \r
- ASSERT( flag_id < NB_OF_PPE_FLAGS );\r
- \r
- flag_bit_offset = ((uint32_t)flag_id & FLAG_BIT_OFFSET_MASK);\r
- ppe_flag_group = ((uint32_t)flag_id >> FLAG_PPE_REG_SHIFT);\r
- flag_id_mask = 1uL << flag_bit_offset;\r
- \r
- ASSERT( ppe_flag_group < NB_OF_FLAG_GROUPS );\r
- \r
- if ( ppe_flag_group < NB_OF_FLAG_GROUPS )\r
- {\r
- *(flags_irq_enable_regs_lut[ppe_flag_group]) |= flag_id_mask;\r
- }\r
- \r
- NVIC_EnableIRQ( threshold_irqn_lut[flag_bit_offset] );\r
- }\r
-#endif\r
-}\r
-\r
-/*-------------------------------------------------------------------------*//**\r
- *\r
- */\r
-void ACE_disable_flag_irq\r
-(\r
- ace_flag_handle_t flag_handle\r
-)\r
-{\r
-#if (ACE_NB_OF_PPE_FLAGS > 0)\r
- ASSERT( flag_handle < NB_OF_ACE_FLAG_HANDLES );\r
- \r
- if ( flag_handle < NB_OF_ACE_FLAG_HANDLES )\r
- {\r
- ppe_flag_id_t flag_id;\r
- uint32_t flag_bit_offset;\r
- uint32_t ppe_flag_group;\r
- uint32_t flag_id_mask;\r
- \r
- flag_id = g_ppe_flags_desc_table[flag_handle].flag_id;\r
- \r
- ASSERT( flag_id < NB_OF_PPE_FLAGS );\r
- \r
- flag_bit_offset = ((uint32_t)flag_id & FLAG_BIT_OFFSET_MASK);\r
- ppe_flag_group = ((uint32_t)flag_id >> FLAG_PPE_REG_SHIFT);\r
- flag_id_mask = 1uL << flag_bit_offset;\r
- \r
- ASSERT( ppe_flag_group < NB_OF_FLAG_GROUPS );\r
- \r
- if ( ppe_flag_group < NB_OF_FLAG_GROUPS )\r
- {\r
- *(flags_irq_enable_regs_lut[ppe_flag_group]) &= (uint32_t)~flag_id_mask;\r
- }\r
- }\r
-#endif\r
-}\r
-\r
-/*-------------------------------------------------------------------------*//**\r
- *\r
- */\r
-void ACE_clear_flag_irq\r
-(\r
- ace_flag_handle_t flag_handle\r
-)\r
-{\r
-#if (ACE_NB_OF_PPE_FLAGS > 0)\r
- ASSERT( flag_handle < NB_OF_ACE_FLAG_HANDLES );\r
- \r
- if ( flag_handle < NB_OF_ACE_FLAG_HANDLES )\r
- {\r
- ppe_flag_id_t flag_id;\r
- uint32_t flag_bit_offset;\r
- uint32_t ppe_flag_group;\r
- uint32_t flag_id_mask;\r
- \r
- flag_id = g_ppe_flags_desc_table[flag_handle].flag_id;\r
- \r
- ASSERT( flag_id < NB_OF_PPE_FLAGS );\r
- \r
- flag_bit_offset = ((uint32_t)flag_id & FLAG_BIT_OFFSET_MASK);\r
- ppe_flag_group = ((uint32_t)flag_id >> FLAG_PPE_REG_SHIFT);\r
- flag_id_mask = 1uL << flag_bit_offset;\r
- \r
- ASSERT( ppe_flag_group < NB_OF_FLAG_GROUPS );\r
- \r
- if ( ppe_flag_group < NB_OF_FLAG_GROUPS )\r
- {\r
- *(flags_irq_clear_regs_lut[ppe_flag_group]) |= flag_id_mask;\r
- }\r
- }\r
-#endif\r
-}\r
-\r
-/*-------------------------------------------------------------------------*//**\r
- *\r
- */\r
-void ACE_register_flag_isr\r
-(\r
- ace_flag_handle_t flag_handle,\r
- flag_isr_t flag_isr\r
-)\r
-{\r
-#if (ACE_NB_OF_PPE_FLAGS > 0)\r
- ppe_flag_id_t flag_id;\r
- \r
- ASSERT( flag_handle < NB_OF_ACE_FLAG_HANDLES );\r
- \r
- if ( flag_handle < NB_OF_ACE_FLAG_HANDLES )\r
- {\r
- flag_id = g_ppe_flags_desc_table[flag_handle].flag_id;\r
- \r
- ASSERT( flag_id < NB_OF_PPE_FLAGS );\r
- \r
- if ( flag_id < NB_OF_PPE_FLAGS )\r
- {\r
- g_ppe_flags_isr_lut[flag_id] = flag_isr;\r
- }\r
- }\r
-#endif\r
-}\r
-\r
-/*-------------------------------------------------------------------------*//**\r
- *\r
- */\r
-void ACE_register_channel_flags_isr\r
-(\r
- ace_channel_handle_t channel_handle,\r
- channel_flag_isr_t channel_flag_isr\r
-)\r
-{\r
-#if (ACE_NB_OF_PPE_FLAGS > 0)\r
- ASSERT( channel_handle < NB_OF_ACE_CHANNEL_HANDLES );\r
- \r
- if ( channel_handle < NB_OF_ACE_CHANNEL_HANDLES )\r
- {\r
- g_ppe_channel_flags_isr_lut[channel_handle] = channel_flag_isr;\r
- }\r
-#endif\r
-}\r
-\r
-/*-------------------------------------------------------------------------*//**\r
- *\r
- */\r
-void ACE_register_global_flags_isr\r
-(\r
- global_flag_isr_t global_flag_isr\r
-)\r
-{\r
-#if (ACE_NB_OF_PPE_FLAGS > 0)\r
- g_ppe_global_flags_isr = global_flag_isr;\r
-#endif\r
-}\r
-\r
-\r
-/*==============================================================================\r
- *\r
- */\r
- \r
-/*-------------------------------------------------------------------------*//**\r
- * Actual PPE flag interrupt service routines:\r
- */\r
-\r
-static void process_flag_irq( uint8_t threshold_flag_id )\r
-{\r
-#if (ACE_NB_OF_PPE_FLAGS > 0)\r
- uint8_t flag_group;\r
- uint32_t threshold_flag_mask;\r
- ppe_flag_id_t flag_id;\r
- uint32_t irq_enable_reg;\r
- uint32_t irq_status_reg;\r
- uint32_t irq_active;\r
- \r
- threshold_flag_mask = 1uL << threshold_flag_id;\r
- \r
- \r
- for ( flag_group = 0u; flag_group < NB_OF_FLAG_GROUPS; ++flag_group )\r
- {\r
- irq_enable_reg = *flags_irq_enable_regs_lut[flag_group];\r
- irq_status_reg = *flags_irq_status_regs_lut[flag_group];\r
- irq_active = threshold_flag_mask & irq_enable_reg & irq_status_reg;\r
- \r
- if ( irq_active )\r
- {\r
- ace_flag_handle_t flag_handle;\r
- ace_channel_handle_t channel_handle;\r
- \r
- flag_id = (ppe_flag_id_t)((flag_group * NB_OF_FLAGS_PER_GROUP) + threshold_flag_id);\r
- flag_handle = g_ppe_flag_handles_lut[flag_id];\r
- \r
- /* Call individual flag handler */\r
- if ( g_ppe_flags_isr_lut[flag_id] != 0 ) \r
- {\r
- g_ppe_flags_isr_lut[flag_id]( flag_handle );\r
- }\r
- \r
- /* Call the channel flag handler. */\r
- channel_handle = g_ppe_flags_desc_table[flag_handle].channel_handle;\r
- if ( channel_handle < NB_OF_ACE_CHANNEL_HANDLES )\r
- {\r
- if ( g_ppe_channel_flags_isr_lut[channel_handle] != 0 )\r
- {\r
- g_ppe_channel_flags_isr_lut[channel_handle]( flag_handle );\r
- }\r
- }\r
- \r
- /* Call the global flag handler. */\r
- if ( g_ppe_global_flags_isr != 0 )\r
- {\r
- g_ppe_global_flags_isr( flag_handle, channel_handle );\r
- }\r
- \r
- /* Clear the flag interrupt */\r
- *flags_irq_clear_regs_lut[flag_group] |= threshold_flag_mask;\r
- }\r
- }\r
-#endif\r
-}\r
-\r
-/*-------------------------------------------------------------------------*//**\r
- *\r
- */\r
-#if defined(__GNUC__)\r
-__attribute__((__interrupt__)) void ACE_PPE_Flag0_IRQHandler( void )\r
-#else\r
-void ACE_PPE_Flag0_IRQHandler( void )\r
-#endif\r
-{\r
- process_flag_irq( THRESHOLD_FLAG0 );\r
- NVIC_ClearPendingIRQ( ACE_PPE_Flag0_IRQn );\r
-}\r
-\r
-/*-------------------------------------------------------------------------*//**\r
- *\r
- */\r
-#if defined(__GNUC__)\r
-__attribute__((__interrupt__)) void ACE_PPE_Flag1_IRQHandler( void )\r
-#else\r
-void ACE_PPE_Flag1_IRQHandler( void )\r
-#endif\r
-{\r
- process_flag_irq( THRESHOLD_FLAG1 );\r
- NVIC_ClearPendingIRQ( ACE_PPE_Flag1_IRQn );\r
-}\r
-\r
-/*-------------------------------------------------------------------------*//**\r
- *\r
- */\r
-#if defined(__GNUC__)\r
-__attribute__((__interrupt__)) void ACE_PPE_Flag2_IRQHandler( void )\r
-#else\r
-void ACE_PPE_Flag2_IRQHandler( void )\r
-#endif\r
-{\r
- process_flag_irq( THRESHOLD_FLAG2 );\r
- NVIC_ClearPendingIRQ( ACE_PPE_Flag2_IRQn );\r
-}\r
-\r
-/*-------------------------------------------------------------------------*//**\r
- *\r
- */\r
-#if defined(__GNUC__)\r
-__attribute__((__interrupt__)) void ACE_PPE_Flag3_IRQHandler( void )\r
-#else\r
-void ACE_PPE_Flag3_IRQHandler( void )\r
-#endif\r
-{\r
- process_flag_irq( THRESHOLD_FLAG3 );\r
- NVIC_ClearPendingIRQ( ACE_PPE_Flag3_IRQn );\r
-}\r
-\r
-/*-------------------------------------------------------------------------*//**\r
- *\r
- */\r
-#if defined(__GNUC__)\r
-__attribute__((__interrupt__)) void ACE_PPE_Flag4_IRQHandler( void )\r
-#else\r
-void ACE_PPE_Flag4_IRQHandler( void )\r
-#endif\r
-{\r
- process_flag_irq( THRESHOLD_FLAG4 );\r
- NVIC_ClearPendingIRQ( ACE_PPE_Flag4_IRQn );\r
-}\r
-\r
-/*-------------------------------------------------------------------------*//**\r
- *\r
- */\r
-#if defined(__GNUC__)\r
-__attribute__((__interrupt__)) void ACE_PPE_Flag5_IRQHandler( void )\r
-#else\r
-void ACE_PPE_Flag5_IRQHandler( void )\r
-#endif\r
-{\r
- process_flag_irq( THRESHOLD_FLAG5 );\r
- NVIC_ClearPendingIRQ( ACE_PPE_Flag5_IRQn );\r
-}\r
-\r
-/*-------------------------------------------------------------------------*//**\r
- *\r
- */\r
-#if defined(__GNUC__)\r
-__attribute__((__interrupt__)) void ACE_PPE_Flag6_IRQHandler( void )\r
-#else\r
-void ACE_PPE_Flag6_IRQHandler( void )\r
-#endif\r
-{\r
- process_flag_irq( THRESHOLD_FLAG6 );\r
- NVIC_ClearPendingIRQ( ACE_PPE_Flag6_IRQn );\r
-}\r
-\r
-/*-------------------------------------------------------------------------*//**\r
- *\r
- */\r
-#if defined(__GNUC__)\r
-__attribute__((__interrupt__)) void ACE_PPE_Flag7_IRQHandler( void )\r
-#else\r
-void ACE_PPE_Flag7_IRQHandler( void )\r
-#endif\r
-{\r
- process_flag_irq( THRESHOLD_FLAG7 );\r
- NVIC_ClearPendingIRQ( ACE_PPE_Flag7_IRQn );\r
-}\r
-\r
-/*-------------------------------------------------------------------------*//**\r
- *\r
- */\r
-#if defined(__GNUC__)\r
-__attribute__((__interrupt__)) void ACE_PPE_Flag8_IRQHandler( void )\r
-#else\r
-void ACE_PPE_Flag8_IRQHandler( void )\r
-#endif\r
-{\r
- process_flag_irq( THRESHOLD_FLAG8 );\r
- NVIC_ClearPendingIRQ( ACE_PPE_Flag8_IRQn );\r
-}\r
-\r
-/*-------------------------------------------------------------------------*//**\r
- *\r
- */\r
-#if defined(__GNUC__)\r
-__attribute__((__interrupt__)) void ACE_PPE_Flag9_IRQHandler( void )\r
-#else\r
-void ACE_PPE_Flag9_IRQHandler( void )\r
-#endif\r
-{\r
- process_flag_irq( THRESHOLD_FLAG9 );\r
- NVIC_ClearPendingIRQ( ACE_PPE_Flag9_IRQn );\r
-}\r
-\r
-/*-------------------------------------------------------------------------*//**\r
- *\r
- */\r
-#if defined(__GNUC__)\r
-__attribute__((__interrupt__)) void ACE_PPE_Flag10_IRQHandler( void )\r
-#else\r
-void ACE_PPE_Flag10_IRQHandler( void )\r
-#endif\r
-{\r
- process_flag_irq( THRESHOLD_FLAG10 );\r
- NVIC_ClearPendingIRQ( ACE_PPE_Flag10_IRQn );\r
-}\r
-\r
-/*-------------------------------------------------------------------------*//**\r
- *\r
- */\r
-#if defined(__GNUC__)\r
-__attribute__((__interrupt__)) void ACE_PPE_Flag11_IRQHandler( void )\r
-#else\r
-void ACE_PPE_Flag11_IRQHandler( void )\r
-#endif\r
-{\r
- process_flag_irq( THRESHOLD_FLAG11 );\r
- NVIC_ClearPendingIRQ( ACE_PPE_Flag11_IRQn );\r
-}\r
-\r
-/*-------------------------------------------------------------------------*//**\r
- *\r
- */\r
-#if defined(__GNUC__)\r
-__attribute__((__interrupt__)) void ACE_PPE_Flag12_IRQHandler( void )\r
-#else\r
-void ACE_PPE_Flag12_IRQHandler( void )\r
-#endif\r
-{\r
- process_flag_irq( THRESHOLD_FLAG12 );\r
- NVIC_ClearPendingIRQ( ACE_PPE_Flag12_IRQn );\r
-}\r
-\r
-/*-------------------------------------------------------------------------*//**\r
- *\r
- */\r
-#if defined(__GNUC__)\r
-__attribute__((__interrupt__)) void ACE_PPE_Flag13_IRQHandler( void )\r
-#else\r
-void ACE_PPE_Flag13_IRQHandler( void )\r
-#endif\r
-{\r
- process_flag_irq( THRESHOLD_FLAG13 );\r
- NVIC_ClearPendingIRQ( ACE_PPE_Flag13_IRQn );\r
-}\r
-\r
-/*-------------------------------------------------------------------------*//**\r
- *\r
- */\r
-#if defined(__GNUC__)\r
-__attribute__((__interrupt__)) void ACE_PPE_Flag14_IRQHandler( void )\r
-#else\r
-void ACE_PPE_Flag14_IRQHandler( void )\r
-#endif\r
-{\r
- process_flag_irq( THRESHOLD_FLAG14 );\r
- NVIC_ClearPendingIRQ( ACE_PPE_Flag14_IRQn );\r
-}\r
-\r
-/*-------------------------------------------------------------------------*//**\r
- *\r
- */\r
-#if defined(__GNUC__)\r
-__attribute__((__interrupt__)) void ACE_PPE_Flag15_IRQHandler( void )\r
-#else\r
-void ACE_PPE_Flag15_IRQHandler( void )\r
-#endif\r
-{\r
- process_flag_irq( THRESHOLD_FLAG15 );\r
- NVIC_ClearPendingIRQ( ACE_PPE_Flag15_IRQn );\r
-}\r
-\r
-/*-------------------------------------------------------------------------*//**\r
- *\r
- */\r
-#if defined(__GNUC__)\r
-__attribute__((__interrupt__)) void ACE_PPE_Flag16_IRQHandler( void )\r
-#else\r
-void ACE_PPE_Flag16_IRQHandler( void )\r
-#endif\r
-{\r
- process_flag_irq( THRESHOLD_FLAG16 );\r
- NVIC_ClearPendingIRQ( ACE_PPE_Flag16_IRQn );\r
-}\r
-\r
-/*-------------------------------------------------------------------------*//**\r
- *\r
- */\r
-#if defined(__GNUC__)\r
-__attribute__((__interrupt__)) void ACE_PPE_Flag17_IRQHandler( void )\r
-#else\r
-void ACE_PPE_Flag17_IRQHandler( void )\r
-#endif\r
-{\r
- process_flag_irq( THRESHOLD_FLAG17 );\r
- NVIC_ClearPendingIRQ( ACE_PPE_Flag17_IRQn );\r
-}\r
-\r
-/*-------------------------------------------------------------------------*//**\r
- *\r
- */\r
-#if defined(__GNUC__)\r
-__attribute__((__interrupt__)) void ACE_PPE_Flag18_IRQHandler( void )\r
-#else\r
-void ACE_PPE_Flag18_IRQHandler( void )\r
-#endif\r
-{\r
- process_flag_irq( THRESHOLD_FLAG18 );\r
- NVIC_ClearPendingIRQ( ACE_PPE_Flag18_IRQn );\r
-}\r
-\r
-/*-------------------------------------------------------------------------*//**\r
- *\r
- */\r
-#if defined(__GNUC__)\r
-__attribute__((__interrupt__)) void ACE_PPE_Flag19_IRQHandler( void )\r
-#else\r
-void ACE_PPE_Flag19_IRQHandler( void )\r
-#endif\r
-{\r
- process_flag_irq( THRESHOLD_FLAG19 );\r
- NVIC_ClearPendingIRQ( ACE_PPE_Flag19_IRQn );\r
-}\r
-\r
-/*-------------------------------------------------------------------------*//**\r
- *\r
- */\r
-#if defined(__GNUC__)\r
-__attribute__((__interrupt__)) void ACE_PPE_Flag20_IRQHandler( void )\r
-#else\r
-void ACE_PPE_Flag20_IRQHandler( void )\r
-#endif\r
-{\r
- process_flag_irq( THRESHOLD_FLAG20 );\r
- NVIC_ClearPendingIRQ( ACE_PPE_Flag20_IRQn );\r
-}\r
-\r
-/*-------------------------------------------------------------------------*//**\r
- *\r
- */\r
-#if defined(__GNUC__)\r
-__attribute__((__interrupt__)) void ACE_PPE_Flag21_IRQHandler( void )\r
-#else\r
-void ACE_PPE_Flag21_IRQHandler( void )\r
-#endif\r
-{\r
- process_flag_irq( THRESHOLD_FLAG21 );\r
- NVIC_ClearPendingIRQ( ACE_PPE_Flag21_IRQn );\r
-}\r
-\r
-/*-------------------------------------------------------------------------*//**\r
- *\r
- */\r
-#if defined(__GNUC__)\r
-__attribute__((__interrupt__)) void ACE_PPE_Flag22_IRQHandler( void )\r
-#else\r
-void ACE_PPE_Flag22_IRQHandler( void )\r
-#endif\r
-{\r
- process_flag_irq( THRESHOLD_FLAG22 );\r
- NVIC_ClearPendingIRQ( ACE_PPE_Flag22_IRQn );\r
-}\r
-\r
-/*-------------------------------------------------------------------------*//**\r
- *\r
- */\r
-#if defined(__GNUC__)\r
-__attribute__((__interrupt__)) void ACE_PPE_Flag23_IRQHandler( void )\r
-#else\r
-void ACE_PPE_Flag23_IRQHandler( void )\r
-#endif\r
-{\r
- process_flag_irq( THRESHOLD_FLAG23 );\r
- NVIC_ClearPendingIRQ( ACE_PPE_Flag23_IRQn );\r
-}\r
-\r
-/*-------------------------------------------------------------------------*//**\r
- *\r
- */\r
-#if defined(__GNUC__)\r
-__attribute__((__interrupt__)) void ACE_PPE_Flag24_IRQHandler( void )\r
-#else\r
-void ACE_PPE_Flag24_IRQHandler( void )\r
-#endif\r
-{\r
- process_flag_irq( THRESHOLD_FLAG24 );\r
- NVIC_ClearPendingIRQ( ACE_PPE_Flag24_IRQn );\r
-}\r
-\r
-/*-------------------------------------------------------------------------*//**\r
- *\r
- */\r
-#if defined(__GNUC__)\r
-__attribute__((__interrupt__)) void ACE_PPE_Flag25_IRQHandler( void )\r
-#else\r
-void ACE_PPE_Flag25_IRQHandler( void )\r
-#endif\r
-{\r
- process_flag_irq( THRESHOLD_FLAG25 );\r
- NVIC_ClearPendingIRQ( ACE_PPE_Flag25_IRQn );\r
-}\r
-\r
-/*-------------------------------------------------------------------------*//**\r
- *\r
- */\r
-#if defined(__GNUC__)\r
-__attribute__((__interrupt__)) void ACE_PPE_Flag26_IRQHandler( void )\r
-#else\r
-void ACE_PPE_Flag26_IRQHandler( void )\r
-#endif\r
-{\r
- process_flag_irq( THRESHOLD_FLAG26 );\r
- NVIC_ClearPendingIRQ( ACE_PPE_Flag26_IRQn );\r
-}\r
-\r
-/*-------------------------------------------------------------------------*//**\r
- *\r
- */\r
-#if defined(__GNUC__)\r
-__attribute__((__interrupt__)) void ACE_PPE_Flag27_IRQHandler( void )\r
-#else\r
-void ACE_PPE_Flag27_IRQHandler( void )\r
-#endif\r
-{\r
- process_flag_irq( THRESHOLD_FLAG27 );\r
- NVIC_ClearPendingIRQ( ACE_PPE_Flag27_IRQn );\r
-}\r
-\r
-/*-------------------------------------------------------------------------*//**\r
- *\r
- */\r
-#if defined(__GNUC__)\r
-__attribute__((__interrupt__)) void ACE_PPE_Flag28_IRQHandler( void )\r
-#else\r
-void ACE_PPE_Flag28_IRQHandler( void )\r
-#endif\r
-{\r
- process_flag_irq( THRESHOLD_FLAG28 );\r
- NVIC_ClearPendingIRQ( ACE_PPE_Flag28_IRQn );\r
-}\r
-\r
-/*-------------------------------------------------------------------------*//**\r
- *\r
- */\r
-#if defined(__GNUC__)\r
-__attribute__((__interrupt__)) void ACE_PPE_Flag29_IRQHandler( void )\r
-#else\r
-void ACE_PPE_Flag29_IRQHandler( void )\r
-#endif\r
-{\r
- process_flag_irq( THRESHOLD_FLAG29 );\r
- NVIC_ClearPendingIRQ( ACE_PPE_Flag29_IRQn );\r
-}\r
-\r
-/*-------------------------------------------------------------------------*//**\r
- *\r
- */\r
-#if defined(__GNUC__)\r
-__attribute__((__interrupt__)) void ACE_PPE_Flag30_IRQHandler( void )\r
-#else\r
-void ACE_PPE_Flag30_IRQHandler( void )\r
-#endif\r
-{\r
- process_flag_irq( THRESHOLD_FLAG30 );\r
- NVIC_ClearPendingIRQ( ACE_PPE_Flag30_IRQn );\r
-}\r
-\r
-/*-------------------------------------------------------------------------*//**\r
- *\r
- */\r
-#if defined(__GNUC__)\r
-__attribute__((__interrupt__)) void ACE_PPE_Flag31_IRQHandler( void )\r
-#else\r
-void ACE_PPE_Flag31_IRQHandler( void )\r
-#endif\r
-{\r
- process_flag_irq( THRESHOLD_FLAG31 );\r
- NVIC_ClearPendingIRQ( ACE_PPE_Flag31_IRQn );\r
-}\r
-\r
-#ifdef __cplusplus\r
-}\r
-#endif\r
-\r
+++ /dev/null
-/*******************************************************************************\r
- * (c) Copyright 2009 Actel Corporation. All rights reserved.\r
- * \r
- * SVN $Revision: 2905 $\r
- * SVN $Date: 2010-08-20 14:03:28 +0100 (Fri, 20 Aug 2010) $\r
- */\r
-#include "mss_ace.h"\r
-#include "mss_ace_configurator.h"\r
-#include "../../drivers_config/mss_ace/ace_handles.h"\r
-#include "../../drivers_config/mss_ace/ace_config.h"\r
-\r
-#include "../../CMSIS/a2fxxxm3.h"\r
-#include "../../CMSIS/mss_assert.h"\r
-#include <string.h>\r
-\r
-#ifdef __cplusplus\r
-extern "C" {\r
-#endif \r
-\r
-#define SSE_START 1uL\r
-#define SSE_STOP 0uL\r
-\r
-#define NB_OF_ANALOG_BLOCKS 3u\r
-#define SEE_RAM_WORD_SIZE 512\r
-\r
-#define TS_ENABLE_MASK 0x01u\r
-#define PPE_ENABLE_MASK 0x01u\r
-#define ADC_RESET_MASK 0x10u\r
-#define ADC_FIFO_CLR_MASK 0x04u\r
-#define PDMA_DATAOUT_CLR_MASK 0x04u\r
-\r
-\r
-/*-------------------------------------------------------------------------*//**\r
- *\r
- */\r
-extern ace_procedure_desc_t g_sse_sequences_desc_table[ACE_NB_OF_SSE_PROCEDURES];\r
- \r
-/*-------------------------------------------------------------------------*//**\r
- *\r
- */\r
-sse_sequence_handle_t\r
-ACE_get_sse_seq_handle\r
-(\r
- const uint8_t * p_sz_sequence_name\r
-)\r
-{\r
- uint16_t seq_idx;\r
- sse_sequence_handle_t handle = INVALID_SSE_SEQ_HANDLE;\r
- \r
- for ( seq_idx = 0u; seq_idx < (uint32_t)ACE_NB_OF_SSE_PROCEDURES; ++seq_idx )\r
- {\r
- if ( g_sse_sequences_desc_table[seq_idx].p_sz_proc_name != 0 )\r
- {\r
- int32_t diff;\r
- diff = strncmp( (const char *)p_sz_sequence_name, (const char *)g_sse_sequences_desc_table[seq_idx].p_sz_proc_name, MAX_PROCEDURE_NAME_LENGTH );\r
- if ( 0 == diff )\r
- {\r
- /* channel name found. */\r
- handle = seq_idx;\r
- break;\r
- }\r
- }\r
- }\r
- return handle;\r
-}\r
-\r
-/*-------------------------------------------------------------------------*//**\r
- *\r
- */\r
-static uint32_t volatile * const sse_pc_ctrl_lut[NB_OF_ANALOG_BLOCKS] =\r
-{\r
- &ACE->PC0_CTRL,\r
- &ACE->PC1_CTRL,\r
- &ACE->PC2_CTRL\r
-};\r
-\r
-static uint32_t volatile * const sse_pc_lo_lut[NB_OF_ANALOG_BLOCKS] =\r
-{\r
- &ACE->PC0_LO,\r
- &ACE->PC1_LO,\r
- &ACE->PC2_LO\r
-};\r
-\r
-static uint32_t volatile * const sse_pc_hi_lut[NB_OF_ANALOG_BLOCKS] =\r
-{\r
- &ACE->PC0_HI,\r
- &ACE->PC1_HI,\r
- &ACE->PC2_HI\r
-};\r
-\r
-/*-------------------------------------------------------------------------*//**\r
- *\r
- */\r
-void ACE_load_sse\r
-(\r
- sse_sequence_handle_t sequence\r
-)\r
-{\r
- ASSERT( sequence < (sse_sequence_handle_t)ACE_NB_OF_SSE_PROCEDURES );\r
- \r
- if ( sequence < (sse_sequence_handle_t)ACE_NB_OF_SSE_PROCEDURES )\r
- {\r
- uint16_t i;\r
- uint16_t offset;\r
- const uint16_t * p_ucode;\r
- \r
- ASSERT( g_sse_sequences_desc_table[sequence].sse_pc_id < NB_OF_ANALOG_BLOCKS );\r
- \r
- if ( g_sse_sequences_desc_table[sequence].sse_pc_id < NB_OF_ANALOG_BLOCKS )\r
- {\r
- /* Stop relevant program counter. */\r
- *sse_pc_ctrl_lut[g_sse_sequences_desc_table[sequence].sse_pc_id] = SSE_STOP;\r
- \r
- /* Load microcode into SEE RAM.*/\r
- p_ucode = g_sse_sequences_desc_table[sequence].sse_ucode;\r
- offset = g_sse_sequences_desc_table[sequence].sse_load_offset;\r
- \r
- for ( i = 0u; i < g_sse_sequences_desc_table[sequence].sse_ucode_length; ++i )\r
- {\r
- ACE->SSE_RAM_DATA[offset + i] = (uint32_t)*p_ucode;\r
- ++p_ucode;\r
- }\r
- }\r
- }\r
-}\r
-\r
-\r
-/*-------------------------------------------------------------------------*//**\r
- *\r
- */\r
-void ACE_start_sse\r
-(\r
- sse_sequence_handle_t sequence\r
-)\r
-{\r
- ASSERT( sequence < (sse_sequence_handle_t)ACE_NB_OF_SSE_PROCEDURES );\r
- \r
- if ( sequence < (sse_sequence_handle_t)ACE_NB_OF_SSE_PROCEDURES )\r
- {\r
- uint16_t pc;\r
- \r
- ASSERT( g_sse_sequences_desc_table[sequence].sse_pc_id < NB_OF_ANALOG_BLOCKS );\r
- ASSERT( g_sse_sequences_desc_table[sequence].sse_load_offset < SEE_RAM_WORD_SIZE );\r
- \r
- pc = g_sse_sequences_desc_table[sequence].sse_load_offset;\r
- \r
- if ( pc < 256u )\r
- {\r
- *sse_pc_lo_lut[g_sse_sequences_desc_table[sequence].sse_pc_id] = pc;\r
- }\r
- else\r
- {\r
- *sse_pc_hi_lut[g_sse_sequences_desc_table[sequence].sse_pc_id] = pc - 256;\r
- }\r
- \r
- *sse_pc_ctrl_lut[g_sse_sequences_desc_table[sequence].sse_pc_id] = SSE_START;\r
- \r
- /* Enable Sample Sequencing Engine in case it was not done as part of\r
- * system boot. */\r
- ACE->SSE_TS_CTRL |= TS_ENABLE_MASK;\r
- }\r
-}\r
-\r
-/*-------------------------------------------------------------------------*//**\r
- *\r
- */\r
-void ACE_restart_sse\r
-(\r
- sse_sequence_handle_t sequence\r
-)\r
-{\r
- ASSERT( sequence < ACE_NB_OF_SSE_PROCEDURES );\r
- ASSERT( g_sse_sequences_desc_table[sequence].sse_pc_id < NB_OF_ANALOG_BLOCKS );\r
- ASSERT( g_sse_sequences_desc_table[sequence].sse_load_offset < SEE_RAM_WORD_SIZE );\r
- \r
- if ( sequence < (sse_sequence_handle_t)ACE_NB_OF_SSE_PROCEDURES )\r
- {\r
- uint16_t pc;\r
- \r
- pc = g_sse_sequences_desc_table[sequence].sse_loop_pc;\r
- \r
- if ( pc < 256u )\r
- {\r
- *sse_pc_lo_lut[g_sse_sequences_desc_table[sequence].sse_pc_id] = pc;\r
- }\r
- else\r
- {\r
- *sse_pc_hi_lut[g_sse_sequences_desc_table[sequence].sse_pc_id] = pc - 256;\r
- }\r
- \r
- *sse_pc_ctrl_lut[g_sse_sequences_desc_table[sequence].sse_pc_id] = SSE_START;\r
- }\r
-}\r
-\r
-/*-------------------------------------------------------------------------*//**\r
- *\r
- */\r
-void ACE_stop_sse\r
-(\r
- sse_sequence_handle_t sequence\r
-)\r
-{\r
- ASSERT( sequence < ACE_NB_OF_SSE_PROCEDURES );\r
- \r
- if ( sequence < (sse_sequence_handle_t)ACE_NB_OF_SSE_PROCEDURES )\r
- {\r
- /* Stop relevant program counter. */\r
- *sse_pc_ctrl_lut[g_sse_sequences_desc_table[sequence].sse_pc_id] = SSE_STOP;\r
- }\r
-}\r
-\r
-/*-------------------------------------------------------------------------*//**\r
- *\r
- */\r
-void ACE_resume_sse\r
-(\r
- sse_sequence_handle_t sequence\r
-)\r
-{\r
- ASSERT( sequence < ACE_NB_OF_SSE_PROCEDURES );\r
- \r
- if ( sequence < (sse_sequence_handle_t)ACE_NB_OF_SSE_PROCEDURES )\r
- {\r
- *sse_pc_ctrl_lut[g_sse_sequences_desc_table[sequence].sse_pc_id] = SSE_START;\r
- }\r
-}\r
-\r
-/*-------------------------------------------------------------------------*//**\r
- *\r
- */\r
-void ACE_enable_sse_irq\r
-(\r
- sse_irq_id_t sse_irq_id\r
-)\r
-{\r
- ASSERT( sse_irq_id < NB_OF_SSE_FLAG_IRQS );\r
- \r
- ACE->SSE_IRQ_EN |= 1uL << (uint32_t)sse_irq_id;\r
-}\r
-\r
-/*-------------------------------------------------------------------------*//**\r
- *\r
- */\r
-void ACE_disable_sse_irq\r
-(\r
- sse_irq_id_t sse_irq_id\r
-)\r
-{\r
- ASSERT( sse_irq_id < NB_OF_SSE_FLAG_IRQS );\r
- \r
- ACE->SSE_IRQ_EN &= (uint32_t)~(1uL << (uint32_t)sse_irq_id);\r
-}\r
-\r
-/*-------------------------------------------------------------------------*//**\r
- *\r
- */\r
-void ACE_clear_sse_irq\r
-(\r
- sse_irq_id_t sse_irq_id\r
-)\r
-{\r
- ASSERT( sse_irq_id < NB_OF_SSE_FLAG_IRQS );\r
- \r
- ACE->SSE_IRQ_CLR |= 1uL << (uint32_t)sse_irq_id;\r
-}\r
-\r
-/*-------------------------------------------------------------------------*//**\r
- *\r
- */\r
-void ACE_clear_sample_pipeline(void)\r
-{\r
- uint32_t saved_sse_ctrl;\r
- uint32_t saved_ppe_ctrl;\r
- \r
- /* Pause the Sample Sequencing Engine. */\r
- saved_sse_ctrl = ACE->SSE_TS_CTRL;\r
- ACE->SSE_TS_CTRL = ACE->SSE_TS_CTRL & ~((uint32_t)TS_ENABLE_MASK);\r
- \r
- /* Pause the Post Processing Engine. */\r
- saved_ppe_ctrl = ACE->PPE_CTRL;\r
- ACE->PPE_CTRL = ACE->PPE_CTRL & ~((uint32_t)PPE_ENABLE_MASK);\r
- \r
- /* Reset the ADCs */\r
- ACE->ADC0_MISC_CTRL |= ADC_RESET_MASK;\r
- ACE->ADC1_MISC_CTRL |= ADC_RESET_MASK;\r
- ACE->ADC2_MISC_CTRL |= ADC_RESET_MASK;\r
- \r
- /* Clear ADC FIFOs */\r
- ACE->ADC0_FIFO_CTRL |= ADC_FIFO_CLR_MASK;\r
- ACE->ADC1_FIFO_CTRL |= ADC_FIFO_CLR_MASK;\r
- ACE->ADC2_FIFO_CTRL |= ADC_FIFO_CLR_MASK;\r
- \r
- /* clear DMA FIFOs */\r
- ACE->PPE_PDMA_CTRL |= PDMA_DATAOUT_CLR_MASK;\r
- \r
- /* Unpause the Post Processing Engine. */\r
- ACE->PPE_CTRL = saved_ppe_ctrl;\r
- \r
- /* Unpause the Sample Sequencing Engine. */\r
- ACE->SSE_TS_CTRL = saved_sse_ctrl;\r
-}\r
-\r
-#ifdef __cplusplus\r
-}\r
-#endif\r
-\r
+++ /dev/null
-/*******************************************************************************\r
- * (c) Copyright 2010 Actel Corporation. All rights reserved.\r
- *\r
- * This file contains the implementation of the functions used to dynamically\r
- * control the linear transforms applied by the ACE post processing engine to\r
- * the samples read from the SSE.\r
- *\r
- * SVN $Revision: 2908 $\r
- * SVN $Date: 2010-08-20 16:01:28 +0100 (Fri, 20 Aug 2010) $\r
- */\r
-\r
-#include "mss_ace.h"\r
-#include "mss_ace_configurator.h"\r
-#include "mtd_data.h"\r
-#include "envm_layout.h"\r
-#include "../../CMSIS/a2fxxxm3.h"\r
-#include "../../CMSIS/mss_assert.h"\r
-#include "../../drivers_config/mss_ace/ace_config.h"\r
-\r
-#ifdef __cplusplus\r
-extern "C" {\r
-#endif \r
-\r
-/*\r
- * The ACE_set_linear_transform() is only available when using ACE configuration\r
- * files generated by Libero 9.1 or later.\r
- */\r
-#ifdef ACE_CFG_DATA_FORMAT_VERSION\r
-\r
-/*------------------------------------------------------------------------------\r
- * Masks ans shift values used to derive the ABPS ranges from the analog block\r
- * configuration.\r
- */\r
-#define ABPS1_CFG_BITS_MASK (uint32_t)0x06\r
-#define ABPS1_CFG_BITS_SHIFT (uint32_t)1\r
-\r
-#define ABPS2_CFG_BITS_MASK (uint32_t)0x60\r
-#define ABPS2_CFG_BITS_SHIFT (uint32_t)5\r
-\r
-/*------------------------------------------------------------------------------\r
- * One Bit DAC definitions.\r
- */\r
-#define OBD_CURRENT (uint32_t)1\r
-#define OBD_VOLTAGE (uint32_t)0\r
-\r
-#define OBD_MODE_MASK (uint32_t)0x01\r
-#define OBD_CHOPPING_MASK (uint32_t)0x02\r
-\r
-/*-------------------------------------------------------------------------*//**\r
- Neutral factor and offset for m*x + c trnasform.\r
- */\r
-#define NEUTRAL_M_FACTOR 0x4000\r
-#define NEUTRAL_C_OFFSET 0x0000\r
-\r
-/*-------------------------------------------------------------------------*//**\r
- Enumearation of the various input channel types. This is used to differentiate\r
- between channel types in order to extract the relevant factory calibration\r
- data(m1 and c1).\r
- */\r
-typedef enum channel_type\r
-{\r
- ABPS1_CHAN = 0,\r
- ABPS2_CHAN,\r
- CMB_CHAN,\r
- TMB_CHAN,\r
- DIRECT_ADC_INPUT_CHAN,\r
- OBDOUT_CHAN,\r
- FLOATING_CHAN\r
-} cal_channel_type_t;\r
-\r
-/*-------------------------------------------------------------------------*//**\r
- This data structure is used to store factory calibration data for a specific\r
- analog input.\r
- */\r
-typedef struct __channel_calibration_t\r
-{\r
- uint16_t mext;\r
- uint16_t m1;\r
- uint16_t c1;\r
-} channel_calibration_t;\r
-\r
-/*-------------------------------------------------------------------------*//**\r
- Local functions\r
- */\r
-int32_t extend_sign\r
-(\r
- uint16_t x\r
-);\r
-\r
-uint32_t adjust_to_24bit_ace_format\r
-(\r
- int64_t signed48\r
-);\r
-\r
-uint32_t adjust_to_16bit_ace_format\r
-(\r
- int64_t signed48\r
-);\r
-\r
-void get_calibration\r
-(\r
- adc_channel_id_t channel_id,\r
- channel_calibration_t * p_calibration\r
-);\r
-\r
-void write_transform_coefficients\r
-(\r
- ace_channel_handle_t channel_handle,\r
- uint32_t m,\r
- uint32_t c\r
-);\r
-\r
-/*-------------------------------------------------------------------------*//**\r
- \r
- */\r
-extern const uint8_t g_ace_external_varef_used[ACE_NB_OF_ADC];\r
-\r
-extern ace_channel_desc_t g_ace_channel_desc_table[ACE_NB_OF_INPUT_CHANNELS];\r
-\r
-extern const ppe_transforms_desc_t g_ace_ppe_transforms_desc_table[ACE_NB_OF_INPUT_CHANNELS];\r
-\r
-/*------------------------------------------------------------------------------\r
- * Pointer to the manufacturing test data containing trimming information\r
- * generated during manufacturing.\r
- */\r
-static const mtd_data_t * const p_mtd_data = (mtd_data_t *)MTD_ADDRESS;\r
-\r
-/*-------------------------------------------------------------------------*//**\r
- See "mss_ace.h" for details of how to use this function.\r
- */\r
-int16_t ACE_get_default_m_factor\r
-(\r
- ace_channel_handle_t channel_handle\r
-)\r
-{\r
- ASSERT( channel_handle < NB_OF_ACE_CHANNEL_HANDLES );\r
- \r
- return g_ace_ppe_transforms_desc_table[channel_handle].m_ppe_offset;\r
-}\r
-\r
-/*-------------------------------------------------------------------------*//**\r
- See "mss_ace.h" for details of how to use this function.\r
- */\r
-int16_t ACE_get_default_c_offset\r
-(\r
- ace_channel_handle_t channel_handle\r
-)\r
-{\r
- ASSERT( channel_handle < NB_OF_ACE_CHANNEL_HANDLES );\r
- \r
- return g_ace_ppe_transforms_desc_table[channel_handle].c_ppe_offset;\r
-}\r
-\r
-/*-------------------------------------------------------------------------*//**\r
- See "mss_ace.h" for details of how to use this function.\r
- \r
- m = m2 * m1 * mext\r
- c = (m2 * c1 * mext) + (c2 * mext)\r
- */\r
-void ACE_set_linear_transform\r
-(\r
- ace_channel_handle_t channel_handle,\r
- int16_t m2,\r
- int16_t c2\r
-)\r
-{\r
- adc_channel_id_t channel_id;\r
- uint32_t m;\r
- uint32_t c;\r
- int32_t m32;\r
- int64_t m64;\r
- int32_t c32;\r
- int64_t c64_1;\r
- int64_t c64_2;\r
- uint16_t m1;\r
- uint16_t c1;\r
- uint16_t mext;\r
- \r
- channel_calibration_t calibration;\r
- \r
- ASSERT( channel_handle < NB_OF_ACE_CHANNEL_HANDLES );\r
- \r
- if(channel_handle < NB_OF_ACE_CHANNEL_HANDLES)\r
- {\r
- channel_id = g_ace_channel_desc_table[channel_handle].signal_id;\r
- \r
- get_calibration(channel_id, &calibration);\r
- \r
- m1 = calibration.m1;\r
- c1 = calibration.c1;\r
- \r
- mext = calibration.mext;\r
-\r
- /* \r
- * m = m2 * m1 * mext\r
- */\r
- m32 = extend_sign(m2) * extend_sign(m1);\r
- m64 = (int64_t)m32 * extend_sign(mext);\r
- \r
- /* Convert 48-bit result to 32-bit ACE format result. */\r
- m = adjust_to_16bit_ace_format(m64);\r
-\r
- /*\r
- * c = (m2 * c1 * mext) + (c2 * mext)\r
- */\r
- c32 = extend_sign(m2) * extend_sign(c1);\r
- c64_1 = (int64_t)c32 * extend_sign(mext);\r
-\r
- c64_2 = ((int64_t)(extend_sign(c2) * extend_sign(mext))) << 14;\r
- \r
- c = adjust_to_24bit_ace_format(c64_1 + c64_2);\r
- \r
- write_transform_coefficients(channel_handle, m, c);\r
- }\r
-}\r
-\r
-/*-------------------------------------------------------------------------*//**\r
- Extend 16-bit signed number to 32-bit signed number.\r
- */\r
-int32_t extend_sign\r
-(\r
- uint16_t x\r
-)\r
-{\r
- int32_t y;\r
- const uint32_t sign_bit_mask = 0x00008000u;\r
- \r
- y = (x ^ sign_bit_mask) - sign_bit_mask;\r
- \r
- return y;\r
-}\r
-\r
-/*-------------------------------------------------------------------------*//**\r
- Take a 48-bit signed number, adjust it for saturation in the range -8 to\r
- +7.999, translate into 24-bit ACE format.\r
- */\r
-uint32_t adjust_to_24bit_ace_format\r
-(\r
- int64_t signed48\r
-)\r
-{\r
- int32_t ace24_format;\r
- const int64_t MAX_POSITIVE = 0x00001FFFFFFFFFFFuLL; /* +7.9999 */\r
- const int64_t MIN_NEGATIVE = 0xFFFF200000000000uLL; /* -8 */\r
- \r
- /* Check saturation. */\r
- if(signed48 > MAX_POSITIVE)\r
- {\r
- signed48 = MAX_POSITIVE;\r
- }\r
- else if(signed48 < MIN_NEGATIVE)\r
- {\r
- signed48 = MIN_NEGATIVE;\r
- }\r
- \r
- /* Adjust to 24-bit ACE format. */\r
- ace24_format = (uint32_t)(signed48 >> 14);\r
- \r
- return ace24_format;\r
-}\r
-\r
-/*-------------------------------------------------------------------------*//**\r
- Take a 48-bit signed number, adjust it for saturation in the range -8 to\r
- +7.999, translate into 16-bit ACE format.\r
- */\r
-uint32_t adjust_to_16bit_ace_format\r
-(\r
- int64_t signed48\r
-)\r
-{\r
- int32_t ace24_format;\r
- const int64_t MAX_POSITIVE = 0x00001FFFFFFFFFFFuLL; /* +7.9999 */\r
- const int64_t MIN_NEGATIVE = 0xFFFF200000000000uLL; /* -8 */\r
- \r
- /* Check saturation. */\r
- if(signed48 > MAX_POSITIVE)\r
- {\r
- signed48 = MAX_POSITIVE;\r
- }\r
- else if(signed48 < MIN_NEGATIVE)\r
- {\r
- signed48 = MIN_NEGATIVE;\r
- }\r
- \r
- /* Adjust to 24-bit ACE format. */\r
- ace24_format = (uint32_t)(signed48 >> 20);\r
- \r
- return ace24_format;\r
-}\r
-\r
-/*-------------------------------------------------------------------------*//**\r
- \r
- */\r
-void get_calibration\r
-(\r
- adc_channel_id_t channel_id,\r
- channel_calibration_t * p_calibration\r
-)\r
-{\r
- const uint32_t channel_mask = 0x0000000F;\r
- const uint32_t CMB_MUX_SEL_MASK = 0x01;\r
- const uint32_t TMB_MUX_SEL_MASK = 0x01;\r
- \r
- const cal_channel_type_t channel_type_lut[16] =\r
- {\r
- FLOATING_CHAN,\r
- ABPS1_CHAN,\r
- ABPS2_CHAN,\r
- CMB_CHAN,\r
- TMB_CHAN,\r
- ABPS1_CHAN,\r
- ABPS2_CHAN,\r
- CMB_CHAN,\r
- TMB_CHAN,\r
- DIRECT_ADC_INPUT_CHAN,\r
- DIRECT_ADC_INPUT_CHAN,\r
- DIRECT_ADC_INPUT_CHAN,\r
- DIRECT_ADC_INPUT_CHAN,\r
- FLOATING_CHAN,\r
- FLOATING_CHAN,\r
- OBDOUT_CHAN\r
- };\r
- \r
- cal_channel_type_t channel_type;\r
- uint32_t channel_nb;\r
- uint32_t adc_nb;\r
- uint32_t range;\r
- uint32_t quad_id;\r
- mtd_calibration_mc_t const * p_mc_coeff = 0;\r
- \r
- channel_nb = channel_id & channel_mask;\r
- channel_type = channel_type_lut[channel_nb];\r
- adc_nb = ((uint32_t)channel_id & 0x30u) >> 4u;\r
- \r
- quad_id = adc_nb * 2;\r
- \r
- if ( (channel_nb > 4) && (channel_nb < 9) ) { ++quad_id; }\r
- \r
- switch ( channel_type )\r
- {\r
- case ABPS1_CHAN:\r
- range = (ACE->ACB_DATA[quad_id].b8 & ABPS1_CFG_BITS_MASK) >> ABPS1_CFG_BITS_SHIFT;\r
- p_mc_coeff = &p_mtd_data->abps_calibration[quad_id][0][range];\r
- break;\r
- \r
- case ABPS2_CHAN:\r
- range = (ACE->ACB_DATA[quad_id].b8 & ABPS2_CFG_BITS_MASK) >> ABPS2_CFG_BITS_SHIFT;\r
- p_mc_coeff = &p_mtd_data->abps_calibration[quad_id][1][range];\r
- break;\r
- \r
- case CMB_CHAN:\r
- {\r
- uint32_t cmb_mux_sel = (uint32_t)ACE->ACB_DATA[quad_id].b9 & CMB_MUX_SEL_MASK;\r
- if ( cmb_mux_sel == 0 )\r
- { /* current monitor */\r
- p_mc_coeff = &p_mtd_data->cm_calibration[quad_id];\r
- }\r
- else\r
- { /* direct input */\r
- p_mc_coeff = &p_mtd_data->quads_direct_input_cal[quad_id][0];\r
- }\r
- }\r
- break;\r
- \r
- case TMB_CHAN:\r
- {\r
- uint32_t tmb_mux_sel = (uint32_t)ACE->ACB_DATA[quad_id].b10 & TMB_MUX_SEL_MASK;\r
- if ( tmb_mux_sel == 0 )\r
- { /* temperature monitor */\r
- p_mc_coeff = &p_mtd_data->tm_calibration[quad_id];\r
- }\r
- else\r
- { /* direct input */\r
- p_mc_coeff = &p_mtd_data->quads_direct_input_cal[quad_id][1];\r
- }\r
- }\r
- break;\r
- \r
- case DIRECT_ADC_INPUT_CHAN:\r
- {\r
- const uint32_t channel_to_direct_in_lut[16]\r
- = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 2, 3, 0, 0, 0};\r
- uint32_t direct_in_id;\r
- \r
- direct_in_id = channel_to_direct_in_lut[channel_id & channel_mask];\r
- p_mc_coeff = &p_mtd_data->adc_direct_input_cal[adc_nb][direct_in_id];\r
- }\r
- break;\r
- \r
- case OBDOUT_CHAN:\r
- {\r
- uint32_t obd_mode = (uint32_t)ACE->ACB_DATA[quad_id].b6 & OBD_MODE_MASK;\r
- uint32_t chopping_option = (uint32_t)ACE->ACB_DATA[quad_id].b6 & OBD_CHOPPING_MASK;\r
- if (obd_mode > 0)\r
- {\r
- obd_mode = 1;\r
- }\r
- if (chopping_option > 0)\r
- {\r
- chopping_option = 1;\r
- }\r
- p_mc_coeff = &p_mtd_data->obd_calibration[adc_nb][obd_mode][chopping_option];\r
- }\r
- break;\r
- \r
- case FLOATING_CHAN:\r
- default:\r
- /* Give neutral values is invalid channel. */\r
- p_calibration->m1 = NEUTRAL_M_FACTOR;\r
- p_calibration->c1 = NEUTRAL_C_OFFSET;\r
- break;\r
- }\r
- \r
- if (p_mc_coeff != 0)\r
- {\r
- p_calibration->m1 = p_mc_coeff->m;\r
- p_calibration->c1 = p_mc_coeff->c;\r
- \r
- }\r
- \r
- /*--------------------------------------------------------------------------\r
- Retrieve the value of the mext factor. This depends if external VAREF is\r
- used by the ADC sampling the analog input channel.\r
- */\r
- if (g_ace_external_varef_used[adc_nb])\r
- {\r
- p_calibration->mext = p_mtd_data->global_settings.varef_m;\r
- }\r
- else\r
- {\r
- p_calibration->mext = NEUTRAL_M_FACTOR;\r
- }\r
-}\r
-\r
-/*-------------------------------------------------------------------------*//**\r
- Write new m and c transform factors into the PPE RAM. The m and c factors\r
- should be in 32-bit ACE number format. The factors will be merged with\r
- relevant PE opcode into PPE RAM. The 32-bit factors are shifted right by one\r
- byte giving a 24-bit ACE number which is then merged with an 8-bit PPE opcode\r
- located in the most significant byte of the PPE RAM location.\r
- */\r
-void write_transform_coefficients\r
-(\r
- ace_channel_handle_t channel_handle,\r
- uint32_t m,\r
- uint32_t c\r
-)\r
-{\r
- uint16_t m_ppe_offset;\r
- uint16_t c_ppe_offset;\r
- const uint32_t PPE_OPCODE_MASK = 0xFF000000u;\r
- \r
- m_ppe_offset = g_ace_ppe_transforms_desc_table[channel_handle].m_ppe_offset;\r
- c_ppe_offset = g_ace_ppe_transforms_desc_table[channel_handle].c_ppe_offset;\r
- \r
- ACE->PPE_RAM_DATA[m_ppe_offset]\r
- = (ACE->PPE_RAM_DATA[m_ppe_offset] & PPE_OPCODE_MASK) | (m >> 8u);\r
- \r
- ACE->PPE_RAM_DATA[c_ppe_offset]\r
- = (ACE->PPE_RAM_DATA[c_ppe_offset] & PPE_OPCODE_MASK) | (c >> 8u);\r
-}\r
-\r
-#endif /* ACE_CFG_DATA_FORMAT_VERSION */\r
-\r
-#ifdef __cplusplus\r
-}\r
-#endif\r
/*******************************************************************************\r
* (c) Copyright 2009 Actel Corporation. All rights reserved.\r
- * \r
+ *\r
* SVN $Revision: 2905 $\r
* SVN $Date: 2010-08-20 14:03:28 +0100 (Fri, 20 Aug 2010) $\r
*/\r
\r
#ifdef __cplusplus\r
extern "C" {\r
-#endif \r
+#endif\r
\r
#define START_ADC_CONVERSION 0x80uL\r
\r
void ACE_init( void )\r
{\r
/* Initialize driver's internal data. */\r
- ace_init_flags();\r
- \r
+ #if (ACE_NB_OF_PPE_FLAGS > 0)\r
+ ace_init_flags();\r
+ #endif\r
+\r
/* Initialize the data structures used by conversion functions. */\r
ace_init_convert();\r
}\r
uint32_t data_valid;\r
\r
ASSERT( adc_id < NB_OF_ANALOG_MODULES );\r
- \r
+\r
if ( adc_id < (uint8_t)NB_OF_ANALOG_MODULES )\r
{\r
do {\r
data_valid = *adc_status_reg_lut[adc_id] & ADC_DATAVALID_MASK;\r
} while ( !data_valid );\r
- \r
+\r
result = (uint16_t)(*adc_status_reg_lut[adc_id] & ADC_RESULT_MASK);\r
}\r
return result;\r
\r
#define SDD_ENABLE_MASK 0x20uL\r
#define SDD_REG_SEL_MASK 0x40uL\r
- \r
+\r
#define DAC0_SYNC_EN_MASK 0x10uL\r
#define DAC1_SYNC_EN_MASK 0x20uL\r
#define DAC2_SYNC_EN_MASK 0x40uL\r
)\r
{\r
ASSERT( sdd_id < NB_OF_SDD );\r
- \r
+\r
if ( sdd_id < NB_OF_SDD )\r
{\r
const uint8_t sdd_2_quad_lut[NB_OF_SDD] = {0u, 2u, 4u};\r
uint8_t obd_mode_idx = 1u;\r
uint8_t chopping_mode_idx = 0u;\r
uint32_t saved_pc2_ctrl;\r
- \r
+\r
quad_id = sdd_2_quad_lut[sdd_id];\r
- \r
+\r
/* Pause the SSE PC2 while accesses to ACB from APB3 are taking place. */\r
saved_pc2_ctrl = ACE->PC2_CTRL;\r
ACE->PC2_CTRL = 0u;\r
- \r
+\r
/* Select between voltage/current and RTZ modes.*/\r
ACE->ACB_DATA[quad_id].b6 = mode;\r
- \r
+\r
/* Load manufacturing generated trim value. */\r
if ( (mode & OBD_MODE_MASK) > 0u )\r
{\r
}\r
ACE->ACB_DATA[quad_id].b4\r
= p_mtd_data->odb_trimming[sdd_id][obd_mode_idx][chopping_mode_idx];\r
- \r
+\r
/* Restore SSE PC2 operations since no ACB accesses should take place\r
* beyond this point. */\r
ACE->PC2_CTRL = saved_pc2_ctrl;\r
- \r
+\r
/* Set SDD resolution. */\r
*dac_ctrl_reg_lut[sdd_id] = (uint32_t)resolution;\r
- \r
+\r
/* Update SDD value through SSE_DACn_BYTES01. */\r
*dac_ctrl_reg_lut[sdd_id] |= SDD_REG_SEL_MASK;\r
- \r
+\r
/* Synchronous or individual SDD update. */\r
if ( INDIVIDUAL_UPDATE == sync_update )\r
{\r
)\r
{\r
ASSERT( sdd_id < NB_OF_SDD );\r
- \r
+\r
if ( sdd_id < NB_OF_SDD )\r
{\r
*dac_ctrl_reg_lut[sdd_id] |= SDD_ENABLE_MASK;\r
)\r
{\r
ASSERT( sdd_id < NB_OF_SDD );\r
- \r
+\r
if ( sdd_id < NB_OF_SDD )\r
{\r
*dac_ctrl_reg_lut[sdd_id] &= ~SDD_ENABLE_MASK;\r
)\r
{\r
ASSERT( sdd_id < NB_OF_SDD );\r
- \r
+\r
if ( sdd_id < NB_OF_SDD )\r
{\r
*dac_byte2_reg_lut[sdd_id] = sdd_value >> 16;\r
)\r
{\r
uint32_t dac_sync_ctrl;\r
- \r
+\r
dac_sync_ctrl = ACE->DAC_SYNC_CTRL;\r
- \r
+\r
if ( SDD_NO_UPDATE != sdd0_value )\r
{\r
ACE->DAC0_BYTE2 = sdd0_value >> 16;\r
ACE->SSE_DAC2_BYTES01 = sdd2_value;\r
dac_sync_ctrl |= DAC2_SYNC_UPDATE;\r
}\r
- \r
+\r
ACE->DAC_SYNC_CTRL = dac_sync_ctrl;\r
}\r
\r
{\r
uint8_t scb_id;\r
uint32_t odd;\r
- \r
+\r
odd = (uint32_t)comp_id & 0x01uL;\r
- \r
+\r
ASSERT( comp_id < NB_OF_COMPARATORS );\r
ASSERT( reference < NB_OF_COMP_REF );\r
ASSERT( odd ); /* Only Temperature block comparators have configurable reference input. */\r
- \r
+\r
if ( (comp_id < NB_OF_COMPARATORS) && (reference < NB_OF_COMP_REF) && (odd) )\r
{\r
uint32_t saved_pc2_ctrl;\r
- \r
+\r
scb_id = comp_id_2_scb_lut[comp_id];\r
- \r
+\r
/* Pause the SSE PC2 while accesses to ACB from APB3 are taking place. */\r
saved_pc2_ctrl = ACE->PC2_CTRL;\r
ACE->PC2_CTRL = 0u;\r
- \r
+\r
if ( ADC_IN_COMP_REF == reference )\r
{\r
ACE->ACB_DATA[scb_id].b10 &= (uint8_t)~B10_COMP_VREF_SW_MASK;\r
ACE->ACB_DATA[scb_id].b10 &= (uint8_t)~B10_COMP_VREF_SW_MASK;\r
ACE->ACB_DATA[scb_id].b11 = (ACE->ACB_DATA[scb_id].b11 & (uint8_t)~B11_DAC_MUXSEL_MASK) + (uint8_t)reference;\r
}\r
- \r
+\r
/* Restore SSE PC2 operations since no ACB accesses should take place\r
* beyond this point. */\r
ACE->PC2_CTRL = saved_pc2_ctrl;\r
)\r
{\r
uint8_t scb_id;\r
- \r
+\r
ASSERT( comp_id < NB_OF_COMPARATORS );\r
ASSERT( hysteresis < NB_OF_HYSTERESIS );\r
- \r
+\r
if ( (comp_id < NB_OF_COMPARATORS) && (hysteresis < NB_OF_HYSTERESIS) )\r
{\r
uint32_t odd;\r
uint32_t saved_pc2_ctrl;\r
- \r
+\r
scb_id = comp_id_2_scb_lut[comp_id];\r
odd = (uint32_t)comp_id & 0x01uL;\r
- \r
+\r
/* Pause the SSE PC2 while accesses to ACB from APB3 are taking place. */\r
saved_pc2_ctrl = ACE->PC2_CTRL;\r
ACE->PC2_CTRL = 0u;\r
- \r
+\r
if ( odd )\r
{\r
/* Temperature monitor block comparator. */\r
/* Current monitor block comparator. */\r
ACE->ACB_DATA[scb_id].b9 = (ACE->ACB_DATA[scb_id].b9 & HYSTERESIS_MASK) | (uint8_t)((uint8_t)hysteresis << HYSTERESIS_SHIFT);\r
}\r
- \r
+\r
/* Restore SSE PC2 operations since no ACB accesses should take place\r
* beyond this point. */\r
ACE->PC2_CTRL = saved_pc2_ctrl;\r
}\r
\r
/*-------------------------------------------------------------------------*//**\r
- \r
+\r
*/\r
void ACE_enable_comp\r
(\r
)\r
{\r
uint8_t scb_id;\r
- \r
+\r
ASSERT( comp_id < NB_OF_COMPARATORS );\r
- \r
+\r
if ( comp_id < NB_OF_COMPARATORS )\r
{\r
uint32_t odd;\r
uint32_t saved_pc2_ctrl;\r
- \r
+\r
scb_id = comp_id_2_scb_lut[comp_id];\r
odd = (uint32_t)comp_id & 0x01uL;\r
- \r
+\r
/* Pause the SSE PC2 while accesses to ACB from APB3 are taking place. */\r
saved_pc2_ctrl = ACE->PC2_CTRL;\r
ACE->PC2_CTRL = 0u;\r
- \r
+\r
if ( odd )\r
{\r
/* Temperature monitor block comparator. */\r
/* Current monitor block comparator. */\r
ACE->ACB_DATA[scb_id].b9 |= COMPARATOR_ENABLE_MASK;\r
}\r
- \r
+\r
/* Restore SSE PC2 operations since no ACB accesses should take place\r
* beyond this point. */\r
ACE->PC2_CTRL = saved_pc2_ctrl;\r
)\r
{\r
uint8_t scb_id;\r
- \r
+\r
ASSERT( comp_id < NB_OF_COMPARATORS );\r
- \r
+\r
if ( comp_id < NB_OF_COMPARATORS )\r
{\r
uint32_t odd;\r
uint32_t saved_pc2_ctrl;\r
- \r
+\r
scb_id = comp_id_2_scb_lut[comp_id];\r
odd = (uint32_t)comp_id & 0x01uL;\r
- \r
+\r
/* Pause the SSE PC2 while accesses to ACB from APB3 are taking place. */\r
saved_pc2_ctrl = ACE->PC2_CTRL;\r
ACE->PC2_CTRL = 0u;\r
- \r
+\r
if ( odd )\r
{\r
/* Temperature monitor block comparator. */\r
/* Current monitor block comparator. */\r
ACE->ACB_DATA[scb_id].b9 &= (uint8_t)~COMPARATOR_ENABLE_MASK;\r
}\r
- \r
+\r
/* Restore SSE PC2 operations since no ACB accesses should take place\r
* beyond this point. */\r
ACE->PC2_CTRL = saved_pc2_ctrl;\r
)\r
{\r
ASSERT( comp_id < NB_OF_COMPARATORS );\r
- \r
+\r
ACE->COMP_IRQ_EN |= (FIRST_RISE_IRQ_MASK << (uint32_t)comp_id);\r
}\r
\r
)\r
{\r
ASSERT( comp_id < NB_OF_COMPARATORS );\r
- \r
+\r
ACE->COMP_IRQ_EN &= ~(FIRST_RISE_IRQ_MASK << (uint32_t)comp_id);\r
}\r
\r
)\r
{\r
ASSERT( comp_id < NB_OF_COMPARATORS );\r
- \r
+\r
ACE->COMP_IRQ_CLR |= (FIRST_RISE_IRQ_MASK << (uint32_t)comp_id);\r
}\r
\r
)\r
{\r
ASSERT( comp_id < NB_OF_COMPARATORS );\r
- \r
+\r
ACE->COMP_IRQ_EN |= (FIRST_FALL_IRQ_MASK << (uint32_t)comp_id);\r
}\r
\r
)\r
{\r
ASSERT( comp_id < NB_OF_COMPARATORS );\r
- \r
+\r
ACE->COMP_IRQ_EN &= ~(FIRST_FALL_IRQ_MASK << (uint32_t)comp_id);\r
}\r
\r
)\r
{\r
ASSERT( comp_id < NB_OF_COMPARATORS );\r
- \r
+\r
ACE->COMP_IRQ_CLR |= (FIRST_FALL_IRQ_MASK << (uint32_t)comp_id);\r
}\r
\r
)\r
{\r
ace_channel_handle_t channel_handle;\r
- \r
+\r
channel_handle = (ace_channel_handle_t)0;\r
- \r
+\r
return channel_handle;\r
}\r
\r
)\r
{\r
++channel_handle;\r
- \r
+\r
if ( channel_handle >= NB_OF_ACE_CHANNEL_HANDLES )\r
{\r
channel_handle = (ace_channel_handle_t)0;\r
}\r
- \r
+\r
return channel_handle;\r
}\r
\r
{\r
uint16_t channel_idx;\r
ace_channel_handle_t channel_handle = INVALID_CHANNEL_HANDLE;\r
- \r
+\r
for ( channel_idx = 0u; channel_idx < (uint16_t)ACE_NB_OF_INPUT_CHANNELS; ++channel_idx )\r
{\r
if ( g_ace_channel_desc_table[channel_idx].p_sz_channel_name != 0 )\r
{\r
uint16_t channel_idx;\r
ace_channel_handle_t channel_handle = INVALID_CHANNEL_HANDLE;\r
- \r
+\r
for ( channel_idx = 0u; channel_idx < (uint16_t)ACE_NB_OF_INPUT_CHANNELS; ++channel_idx )\r
{\r
if ( g_ace_channel_desc_table[channel_idx].signal_id == channel_id )\r
{\r
uint16_t sample;\r
uint16_t ppe_offset;\r
- \r
+\r
ppe_offset = g_ace_channel_desc_table[channel_handle].signal_ppe_offset;\r
sample = (uint16_t)(ACE->PPE_RAM_DATA[ppe_offset] >> 16u);\r
- \r
+\r
return sample;\r
}\r
\r
/*******************************************************************************\r
* (c) Copyright 2009 Actel Corporation. All rights reserved.\r
- * \r
+ *\r
* SmartFusion ACE driver public API.\r
*\r
* SVN $Revision: 2884 $\r
\95 Sigma Delta Digital to Analog Converters (SDD) control\r
\95 Direct analog block configuration and usage\r
\r
- \r
+\r
Initialization\r
The ACE driver is initialized through a call to the ACE_init() function. The\r
ACE_init() function must be called before any other ACE driver functions can\r
be called. It initializes the ACE\92s internal data.\r
\r
- \r
+\r
Reading analog input channels values and properties\r
The ACE driver allows retrieving the most recent post processed sample value\r
for each analog input. It also allows retrieving the name of the analog input\r
\95 const uint8_t * ACE_get_channel_name( ace_channel_handle_t channel_handle )\r
\95 channel_type_t ACE_get_channel_type( ace_channel_handle_t channel_handle )\r
\r
- \r
+\r
Post Processing Engine flags\r
The SmartFusion ACE Post Processing Engine (PPE) provides the ability to monitor\r
the state of analog input channels and detect when certain threshold values are\r
\95 ace_flag_handle_t ACE_get_flag_handle (const uint8_t *p_sz_full_flag_name)\r
\95 ace_flag_handle_t ACE_get_channel_first_flag (ace_channel_handle_t channel_handle, uint16_t *iterator)\r
\95 ace_flag_handle_t ACE_get_channel_next_flag (ace_channel_handle_t channel_handle, uint16_t *iterator)\r
- \r
+\r
The current status of a flag can be polled using the following function:\r
\95 int32_t ACE_get_flag_status (ace_flag_handle_t flag_handle)\r
\r
\95 const uint8_t * ACE_get_flag_name (ace_flag_handle_t flag_handle)\r
\95 ace_channel_handle_t ACE_get_flag_channel (ace_flag_handle_t flag_handle)\r
\r
- \r
+\r
Conversion to and from real world units\r
The ACE driver provides a set of conversion functions to convert sample values\r
read from the post processing engine into real world units:\r
PPE sample values. These functions are typically used for dynamically adjusting\r
flags threshold values.\r
\r
- \r
+\r
Sample Sequencing Engine control\r
The ACE driver provides a set of functions for dynamically controlling the\r
Sample Sequencing Engine. These functions are only required for managing multiple\r
sampling sequences. The use of these functions is not required for most applications\r
since the SSE is already configured and running by the time the application starts.\r
\r
- \r
+\r
Sample Sequencing Engine Interrupts Control\r
The ACE driver provides a set of functions for managing interrupts generated by\r
the Sample Sequencing Engine. These functions allow enabling, disabling and clearing\r
interrupt defined as part of the sampling sequence. These functions also allow\r
controlling interrupts generated by the ADCs.\r
\r
- \r
+\r
Comparators control\r
The ACE driver provides a set of functions for managing interrupts generated based\r
on the change of state of the high speed comparators. Functions are also provided\r
to dynamically modify the comparators configuration.\r
\r
- \r
+\r
Sigma Delta Digital to Analog Converters (SDD) control\r
The ACE driver provides functions for controlling the output value of the Sigma\r
Delta DACs (SDD). Functions are also provided for dynamically adjusting the\r
\r
#ifdef __cplusplus\r
extern "C" {\r
-#endif \r
+#endif\r
\r
-#include "../../drivers_config/mss_ace/ace_handles.h"\r
+#include "ace_handles.h"\r
\r
/*-------------------------------------------------------------------------*//**\r
Analog to Digital Converter channel IDs.\r
/*==============================================================================\r
============== Direct Analog Block Configuration and Usage ====================\r
=============================================================================*/\r
- \r
+\r
/*=========================================================================*//**\r
@defgroup group1 Direct Analog Block Configuration and Usage\r
These functions are intended for using the SmartFusion analog block hardware\r
channel identified by the channel_id parameter. This function is provided for\r
test purposes. It must not be used while the Sample Sequencing Engine is\r
running.\r
- \r
+\r
@param channel_id\r
The channel_id parameter identifies the analog input channel to sample.\r
- \r
+\r
@return\r
This function does not return a value.\r
*/\r
/*-------------------------------------------------------------------------*//**\r
The ACE_get_adc_result () function reads the result of the last input channel\r
sampling performed by the ADC identified as parameter.\r
- \r
+\r
@param adc_id\r
The adc_id parameter identifies which of the possible three ADC to read the\r
sample result from.\r
- \r
+\r
@return\r
The ACE_start_adc_sync() function returns the ADC result from the ADC\r
specified as parameter.\r
/*-------------------------------------------------------------------------*//**\r
The sdd_id_t enumeration is used to identify the Sigma Delta DACs to the SDD\r
control functions, ACE_configure_sdd(), ACE_enable_sdd(), ACE_disable_sdd()\r
- and ACE_set_sdd_value(). There is one SDD per analog module. \r
+ and ACE_set_sdd_value(). There is one SDD per analog module.\r
*/\r
typedef enum\r
{\r
\r
/*-------------------------------------------------------------------------*//**\r
The sdd_resolution_t enumeration is used as a parameter to the\r
- ACE_configure_sdd() function to specify DAC resolution of the Sigma Delta DAC. \r
+ ACE_configure_sdd() function to specify DAC resolution of the Sigma Delta DAC.\r
*/\r
typedef enum\r
{\r
more important than accuracy.\r
A call to this function is not required if relying on the configuration\r
selected in the ACE configurator being loaded after reset by the system boot.\r
- \r
+\r
@param sdd_id\r
The sdd_id parameter specifies which Sigma Delta DAC is configured by this\r
function. Allowed values are:\r
- SDD0_OUT\r
- SDD1_OUT\r
- SDD2_OUT\r
- \r
+\r
@param resolution\r
The resolution parameter specifies the desired resolution of the Sigma Delta DAC.\r
Allowed values are:\r
- SDD_8_BITS\r
- SDD_16_BITS\r
- SDD_24_BITS\r
- \r
+\r
@param mode\r
The mode parameter specifies the operating mode of the Sigma Delta DAC. It\r
specifies whether a current or voltage should be generated and whether\r
- SDD_VOLTAGE_MODE\r
- SDD_RETURN_TO_ZERO\r
- SDD_NON_RTZ\r
- \r
+\r
@param sync_update\r
The sync_update parameter specifies whether the SDD output will be updated\r
individually though a call to ACE_set_sdd_value() or synchronously with one\r
);\r
\r
/*-------------------------------------------------------------------------*//**\r
- The ACE_enable_sdd() function is used to enable a Sigma Delta DAC. \r
- \r
+ The ACE_enable_sdd() function is used to enable a Sigma Delta DAC.\r
+\r
@param sdd_id\r
The sdd_id parameter specifies the Sigma Delta DAC to enable.\r
*/\r
\r
/*-------------------------------------------------------------------------*//**\r
The ACE_disable_sdd() function is used to disable a Sigma Delta DAC.\r
- \r
+\r
@param sdd_id\r
The sdd_id parameter specifies the Sigma Delta DAC to disable.\r
*/\r
the SDD resolution into account. A maximum voltage of 2.56V or a maximum\r
current of 256uA will be generated when the sdd_value is set the maximum value\r
allowed by the SDD resolution\r
- \r
+\r
@param sdd_id\r
The sdd_id parameter specifies which Sigma Delta DAC is being set.\r
- \r
+\r
@param sdd_value\r
The sdd_value parameter specifies the value of the Sigma Delta DAC output.\r
It is a fraction of SDD resolution. The voltage/current value generated from\r
subsequently used as parameter to function ACE_get_ppe_sample() used to read\r
the most recent post processed sample for the analog input identified through\r
the channel/service name passed as argument to this function.\r
- \r
+\r
@param p_sz_channel_name\r
The p_sz_channel_name parameter is a zero-terminated string containing the\r
name of the channel/service as entered in the ACE configurator.\r
- \r
+\r
@return\r
This function returns a channel handle. This channel handle is required as\r
parameter to function ACE_get_ppe_sample().\r
It will return INVALID_CHANNEL_HANDLE if the channel/service name is not\r
recognized.\r
- \r
+\r
@code\r
uint16_t adc_result;\r
ace_channel_handle_t at0;\r
/*-------------------------------------------------------------------------*//**\r
The ACE_get_input_channel_handle() function returns the channel handle for\r
the hardware analog input channel specified as parameter.\r
- \r
+\r
@param channel_id\r
The channel_id parameter identifies a hardware analog input of the ACE.\r
- \r
+\r
@return\r
This function returns a channel handle. This channel handle is required as\r
parameter to other ACE driver functions dealing with analog inputs.\r
The ACE_get_ppe_sample() function is used to read the most recent post\r
processed sample for the analog input channel associated with the channel\r
handle passed as parameter.\r
- \r
+\r
@param channel_handle\r
The channel_handle parameter identifies the analog input channel for which\r
this function will return the most recent ADC conversion result adjusted for\r
ACE_get_channel_handle() when the name of the channel is known, or by\r
iterating though all analog input channel using the ACE_get_first_channel()\r
and ACE_get_next_channel().\r
- \r
+\r
@return\r
This function returns a 16 bit value representing the adjusted value of the\r
ADC conversion result for the analog input channel identified by the channel\r
handle passed as parameter. The return value is actually a 12, 10 or 8 bits\r
number depending on the configuration of the ADC.\r
- \r
+\r
@code\r
uint16_t adc_result;\r
ace_channel_handle_t at0;\r
associated with the channel handle passed as parameter. The channel name is\r
the name used in the ACE configurator software tool when adding a service to\r
the ACE.\r
- \r
+\r
@param channel_handle\r
The channel_handle parameter identifies the analog input channel for which\r
we want to retrieve the channel name. The available channel handle values can\r
to ACE_get_channel_handle() when the name of the channel is known, or by\r
iterating though all analog input channel using the ACE_get_first_channel()\r
and ACE_get_next_channel().\r
- \r
+\r
@return\r
This function returns a pointer to a zero-terminated string containing the\r
name of the channel. It returns 0 if the channel handle passed as parameter\r
analog input channel identified by the channel handle passed as parameter.\r
This function allows determining whether the quantity measured through the ADC\r
is a voltage, current or temperature.\r
- \r
+\r
@param channel_handle\r
The channel_handle parameter identifies one of the analog input channels\r
monitored by the ACE. The available channel handle values can be found in the\r
ACE_get_channel_handle() when the name of the channel is known, or by\r
iterating though all analog input channel using the ACE_get_first_channel()\r
and ACE_get_next_channel().\r
- \r
+\r
@return\r
This function returns one of the following values to report the type of\r
quantity measure throught the channel:\r
The ACE_get_channel_count() function returns the total number of configured\r
analog input channels. It is the number of channels available for use as\r
opposed to the theorical number of physical channels supported by the device.\r
- \r
+\r
@return\r
The ACE_get_channel_count() function returns the total number of input\r
channels that were configured in the ACE configurator.\r
The ACE_get_channel_count() function returns 0 if no input channels were\r
configured.\r
- \r
+\r
@code\r
uint32_t inc;\r
uint32_t nb_of_channels;\r
ace_channel_handle_t current_channel;\r
- \r
+\r
nb_of_channels = ACE_get_channel_count();\r
current_channel = ACE_get_first_channel();\r
- \r
+\r
for (inc = 0; inc < nb_of_channels; ++inc)\r
{\r
adc_result = ACE_get_ppe_sample( current_channel );\r
The ACE_get_first_channel() function returns the channel handle of one of the\r
channel controlled by the ACE. This function is used to start iterating though\r
the list of analog input channels handled by the ACE.\r
- \r
+\r
@return\r
The ACE_get_first_channel() function returns the first channel handle found\r
in the ACE driver's internal channel handles list or INVALID_CHANNEL_HANDLE\r
if there are no channels defined in the ACE configuration.\r
- \r
+\r
@code\r
uint32_t inc;\r
uint32_t nb_of_channels;\r
ace_channel_handle_t current_channel;\r
- \r
+\r
nb_of_channels = ACE_get_channel_count();\r
current_channel = ACE_get_first_channel();\r
- \r
+\r
for (inc = 0; inc < nb_of_channels; ++inc)\r
{\r
adc_result = ACE_get_ppe_sample( current_channel );\r
The ACE_get_next_channel() returns the channel handle of the channel following\r
the one passed as parameter. This function is used to iterate through the list\r
of analog input channels handled by the ACE.\r
- \r
+\r
@param channel_handle\r
The channel_handle parameter identifies from which channel the driver should\r
look in its channel handle list to return the next channel handle. The\r
channel_handle returned by a previous call to ACE_get_first_channel(). The\r
second and subsequent calls to ACE_get_next_channel() would typically use\r
the channel_handle returned by a previous call to ACE_get_next_channel().\r
- \r
+\r
@return\r
The ACE_get_next_channel() function returns the channel handle of the channel\r
following the one passed as parameter or INVALID_CHANNEL_HANDLE if the end of\r
the channels list has been reached.\r
- \r
+\r
@code\r
uint32_t inc;\r
uint32_t nb_of_channels;\r
ace_channel_handle_t current_channel;\r
- \r
+\r
nb_of_channels = ACE_get_channel_count();\r
current_channel = ACE_get_first_channel();\r
- \r
+\r
for (inc = 0; inc < nb_of_channels; ++inc)\r
{\r
adc_result = ACE_get_ppe_sample( current_channel );\r
Sequencing Engine sequence identified by the sequence name passed as parameter.\r
The sequence handler can then be used as parameter to other SSE sequence control\r
functions to identify the sequence to control.\r
- \r
+\r
@param p_sz_sequence_name\r
The p_sz_sequence_name parameter is a pointer to a zero-terminated string\r
containing the name of the sampling sequence for which we want to retrieve\r
the handle.\r
- \r
+\r
@return\r
The ACE_get_sse_seq_handle() function returns the handle used to identify\r
the sequence passed as parameter with other ACE driver sampling sequence\r
control functions. It returns INVALID_SSE_SEQ_HANDLE if the sequence name\r
passed as parameter is not recognized.\r
- \r
+\r
@code\r
sse_sequence_handle_t sse_seq_handle;\r
sse_seq_handle = ACE_get_sse_seq_handle("ProcedureA");\r
The ACE_load_sse() function loads the ACE Sample Sequencing Engine (SSE) RAM\r
with the microcode implementing the sampling sequence identified by the SSE\r
sequence handler passed as parameter.\r
- \r
+\r
@param sequence\r
The sequence parameter is the SSE sequence handler identifying the sampling\r
sequence to load into the ACE SSE. The value for this handler is retrieved\r
before the loop part of the sequence is started.\r
You must ensure that the sampling sequence has been loaded into the ACE's SSE\r
before calling this function.\r
- \r
+\r
@param sequence\r
The sequence parameter is the SSE sequence handler identifying the sampling\r
sequence to load into the ACE SSE. The value for this handler is retrieved\r
intialization phase of the sequence.\r
This function would typically be called after stopping the sampling sequence\r
using the ACE_stop_see() function or with non-repeating sequences.\r
- \r
+\r
@param sequence\r
The sequence parameter is the SSE sequence handler identifying the sampling\r
sequence to load into the ACE SSE. The value for this handler is retrieved\r
/*-------------------------------------------------------------------------*//**\r
The ACE_stop_sse() function stops execution of the Sample Sequencing Engine\r
(SSE) sequence indentified by the sequence handle passed as parameter.\r
- \r
+\r
@param sequence\r
The sequence parameter is the SSE sequence handle identifying the sampling\r
sequence to load into the ACE SSE. The value for this handler is retrieved\r
sampling sequence identified by the sequence handle passed as parameter to\r
resume execution. This function is typically used to restart execution of\r
a sequence at the point where it was stopped through a call to ACE_stop_sse().\r
- \r
+\r
@param sequence\r
The sequence parameter is the SSE sequence handler identifying the sampling\r
sequence to load into the ACE SSE. The value for this handler is retrieved\r
post processed samples within the ACE hardware. It is intended for use when\r
switching between sampling sequences and using peripheral DMA. It avoids\r
receiving stale samples generated as a result of a previous sampling sequence.\r
- \r
+\r
The example below shows how this function can be used to ensure that no sample\r
generated as a result of sampling sequence sequence_a will be generated once\r
sampling sequence_b is started. Please note that it is important to stop the\r
ACE_clear_sample_pipeline();\r
ACE_start_sse(sequence_b);\r
@endcode\r
- \r
+\r
The example below shows how to ensure that the first sample read through PDMA\r
will be from the first channel in the sampling sequence.\r
@code\r
ACE_restart_sse(sequence_a);\r
PDMA_start\r
(\r
- PDMA_CHANNEL_0, \r
- PDMA_ACE_PPE_DATAOUT, \r
- (uint32_t)g_samples_buffer[g_pdma_buffer_idx], \r
+ PDMA_CHANNEL_0,\r
+ PDMA_ACE_PPE_DATAOUT,\r
+ (uint32_t)g_samples_buffer[g_pdma_buffer_idx],\r
SAMPLES_BUFFER_SIZE\r
);\r
@endcode\r
/*-------------------------------------------------------------------------*//**\r
The ACE_enable_sse_irq() function enables the Sample Sequencing Engine (SSE)\r
interrupt source specified as parameter to generate interrupts.\r
- \r
+\r
@param sse_irq_id\r
The sse_irq_id parameter identifies the SSE interrupt source controlled by\r
this function.\r
/*-------------------------------------------------------------------------*//**\r
The ACE_disable_sse_irq() function disables the Sample Sequencing Engine\r
(SSE) interrupt source specified as parameter from generating interrupts.\r
- \r
+\r
@param sse_irq_id\r
The sse_irq_id parameter identifies the SSE interrupt source controlled by\r
this function.\r
/*-------------------------------------------------------------------------*//**\r
The ACE_clear_sse_irq() function clears the Sampling Sequencing Engine (SSE)\r
interrupt specified as parameter.\r
- \r
+\r
@param sse_irq_id\r
The sse_irq_id parameter identifies the SSE interrupt source controlled by\r
this function.\r
The ACE_set_comp_reference() function is used to select the reference input\r
of a temperature monitor block comparator. The reference input of a temperature\r
monitor can be an ADC direct input or one of the SDD's output.\r
- \r
+\r
@param comp_id\r
The comp_id parameter specifies the comparator for which to select the\r
- reference input. Since only temperature monitor block comparators have a \r
+ reference input. Since only temperature monitor block comparators have a\r
selectable reference input, allowed values are:\r
- CMP1\r
- CMP3\r
- CMP7\r
- CMP9\r
- CMP11\r
- \r
+\r
@param reference\r
The reference parameter specify the signal that will be used as reference\r
by the comparator. Allowed values are:\r
The ACE_set_comp_hysteresis() function is used to set the hysteresis of a\r
comparator. There are four possible hystereris settings: no hysteresis,\r
+/-10mV, +/-30mV or +/-100mV.\r
- \r
+\r
@param comp_id\r
The comp_id parameter specifies the comparator for which this function will\r
set the hyteresis.\r
- \r
+\r
@param hysteresis\r
- The hysteresis parameter specifies the hysteresis that will be applied to \r
+ The hysteresis parameter specifies the hysteresis that will be applied to\r
the comparator's input. Allowed values are:\r
- NO_HYSTERESIS\r
- HYSTERESIS_10_MV\r
- HYSTERESIS_30_MV\r
- HYSTERESIS_100_MV\r
- \r
+\r
*/\r
void ACE_set_comp_hysteresis\r
(\r
/*-------------------------------------------------------------------------*//**\r
The ACE_enable_comp() function is used to enable the comparator specified as\r
parameter.\r
- \r
+\r
@param comp_id\r
The comp_id parameter specifies which comparator will be enabled by a call\r
to this function.\r
/*-------------------------------------------------------------------------*//**\r
The ACE_disable_comp() function is used to disable the comparator specified as\r
parameter.\r
- \r
+\r
@param comp_id\r
The comp_id parameter specifies which comparator will be disabled by a call\r
to this function.\r
- void ACE_Comp9_Rise_IRQHandler( void );\r
- void ACE_Comp10_Rise_IRQHandler( void );\r
- void ACE_Comp11_Rise_IRQHandler( void );\r
- \r
+\r
@param comp_id\r
The comp_id parameter specifies which comparator will be enabled to generate\r
rising interrupts.\r
The ACE_disable_comp_rise_irq() function is used to disable interrupts from\r
being generated when the positive input of the comparator specified as parameter\r
rises above the negative input of the comparator.\r
- \r
+\r
@param comp_id\r
The comp_id parameter specifies which comparator will be disabled from\r
generating rising interrupts.\r
/*-------------------------------------------------------------------------*//**\r
The ACE_clear_comp_rise_irq() function is used to clear rise interrupts. This\r
function is typically called as part of the rise interrupt service routine.\r
- \r
+\r
@param comp_id\r
The comp_id parameter specifies the comparator for which to clear the rise\r
interrupt.\r
- \r
+\r
Example:\r
@code\r
void ACE_Comp1_Rise_IRQHandler( void )\r
- void ACE_Comp9_Fall_IRQHandler( void );\r
- void ACE_Comp10_Fall_IRQHandler( void );\r
- void ACE_Comp11_Fall_IRQHandler( void );\r
- \r
+\r
@param comp_id\r
The comp_id parameter specifies which comparator will be enabled to generate\r
fall interrupts.\r
The ACE_disable_comp_fall_irq() function is used to disable interrupts from\r
being generated when the positive input of the comparator specified as parameter\r
falls below the negative input of the comparator.\r
- \r
+\r
@param comp_id\r
The comp_id parameter specifies which comparator will be disabled from\r
generating fall interrupts.\r
/*-------------------------------------------------------------------------*//**\r
The ACE_clear_comp_fall_irq() function is used to clear fall interrupts. This\r
function is typically called as part of the fall interrupt service routine.\r
- \r
+\r
@param comp_id\r
The comp_id parameter specifies the comparator for which to clear the fall\r
interrupt.\r
- \r
+\r
Example:\r
@code\r
void ACE_Comp1_Fall_IRQHandler( void )\r
status. It returns a 32 bit value indicating which comparators experienced a\r
fall and/or rise event. These status bits can be cleared using the\r
ACE_clear_comp_rise_irq() and ACE_clear_comp_fall_irq() functions.\r
- \r
+\r
@return\r
The return value is a 32 bit numnber where bits 0 to 11 indicate which\r
comparator experienced a fall event and bits 21 to 23 indicate which\r
The ACE_is_hysteresis_flag() function indicates if an hysteresis is applied\r
to the analog input sample value when determining the state of the flag\r
identified as parameter.\r
- \r
+\r
@param flag_handle\r
The flag_handle parameter identifies one of the flags generated based on the\r
value of an analog input channel. The available flag handle values can be\r
ACE_get_flag_handle() when the name of the flag is known, or by iterating\r
though all flags associated with an analog input channel using the\r
ACE_get_channel_first_flag() and ACE_get_channel_next_flag().\r
- \r
+\r
@return\r
This function returns the value one if a hysteresis is applied to the channel\r
sample values as part of determining the state of the flag identified as\r
The ACE_is_under_flag() function indicates whether a flag is triggered when the\r
monitored analog input falls below the flag's threshold level or above the\r
flag's threshold level.\r
- \r
+\r
@param flag_handle\r
The flag_handle parameter identifies one of the flags generated based on the\r
value of an analog input channel. The available flag handle values can be\r
ACE_get_flag_handle() when the name of the flag is known, or by iterating\r
though all flags associated with an analog input channel using the\r
ACE_get_channel_first_flag() and ACE_get_channel_next_flag().\r
- \r
+\r
@return\r
This function returns the value one if the flag identified as parameter\r
triggers as a result of the monitored input falling below the flag's\r
over flag configured with a 100 millivolts hysteresis will result in the flag\r
being asserted when the voltage reaches 1.1 volts and deasserted when the\r
voltage falls below 0.9 volt.\r
- \r
+\r
@param flag_handle\r
The flag_handle parameter identifies one of the flags generated based on the\r
value of an analog input channel. The available flag handle values can be\r
ACE_get_flag_handle() when the name of the flag is known, or by iterating\r
though all flags associated with an analog input channel using the\r
ACE_get_channel_first_flag() and ACE_get_channel_next_flag().\r
- \r
+\r
@param new_threshold\r
The new_threshold parameter specifies the new threshold level that must be\r
reached in order for the flag to be raised. The value of this parameter is\r
the sample value resulting from a post processing engine conversion of the\r
desired analog input threshold level.\r
- \r
+\r
Example:\r
The function below sets the threshold of the flag specified as parameter to\r
1 volt.\r
{\r
uint16_t new_threshold;\r
ace_channel_handle_t channel_handle;\r
- \r
+\r
channel_handle = ACE_get_flag_channel(flag_handle);\r
new_threshold = ACE_convert_from_mV(channel_handle, 1000);\r
ACE_set_flag_threshold(flag_handle, new_threshold);\r
ACE_get_flag_handle() when the name of the flag is known, or by iterating\r
though all flags associated with an analog input channel using the\r
ACE_get_channel_first_flag() and ACE_get_channel_next_flag().\r
- \r
+\r
@param adc_hysteresis\r
The adc_hysteresis parameter is the value to add and subtract to the\r
threshold value to obtain the hysteresis high and low limits triggering flag\r
configurator for one of the analog inputs and one of the flags associated\r
with that input.\r
The method used to compute the adc_hysteresis value will work for all\r
- input types including ABPS inputs where zero Volts is not equivalent to a \r
+ input types including ABPS inputs where zero Volts is not equivalent to a\r
PPE sample value of zero.\r
- \r
+\r
@code\r
ace_channel_handle_t channel_handle;\r
ace_flag_handle_t flag_handle;\r
uint16_t adc_hysteresis;\r
uint16_t upper_limit;\r
uint16_t lower_limit;\r
- \r
+\r
channel_handle = VoltageMonitor;\r
flag_handle = VoltageMonitor_OVER_1V;\r
- \r
+\r
upper_limit = ACE_convert_from_mV(channel_handle, 100);\r
lower_limit = ACE_convert_from_mV(channel_handle, 0);\r
- \r
+\r
if (upper_limit > lower_limit)\r
{\r
adc_hysteresis = upper_limit - lower_limit;\r
{\r
adc_hysteresis = lower_limit - upper_limit;\r
}\r
- \r
+\r
ACE_set_flag_hysteresis(flag_handle, adc_hysteresis);\r
@endcode\r
*/\r
ACE_get_flag_handle() when the name of the flag is known, or by iterating\r
though all flags associated with an analog input channel using the\r
ACE_get_channel_first_flag() and ACE_get_channel_next_flag().\r
- \r
+\r
@param assertion_value\r
The assertion_value parameter is the Post Processing Engine sample value that\r
must be reached for the flag, identified through the flag_handle parameter,\r
intended to be used where the threshold value is not centered within the\r
hysteresis window. They allow specifying the actual threshold values at which\r
the flag will be asserted and deasserted.\r
- \r
+\r
@param flag_handle\r
The flag_handle parameter identifies one of the flags generated based on the\r
value of an analog input channel. The available flag handle values can be\r
ACE_get_flag_handle() when the name of the flag is known, or by iterating\r
though all flags associated with an analog input channel using the\r
ACE_get_channel_first_flag() and ACE_get_channel_next_flag().\r
- \r
+\r
@param assertion_value\r
The assertion_value parameter is the Post Processing Engine sample value\r
that must be reached for the flag, identified through the flag_handle\r
analog input channel sample values when generating flags. It sets the\r
hysteresis for all flags generated based on the value of the analog input\r
channel identified by the channel handle passed as first parameter.\r
- \r
+\r
@param channel_handle\r
The channel_handle parameter identifies one of the analog input channels\r
monitored by the ACE. The available channel handle values can be found in\r
/*-------------------------------------------------------------------------*//**\r
*\r
*/\r
- \r
+\r
/*==============================================================================\r
================================== Flags ======================================\r
=============================================================================*/\r
by the flag name passed as parameter. The flag handle obtained through this\r
function is then used as parameter to other flag control functions to identify\r
which flag is to be controlled by the called function.\r
- \r
+\r
@param p_sz_full_flag_name\r
The p_sz_full_flag_name parameter is a pointer to a zero-terminated string\r
holding the name of the flag as specified in the ACE configurator. The full\r
For example, the full name for the flag called "CriticalOver" raised when\r
the input channel called "MainSupply" reaches a critical level would be\r
named "MainSupply:CriticalOver".\r
- \r
+\r
@return\r
The ACE_get_flag_handle() returns the flag handle associated with the flag\r
name passed as parameter. It returns INVALID_FLAG_HANDLE when the flag name\r
The ACE_get_flag_status() function returns the current status of the flag\r
specified as parameter. The flag is identified through the name specified in\r
the ACE configurator when the flag was created.\r
- \r
+\r
@param flag_handle\r
The flag_handle parameter identifies one of the flags generated based on the\r
value of an analog input channel. The available flag handle values can be\r
ACE_get_flag_handle() when the name of the flag is known, or by iterating\r
though all flags associated with an analog input channel using the\r
ACE_get_channel_first_flag() and ACE_get_channel_next_flag().\r
- \r
+\r
@return\r
The ACE_get_flag_status() function returns one of the following values\r
depending on the current status of the flag:\r
sampled on the analog input channel identified as parameter are enabled to\r
generate interrupts by this function. It enables flag interrupts both at the\r
ACE PEE flag and Cortex-M3 interrupt controller levels.\r
- \r
+\r
@param channel_handle\r
The channel_handle parameter identifies one of the analog input channels\r
monitored by the ACE. The available channel handle values can be found in the\r
generating interrupts by this function. The interrupt is only disabled at the\r
ACE PPE flag level in order to avoid disabling other cahnnel's flag interrupts\r
which may happen to use the same ACE threshold interrupt line.\r
- \r
+\r
@param channel_handle\r
The channel_handle parameter identifies one of the analog input channels\r
monitored by the ACE. The available channel handle values can be found in the\r
sampled on the analog input channel identified as parameter are cleared by\r
this function. This function would typically be used before enabling the flag\r
interrupts in order to ignore past events.\r
- \r
+\r
@param channel_handle\r
The channel_handle parameter identifies one of the analog input channels\r
monitored by the ACE. The available channel handle values can be found in the\r
generated flags specified as parameter to interrupt the Cortex-M3 processor.\r
It enables flag interrupts both at the ACE PPE flag and Cortex-M3 interrupt\r
controller levels.\r
- \r
+\r
@param flag_handle\r
The flag_handle parameter identifies one of the flags generated based on the\r
value of an analog input channel. The available flag handle values can be\r
generated flags from interrupting the Cortex-M3. The interrupt is only\r
disabled at the ACE PPE flag level in order to avoid disabling other flags\r
interrupts which may happen to use the same ACE threshold interrupt line.\r
- \r
+\r
@param flag_handle\r
The flag_handle parameter identifies one of the flags generated based on the\r
value of an analog input channel. The available flag handle values can be\r
The ACE_clear_flag_irq() function clears the interrupt for the flag specified\r
as parameter. This function would typically be used before enabling the flag\r
interrupt in order to ignore past events.\r
- \r
+\r
@param flag_handle\r
The flag_handle parameter identifies one of the flags generated based on the\r
value of an analog input channel. The available flag handle values can be\r
/*-------------------------------------------------------------------------*//**\r
The ACE_get_flag_name() function returns the name of the flag identified by\r
the flag handle passed as parameter.\r
- \r
+\r
@param flag_handle\r
The flag_handle parameter identifies one of the flags generated based on the\r
value of an analog input channel. The available flag handle values can be\r
ACE_get_flag_handle() when the name of the flag is known, or by iterating\r
though all flags associated with an analog input channel using the\r
ACE_get_channel_first_flag() and ACE_get_channel_next_flag().\r
- \r
+\r
@return\r
The ACE_get_flag_name() function returns a pointer to a zero-terminated\r
string containing the name of the flag identified by the flag handle passed\r
The ACE_get_flag_channel() function returns the handle of the channel\r
monitored in order to generate the flag identified by the flag handle passed\r
as parameter.\r
- \r
+\r
@param flag_handle\r
The flag_handle parameter identifies one of the flags generated based on the\r
value of an analog input channel. The available flag handle values can be\r
ACE_get_flag_handle() when the name of the flag is known, or by iterating\r
though all flags associated with an analog input channel using the\r
ACE_get_channel_first_flag() and ACE_get_channel_next_flag().\r
- \r
+\r
@return\r
The ACE_get_flag_channel() function returns a channel handle identifying the\r
analog input channel monitored by the flag passed as parameter.\r
associated with the input channel specified by the channel_handle parameter.\r
It indicates how many flags are generated based on the value of the specified\r
analog input channel.\r
- \r
+\r
@param channel_handle\r
The channel_handle parameter identifies one of the analog input channels\r
monitored by the ACE. The available channel handle values can be found in\r
ACE_get_channel_handle() when the name of the channel is known, or by\r
iterating though all analog input channel using the ACE_get_first_channel()\r
and ACE_get_next_channel().\r
- \r
+\r
@return\r
The ACE_get_channel_flag_count() function returns the total number of flags\r
that are generated based on the value of the specified analog input channel.\r
The ACE_get_channel_flag_count() function returns 0 if no input channels were\r
configured.\r
- \r
+\r
Example\r
@code\r
uint32_t inc;\r
uint16_t flag_iterator;\r
ace_flag_handle_t current_flag;\r
ace_channel_handle_t channel_handle;\r
- \r
+\r
nb_of_flags = ACE_get_channel_flag_count(channel_handle);\r
current_flag = ACE_get_channel_first_flag(channel_handle, &flag_iterator);\r
- \r
+\r
for (inc = 0; inc < nb_of_flags; ++inc)\r
{\r
current_flag = ACE_get_channel_next_flag(channel_handle, &flag_iterator);\r
pointed to by the second function parameter. The iterator can be used\r
subsequently as a parameter to the ACE_get_channel_next_flag() function to\r
iterate through all flags associated with the analog input channel.\r
- \r
+\r
@param channel_handle\r
The channel_handle parameter identifies one of the analog input channels\r
monitored by the ACE. The available channel handle values can be found in the\r
ACE_get_channel_handle() when the name of the channel is known, or by\r
iterating though all analog input channel using the ACE_get_first_channel()\r
and ACE_get_next_channel().\r
- \r
+\r
@param iterator\r
The iterator parameter is a pointer to a uint16_t iterator variable. The\r
value of the iterator variable will be set by the ACE_get_channel_first_flag()\r
functions so that it can be used in subsequent calls to\r
ACE_get_channel_next_flag() to keep track of the current location in the\r
list of flags associated with the analog input channel.\r
- \r
+\r
@return\r
The ACE_get_channel_first_flag() function returns a flag handle identifying\r
one of the flags generated based on the value of the analog input channel\r
identified by the channel_handle parameter. It returns INVALID_FLAG_HANDLE\r
if no flags are generated based on the analog input channel input or if the\r
channel handle is invalid.\r
- \r
+\r
Example\r
@code\r
uint32_t inc;\r
uint16_t flag_iterator;\r
ace_flag_handle_t current_flag;\r
ace_channel_handle_t channel_handle;\r
- \r
+\r
nb_of_flags = ACE_get_channel_flag_count(channel_handle);\r
current_flag = ACE_get_channel_first_flag(channel_handle, &flag_iterator);\r
- \r
+\r
for (inc = 0; inc < nb_of_flags; ++inc)\r
{\r
current_flag = ACE_get_channel_next_flag(channel_handle, &flag_iterator);\r
associated with the analog input channel identified by the channel handle\r
passed as parameter. The retrieved flag handle is the next one in the driver's\r
internal flag list based on the iterator parameter.\r
- \r
+\r
@param channel_handle\r
The channel_handle parameter identifies one of the analog input channels\r
monitored by the ACE. The available channel handle values can be found in the\r
ACE_get_channel_handle() when the name of the channel is known, or by\r
iterating though all analog input channel using the ACE_get_first_channel()\r
and ACE_get_next_channel().\r
- \r
+\r
@param iterator\r
The iterator parameter is a pointer to a uint16_t iterator variable. The value\r
of the iterator variable will be set by the ACE_get_channel_first_flag()\r
functions so that it can be used in subsequent calls to\r
ACE_get_channel_next_flag() to keep track of the current location in the list\r
of flags associated with the analog input channel.\r
- \r
+\r
Example\r
@code\r
uint32_t inc;\r
uint16_t flag_iterator;\r
ace_flag_handle_t current_flag;\r
ace_channel_handle_t channel_handle;\r
- \r
+\r
nb_of_flags = ACE_get_channel_flag_count(channel_handle);\r
current_flag = ACE_get_channel_first_flag(channel_handle, &flag_iterator);\r
- \r
+\r
for (inc = 0; inc < nb_of_flags; ++inc)\r
{\r
current_flag = ACE_get_channel_next_flag(channel_handle, &flag_iterator);\r
with the ACE driver and associated with a particular flag through the\r
ACE_register_flag_isr() function. The ACE driver will call the flag handler\r
function when the associated flag is raised.\r
- \r
+\r
Declaring and Implementing PPE Flag Handler Functions\r
PPE flag handler functions should follow the following prototype:\r
void my_flag_handler ( ace_flag_handle_t flag_handle );\r
The actual name of the PPE flag handler is unimportant. You can use any name of\r
- your choice for the PPE flag handler. \r
+ your choice for the PPE flag handler.\r
The flag_handle parameter passes the handle of the raised flag to the flag\r
handler function.\r
*/\r
The ACE_register_flag_isr() function is used to register a handler function\r
with the ACE driver. The registered function will be called by the ACE driver\r
when the associated flag is raised by the ACE post processing engine.\r
- \r
+\r
@param flag_handle\r
The flag_handle parameter identifies one of the flags generated based on the\r
value of an analog input channel. The available flag handle values can be\r
ACE_get_flag_handle() when the name of the flag is known, or by iterating\r
though all flags associated with an analog input channel using the\r
ACE_get_channel_first_flag() and ACE_get_channel_next_flag().\r
- \r
+\r
@param flag_isr\r
The flag_isr parameter is a pointer to a flag handler function with the\r
- following prototype: \r
- void handler_function_name(ace_flag_handle_t flag_handle) \r
+ following prototype:\r
+ void handler_function_name(ace_flag_handle_t flag_handle)\r
The flag handler function is called by the ACE driver as part of the relevant\r
post processing engine flag interrupt service routine. It does not need to\r
handle flag interrupt clearing as this is done by the ACE driver.\r
\r
- \r
+\r
@code\r
void my_critical_handler( void );\r
- \r
+\r
void system_init( void )\r
{\r
ace_flag_handle_t flag_handle;\r
- \r
+\r
flag_handle = ACE_get_flag_handle( "MainSupply:CriticalLevel" );\r
ACE_register_flag_isr( flag_handle, my_critical_handler );\r
ACE_enable_flag_irq( flag_handle );\r
}\r
- \r
+\r
void my_critical_handler( ace_flag_handle_t flag_handle )\r
{\r
panic( flag_handle );\r
}\r
- \r
+\r
@endcode\r
*/\r
void ACE_register_flag_isr\r
channel through the ACE_register_channel_flags_isr() function. The ACE driver\r
will call the channel flags handler function when one of the flags for the\r
associated ADC input channel is raised.\r
- \r
+\r
Declaring and Implementing PPE Channel Flag Handler Functions\r
PPE channel flag handler functions should follow the following prototype:\r
void my_channel_flag_handler ( ace_flag_handle_t flag_handle );\r
handler will be called by the ACE driver when one of the flag generated based\r
on the value of the analog input channel identified by the channel handle\r
passed as parameter is asserted.\r
- \r
+\r
@param channel_handle\r
The channel_handle parameter identifies one of the analog input channels\r
monitored by the ACE. The available channel handle values can be found in the\r
ACE_get_channel_handle() when the name of the channel is known, or by\r
iterating though all analog input channel using the ACE_get_first_channel()\r
and ACE_get_next_channel().\r
- \r
+\r
@param channel_flag_isr\r
The channel_flag_isr parameter is pointer to a function taking a flag handle\r
- as parameter. \r
- void handler_function_name(ace_flag_handle_t flag_handle) \r
+ as parameter.\r
+ void handler_function_name(ace_flag_handle_t flag_handle)\r
The flag handler function is called by the ACE driver as part of the relevant\r
post processing engine flag interrupt service routine. It does not need to\r
handle flag interrupt clearing as this is done by the ACE driver.\r
- \r
+\r
Example\r
The example below demonstrates the use of the ACE_register_channel_flags_isr()\r
function in a system where the ACE is configured to have an analog input\r
channels named "MainSupply" with one flag named "Critical" generated based\r
on the value of "MainSupply" channel. The names "MainSupply" and "Critical"\r
- were user selected in the ACE configurator. \r
+ were user selected in the ACE configurator.\r
@code\r
void main_supply_handler (ace_flag_handle_t flag_handle);\r
- \r
+\r
void system_init(void)\r
{\r
ACE_register_channel_flag_isr(MainSupply, main_supply_handler);\r
ACE_enable_channel_flags_irq(MainSupply);\r
}\r
- \r
+\r
void main_supply_handler (ace_flag_handle_t flag_handle)\r
{\r
if (MainSupply_Critical == flag_handle)\r
panic(flag_handle);\r
}\r
}\r
- \r
+\r
@endcode\r
*/\r
void ACE_register_channel_flags_isr\r
registered with the ACE driver through the ACE_register_global_flags_isr()\r
function. The ACE driver will call the global flags handler function when any\r
flag for any ADC input channel is raised.\r
- \r
+\r
Declaring and Implementing Global Flag Handler Functions\r
PPE global flag handler functions should follow the following prototype:\r
- void my_global_flag_handler( \r
- ace_flag_handle_t flag_handle, \r
- ace_channel_handle_t channel_handle \r
+ void my_global_flag_handler(\r
+ ace_flag_handle_t flag_handle,\r
+ ace_channel_handle_t channel_handle\r
);\r
The actual name of the PPE global flag handler is unimportant. You can use any\r
name of your choice for the PPE global flag handler. The flag_handle parameter\r
The ACE_register_global_flags_isr() function is used to register a global\r
flag handler function with the ACE driver. The registered global handler will\r
be called when any flag interrupt is generated.\r
- \r
+\r
@param global_flag_isr\r
The global_flag_isr parameter is a pointer to a function taking a flag\r
handle and channel handle as parameter.\r
ACE_get_channel_handle() when the name of the channel is known, or by\r
iterating though all analog input channel using the ACE_get_first_channel()\r
and ACE_get_next_channel().\r
- \r
+\r
@param sample_value\r
The sample_value parameter is the result of an analog to digital conversion.\r
- \r
+\r
@return\r
The ACE_convert_adc_input_to_mV() returns the number of millivolts derived\r
from the ADC sample value passed as parameter.\r
/*-------------------------------------------------------------------------*//**\r
The ACE_convert_to_mV() function converts a PPE sample value into milli-Volts.\r
It handles prescaling adjusments based on ACE configuration for ABPS inputs.\r
- \r
+\r
@param channel_handle\r
The channel_handle parameter identifies one of the analog input channels\r
monitored by the ACE. The available channel handle values can be found in the\r
ACE_get_channel_handle() when the name of the channel is known, or by\r
iterating though all analog input channel using the ACE_get_first_channel()\r
and ACE_get_next_channel().\r
- \r
+\r
@param sample_value\r
The sample_value parameter is the result of an analog to digital conversion.\r
- \r
+\r
@return\r
The ACE_convert_to_mV() returns the number of millivolts derived from the\r
PPE sample value passed as parameter. The returned value can be either\r
The ACE_convert_to_mA() function converts a PPE sample value into milli-Amps.\r
The result of the conversion is only meaningful if the PPE sample value\r
results from the conversion of a current monitor input.\r
- \r
+\r
@param channel_handle\r
The channel_handle parameter identifies one of the analog input channels\r
monitored by the ACE. The available channel handle values can be found in the\r
ACE_get_channel_handle() when the name of the channel is known, or by\r
iterating though all analog input channel using the ACE_get_first_channel()\r
and ACE_get_next_channel().\r
- \r
+\r
@param sample_value\r
The sample_value parameter is the result of an analog to digital conversion\r
of the voltage generated by a current monitor analog block.\r
- \r
+\r
@return\r
The ACE_convert_to_mA() returns the number of milliamps derived from the\r
PPE sample value passed as parameter.\r
The ACE_convert_to_Kelvin() function converts a PPE sample value into degrees\r
Kelvin. The result of the conversion is only meaningful if the PPE sample value\r
results from the conversion of a temperature monitor input.\r
- \r
+\r
@param channel_handle\r
The channel_handle parameter identifies one of the analog input channels\r
monitored by the ACE. The available channel handle values can be found in the\r
ACE_get_channel_handle() when the name of the channel is known, or by\r
iterating though all analog input channel using the ACE_get_first_channel()\r
and ACE_get_next_channel().\r
- \r
+\r
@param sample_value\r
The sample_value parameter is the result of an analog to digital conversion\r
of the voltage generated by a temperature monitor analog block.\r
- \r
+\r
@return\r
The ACE_convert_to_Kelvin() returns the number of degrees Kelvin derived\r
from the PPE sample value passed as parameter.\r
The ACE_convert_to_Celsius() function converts a PPE sample value into tenths\r
of degrees Celsius. The result of the conversion is only meaningful if the PPE\r
sample value results from the conversion of a temperature monitor input.\r
- \r
+\r
@param channel_handle\r
The channel_handle parameter identifies one of the analog input channels\r
monitored by the ACE. The available channel handle values can be found in the\r
ACE_get_channel_handle() when the name of the channel is known, or by\r
iterating though all analog input channel using the ACE_get_first_channel()\r
and ACE_get_next_channel().\r
- \r
+\r
@param sample_value\r
The sample_value parameter is the result of an analog to digital conversion\r
of the voltage generated by a temperature monitor analog block.\r
- \r
+\r
@return\r
The ACE_convert_to_Celsius() returns the number of tenths of degrees Celsius\r
derived from the PPE sample value passed as parameter.\r
The ACE_convert_to_Fahrenheit() function converts a PPE sample value into\r
degrees Fahrenheit. The result of the conversion is only meaningful if the PPE\r
sample value results from the conversion of a temperature monitor input.\r
- \r
+\r
@param channel_handle\r
The channel_handle parameter identifies one of the analog input channels\r
monitored by the ACE. The available channel handle values can be found in the\r
ACE_get_channel_handle() when the name of the channel is known, or by\r
iterating though all analog input channel using the ACE_get_first_channel()\r
and ACE_get_next_channel().\r
- \r
+\r
@param sample_value\r
The sample_value parameter is the result of an analog to digital conversion\r
of the voltage generated by a temperature monitor analog block.\r
- \r
+\r
@return\r
The ACE_convert_to_Fahrenheit() returns the number of degrees Fahrenheit\r
derived from the PPE sample value passed as parameter.\r
This function is intended for use when directly controlling the ADC, not when\r
using samples read from the PPE. It does not account for prescaling taking\r
place before the ADC hardware input.\r
- \r
+\r
@param channel_handle\r
The channel_handle parameter identifies one of the analog input channels\r
monitored by the ACE. The available channel handle values can be found in the\r
ACE_get_channel_handle() when the name of the channel is known, or by\r
iterating though all analog input channel using the ACE_get_first_channel()\r
and ACE_get_next_channel().\r
- \r
+\r
@param voltage\r
The voltage parameter is the milli-Volts voltage value for which we want this\r
function to return the associated ADC sample result value.\r
- \r
+\r
@return\r
The ACE_convert_mV_to_adc_value() returns the ADC sample value that would be\r
produced if the analog input channel identified by channel_handle was set to\r
voltage value on the analog input channel specified as parameter.\r
This function handles prescaling adjusments based on ACE configuration for\r
ABPS inputs.\r
- \r
+\r
@param channel_handle\r
The channel_handle parameter identifies one of the analog input channels\r
monitored by the ACE. The available channel handle values can be found in the\r
ACE_get_channel_handle() when the name of the channel is known, or by\r
iterating though all analog input channel using the ACE_get_first_channel()\r
and ACE_get_next_channel().\r
- \r
+\r
@param voltage\r
The voltage parameter is the milli-Volts voltage value for which we want this\r
function to return the associated PPE sample result value.\r
- \r
+\r
@return\r
The ACE_convert_from_mV() returns the PPE sample value that would be produced\r
if the analog input channel identified by channel_handle was set to the\r
current value on the analog input channel specified as parameter.\r
The result of the conversion is only meaningful if the analog input channel\r
specified as parameter is configured as a current monitoring channel.\r
- \r
+\r
@param channel_handle\r
The channel_handle parameter identifies one of the analog input channels\r
monitored by the ACE. The available channel handle values can be found in the\r
ACE_get_channel_handle() when the name of the channel is known, or by\r
iterating though all analog input channel using the ACE_get_first_channel()\r
and ACE_get_next_channel().\r
- \r
+\r
@param current\r
The current parameter is the milli-Amps current value for which we want this\r
function to return the associated PPE sample result value.\r
- \r
+\r
@return\r
The ACE_convert_from_mA() returns the PPE sample value that would be produced\r
if the analog input channel identified by channel_handle was set to the\r
temperature value on the analog input channel specified as parameter.\r
The result of the conversion is only meaningful if the analog input channel\r
specified as parameter is configured as a temperature monitoring channel.\r
- \r
+\r
@param channel_handle\r
The channel_handle parameter identifies one of the analog input channels\r
monitored by the ACE. The available channel handle values can be found in the\r
ACE_get_channel_handle() when the name of the channel is known, or by\r
iterating though all analog input channel using the ACE_get_first_channel()\r
and ACE_get_next_channel().\r
- \r
+\r
@param temperature\r
The temperature parameter is the degrees Kelvin temperature value for which\r
we want this function to return the associated PPE sample result value.\r
- \r
+\r
@return\r
The ACE_convert_from_Kelvin() returns the PPE sample value that would be\r
produced if the analog input channel identified by channel_handle was set to\r
temperature value on the analog input channel specified as parameter.\r
The result of the conversion is only meaningful if the analog input channel\r
specified as parameter is configured as a temperature monitoring channel.\r
- \r
+\r
@param channel_handle\r
The channel_handle parameter identifies one of the analog input channels\r
monitored by the ACE. The available channel handle values can be found in the\r
ACE_get_channel_handle() when the name of the channel is known, or by\r
iterating though all analog input channel using the ACE_get_first_channel()\r
and ACE_get_next_channel().\r
- \r
+\r
@param temperature\r
The temperature parameter is the degrees Celsius temperature value for which\r
we want this function to return the associated PPE sample result value.\r
- \r
+\r
@return\r
The ACE_convert_from_Celsius() returns the PPE sample value that would be\r
produced if the analog input channel identified by channel_handle was set to\r
this temperature value on the analog input channel specified as parameter.\r
The result of the conversion is only meaningful if the analog input channel\r
specified as parameter is configured as a temperature monitoring channel.\r
- \r
+\r
@param channel_handle\r
The channel_handle parameter identifies one of the analog input channels\r
monitored by the ACE. The available channel handle values can be found in the\r
ACE_get_channel_handle() when the name of the channel is known, or by\r
iterating though all analog input channel using the ACE_get_first_channel()\r
and ACE_get_next_channel().\r
- \r
+\r
@param temperature\r
The temperature parameter is the degrees Fahrenheit temperature value for\r
which we want this function to return the associated PPE sample result value.\r
- \r
+\r
@return\r
The ACE_convert_from_Fahrenheit() returns the PPE sample value that would be\r
produced if the analog input channel identified by channel_handle was set to\r
The PDMA sampling values are obtained by configuring the PDMA controller to\r
transfer data from the ACE into a memory buffer. The ACE_translate_pdma_value()\r
function is used to interpret the content of that memory buffer.\r
- \r
+\r
Please note that the translation of PDMA data containing raw ADC values from\r
ABPS inputs will result in sample values with an unexpected polarity.\r
The returned sample value will have the opposite polarity to the actual analog\r
the analog front end that are normally hidden by the PPE processing of ADC raw\r
samples. The translation of raw ADC values from analog inputs other than ABPS\r
inputs will result in correct sample values.\r
- \r
+\r
@param pdma_value\r
The pdma_value parameter is a 32-bit value received from the ACE through a\r
- peripheral DMA transfer. \r
- \r
+ peripheral DMA transfer.\r
+\r
@param channel_id\r
The channel_id parameter is a pointer to an ADC channel ID variable. It is\r
used to return the ID of the ADC channel from which the PPE sample value\r
was generated from. This parameter can be set to zero if retrieving the\r
channel ID is not required.\r
- \r
+\r
@return\r
The ACE_translate_pdma_value() returns the PPE sample value extracted from\r
the PDMA sampling value.\r
- \r
+\r
Example:\r
@code\r
uint16_t ppe_value;\r
uint16_t pdma_value;\r
adc_channel_id_t channel_id;\r
ace_channel_handle_t channel_handle;\r
- \r
+\r
pdma_value = get_next_pdma_ace_sample();\r
ppe_value = ACE_translate_pdma_value(pdma_value, &channel_id);\r
channel_handle = ACE_get_input_channel_handle(channel_id);\r
display_value(channel_handle, ppe_value);\r
}\r
@endcode\r
- \r
+\r
*/\r
uint16_t ACE_translate_pdma_value\r
(\r
- ACE_get_default_c_offset()\r
- ACE_set_linear_transform()\r
The post processing engine performs a linear transform on analog input samples\r
- obtained from the sample sequencing engine. The main purpose of this linear \r
+ obtained from the sample sequencing engine. The main purpose of this linear\r
transform is to apply part specific factory calibration to the analog samples\r
in order to achieve high accuracy. A second user specified linear transform\r
can also be optionally applied to the analog samples. This second linear\r
factor of the user defined linear transform applied by the post processing\r
engine to analog samples. The user defined linear transform m factor default\r
value is selected in the ACE configurator tool.\r
- \r
+\r
@param channel_handle\r
The channel_handle parameter identifies one of the analog input channels\r
monitored by the ACE. The available channel handle values can be found in\r
to ACE_get_channel_handle() when the name of the channel is known, or by\r
iterating though all analog input channel using the ACE_get_first_channel()\r
and ACE_get_next_channel().\r
- \r
+\r
@return\r
The ACE_get_default_m_factor() function returns the user transform m factor\r
default value. It is a signed 16-bit number representing a factor in the\r
offset of the user defined linear transform applied by the post processing\r
engine to analog samples. The user defined linear transform c offset default\r
value is selected in the ACE configurator tool.\r
- \r
+\r
@param channel_handle\r
The channel_handle parameter identifies one of the analog input channels\r
monitored by the ACE. The available channel handle values can be found in\r
to ACE_get_channel_handle() when the name of the channel is known, or by\r
iterating though all analog input channel using the ACE_get_first_channel()\r
and ACE_get_next_channel().\r
- \r
+\r
@return\r
The ACE_get_default_c_offset() function returns the user linear transform\92s\r
c offset default value. It is a signed 16-bit number representing a factor\r
linear transform applied to analog input samples by the post processing\r
engine. The linear transform is of the form y = m.x + b where the m factor\r
and c offset are in the range -2 to +1.99993896484375.\r
- \r
+\r
@param channel_handle\r
The channel_handle parameter identifies one of the analog input channels\r
monitored by the ACE. The available channel handle values can be found in\r
to ACE_get_channel_handle() when the name of the channel is known, or by\r
iterating though all analog input channel using the ACE_get_first_channel()\r
and ACE_get_next_channel().\r
- \r
+\r
@param m2\r
The m2 parameter specifies the user defined transform\92s m factor. It is a\r
signed 16-bit number representing a factor in the range -2 to\r
+1.99993896484375. The value of the m2 factor is obtained by multiplying the\r
parameter\92s absolute value by 2^-14. For example, a value of 0x7000\r
represents a 1.75 factor and a value of 0xE000 represents a -0.5 factor.\r
- \r
+\r
@param c2\r
The c2 parameter specifies the user defined transform\92s c offset. It is a\r
signed 16-bit number representing an offset in the range -2 to\r
+1.99993896484375. The value of the c2 offset is obtained by multiplying the\r
parameter\92s absolute value by 2^-14. For example, a value of 0x1000 represents\r
a 0.25 offset and a value of 0xB000 represents a -1.25 offset.\r
- \r
+\r
@code\r
void reset_to_default(ace_channel_handle_t channel_handle)\r
{\r
int16_t m;\r
int16_t c;\r
- \r
+\r
m = ACE_get_default_m_factor(channel_handle);\r
c = ACE_get_default_c_offset(channel_handle);\r
ACE_set_linear_transform(channel_handle, m, c);\r
);\r
\r
/** @} */\r
- \r
+\r
#ifdef __cplusplus\r
}\r
#endif\r
projects / freertos / commitdiff