▍ Схема питания

1. плата защиты является не контроллером заряда, а лишь ограничителем предельно допустимых значений напряжения, тока и температуры,
2. платы защиты бывают разные и могут не обеспечивать всех необходимых ограничений,
3. не у каждого литиевого аккумулятора имеется плата защиты.

▍ Аналого-цифровое преобразование

1. такие резисторы являются более высоковольтными и имеют лучшую устойчивость к пробою,
2. они лучше охлаждаются, что положительно сказывается на точности измерений, ведь сопротивление токопроводящего слоя зависит от температуры.

    Copyright (c) 2020 Creative Lau (creativelaulab@gmail.com)

    Permission is hereby granted, free of charge, to any person obtaining a copy
    of this software and associated documentation files (the "Software"), to deal
    in the Software without restriction, including without limitation the rights
    to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
    copies of the Software, and to permit persons to whom the Software is
    furnished to do so, subject to the following conditions:

    The above copyright notice and this permission notice shall be included in all
    copies or substantial portions of the Software.

    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
    IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
    FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
    AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
    LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
    OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
    SOFTWARE.

/* scale_h: Time scale 500ms, 200ms, 100ms, 50ms, 20ms, 10ms, 5ms, 2ms, 1ms, 500us, 200us, 100us */
void ADCInit(uint8 scale_h)
{
    uint8 ADC_SPEED;

    switch (scale_h)
    {
    case 0: //500ms
        ADC_SPEED = ADC_SPEED_512;
        break;

    case 1: //200ms
        ADC_SPEED = ADC_SPEED_512;
        break;

    case 2: //100ms
        ADC_SPEED = ADC_SPEED_512;
        break;

    case 3: //50ms
        ADC_SPEED = ADC_SPEED_512;
        break;

    case 4: //20ms
        ADC_SPEED = ADC_SPEED_512;
        break;

    case 5: //10ms
        ADC_SPEED = ADC_SPEED_512;
        break;

    case 6: //5ms
        ADC_SPEED = ADC_SPEED_512;
        break;

    case 7: //2ms
        ADC_SPEED = ADC_SPEED_512;
        break;

    case 8: //1ms
        ADC_SPEED = ADC_SPEED_352;
        break;

    case 9: //500us
        ADC_SPEED = ADC_SPEED_192;
        break;

    case 10: //200us
        ADC_SPEED = ADC_SPEED_32;
        break;

    case 11: //100us
        ADC_SPEED = ADC_SPEED_32;
        break;
    }
    ADCCFG = RESFMT | ADC_SPEED; //Результат выравнивается по правому краю, а тактовая частота АЦП устанавливается на системную тактовую частоту /2/16/16
    ADC_CONTR = ADC_POWER;       //Включаем модуль АЦП
    Delay5ms();                  //Задержка, чтобы АЦП успел включиться
}

uint16 ADCRead(uint8 chx)
{
    uint16 res;
    ADC_RES = 0;            //Очищаем регистры результата
    ADC_RESL = 0;           
    ADC_CONTR &= 0xF0;      //Выбор входного канала АЦП
    ADC_CONTR |= chx;
    ADC_CONTR |= ADC_START; //Запускаем преобразование
    _nop_();
    _nop_();

    while (!(ADC_CONTR & ADC_FLAG))
        ; //Флаг завершения преобразования

    ADC_CONTR &= ~ADC_FLAG;          
    res = (ADC_RES << 8) | ADC_RESL; //Чтение результатов АЦП
    return res;
}

uint16 GetADC_CHX(uint8 chx)
{   uint16 ADCx;
    uint8 i;

    ADCInit(0); //Инициализация АЦП

    //Измеряем напряжение на встроенном источнике опорного напряжения
    ADCRead(chx); //Отбрасываем первые два результата, которые могут быть неточными после переключения канала АЦП
    ADCRead(chx);
    ADCx = 0;

    for (i = 0; i < 16; i++)
    {
        ADCx += ADCRead(chx);
    }

    ADCx >>= 4; //Вычисляем среднее арифметическое
    return ADCx;
}

