ADC модуль это основа любого электронного измерения. Основа любого DMM. Всё что за корпусом микроконтроллера это аналоговый мир. ADC это портал который позволяет аналоговым сигналам переходить в мир цифры.

Постановка задачи
Научиться записывать c PA3 (ADC1_IN3) на STM32F407VE 12-битные семплы в потоковом режиме на частоте дискретизации равной 8kHz. Для точной установки частоты дискретизации использовать аппаратный таймер TIM2 . Использовать встроенный в микроконтроллер ADC. Использовать ADC1. Использовать DMA. Записанные семплы складировать в FIFO. В случае переполнения FIFO выдавать ошибку. При этом не использовать частые прерывания. Не нарушать непрерывность записи семплов. Все эксперименты производить на отладочной плате JZ-F407VET6.

Как отлаживаться?
На плате есть свободные GPIO пины, можно использовать DAC, осциллограф и логический анализатор.

Реализация:

Фаза 1: Настройка GPIO

Сначала выберем пины. Учитывая схемотехнику JZ-F407VET6 есть только такие варианты.

Я выбрал PA3. Этот пин надо сконфигурировать на аналоговую функцию.

Подтяжку к питанию отключить. PinMux выставить в ноль.

17:18-->timer_diag
+----+-----+----------+-----+------------+-------+-------+---------+---------+--------+
|Num | En  | busFreq  | bit | periodReg  |  psc  | dir   |period,s | freq,Hz |busName |
+----+-----+----------+-----+------------+-------+-------+---------+---------+--------+
| 2  |  On |    84.0M | 32  |        656 |    16 |   Up  |  0.125m |  8.003k |   APB1 |
| 3  |  On |    84.0M | 16  |       1000 |    84 |   Up  |  1.000m |  1.000k |   APB1 |
| 4  |  On |    84.0M | 16  |      10500 |     8 |   Up  |  1.000m |  1.000k |   APB1 |
| 5  |  On |    84.0M | 32  | 4294967295 | 65535 |   Up  |  3.351M |  0.298u |   APB1 |
| 8  |  On |   168.0M | 16  |      10500 |    16 |   Up  |  1.000m |  1.000k |   APB2 |
+----+-----+----------+-----+------------+-------+-------+---------+---------+--------+
17:30-->

Проверка логическим анализатором показала, что таймер в самом деле переполняется на частоте 8kHz.

Фаза 3: Настройка Analog-to-digital converter (ADC)

Внутри STM32F407VE заложено три 12 битных SAR-ADC. То есть значения которые мы будем получать будут варьироваться от 0 до 4095. Частота дискретизации может достигать 2.4 мега семплов в секунду. Я выбрал ADC1. ADC1 имеет номер прерывания 18. В распоряжении 16 каналов. Я выбрал канал номер три (PA3), разрешение 12 бит. Для настройки ADC надо подать тактирование на ADC подсистему. Режим непрерывного преобразования ( continuous conversion ) мне не нужен. Так как в этом режме преобразования происходят без паузы. Режим сканирования (Scan mode) мне пока тоже не нужен, так как я собираюсь читать напряжение только с одного пина (PA3). Выбираю выравнивание значащих битов вправо (Right alignment), чтобы можно было визуализировать семплы без преобразований. Ключевой момент в том, чтобы выбрать событие для начала преобразования. Этим событием я выбрал переполнение таймера 2 (0110: Timer 2 TRGO event). Указываю, что надо работать в режиме DMA. Надо указать время накопления заряда на внутреннем конденсаторе в периодах тактирования.

static bool adc_compose_init(const AdcConfig_t* const Config, ADC_InitTypeDef* const pInit) {
    bool res = false;
    if(pInit) {
        pInit->ScanConvMode = DISABLE;  
        pInit->ContinuousConvMode = DISABLE;   
        pInit->NbrOfConversion = 1;
        pInit->DMAContinuousRequests = ENABLE;
        pInit->DataAlign = ADC_DATAALIGN_RIGHT;
        //--

        pInit->DiscontinuousConvMode = DISABLE;
        pInit->ExternalTrigConv = AdcExternalTriggerSourceToExternalTrigConv(Config->trigger_source);
        pInit->Resolution = AdcResolution2code(Config->resolution);
        pInit->ClockPrescaler = ADC_CLOCK_SYNC_PCLK_DIV4;
        pInit->NbrOfDiscConversion = 1;
        pInit->ExternalTrigConvEdge = ADC_EXTERNALTRIGCONVEDGE_RISINGFALLING;

        pInit->EOCSelection = ADC_EOC_SEQ_CONV;
        res = true;
    }
    return res;
}

