src/main/drivers/adc.c

   1 /*
   2  * This file is part of Cleanflight and Betaflight.
   3  *
   4  * Cleanflight and Betaflight are free software. You can redistribute
   5  * this software and/or modify this software under the terms of the
   6  * GNU General Public License as published by the Free Software
   7  * Foundation, either version 3 of the License, or (at your option)
   8  * any later version.
   9  *
  10  * Cleanflight and Betaflight are distributed in the hope that they
  11  * will be useful, but WITHOUT ANY WARRANTY; without even the implied
  12  * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
  13  * See the GNU General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU General Public License
  16  * along with this software.
  17  *
  18  * If not, see <http://www.gnu.org/licenses/>.
  19  */
  20
  21 #include <stdbool.h>
  22 #include <stdint.h>
  23
  24 #include "platform.h"
  25 #include "common/utils.h"
  26
  27 #ifdef USE_ADC
  28
  29 #include "build/build_config.h"
  30 #include "build/debug.h"
  31
  32 #include "drivers/adc_impl.h"
  33 #include "drivers/io.h"
  34
  35 #include "pg/adc.h"
  36
  37 #include "adc.h"
  38
  39 //#define DEBUG_ADC_CHANNELS
  40
  41 adcOperatingConfig_t adcOperatingConfig[ADC_CHANNEL_COUNT];
  42
  43 #if defined(STM32F7)
  44 volatile FAST_DATA_ZERO_INIT uint16_t adcValues[ADC_CHANNEL_COUNT];
  45 #else
  46 volatile uint16_t adcValues[ADC_CHANNEL_COUNT];
  47 #endif
  48
  49 uint8_t adcChannelByTag(ioTag_t ioTag)
  50 {
  51     for (uint8_t i = 0; i < ARRAYLEN(adcTagMap); i++) {
  52         if (ioTag == adcTagMap[i].tag)
  53             return adcTagMap[i].channel;
  54     }
  55     return 0;
  56 }
  57
  58 ADCDevice adcDeviceByInstance(ADC_TypeDef *instance)
  59 {
  60     if (instance == ADC1) {
  61         return ADCDEV_1;
  62     }
  63
  64 #if defined(ADC2)
  65     if (instance == ADC2) {
  66         return ADCDEV_2;
  67     }
  68 #endif
  69 #if defined(ADC3)
  70     if (instance == ADC3) {
  71         return ADCDEV_3;
  72     }
  73 #endif
  74 #if defined(ADC4)
  75     if (instance == ADC4) {
  76         return ADCDEV_4;
  77     }
  78 #endif
  79 #if defined(ADC5)
  80     if (instance == ADC5) {
  81         return ADCDEV_5;
  82     }
  83 #endif
  84
  85     return ADCINVALID;
  86 }
  87
  88 uint16_t adcGetChannel(uint8_t channel)
  89 {
  90     adcGetChannelValues();
  91
  92 #ifdef DEBUG_ADC_CHANNELS
  93     if (adcOperatingConfig[0].enabled) {
  94         debug[0] = adcValues[adcOperatingConfig[0].dmaIndex];
  95     }
  96     if (adcOperatingConfig[1].enabled) {
  97         debug[1] = adcValues[adcOperatingConfig[1].dmaIndex];
  98     }
  99     if (adcOperatingConfig[2].enabled) {
 100         debug[2] = adcValues[adcOperatingConfig[2].dmaIndex];
 101     }
 102     if (adcOperatingConfig[3].enabled) {
 103         debug[3] = adcValues[adcOperatingConfig[3].dmaIndex];
 104     }
 105 #endif
 106     return adcValues[adcOperatingConfig[channel].dmaIndex];
 107 }
 108
 109 // Verify a pin designated by tag has connection to an ADC instance designated by device
 110
 111 bool adcVerifyPin(ioTag_t tag, ADCDevice device)
 112 {
 113     if (!tag) {
 114         return false;
 115     }
 116
 117     for (int map = 0 ; map < ADC_TAG_MAP_COUNT ; map++) {
 118 #if defined(STM32F1)
 119         UNUSED(device);
 120         if ((adcTagMap[map].tag == tag)) {
 121             return true;
 122         }
 123 #else
 124         if ((adcTagMap[map].tag == tag) && (adcTagMap[map].devices & (1 << device))) {
 125             return true;
 126         }
 127 #endif
 128     }
 129
 130     return false;
 131 }
 132
 133 #ifdef USE_ADC_INTERNAL
 134
 135 int32_t adcVREFINTCAL;      // ADC value (12-bit) of band gap with Vref = VREFINTCAL_VREF
 136 int32_t adcTSCAL1;
 137 int32_t adcTSCAL2;
 138 int32_t adcTSSlopeK;
 139
 140 uint16_t adcInternalCompensateVref(uint16_t vrefAdcValue)
 141 {
 142     // This is essentially a tuned version of
 143     // __HAL_ADC_CALC_VREFANALOG_VOLTAGE(vrefAdcValue, ADC_RESOLUTION_12B);
 144     return (uint16_t)((uint32_t)(adcVREFINTCAL * VREFINT_CAL_VREF) / vrefAdcValue);
 145 }
 146
 147 int16_t adcInternalComputeTemperature(uint16_t tempAdcValue, uint16_t vrefValue)
 148 {
 149     // This is essentially a tuned version of
 150     // __HAL_ADC_CALC_TEMPERATURE(vrefValue, tempAdcValue, ADC_RESOLUTION_12B);
 151
 152     return ((((int32_t)((tempAdcValue * vrefValue) / TEMPSENSOR_CAL_VREFANALOG) - adcTSCAL1) * adcTSSlopeK) + 500) / 1000 + TEMPSENSOR_CAL1_TEMP;
 153 }
 154 #endif // USE_ADC_INTERNAL
 155
 156 #else
 157 uint16_t adcGetChannel(uint8_t channel)
 158 {
 159     UNUSED(channel);
 160     return 0;
 161 }
 162 #endif