uint16 GetVoltage(uint8 chx, uint16 lsb)
{
    uint16 ADCbg;
    uint16 *BGV;
    uint16 ADCx;
    uint16 Vx;

    ADCInit(0); 

    //Получаем усреднённое значение напряжения ИОН через 16-й канал АЦП
    ADCbg = GetADC_CHX(ADC_CHS_BG);

    //Получаем усреднённое значение входного напряжения ИОН через канал chx
    ADCx = GetADC_CHX(chx);

    //Рассчитываем входное напряжение
    BGV = GetBGV();
    Vx = (uint32)*BGV * ADCx * lsb / ADCbg / 100;
    return Vx;
}

//	ADCRead(chx) Timing:500ms, 200ms, 100ms, 50ms, 20ms, 10ms, 5ms, 2ms, 1ms, 500us, 200us, 100us
//	Горизонтальное разрешение равно 100 точкам - 4 группам по 25
//  24MHz
//	ADC_SPEED_512 28us
//	ADC_SPEED_480 26.2us
//	ADC_SPEED_448 25us
//	ADC_SPEED_416 23.8us
//	ADC_SPEED_384 22us
//	ADC_SPEED_352 20us
//	ADC_SPEED_320 18us
//	ADC_SPEED_288 17us
//	ADC_SPEED_256 15us
//	ADC_SPEED_224 14us
//	ADC_SPEED_192 12us
//	ADC_SPEED_160 10.4us
//	ADC_SPEED_128 9us
//	ADC_SPEED_96 7us
//	ADC_SPEED_64 5.6us
//	ADC_SPEED_32 4us
//
//  27MHz
//	ADC_SPEED_512 26us
//	ADC_SPEED_352 19us
//	ADC_SPEED_192 11us
//	ADC_SPEED_32 4us
void switch_Dealy(uint8 scale_h)
{
    switch (scale_h)
    {
        //500ms ADC_SPEED_512
    case 0:
        Delay19971us();
        break;

        //200ms ADC_SPEED_512
    case 1:
        Delay7971us();
        break;

        //100ms	ADC_SPEED_512
    case 2:
        Delay3971us();
        break;

        //50ms ADC_SPEED_512
    case 3:
        Delay1971us();
        break;

        //20ms ADC_SPEED_512
    case 4:
        Delay771us();
        break;

        //10ms ADC_SPEED_512
    case 5:
        Delay371us();
        break;

        //5ms ADC_SPEED_512
    case 6:
        Delay171us();
        break;

        //2ms ADC_SPEED_512
    case 7:
        Delay51us();
        break;

        //1ms ADC_SPEED_352
    case 8:
        Delay18us();
        break;

        //500us	ADC_SPEED_192
    case 9:
        Delay6us();
        break;

        //200us ADC_SPEED_32
    case 10:
        /* Точная настройка интервала выборки */
        _nop_();
        //_nop_();
        break;

        //100us ADC_SPEED_32
    case 11:

        break;
    }
}

▍ Синхронизация и развёртка

Развёртка может срабатывать однократно, фиксируя осциллограмму до ручного перезапуска, либо автоматически перезапускаться двумя способами: после каждого заполнения буфера для периодических сигналов, либо после срабатывания синхронизации для апериодических или редко повторяющихся.