Фаза 4: Настройка DMA

DMA — Сердце потоковой записи. Должно перекачивать данные от ADC в память. Peripheral To Memory . DMA должно работать в режиме цирка (Circular mode), на каждой итерации увеличивать память, выравнивать запись по 16 бит.

#ifndef DMA_CHANNEL_CONFIG_ADC_H
#define DMA_CHANNEL_CONFIG_ADC_H

#ifdef __cplusplus
extern "C" {
#endif

#include "dma_channel_types.h"
#include "adc_config.h"

bool CallBackHalfAdc1(void);
bool CallBackDoneAdc1(void);

/*
  Table 43. DMA2 request mapping
 */
#define DMA_CHANNEL_ADC1                               \
    {                                                  \
        .num = DMA_CHANNEL_NUM_ADC1,                   \
        .DmaPad = {.dma_num = 2, .channel = 0},        \
        .name = "adc1",                                \
        .dir = DMA_MCAL_DIR_PERIPH_TO_MEMORY,          \
        .CallBackHalf = CallBackHalfAdc1,              \
        .CallBackDone = CallBackDoneAdc1,              \
        .mem_inc = DMA_INC_ON,                         \
        .per_inc = DMA_INC_OFF,                        \
        .valid = true,                                 \
        .aligment_mem = DMA_ALIGNMENT_WORD,            \
        .aligment_per = DMA_ALIGNMENT_WORD,            \
        .mode = DMA_MODE_CIRCULAR,                     \
        .interrupt_on = true,                          \
        .priority = DMA_PRIOR_MED,                     \
        .base_addr_source = (uint32_t) &(ADC1->DR),    \
        .base_addr_destination = (uint32_t) Adc1RxSamples, \
        .move_size = (uint32_t) ADC1_RX_SAMPLE_CNT,    \
        .block_size = (uint32_t) DMA_MEMCPY_SIZE,      \
        .block_count = 1,                              \
        .fifo = DMA_FIFO_OFF,                          \
        .memory_burst = DMA_BURST_SINGLE,              \
        .periph_burst = DMA_BURST_SINGLE,              \
    },

#define DMA_CHANNEL_ADC                              \
        DMA_CHANNEL_ADC1

#ifdef __cplusplus
}
#endif

#endif /* DMA_CHANNEL_CONFIG_ADC_H  */

C ADC1 может работать только DMA2 причет только каналы 0 и 4. Я выбрал канал ноль.

DMA надо настроить так, чтобы оно писало в циклическом режиме один и тот же массив. Данные следует выгребать в прерываниях по половинном заполнении и при полоном заполнении. Под выгребанием семплов подразумевается перекачка семплов из массива в очередь ADC1.RxFiFo.

Фаза 5: Организация FIFO

DMA в прерывании запускает две функции. Одна стартует при половинной записи массива, вторая при полной записи. Внутри этих прерываний надо успеть переложить семплы для обработки в приложении, пока не стартанет второй обработчик прерываний. Поэтому надо аккуратно извлечь семплы из массива приемника и переложить из в RxFiFo.

void HAL_ADC_ConvCpltCallback(ADC_HandleTypeDef* hadc) {
    AdcHandle_t* Node = AdcHalHandle2Handle(hadc);
    if(Node) {
        Node->conv_done = true;
        Node->conv_done_cnt++;
        uint32_t i = 0 ;
        for(i=Node->RxSamplesCnt/2;i<Node->RxSamplesCnt;i++){
            i_status ret = iqueue_enqueue(&Node->iQueue, &Node->RxSamples[i]);
            iqueue_ret_res(ret);
        }
    }
}

void HAL_ADC_ConvHalfCpltCallback(ADC_HandleTypeDef* hadc) {
    AdcHandle_t*  Node = AdcHalHandle2Handle(hadc);
    if(Node) {
        Node->half_cplt_done = true;
        Node->half_cplt_done_cnt++;
        uint32_t i = 0;
        for(i=0;i<Node->RxSamplesCnt/2;i++){
            i_status ret = iqueue_enqueue(&Node->iQueue, &Node->RxSamples[i]);
            iqueue_ret_res(ret);
        }
    }
}

