git.sur5r.net Git - freertos/blob - FreeRTOS/Demo/CORTEX_A2F200_SoftConsole/MicroSemi_Code/drivers/mss_ace/ace_convert.c

   1 /*******************************************************************************\r
   2  * (c) Copyright 2009 Actel Corporation.  All rights reserved.\r
   3  * \r
   4  * SVN $Revision: 2905 $\r
   5  * SVN $Date: 2010-08-20 14:03:28 +0100 (Fri, 20 Aug 2010) $\r
   6  */\r
   7 #include "mss_ace.h"\r
   8 #include "mss_ace_configurator.h"\r
   9 #include "../../CMSIS/a2fxxxm3.h"\r
  10 #include "../../CMSIS/mss_assert.h"\r
  11 #include "../../drivers_config/mss_ace/ace_handles.h"\r
  12 #include "../../drivers_config/mss_ace/ace_config.h"\r
  13 \r
  14 #ifdef __cplusplus\r
  15 extern "C" {\r
  16 #endif \r
  17 \r
  18 /*-------------------------------------------------------------------------*//**\r
  19  *\r
  20  */\r
  21 extern ace_channel_desc_t g_ace_channel_desc_table[ACE_NB_OF_INPUT_CHANNELS];\r
  22 extern ace_adc_config_t g_ace_adc_config[ACE_NB_OF_ADC];\r
  23 extern const uint32_t g_ace_current_resistors[ACE_NB_OF_CURRENT_MONITORS];\r
  24 \r
  25 /*-------------------------------------------------------------------------*//**\r
  26  *\r
  27  */\r
  28 static uint16_t convert_mV_to_ppe_value\r
  29 (\r
  30     ace_channel_handle_t    channel_handle,\r
  31     uint32_t                voltage\r
  32 );\r
  33 \r
  34 /*-------------------------------------------------------------------------*//**\r
  35  *\r
  36  */\r
  37 void ace_init_convert(void);\r
  38 \r
  39 /*-------------------------------------------------------------------------*//**\r
  40  * \r
  41  */\r
  42 #define VOLTAGE_CHANNEL     0u\r
  43 #define CURRENT_CHANNEL     1u\r
  44 #define TEMPERATURE_CHANNEL 2u\r
  45 #define INVALID_CHANNEL     0xFFu\r
  46 \r
  47 static const uint8_t channel_type_lut[] =\r
  48 {\r
  49     VOLTAGE_CHANNEL,        /* ADC0_1P5V = 0 */\r
  50     VOLTAGE_CHANNEL,        /* ABPS0 = 1 */\r
  51     VOLTAGE_CHANNEL,        /* ABPS1 = 2 */\r
  52     CURRENT_CHANNEL,        /* CM0 = 3 */\r
  53     TEMPERATURE_CHANNEL,    /* TM0 = 4 */\r
  54     VOLTAGE_CHANNEL,        /* ABPS2 = 5 */\r
  55     VOLTAGE_CHANNEL,        /* ABPS3 = 6 */\r
  56     CURRENT_CHANNEL,        /* CM1 = 7 */\r
  57     TEMPERATURE_CHANNEL,    /* TM1 = 8 */\r
  58     VOLTAGE_CHANNEL,        /* ADC0 = 9 */\r
  59     VOLTAGE_CHANNEL,        /* ADC1 = 10 */\r
  60     VOLTAGE_CHANNEL,        /* ADC2 = 11 */\r
  61     VOLTAGE_CHANNEL,        /* ADC3 = 12 */\r
  62     INVALID_CHANNEL,\r
  63     INVALID_CHANNEL,\r
  64     VOLTAGE_CHANNEL,        /* SDD0_IN = 15 */\r
  65 \r
  66     VOLTAGE_CHANNEL,        /* ADC1_1P5V = 16 */\r
  67     VOLTAGE_CHANNEL,        /* ABPS4 = 17 */\r
  68     VOLTAGE_CHANNEL,        /* ABPS5 = 18 */\r
  69     CURRENT_CHANNEL,        /* CM2 = 19 */\r
  70     TEMPERATURE_CHANNEL,    /* TM2 = 20 */\r
  71     VOLTAGE_CHANNEL,        /* ABPS6 = 21 */\r
  72     VOLTAGE_CHANNEL,        /* ABPS7 = 22 */\r
  73     CURRENT_CHANNEL,        /* CM3 = 23 */\r
  74     TEMPERATURE_CHANNEL,    /* TM3 = 24 */\r
  75     VOLTAGE_CHANNEL,        /* ADC4 = 25 */\r
  76     VOLTAGE_CHANNEL,        /* ADC5 = 26 */\r
  77     VOLTAGE_CHANNEL,        /* ADC6 = 27 */\r
  78     VOLTAGE_CHANNEL,        /* ADC7 = 28 */\r
  79     INVALID_CHANNEL,\r
  80     INVALID_CHANNEL,\r
  81     VOLTAGE_CHANNEL,        /* SDD1_IN = 31 */\r
  82 \r
  83     VOLTAGE_CHANNEL,        /* ADC2_1P5V = 32 */\r
  84     VOLTAGE_CHANNEL,        /* ABPS8 = 33 */\r
  85     VOLTAGE_CHANNEL,        /* ABPS9 = 34 */\r
  86     CURRENT_CHANNEL,        /* CM4 = 35 */\r
  87     TEMPERATURE_CHANNEL,    /* TM4 = 36 */\r
  88     VOLTAGE_CHANNEL,        /* ABPS10 = 37 */\r
  89     VOLTAGE_CHANNEL,        /* ABPS11 = 38 */\r
  90     CURRENT_CHANNEL,        /* CM5 = 39 */\r
  91     TEMPERATURE_CHANNEL,    /* TM5 = 40 */\r
  92     VOLTAGE_CHANNEL,        /* ADC8 = 41 */\r
  93     VOLTAGE_CHANNEL,        /* ADC9 = 42 */\r
  94     VOLTAGE_CHANNEL,        /* ADC10 = 43 */\r
  95     VOLTAGE_CHANNEL,        /* ADC11 = 44 */\r
  96     INVALID_CHANNEL,\r
  97     INVALID_CHANNEL,\r
  98     VOLTAGE_CHANNEL         /* SDD2_IN = 47 */\r
  99 };\r
 100 \r
 101 static const uint8_t channel_quad_lut[] =\r
 102 {\r
 103     0xFFu,   /* ADC0_1P5V = 0 */\r
 104     0u,      /* ABPS0 = 1 */\r
 105     0u,      /* ABPS1 = 2 */\r
 106     0u,      /* CM0 = 3 */\r
 107     0u,      /* TM0 = 4 */\r
 108     1u,      /* ABPS2 = 5 */\r
 109     1u,      /* ABPS3 = 6 */\r
 110     1u,      /* CM1 = 7 */\r
 111     1u,      /* TM1 = 8 */\r
 112     0xFFu,   /* ADC0 = 9 */\r
 113     0xFFu,   /* ADC1 = 10 */\r
 114     0xFFu,   /* ADC2 = 11 */\r
 115     0xFFu,   /* ADC3 = 12 */\r
 116     INVALID_CHANNEL,\r
 117     INVALID_CHANNEL,\r
 118     0xFFu,   /* SDD0_IN = 15 */\r
 119 \r
 120     0xFFu,   /* ADC1_1P5V = 16 */\r
 121     2u,      /* ABPS4 = 17 */\r
 122     2u,      /* ABPS5 = 18 */\r
 123     2u,      /* CM2 = 19 */\r
 124     2u,      /* TM2 = 20 */\r
 125     3u,      /* ABPS6 = 21 */\r
 126     3u,      /* ABPS7 = 22 */\r
 127     3u,      /* CM3 = 23 */\r
 128     3u,      /* TM3 = 24 */\r
 129     0xFFu,   /* ADC4 = 25 */\r
 130     0xFFu,   /* ADC5 = 26 */\r
 131     0xFFu,   /* ADC6 = 27 */\r
 132     0xFFu,   /* ADC7 = 28 */\r
 133     INVALID_CHANNEL,\r
 134     INVALID_CHANNEL,\r
 135     0xFFu,   /* SDD1_IN = 31 */\r
 136 \r
 137     0xFFu,   /* ADC2_1P5V = 32 */\r
 138     4u,      /* ABPS8 = 33 */\r
 139     4u,      /* ABPS9 = 34 */\r
 140     4u,      /* CM4 = 35 */\r
 141     4u,      /* TM4 = 36 */\r
 142     5u,      /* ABPS10 = 37 */\r
 143     5u,      /* ABPS11 = 38 */\r
 144     5u,      /* CM5 = 39 */\r
 145     5u,      /* TM5 = 40 */\r
 146     0xFFu,   /* ADC8 = 41 */\r
 147     0xFFu,   /* ADC9 = 42 */\r
 148     0xFFu,   /* ADC10 = 43 */\r
 149     0xFFu,   /* ADC11 = 44 */\r
 150     INVALID_CHANNEL,\r
 151     INVALID_CHANNEL,\r
 152     0xFFu    /* SDD2_IN = 47 */\r
 153 };\r
 154 \r
 155 /*-------------------------------------------------------------------------*//**\r
 156  *\r
 157  */\r
 158 #define NON_ABPS_CHANNEL    0xFFu\r
 159 #define MAX_NB_OF_APBS      12u\r
 160 \r
 161 /*-------------------------------------------------------------------------*//**\r
 162  * Lookup of the quad to which an ABPS belongs\r
 163  */\r
 164 static const uint8_t abps_channel_lut[] =\r
 165 {\r
 166     NON_ABPS_CHANNEL,   /* ADC0_1P5V = 0 */\r
 167     0u,                 /* ABPS0 = 1 */\r
 168     0u,                 /* ABPS1 = 2 */\r
 169     NON_ABPS_CHANNEL,   /* CM0 = 3 */\r
 170     NON_ABPS_CHANNEL,   /* TM0 = 4 */\r
 171     1u,                 /* ABPS2 = 5 */\r
 172     1u,                 /* ABPS3 = 6 */\r
 173     NON_ABPS_CHANNEL,   /* CM1 = 7 */\r
 174     NON_ABPS_CHANNEL,   /* TM1 = 8 */\r
 175     NON_ABPS_CHANNEL,   /* ADC0 = 9 */\r
 176     NON_ABPS_CHANNEL,   /* ADC1 = 10 */\r
 177     NON_ABPS_CHANNEL,   /* ADC2 = 11 */\r
 178     NON_ABPS_CHANNEL,   /* ADC3 = 12 */\r
 179     INVALID_CHANNEL,\r
 180     INVALID_CHANNEL,\r
 181     NON_ABPS_CHANNEL,   /* SDD0_IN = 15 */\r
 182 \r
 183     NON_ABPS_CHANNEL,   /* ADC1_1P5V = 16 */\r
 184     2u,                 /* ABPS4 = 17 */\r
 185     2u,                 /* ABPS5 = 18 */\r
 186     NON_ABPS_CHANNEL,   /* CM2 = 19 */\r
 187     NON_ABPS_CHANNEL,   /* TM2 = 20 */\r
 188     3u,                 /* ABPS6 = 21 */\r
 189     3u,                 /* ABPS7 = 22 */\r
 190     NON_ABPS_CHANNEL,   /* CM3 = 23 */\r
 191     NON_ABPS_CHANNEL,   /* TM3 = 24 */\r
 192     NON_ABPS_CHANNEL,   /* ADC4 = 25 */\r
 193     NON_ABPS_CHANNEL,   /* ADC5 = 26 */\r
 194     NON_ABPS_CHANNEL,   /* ADC6 = 27 */\r
 195     NON_ABPS_CHANNEL,   /* ADC7 = 28 */\r
 196     INVALID_CHANNEL,\r
 197     INVALID_CHANNEL,\r
 198     NON_ABPS_CHANNEL,   /* SDD1_IN = 31 */\r
 199 \r
 200     NON_ABPS_CHANNEL,   /* ADC2_1P5V = 32 */\r
 201     4u,                 /* ABPS8 = 33 */\r
 202     4u,                 /* ABPS9 = 34 */\r
 203     NON_ABPS_CHANNEL,   /* CM4 = 35 */\r
 204     NON_ABPS_CHANNEL,   /* TM4 = 36 */\r
 205     5u,                 /* ABPS10 = 37 */\r
 206     5u,                 /* ABPS11 = 38 */\r
 207     NON_ABPS_CHANNEL,   /* CM5 = 39 */\r
 208     NON_ABPS_CHANNEL,   /* TM5 = 40 */\r
 209     NON_ABPS_CHANNEL,   /* ADC8 = 41 */\r
 210     NON_ABPS_CHANNEL,   /* ADC9 = 42 */\r
 211     NON_ABPS_CHANNEL,   /* ADC10 = 43 */\r
 212     NON_ABPS_CHANNEL,   /* ADC11 = 44 */\r
 213     INVALID_CHANNEL,\r
 214     INVALID_CHANNEL,\r
 215     NON_ABPS_CHANNEL    /* SDD2_IN = 47 */\r
 216 };\r
 217 \r
 218 static const uint8_t abps_idx_lut[] =\r
 219 {\r
 220     NON_ABPS_CHANNEL,   /* ADC0_1P5V = 0 */\r
 221     0u,                 /* ABPS0 = 1 */\r
 222     1u,                 /* ABPS1 = 2 */\r
 223     NON_ABPS_CHANNEL,   /* CM0 = 3 */\r
 224     NON_ABPS_CHANNEL,   /* TM0 = 4 */\r
 225     2u,                 /* ABPS2 = 5 */\r
 226     3u,                 /* ABPS3 = 6 */\r
 227     NON_ABPS_CHANNEL,   /* CM1 = 7 */\r
 228     NON_ABPS_CHANNEL,   /* TM1 = 8 */\r
 229     NON_ABPS_CHANNEL,   /* ADC0 = 9 */\r
 230     NON_ABPS_CHANNEL,   /* ADC1 = 10 */\r
 231     NON_ABPS_CHANNEL,   /* ADC2 = 11 */\r
 232     NON_ABPS_CHANNEL,   /* ADC3 = 12 */\r
 233     INVALID_CHANNEL,\r
 234     INVALID_CHANNEL,\r
 235     NON_ABPS_CHANNEL,   /* SDD0_IN = 15 */\r
 236 \r
 237     NON_ABPS_CHANNEL,   /* ADC1_1P5V = 16 */\r
 238     4u,                 /* ABPS4 = 17 */\r
 239     5u,                 /* ABPS5 = 18 */\r
 240     NON_ABPS_CHANNEL,   /* CM2 = 19 */\r
 241     NON_ABPS_CHANNEL,   /* TM2 = 20 */\r
 242     6u,                 /* ABPS6 = 21 */\r
 243     7u,                 /* ABPS7 = 22 */\r
 244     NON_ABPS_CHANNEL,   /* CM3 = 23 */\r
 245     NON_ABPS_CHANNEL,   /* TM3 = 24 */\r
 246     NON_ABPS_CHANNEL,   /* ADC4 = 25 */\r
 247     NON_ABPS_CHANNEL,   /* ADC5 = 26 */\r
 248     NON_ABPS_CHANNEL,   /* ADC6 = 27 */\r
 249     NON_ABPS_CHANNEL,   /* ADC7 = 28 */\r
 250     INVALID_CHANNEL,\r
 251     INVALID_CHANNEL,\r
 252     NON_ABPS_CHANNEL,   /* SDD1_IN = 31 */\r
 253 \r
 254     NON_ABPS_CHANNEL,   /* ADC2_1P5V = 32 */\r
 255     8u,                 /* ABPS8 = 33 */\r
 256     9u,                 /* ABPS9 = 34 */\r
 257     NON_ABPS_CHANNEL,   /* CM4 = 35 */\r
 258     NON_ABPS_CHANNEL,   /* TM4 = 36 */\r
 259     10u,                 /* ABPS10 = 37 */\r
 260     11u,                 /* ABPS11 = 38 */\r
 261     NON_ABPS_CHANNEL,   /* CM5 = 39 */\r
 262     NON_ABPS_CHANNEL,   /* TM5 = 40 */\r
 263     NON_ABPS_CHANNEL,   /* ADC8 = 41 */\r
 264     NON_ABPS_CHANNEL,   /* ADC9 = 42 */\r
 265     NON_ABPS_CHANNEL,   /* ADC10 = 43 */\r
 266     NON_ABPS_CHANNEL,   /* ADC11 = 44 */\r
 267     INVALID_CHANNEL,\r
 268     INVALID_CHANNEL,\r
 269     NON_ABPS_CHANNEL    /* SDD2_IN = 47 */\r
 270 };\r
 271 \r
 272 /*-------------------------------------------------------------------------*//**\r
 273  *\r
 274  */\r
 275 static const int8_t apbs_gain_lut[] =\r
 276 {\r
 277     12,\r
 278     8,\r
 279     4,\r
 280     2\r
 281 };\r
 282 \r
 283 static const int16_t apbs_range[] =\r
 284 {\r
 285     15360,\r
 286     10240,\r
 287     5120,\r
 288     2560\r
 289 };\r
 290 \r
 291 static uint8_t g_gdec_lut[MAX_NB_OF_APBS];\r
 292 static channel_type_t channel_type_lut_h[ACE_NB_OF_INPUT_CHANNELS];\r
 293 \r
 294 \r
 295 /*-------------------------------------------------------------------------*//**\r
 296  *\r
 297  */\r
 298 channel_type_t\r
 299 ACE_get_channel_type\r
 300 (\r
 301     ace_channel_handle_t    channel_handle\r
 302 )\r
 303 {\r
 304     channel_type_t channel_type = VOLTAGE;\r
 305     \r
 306     ASSERT(channel_handle < ACE_NB_OF_INPUT_CHANNELS);\r
 307     \r
 308     if((int32_t)channel_handle < ACE_NB_OF_INPUT_CHANNELS)\r
 309     {\r
 310         channel_type = channel_type_lut_h[channel_handle];\r
 311     }\r
 312     else\r
 313     {\r
 314         channel_type = VOLTAGE;\r
 315     }\r
 316     \r
 317     return channel_type;\r
 318 }\r
 319 \r
 320 /*-------------------------------------------------------------------------*//**\r
 321  *\r
 322  */\r
 323 uint32_t ACE_convert_adc_input_to_mV\r
 324 (\r
 325     ace_channel_handle_t    channel_handle,\r
 326     uint16_t                sample_value\r
 327 )\r
 328 {\r
 329     uint32_t voltage;\r
 330     adc_channel_id_t channel_id;\r
 331     uint8_t adc_id;\r
 332     \r
 333     channel_id = g_ace_channel_desc_table[channel_handle].signal_id;\r
 334     adc_id = (uint8_t)channel_id >> 4u;\r
 335     voltage = ( g_ace_adc_config[adc_id].va_ref * (uint32_t)sample_value ) / g_ace_adc_config[adc_id].adc_resolution;\r
 336     \r
 337     return voltage;\r
 338 }\r
 339 \r
 340 /*-------------------------------------------------------------------------*//**\r
 341  *\r
 342  */\r
 343 #define PPE_SAMPLES_RESOLUTION    4095u\r
 344 \r
 345 /*-------------------------------------------------------------------------*//**\r
 346  *\r
 347  */\r
 348 void ace_init_convert(void)\r
 349 {\r
 350     uint8_t abps_idx;\r
 351     int32_t channel;\r
 352     uint32_t saved_pc2_ctrl;\r
 353     \r
 354     /* Pause the SSE PC2 while accesses to ACB from APB3 are taking place. */\r
 355     saved_pc2_ctrl = ACE->PC2_CTRL;\r
 356     ACE->PC2_CTRL = 0u;\r
 357     \r
 358     /* Populate the g_gdec_lut look-up table. */\r
 359     for(abps_idx = 0u; abps_idx < MAX_NB_OF_APBS; ++abps_idx)\r
 360     {\r
 361         uint8_t quad_id;\r
 362         uint8_t acb_config_byte;\r
 363         uint32_t channel_is_abps2;\r
 364         \r
 365         quad_id = abps_idx / 2u;\r
 366         acb_config_byte = ACE->ACB_DATA[quad_id].b8;\r
 367         channel_is_abps2 = abps_idx & 0x01uL;\r
 368         if(channel_is_abps2)\r
 369         {\r
 370             /* ABPS2 */\r
 371             g_gdec_lut[abps_idx] = (acb_config_byte >> 5u) & 0x03u;\r
 372         }\r
 373         else\r
 374         {\r
 375             /* ABPS1 */\r
 376             g_gdec_lut[abps_idx] = (acb_config_byte >> 1u) & 0x03u;\r
 377         }\r
 378     }\r
 379     \r
 380     /* Populate the channel_type_lut_h look-up table. */\r
 381     for(channel = 0; channel < ACE_NB_OF_INPUT_CHANNELS; ++channel)\r
 382     {\r
 383         uint8_t quad_id;\r
 384         uint8_t acb_config_byte;\r
 385         adc_channel_id_t channel_id;\r
 386         channel_type_t channel_type;\r
 387     \r
 388         channel_id = g_ace_channel_desc_table[channel].signal_id;\r
 389         quad_id = channel_quad_lut[channel_id];\r
 390         \r
 391         switch (channel_type_lut[channel_id])\r
 392         {\r
 393             case VOLTAGE_CHANNEL:\r
 394                 channel_type = VOLTAGE;\r
 395                 break;\r
 396                 \r
 397             case CURRENT_CHANNEL:\r
 398                 ASSERT( quad_id != 0xFFu );\r
 399                 acb_config_byte = ACE->ACB_DATA[quad_id].b9;\r
 400                 if ( acb_config_byte & 0x01u )\r
 401                 {\r
 402                     channel_type = VOLTAGE;\r
 403                 }\r
 404                 else\r
 405                 {\r
 406                     channel_type = CURRENT;\r
 407                 }\r
 408                 break;\r
 409             \r
 410             case TEMPERATURE_CHANNEL:\r
 411                 ASSERT( quad_id != 0xFFu );\r
 412                 acb_config_byte = ACE->ACB_DATA[quad_id].b10;\r
 413                 if ( acb_config_byte & 0x01u )\r
 414                 {\r
 415                     channel_type = VOLTAGE;\r
 416                 }\r
 417                 else\r
 418                 {\r
 419                     channel_type = TEMPERATURE;\r
 420                 }\r
 421                 break;\r
 422                 \r
 423             default:\r
 424                 ASSERT(0);\r
 425                 channel_type = VOLTAGE;\r
 426                 break;\r
 427         }\r
 428         \r
 429         channel_type_lut_h[channel] = channel_type;\r
 430     }\r
 431     \r
 432     /* Restore SSE PC2 operations. */\r
 433     ACE->PC2_CTRL = saved_pc2_ctrl;\r
 434 }\r
 435 \r
 436 /*-------------------------------------------------------------------------*//**\r
 437  *\r
 438  */\r
 439 int32_t ACE_convert_to_mV\r
 440 (\r
 441     ace_channel_handle_t    channel_handle,\r
 442     uint16_t                sample_value\r
 443 )\r
 444 {\r
 445     uint32_t adc_voltage;\r
 446     int32_t voltage;\r
 447     adc_channel_id_t channel_id;\r
 448     uint8_t adc_id;\r
 449     uint8_t apbs_idx;\r
 450     \r
 451     channel_id = g_ace_channel_desc_table[channel_handle].signal_id;\r
 452     adc_id = (uint8_t)channel_id >> 4u;\r
 453     adc_voltage = ( g_ace_adc_config[adc_id].va_ref * (uint32_t)sample_value ) / PPE_SAMPLES_RESOLUTION;\r
 454     voltage = (int32_t)adc_voltage;\r
 455 \r
 456     apbs_idx = abps_idx_lut[channel_id];\r
 457     if ( abps_channel_lut[channel_id] != NON_ABPS_CHANNEL )\r
 458     {\r
 459         uint8_t gdec;\r
 460         gdec = g_gdec_lut[apbs_idx];\r
 461         voltage = (voltage * apbs_gain_lut[gdec]) - apbs_range[gdec];\r
 462     }\r
 463     return voltage;\r
 464 }\r
 465 \r
 466 /*-------------------------------------------------------------------------*//**\r
 467  *\r
 468  */\r
 469 uint32_t ACE_convert_to_mA\r
 470 (\r
 471     ace_channel_handle_t    channel_handle,\r
 472     uint16_t                sample_value\r
 473 )\r
 474 {\r
 475     uint32_t current = 0u;\r
 476     \r
 477     ASSERT(channel_handle < ACE_NB_OF_INPUT_CHANNELS);\r
 478     \r
 479     if((int32_t)channel_handle < ACE_NB_OF_INPUT_CHANNELS)\r
 480     {\r
 481         adc_channel_id_t channel_id;\r
 482         uint8_t current_monitor_idx;\r
 483         \r
 484         channel_id = g_ace_channel_desc_table[channel_handle].signal_id;\r
 485         ASSERT(channel_id < sizeof(channel_type_lut));\r
 486         if(CURRENT_CHANNEL == channel_type_lut[channel_id])\r
 487         {\r
 488             uint32_t resistor;\r
 489             uint32_t voltage;\r
 490             \r
 491             /* Compute index into g_ace_current_resistors[] from the current\r
 492              * channel number. This uses bit 2, 4 and 5 of the channel number\r
 493              * to derive the index as follows:\r
 494              *  channel name : channel number : index\r
 495              *       CM0     :       0x03     :   0\r
 496              *       CM1     :       0x07     :   1\r
 497              *       CM2     :       0x13     :   2\r
 498              *       CM3     :       0x17     :   3\r
 499              *       CM4     :       0x23     :   4\r
 500              *       CM5     :       0x27     :   5\r
 501              */\r
 502             current_monitor_idx\r
 503                 = (((uint8_t)channel_id & 0x04u) >> 2u) + (((uint8_t)channel_id & 0x30u) >> 3u);\r
 504             \r
 505             if(current_monitor_idx < (uint8_t)ACE_NB_OF_CURRENT_MONITORS)\r
 506             {\r
 507                 /* Retrieve the current sensing external resistor value from \r
 508                  * the ACE configuration data generated by the ACE configurator. */\r
 509                 resistor = g_ace_current_resistors[current_monitor_idx];\r
 510                 \r
 511                 /* Compute mA current value taking into account the amplication\r
 512                  * factor of 50 used within the current monitor hardware. */\r
 513                 voltage = ACE_convert_adc_input_to_mV(channel_handle, sample_value);\r
 514                 current = (voltage * (1000u / 50u)) / resistor;\r
 515 ;\r
 516             }\r
 517         }\r
 518     }\r
 519     \r
 520     return current;\r
 521 }\r
 522 \r
 523 /*-------------------------------------------------------------------------*//**\r
 524  *\r
 525  */\r
 526 uint32_t ACE_convert_to_Kelvin\r
 527 (\r
 528     ace_channel_handle_t    channel_handle,\r
 529     uint16_t                sample_value\r
 530 )\r
 531 {\r
 532     uint32_t temperature;\r
 533     uint32_t voltage;\r
 534     \r
 535     voltage = ACE_convert_adc_input_to_mV( channel_handle, sample_value );\r
 536     \r
 537     /* Tk = (V * 10^3) / 2.5  */\r
 538     temperature = (voltage * 10u) / 25u;\r
 539     \r
 540     return temperature;\r
 541 }\r
 542 \r
 543 /*-------------------------------------------------------------------------*//**\r
 544  *\r
 545  */\r
 546 int32_t ACE_convert_to_Celsius\r
 547 (\r
 548     ace_channel_handle_t    channel_handle,\r
 549     uint16_t                sample_value\r
 550 )\r
 551 {\r
 552     int32_t temperature;\r
 553     int32_t voltage;\r
 554     \r
 555     voltage = (int32_t)ACE_convert_adc_input_to_mV( channel_handle, sample_value );\r
 556     \r
 557     /* Tk = (V * 10^3) / 2.5  */\r
 558     /* Tc = Tk - 273.15 */\r
 559     temperature = (voltage * 4) - 2731;\r
 560     \r
 561     return temperature;\r
 562 }\r
 563 \r
 564 /*-------------------------------------------------------------------------*//**\r
 565  *\r
 566  */\r
 567 int32_t ACE_convert_to_Fahrenheit\r
 568 (\r
 569     ace_channel_handle_t    channel_handle,\r
 570     uint16_t                sample_value\r
 571 )\r
 572 {\r
 573     int32_t temperature;\r
 574     \r
 575     temperature = (int32_t)ACE_convert_to_Kelvin( channel_handle, sample_value );\r
 576     \r
 577     /* F = (K * 9/5) - 459.67 */\r
 578     temperature = ((temperature * 9) / 5) - 459;\r
 579     \r
 580     return temperature;\r
 581 }\r
 582 \r
 583 /*-------------------------------------------------------------------------*//**\r
 584  *\r
 585  */\r
 586 const uint8_t * ACE_get_channel_name\r
 587 (\r
 588     ace_channel_handle_t    channel_handle\r
 589 )\r
 590 {\r
 591     const uint8_t * p_channel_name = 0;\r
 592     \r
 593     if ( channel_handle < NB_OF_ACE_CHANNEL_HANDLES)\r
 594     {\r
 595         p_channel_name = g_ace_channel_desc_table[channel_handle].p_sz_channel_name;\r
 596     }\r
 597     \r
 598     return p_channel_name;\r
 599 }\r
 600 \r
 601 /*-------------------------------------------------------------------------*//**\r
 602  *\r
 603  */\r
 604 uint16_t ACE_convert_mV_to_adc_value\r
 605 (\r
 606     ace_channel_handle_t    channel_handle,\r
 607     uint32_t                voltage\r
 608 )\r
 609 {\r
 610     uint16_t sample_value;\r
 611     adc_channel_id_t channel_id;\r
 612     uint8_t adc_id;\r
 613     \r
 614     channel_id = g_ace_channel_desc_table[channel_handle].signal_id;\r
 615     adc_id = (uint8_t)channel_id >> 4u;\r
 616     \r
 617     if (voltage > g_ace_adc_config[adc_id].va_ref)\r
 618     {\r
 619         sample_value = g_ace_adc_config[adc_id].adc_resolution - 1u;\r
 620     }\r
 621     else\r
 622     {\r
 623         sample_value = (uint16_t)((voltage * (g_ace_adc_config[adc_id].adc_resolution - 1)) / g_ace_adc_config[adc_id].va_ref);\r
 624     }\r
 625     \r
 626     return sample_value;\r
 627 }\r
 628 \r
 629 /*-------------------------------------------------------------------------*//**\r
 630  *\r
 631  */\r
 632 static uint16_t convert_mV_to_ppe_value\r
 633 (\r
 634     ace_channel_handle_t    channel_handle,\r
 635     uint32_t                voltage\r
 636 )\r
 637 {\r
 638     uint16_t sample_value;\r
 639     adc_channel_id_t channel_id;\r
 640     uint8_t adc_id;\r
 641     \r
 642     channel_id = g_ace_channel_desc_table[channel_handle].signal_id;\r
 643     adc_id = (uint8_t)channel_id >> 4u;\r
 644     \r
 645     if (voltage > g_ace_adc_config[adc_id].va_ref)\r
 646     {\r
 647         sample_value = PPE_SAMPLES_RESOLUTION;\r
 648     }\r
 649     else\r
 650     {\r
 651         sample_value = (uint16_t)((voltage * PPE_SAMPLES_RESOLUTION) / g_ace_adc_config[adc_id].va_ref);\r
 652     }\r
 653     \r
 654     return sample_value;\r
 655 }\r
 656 \r
 657 #define MAX_PPE_SAMPLE_VALUE    0x0FFFu\r
 658 \r
 659 /*-------------------------------------------------------------------------*//**\r
 660  *\r
 661  */\r
 662 uint16_t ACE_convert_from_mV\r
 663 (\r
 664     ace_channel_handle_t    channel_handle,\r
 665     int32_t                 voltage\r
 666 )\r
 667 {\r
 668     uint16_t sample_value;\r
 669     adc_channel_id_t channel_id;\r
 670     uint8_t adc_id;\r
 671     uint32_t adc_voltage;\r
 672     \r
 673     channel_id = g_ace_channel_desc_table[channel_handle].signal_id;\r
 674     adc_id = (uint8_t)channel_id >> 4u;\r
 675     \r
 676     if ( abps_channel_lut[channel_id] == NON_ABPS_CHANNEL )\r
 677     {\r
 678         if (voltage > 0)\r
 679         {\r
 680             adc_voltage = (uint32_t)voltage;\r
 681         }\r
 682         else\r
 683         {\r
 684             adc_voltage = 0u;\r
 685         }\r
 686     }\r
 687     else\r
 688     {\r
 689         uint8_t apbs_idx;\r
 690         uint8_t gdec;\r
 691         \r
 692         apbs_idx = abps_idx_lut[channel_id];\r
 693         gdec = g_gdec_lut[apbs_idx];\r
 694         voltage = voltage + apbs_range[gdec];\r
 695         if (voltage > 0)\r
 696         {\r
 697                 adc_voltage = (uint32_t)voltage;\r
 698                 adc_voltage = adc_voltage / (uint8_t)apbs_gain_lut[gdec];\r
 699         }\r
 700         else\r
 701         {\r
 702                 adc_voltage = 0;\r
 703         }\r
 704     }\r
 705     \r
 706     sample_value = (uint16_t)((adc_voltage * PPE_SAMPLES_RESOLUTION) / g_ace_adc_config[adc_id].va_ref);\r
 707     \r
 708     if (sample_value > MAX_PPE_SAMPLE_VALUE)\r
 709     {\r
 710         sample_value = MAX_PPE_SAMPLE_VALUE;\r
 711     }\r
 712     return sample_value;\r
 713 }\r
 714 \r
 715 /*-------------------------------------------------------------------------*//**\r
 716  *\r
 717  */\r
 718 uint16_t ACE_convert_from_mA\r
 719 (\r
 720     ace_channel_handle_t    channel_handle,\r
 721     uint32_t                current\r
 722 )\r
 723 {\r
 724     uint16_t sample_value;\r
 725     uint32_t voltage;\r
 726     uint32_t resistor = 1u;\r
 727     \r
 728     voltage = current * 50u * resistor;\r
 729     sample_value = convert_mV_to_ppe_value( channel_handle, voltage );\r
 730     \r
 731     if (sample_value > MAX_PPE_SAMPLE_VALUE)\r
 732     {\r
 733         sample_value = MAX_PPE_SAMPLE_VALUE;\r
 734     }\r
 735     return sample_value;\r
 736 }\r
 737 \r
 738 /*-------------------------------------------------------------------------*//**\r
 739  *\r
 740  */\r
 741 uint16_t ACE_convert_from_Kelvin\r
 742 (\r
 743     ace_channel_handle_t    channel_handle,\r
 744     uint32_t                temperature\r
 745 )\r
 746 {\r
 747     uint16_t sample_value;\r
 748     uint32_t voltage;\r
 749     \r
 750     voltage = (temperature * 25u) / 10u;\r
 751     sample_value = convert_mV_to_ppe_value( channel_handle, voltage );\r
 752     \r
 753     if (sample_value > MAX_PPE_SAMPLE_VALUE)\r
 754     {\r
 755         sample_value = MAX_PPE_SAMPLE_VALUE;\r
 756     }\r
 757     return sample_value;\r
 758 }\r
 759 \r
 760 /*-------------------------------------------------------------------------*//**\r
 761  *\r
 762  */\r
 763 uint16_t ACE_convert_from_Celsius\r
 764 (\r
 765     ace_channel_handle_t    channel_handle,\r
 766     int32_t                 temperature\r
 767 )\r
 768 {\r
 769     uint16_t sample_value;\r
 770     uint32_t voltage;\r
 771     \r
 772     temperature = temperature + 2731;\r
 773     voltage = (uint32_t)temperature / 4u;\r
 774     sample_value = convert_mV_to_ppe_value( channel_handle, voltage );\r
 775     \r
 776     if (sample_value > MAX_PPE_SAMPLE_VALUE)\r
 777     {\r
 778         sample_value = MAX_PPE_SAMPLE_VALUE;\r
 779     }\r
 780     return sample_value;\r
 781 }\r
 782 \r
 783 /*-------------------------------------------------------------------------*//**\r
 784  *\r
 785  */\r
 786 uint16_t ACE_convert_from_Fahrenheit\r
 787 (\r
 788     ace_channel_handle_t    channel_handle,\r
 789     int32_t                 temperature\r
 790 )\r
 791 {\r
 792     uint16_t sample_value;\r
 793     uint32_t kelvin;\r
 794     \r
 795     temperature = temperature + 459;\r
 796     kelvin = (uint32_t)temperature;\r
 797     kelvin = (kelvin * 5u) / 9u;\r
 798     \r
 799     sample_value = ACE_convert_from_Kelvin( channel_handle, kelvin );\r
 800     \r
 801     if (sample_value > MAX_PPE_SAMPLE_VALUE)\r
 802     {\r
 803         sample_value = MAX_PPE_SAMPLE_VALUE;\r
 804     }\r
 805     return sample_value;\r
 806 }\r
 807 \r
 808 /*-------------------------------------------------------------------------*//**\r
 809  *\r
 810  */\r
 811 uint16_t ACE_translate_pdma_value\r
 812 (\r
 813     uint32_t            pdma_value,\r
 814     adc_channel_id_t *  channel_id\r
 815 )\r
 816 {\r
 817     uint16_t ppe_value;\r
 818       \r
 819     ppe_value = (pdma_value >> 8u) & 0xFFFFu;\r
 820     if ( channel_id != 0 )\r
 821     {\r
 822         *channel_id = (adc_channel_id_t)((pdma_value >> 24u) & 0xFFu);\r
 823     }\r
 824     \r
 825     return ppe_value;\r
 826 }\r
 827 \r
 828 #ifdef __cplusplus\r
 829 }\r
 830 #endif\r
 831 \r