uint16 *GetWaveADC(uint8 chx, uint8 scale_h)
{
    uint8 i, j;
    static uint16 ADCSampling[SAMPLE_NUM];
    uint16 ADCPreSampling[PRE_BUF_NUM + 1]; //Первая дополнительная позиция используется для копирования значения последней позиции при формировании циклического кэша.

    ADCComplete = 0; //Снимаем флаг завершения выборки
    if (ADCInterrupt)
        return ADCSampling;
    memset(ADCSampling, 0x00, SAMPLE_NUM * 2);
    memset(ADCPreSampling, 0x00, (PRE_BUF_NUM + 1) * 2);
    //BGV = GetBGV(); 
    ADCbg = GetADC_CHX(ADC_CHS_BG);                         //Получаем значение опорного напряжения
    TriggerADC = Convert_mv_ADC(TriLevel, BGV, ADCbg, Lsb); //Преобразовываем заданное пользователем значение порога синхронизации в значение АЦП

    //Ждём стабилизации напряжения ИОН
    ADCInit(scale_h);
    ADCRead(chx); //Отбрасываем первые два результата
    ADCRead(chx);

    //Минимальный временной интервал 100 микросекунд не поддерживает однократную развёртку
    if (scale_h == 11) //100 us
    {
        P_Ready = 1; //Начинаем фиксацию мгновенных значений и зажигаем светодиод — индикатор синхронизации
        for (i = 0; i < SAMPLE_NUM; i++)
        {
            if (ADCInterrupt)
                return ADCSampling;
            ADCSampling[i] = ADCRead(chx);
#ifdef DEBUG
            P15 = ~P15;
#endif
        }
        P_Ready = 0; //После заполнения буфера гасим индикатор синхронизации
    }

    /* Выбор режима: однократная или повторяющаяся развёртка*/
    else if (TriMode)
    {
        P_Ready = 0;                       //Предварительно заполняем буфер, не реагируя на порог синхронизации, чтобы не потерять левую часть осциллограммы
        for (j = 1; j <= PRE_BUF_NUM; j++) 
        {
            if (ADCInterrupt)
                return ADCSampling;

            Delay3us();            //Коррекция временного интервала: цикл выборки при однократной развёртке или первом запуске непрерывной на 3 мкс медленнее, чем при автоматическом перезапуске.
            switch_Dealy(scale_h); //Задержка выборки
            ADCPreSampling[j] = ADCRead(chx);
#ifdef DEBUG
            P15 = ~P15;
#endif
        }
        P_Ready = 1; //Когда предварительное кэширование завершено, загорается индикатор и можно обрабатывать порог синхронизации.

        //Цикл кэширует точки выборки PRE_BUF_NUM перед запуском и определяет, соответствуют ли точки выборки условиям запуска.
        while (1)
        {
            if (ADCInterrupt)
                return ADCSampling;

            //Если предварительный буфер переполняется, то последнее значение выборки копируется в первую позицию.
            if (j > PRE_BUF_NUM)
            {
                j = 1;
                ADCPreSampling[0] = ADCPreSampling[PRE_BUF_NUM];
            }
            switch_Dealy(scale_h); //Задержка выборки
            ADCPreSampling[j] = ADCRead(chx);
            if (GetTriggerPos(ADCPreSampling[j - 1], ADCPreSampling[j], TriggerADC, TriSlope)) //Соблюдаются ли условия срабатывания триггера синхронизации?
            {
                P_Ready = 0; //После успешной синхронизации выходим из цикла while и гасим светодиод
                break;
            }
            j++;
#ifdef DEBUG
            P15 = ~P15;
#endif
        }

        //Продолжаем запоминание мгновенных значений входного напряжения
        for (i = 0; i < AFT_BUF_NUM; i++)
        {
            if (ADCInterrupt)
                return ADCSampling;

            Delay3us();            
            switch_Dealy(scale_h); 
            ADCSampling[i + PRE_BUF_NUM] = ADCRead(chx);
#ifdef DEBUG
            P15 = ~P15;
#endif
        }

        //Объединяем первую и последнюю точки выборки PRE_BUF_NUM в полную форму волны.
        for (i = 0; i < PRE_BUF_NUM; i++) //Первое и последнее значения выборки в предварительном кэше равны, первое значение отбрасываем, а оставшиеся точки выборки PRE_BUF_NUM-1 сортируем в порядке выборки как первые точки выборки PRE_BUF_NUM-1 ADCSampling.
        {
            if (ADCInterrupt)
                return ADCSampling;
            if (++j > PRE_BUF_NUM) //Переполнение предварительного кэша
                j = 1;

            ADCSampling[i] = ADCPreSampling[j];
        }
    }

    /* Режим повторяющейся (автоматической) развёртки */
    else
    {
        P_Ready = 1; //Начинаем отбор мгновенных значений и зажигаем индикатор
        for (i = 0; i < SAMPLE_NUM; i++)
        {
            if (ADCInterrupt)
                return ADCSampling;
            ADCSampling[i] = ADCRead(chx);
            Delay3us();            //Коррекция временного интервала
            switch_Dealy(scale_h); //Задержка выборки
#ifdef DEBUG
            P15 = ~P15;
#endif
        }
        P_Ready = 0; //Гасим светодиод
    }
    ADCComplete = 1; //Устанавливаем флаг завершения выборки
    return ADCSampling;
}

#endif

▍ Генератор стандартных сигналов

▍ Итоги работы

Telegram-канал со скидками, розыгрышами призов и новостями IT ?