Реализация FIFO это отдельная большая задача. Однако я выбрал готовую реализацию FIFO c open source репозитория разработчики-барсуки. Этот программный компонент называется iQueue.

i_status iqueue_init(iqueue_t* _queue, 
                     uint32_t _max_elements, 
                     size_t _element_size, void* _storage);
i_status iqueue_enqueue(iqueue_t* _queue, void* _element);
i_status iqueue_dequeue(iqueue_t* _queue, void* _element);
i_status iqueue_size(iqueue_t* _queue, size_t* _size);

На время заполнения FiFo надо отключить DMA прерывания (активировать критическую секцию). Без этого может произойти одновременный доступ на изменение переменных FIFO в обработчике прерываний и в функции main. Это приведет к непредсказуемым значениям внутри FIFO.

float AdcSample12ToVoltageVef3_3(const uint32_t sample) {
    float voltage_v = 0.0f;
    voltage_v = (3.3f *( (float) sample))/((float)ADC_MAX_VAL_12BIT);
    return voltage_v;
}

bool adc_proc_one(uint8_t num) {
    bool res = false;
    log_level_t ll = log_level_get(LG_ADC);
    AdcHandle_t* Node = AdcGetNode(num);
    if(Node) {
        i_status ret;
        size_t size = 0;
        ret = iqueue_size(&Node->iQueue, &size);
        if(I_OK==ret) {
            uint32_t i = 0;
            for(i=0; i<size; i++) {
                uint16_t sample = 0;
                ret = iqueue_dequeue(&Node->iQueue, (void*) &sample);
                if(I_OK == ret) {
                    if(LOG_LEVEL_DEBUG == ll) {
                        cli_printf("\rCode:%4u,%5.3f V", 
                                   sample, 
                                   AdcSample12ToVoltageVef3_3(sample));
                    }
                }
            }
        }
    }
    return res;
}

При этом чтобы что-то отображать надо что-то записывать. Поэтому второй канал DAC я запрограммировал генерировать программный синус сигнал, а первый канал DAC я настроил просто отображать принятые ADC семплы. Получилось полностью аналоговое эхо. Чтобы успевать высвобождать очередь TxFIFO, отображение семплов происходит в обработчике прерываний по таймеру 2.

Для программной реализации генерации синуса пришлось написать отдельный программный компонент DDS (Direct Digital Synthesis). Реализация DDS - это отдельная большая задача. Его задача - обсчитывать семплы для генерации sin функции. Хороший DDS может генерировать все виды сигналов: PWM, SAW, Fence, Chirp, DTMF, BPSK и прочие.

float calc_sin_sample(uint64_t time_us, 
                      float frequency, 
                      float phase_ms, 
                      float des_amplitude, 
                      float in_offset) {
    float lineVal = 0.0f;
    float argument = 0.0f;
    float amplitude = 0.0f;
    float amplitude_scaled = 0.0f;
    float cur_time_ms = ((float)time_us) / 1000.0f;
    lineVal = ((cur_time_ms + phase_ms) / 1000.0f) * frequency;
    argument = 2.0f * M_PI * lineVal;
    amplitude = (float)sinf((float)argument);
    amplitude_scaled = (des_amplitude * amplitude) + in_offset;
    return amplitude_scaled;
}

Как можно заметить, сигналы совпадают по частоте, амплитуде и форме. Значит связка ADC, DMA, RxFIFO,TxFIFO DAC работает корректно. Отличие по фазе пропорционально размеру TxFIFO.

Результат

Удалось научиться читать приложенное к пину напряжение при помощи встроенного в STM32 модуля ADC. Как видите, чтобы просто прочитать напряжение при помощи ADC Вам надо настроить GPIO, ADC, DMA, TIMER. Добавить надёжную абстрактную структуру данных FIFO. Запустить UART, чтобы можно было всё это отлаживать через CLI. Плюс еще запустить DAC и реализовать программный компонент DDS, чтобы отлаживаться в режиме аналогового эха.

Ссылки

Вопросы

--Зачем нужно выравнивание ADC семплов влево? Ведь это потом неудобно анализировать при печати.