Цифровая АРУ 0...1

[ra0ahc]

Код: [Выделить]

float32_t max = 0.49905586f; //максималка 0.49975586fот -0.5 до +0.5 примерно для 12 бит
uint16_t count = 100;
uint8_t stopGoingUp = 0;

float32_t rmsFrame = 0;
uint16_t uOldPStartIdx;
float32_t uOldPikV;
uint16_t wait = 5;
float32_t rate = 24000.0f;

///@brief АРУ
///@param buffer
void agcDo(float32_t *buffer) {
    float32_t rmsPik = 0;
    float32_t agcMetrTemp = 0;
    float32_t pit1 = -1;
    float32_t pit2 = 0;
    uint16_t pikCount = 0;
    if (tim > 0)tim--; //уменьшение задержки
    stopGoingUp = 0;
    uint16_t uLastNullIdx = 0;


    for (uint16_t i = 0; i < FRAME_SIZE; i++) {
        float32_t a;
        //a = (buffer[i] < 0.0f) ? -1.0f * buffer[i] : buffer[i];// adc V
        a = fabsf(buffer[i]);
        // seach min
        if (a > 0)nowAgc = max / a;
        else nowAgc = max / 0.000005f;


        uint16_t upIdx = i;

        float32_t pikBuf;
        uint8_t exit = 1;
        uint8_t exitYN = 0;
        uint16_t wait = 0;// 1msec

        uint16_t uPikIxxPlus = 0;
        uint16_t uPikIxxMinus = 0;
        float32_t uPikVPlus = 0; //V + pik
        float32_t uPikVMinus = 0;//V - pik
        //direction
        int direction = 1;//напрвление вниз (отрицательная синусоида)
        if (i + 1 < FRAME_SIZE) {
            if (buffer[i] <= 0 || buffer[i + 1] < 0) direction = 0;//напрвление вверх (положительная синусоида)
        } else {
            if (buffer[i] <= 0 || buffer[i - 1] > 0) direction = 0;//напрвление вверх (положительная синусоида)
        }

        while (exit) { //поиск пика в блоке от 0 до 0
            exit = 0;//выходим
            float32_t p1 = fabsf(buffer[upIdx]);//feature
            if (direction) {//+++++++++++++++++++++++++++++
                //если условие остановило в ++ то добиваем его до 0
                if ((buffer[upIdx] > 0 && !exitYN)) {
                    if (p1 > uPikVPlus) uPikVPlus = p1;
                    exit = 1;
                }
                //центральная точка
                if ((buffer[upIdx] > 0 && buffer[upIdx + 1] <= 0) && upIdx + 1 < FRAME_SIZE && !exitYN) {
                    uLastNullIdx = upIdx;
                }
                //если условие остановило в -- то добиваем его до 0 и выходим
                if ((buffer[upIdx] <= 0)) {
                    exitYN = 1; //не дадим пред условию сработать
                    if (p1 > uPikVMinus) uPikVMinus = p1;
                    exit = 1;
                }

            } else { //------------------------
                //going up
                //если условие остановило в -- то добиваем его до 0 и выходим
                if ((buffer[upIdx] <= 0 && !exitYN)) {
                    if (p1 > uPikVMinus) uPikVMinus = p1;
                    exit = 1;
                }
                //центральная точка
                if ((buffer[upIdx] <= 0 && buffer[upIdx + 1] > 0) && upIdx + 1 < FRAME_SIZE && !exitYN) {
                    uLastNullIdx = upIdx;
                }
                //если условие остановило в ++ то добиваем его до 0
                if ((buffer[upIdx] > 0)) {//
                    exitYN = 1; //не дадим пред условию сработать
                    if (p1 > uPikVPlus) uPikVPlus = p1;
                    exit = 1;
                }
            }
            if (upIdx + 1 < FRAME_SIZE && exit) upIdx++;
            else exit = 0;//выходим

        }//while
        if (upIdx + 1 == FRAME_SIZE) {} else upIdx -= 1;
        if (upIdx > i) { //если блок не пустой то...

            //upIdx -= 1;
            float32_t locNowAgc;


            if (uPikVPlus > uPikVMinus) {
                locNowAgc = max / (uPikVPlus ? uPikVPlus : 0.000001f);
                pikBuf = (uPikVPlus ? uPikVPlus : 0.000001f);
            } else {
                locNowAgc = max / (uPikVMinus ? uPikVMinus : 0.000001f);
                pikBuf = (uPikVMinus ? uPikVMinus : 0.000001f);
            }

            //типа среднее значение этого блока. исползуется для отката .
            rmsPik += (uPikVPlus + uPikVMinus) / 2.0f;
            pikCount++;//количество синусоид, нужен для расчета среднего пика по блоку
            //agcLevel == текущий уровень ару
            if (locNowAgc <= agcLevel) { // всплеск или питч V, идем вниз || wasVariant..........................
                stopGoingUp = 0;
                //заполним блок

                for (uint16_t z = i; z <= upIdx; z++) {//(upIdx+1==FRAME_SIZE?uLastNullIdx:upIdx)
                    buffer[z] *= locNowAgc;
                }


                //откат усиления назад по блоку
                //убират стук
                if (locNowAgc != agcLevel) {
                    uint16_t d = 0;
                    float32_t dx = locNowAgc / agcLevel;
                    if (i == 0) {

                        uint16_t dmax =(( (uint16_t) (FRAME_SIZE - uOldPStartIdx))) ;
                        uint16_t index = 1;
                        uint16_t srI=FRAME_SIZE/2;
                        if(dmax<50)dmax=200;
                        while (d < dmax-1) {
                            uint8_t o = (uint8_t) (dacTxBankNawNumber ? 0 : 1);
                            d++;

                            int buf0 = (int) (pOutDac[o][srI - index] >>16) - 2047;
                            int buf1 = (int) (pOutDac[o][srI - index] & 0x0000ffff) - 2047;

//                            if (d < FRAME_SIZE - uLastNullIdx && uLastNullIdx > 0)
//                                pOutDac[o][FRAME_SIZE - index] = ((uint32_t) (buf0 * dx + 2047)) << 16;
//                            else
                                pOutDac[o][srI - index] = ((uint32_t) (buf0 * (dx + d * (1 - dx) / dmax) + 2047))<< 16;

                            d++;
//                            if (d < FRAME_SIZE - uLastNullIdx && uLastNullIdx > 0)
//                                pOutDac[o][FRAME_SIZE - index] |= ((uint32_t) (buf1 * dx + 2047)) ;
//                            else
                                pOutDac[o][srI - index] |=
                                        ((uint32_t) (buf1 * (dx + d * (1 - dx) / dmax) + 2047)) ;

                            index++;
//                            pOutDac[o][srI - index]=0xffffffff;
                        }
                        // buffer[i]=0;
                    } else {
                        float32_t dmax = (i - uOldPStartIdx);
                        if (dmax <= 0 || uOldPStartIdx == 0) dmax = i;

                        while (d < dmax) {
                            d++;
                            buffer[i - d] *= dx + d * (1 - dx) / dmax;
                        }

                    }
                }
                //питч детектор
                stopGoingUp = 0;
                //tim = wait;//задежка отпускания
                if ((pit2 < pit1 && pit1 < pikBuf)) {//не питч
                    tim = wait;
                }
                agcLevel = locNowAgc;
                pit2 = pit1;
                pit1 = pikBuf;

            } else {//идем вверх/////////////////////////////////////////////////////////////////////
                float32_t cc;
                float32_t sred = agcLevel / locNowAgc;
                float32_t rmsNow = (rmsFrame + rmsPik / pikCount) / 2.0f;
                float32_t oldAgcLevel = agcLevel;

                if (tim == 0 && upIdx + 10 < FRAME_SIZE && i > 100) {//подождали и начинаем x
                    cc = agcLevel + (sred / rmsNow) / 50.5f;
                    //проверим можем нет еще откатить
                    if (pikBuf * cc < max - 0.2f && !stopGoingUp) {//дельта отката 0.4
                        agcLevel = cc;
                    } else {
                        stopGoingUp = 1; //остановить откат
                    }
                }
                float32_t kof = agcLevel / oldAgcLevel;
                uint16_t dmax = (upIdx - i);

                //заполним период
                for (uint16_t z = i; z <= upIdx; z++) {
                    buffer[z] *= oldAgcLevel * (kof + (upIdx - z) * (1 - kof) / dmax);//применить новый коэфф

                }
            }
            uOldPStartIdx = i;
            i = upIdx; // след цикл будет стратовать от upIdx
        } else { //это сетуация редкая но тоже надо . сделано по класике одного замера
            stopGoingUp = 0;
            if (nowAgc < agcLevel) { // всплеск V
                // tim = wait;//задежка отпускания
                buffer[i] *= nowAgc;
            } else {
                buffer[i] *= agcLevel;
            }
            uOldPStartIdx = i;

        }
        uLastNullIdx = 0; //на случай если больше не будет центра


        if (a > agcMetrTemp) agcMetrTemp = a; //s-meter макс V
    }//for
    // buffer[0] = 0;
    //средний V за этот блок и прошлые (отсчет по пикам)
    //нужен для ограничения усиления при снятия сигнала
    float32_t mm = rmsPik / pikCount;

    if (mm > rmsFrame)rmsFrame = mm;
    else rmsFrame = (rmsFrame + mm) / 2.0f;

    agcMetr = agcMetrTemp; //s-meter
}


[ra0ahc]

Убрал все лишнее и написал коменты

Код: [Выделить]

loat32_t max = 0.49905586f; //максималка 0.49975586fот -0.5 до +0.5 примерно для 12 бит
uint16_t count = 100;
uint8_t stopGoingUp = 0;

float32_t rmsFrame = 0;
uint16_t uOldPStartIdx;
uint16_t wait = 20;//задержка возврата ару, в блоках 40мс каждый блок

///@brief АРУ
///@param buffer
void agcDo(float32_t *buffer) {
    float32_t rmsPik = 0;
    float32_t agcMetrTemp = 0;
    float32_t pit1 = -1;
    float32_t pit2 = 0;
    uint16_t pikCount = 0;
    if (tim > 0)tim--; //уменьшение задержки
    stopGoingUp = 0;


    for (uint16_t i = 0; i < FRAME_SIZE; i++) {
        float32_t a;
        a = fabsf(buffer[i]);
        if (a > 0)nowAgc = max / a;
        else nowAgc = max / (a?a:0.000005f);

        uint16_t upIdx = i;
        float32_t pikBuf = 0;
        uint8_t exit = 1;
        uint8_t exitYN = 0;
        //direction
         int direction = 1;// напрвление вверх (положительная синусоида)
        if (i + 1 < FRAME_SIZE) {
            if (buffer[i] <= 0 || buffer[i + 1] < 0) direction = 0;//напрвление вниз (отрицательная синусоида)
        } else {
            if (buffer[i] <= 0 || buffer[i - 1] > 0) direction = 0;//напрвление вниз (отрицательная синусоида)
        }

        while (exit) { //поиск пика в блоке от 0 до 0
            exit = 0;//выходим
            float32_t p1 = fabsf(buffer[upIdx]);//feature
            if (direction) {//+++++++++++++++++++++++++++++
                if ((buffer[upIdx] > 0 && !exitYN)) {
                    if (p1 > pikBuf) pikBuf = p1;
                    exit = 1;
                }
                if (buffer[upIdx] <=0 ) {// добиваем его до 0 и выходим
                    exitYN = 1; //не дадим пред условию сработать
                    if (p1 > pikBuf) pikBuf = p1;
                    exit = 1;
                }

            } else { //------------------------
                //going up
                if ((buffer[upIdx] <= 0 && !exitYN)) {
                    if (p1 > pikBuf) pikBuf = p1;
                    exit = 1;
                }
                if (buffer[upIdx] >0 ) {// добиваем его до 0
                    exitYN = 1; //не дадим пред условию сработать
                    if (p1 > pikBuf) pikBuf = p1;
                    exit = 1;
                }
            }
            if (upIdx + 1 < FRAME_SIZE && exit) upIdx++;
            else exit = 0;//выходим

        }//while
        if (upIdx + 1 == FRAME_SIZE) {} else upIdx -= 1;
        if (upIdx > i) { //если блок не пустой то...

            //upIdx -= 1;
            float32_t locNowAgc;
            locNowAgc = max / (pikBuf ? pikBuf : 0.000001f);

            //типа среднее значение этого блока. используется для отката .
            rmsPik += pikBuf;
            pikCount++;//количество синусоид, нужен для расчета среднего пика по блоку
            //agcLevel == текущий уровень ару
            if (locNowAgc <= agcLevel) { // всплеск или питч V, идем вниз ..........................
                stopGoingUp = 0;
                //заполним блок
                for (uint16_t z = i; z <= upIdx; z++) {
                    buffer[z] *= locNowAgc;
                }

                //откат усиления назад по блоку
                //убирает стук
                if (locNowAgc != agcLevel) {
                    uint16_t d = 0;
                    float32_t dx = locNowAgc / agcLevel;
                    //если начало фрэйма
                    if (i == 0) {//лезим в старый буфер который уже летит в цап
                        uint16_t dmax = (uint16_t) (FRAME_SIZE - uOldPStartIdx);
                        uint16_t index = 1;
                        uint16_t srI = FRAME_SIZE / 2;//в цап летят 16 битные данные
                        if (dmax < 50)dmax = 200;//нагло , можно уменьшить
                        while (d < dmax - 1) {
                            uint8_t o = (uint8_t) (dacTxBankNawNumber ? 0 : 1);
                            d++;
                            //плавное уменьшение  назад по старомы фрейму от dx до 1
                            int buf0 = (int) (pOutDac[o][srI - index] >> 16) - 2047;
                            int buf1 = (int) (pOutDac[o][srI - index] & 0x0000ffff) - 2047;
                            //первые 16 бит
                            pOutDac[o][srI - index] = ((uint32_t) (buf0 * (dx + d * (1 - dx) / dmax) + 2047)) << 16;

                            d++;
                            //вторые 16 бит
                            pOutDac[o][srI - index] |=
                                    ((uint32_t) (buf1 * (dx + d * (1 - dx) / dmax) + 2047));
                            index++;
                        }
                    } else {//просто откат на один период с уменьшением.
                        float32_t dmax = (i - uOldPStartIdx);
                        if (dmax <= 0 || uOldPStartIdx == 0) dmax = i;
                        //плавное уменьшение  назад по фрейму от dx до 1
                        while (d < dmax) {
                            d++;
                            buffer[i - d] *= dx + d * (1 - dx) / dmax;
                        }
                    }
                }
                stopGoingUp = 0;
                //питч детектор
                //нужно добавить еще уменьшение скорости отката и потом его возрат
                //для полной обработки питчиков
                if ((pit2 < pit1 && pit1 < pikBuf)) {//не питч
                    tim = wait;
                }
                agcLevel = locNowAgc;
                pit2 = pit1;
                pit1 = pikBuf;

            } else {//идем вверх/////////////////////////////////////////////////////////////////////
                float32_t cc;
                float32_t sred = agcLevel / locNowAgc;
                float32_t rmsNow = (rmsFrame + rmsPik / pikCount) / 2.0f;
                float32_t oldAgcLevel = agcLevel;
                //первый период и последний не поднимаем
                if (tim == 0 && upIdx + 10 < FRAME_SIZE && i > 100) {//подождали и начинаем x
                    cc = agcLevel + (sred / rmsNow) / 50.5f; // скорость отката 200...0.5
                    //проверим можем нет еще откатить
                    if (pikBuf * cc < max - 0.2f && !stopGoingUp) {//дельта ВОРОТА  0.3=8дб
                        agcLevel = cc;
                    } else {
                        stopGoingUp = 1; //остановить откат
                    }
                }
                float32_t kof = agcLevel / oldAgcLevel;
                uint16_t dmax = (upIdx - i);

                //заполним период , плавно!!!
                for (uint16_t z = i; z <= upIdx; z++) {
                    buffer[z] *= oldAgcLevel * (kof + (upIdx - z) * (1 - kof) / dmax);//применить новый коэфф
                }
            }
            uOldPStartIdx = i;
            i = upIdx; // след цикл будет стратовать от upIdx
        } else { //это ситуация редкая, но тоже надо . сделано по класике одного замера
            stopGoingUp = 0;
            if (nowAgc < agcLevel) buffer[i] *= nowAgc;
            else buffer[i] *= agcLevel;
            uOldPStartIdx = i;
        }
        if (a > agcMetrTemp) agcMetrTemp = a; //s-meter макс V
    }//for
    //средний V за этот блок и прошлые (отсчет по пикам)
    //нужен для ограничения усиления при снятия сигнала
    float32_t mm = rmsPik / pikCount;

    if (mm > rmsFrame)rmsFrame = mm;
    else rmsFrame = (rmsFrame + mm) / 2.0f;

    agcMetr = agcMetrTemp; //s-meter
}


[6Ж2П]

Скорость АРУ - нормальная. Ворота 4дб. Задержка на отпускания 100мс

Вы обрезаете ось времени на спектрограмме? Не видно интервалы времени.
Что за сигнал подаёте?
По спектрограмме видно, что АРУ в постоянной работе у Вас, спектр постоянно разлетается на всю высоту (ширину полосы 7 кГц)

[ra0ahc]

Он и будет разливаться вы же сами говорили. Просто раньше прям ступеньки проскакивали и их капец как слышно , а сегодня я победил их. Вверху чёрный водопад и на нем видно разлив на сколько.
Там фишка в чем с этим разливом: если нужно резко убрать усиление то мы умножаем на понижающий коэффициент часть фрейма у меня это один период от 0 до 0. Так появляются изломы ко лове спектр разливаю жестко и далеко и его слышно хоть и нет перегрузки по напряжению , просто цок в наушниках и все. Так вот, мне нужно сгладить этот перелом . Я беру и начинаю идти обратно плавно изменяя этот коэффициент. Эта обратная дороги моде в один период выйти , а может и в пару мс. И чем плавнее мы идём тем меньше разлив. Пока все просто . Теперь возьмём крайние варианты, а точнее переход между фреймами, там самое веселое было прогнать плавным коэффициентом. Прогнал - заработало. Теперь нам надо сделать тоже само с тем когда сил ней сигнал уходит и нам надо усилить сигнал тоже перемножив его на коэффициент. И там тоже происходит разлив спектра , поэтому я и там сделал плавный коэффициент и всё получилось.

[6Ж2П]

Не смотрел, как у Вас в коде написано, потому мог не так понять со слов, но показалось, что делаете подобное тому, как я графики обрабатываю. Прохожу по всем значениям весовой функцией а-ля кривая Гаусса, только количество точек маленькое - 5, 7.
Вы не откомментировали, почему АРУ постоянно в работе, что за сигнал?

[ra0ahc]

Интересные у вас задачки , я про ваши графики. Вроде что то подобное для фильтрация импульс использовать надо. Рисуем ачх потом как раз проходим импульсом по нему и типа фильтр готов.

Про ару

Я специально загнал ару в самый жесткий режим : почти мгновенный откат, 0дб ворота- типа плоский эфир, 0 время задержки (вообще не ждём и сразу после снятия сигнала начинаем поднимать усиление) . По этому кажется что ару постоянно работает ... хотя так и есть.  Сигнал реального эфира с вэб сдр Тульского сайта, там я отключаю ихнее ару и на вход своей платы завожу сигнал без ару , и уже ару работает в моей платке. Понятно , что я не смогу получить такую же чуйку из-за 12 битного ацп у меня, ну да не суть , я же ару делал с не приставку к компу. Этот алгоритм может быть будет работать в ddc трансивере на базе Аиста с новым процессором.

[ra0ahc]

Немного теории.

[veso74]

скорее так (см. ниже):

"АРУ с задержкой" звучит лучше, где "угол преломления" около RS: 56-58.
Так не теряем усиление при слабых сигналах, а эфир чист, "прозрачен" на низких уровнях, и уровень немного повышается на сильных (напр. не нужно смотреть на S-метр, кто сильнее), а и усиление в ограничение никогда не доходит, даже при самых сильных входных сигналах.

диаграмма взята из:
Исследование систем автоматической регулировки усиления (ару) и автоматической подстройки частоты (апч)

[ra0ahc]

Нет, Веселин, это другое. Нам же нужно тихий сигнал поднимать до уровня идеальной ару прямо с самого 0. Нам надо слышать "шум эфира" . Нет там на выходе спада выходного сигнала на наушники до 0, мы всегда слышим шум достаточной громкости.

[ra0ahc]

"АРУ с задержкой" звучит лучше,

Даже спорить не буду. Просто задержку во времени сложно изобразить. Она (задержка) будет задерживать откат усиления после снятия сильного сигнала. Хотя это всего лишь переменная настройки АРУ - можно делать и "с" и "без" задержки

[veso74]

Да, "АРУ с задержкой" точно так, см. начало х-ки.

А "задержка" в имени (и в действии), ето задержка по уровень (реакции по уровень), а не по время (откат усиления после снятия сильного сигнала).

(А все действия условно без задержки по время реакции. Если необходимо - то интегратор: аналоговой или у вас - с цифровой метод: повторяем или постепенно уменьшаем уровень с нач. уровнем предыдущего накопления)). Пфу, нет у меня русс. слова, вероятно говорим для тех же вещей, но теряется при переводе BG-RU, RU-BG, sorry).

[ra0ahc]

График не правильный. Увы, но в нем ошибка. Либо мы в терминологии запутались.
Я имею ввиду, что если вытащить антенну , то мы услышим шум точно такой же , что и с антенной (понятно другого оттенка) по уровню. А на этом графике, если вытащить антенну то в наушниках будет 0. Понятно, что это можно регулировать "воротами", что собственно и сделано. Из экспериментов я пришел к выводу, что 7-9дб ворот -это в самый раз. 

[ra0ahc]

А "задержка" в имени (и в действии)

А зачем она? Это пережитки аналогового радио, там всегда будет всплеск работы ару из-за задержак работы цепей обратной связи (скаты кф и эмф)
Кстати, он всегда "бьет по ушам"

[veso74]

там всегда будет всплеск работы ару

Ето всплеск только при АРУ при НЧ детекция сигнала для АРУ.
При детекция по ПЧ нет такой. Почему запутались не знаю, там реакция мгновенная (начальная).

Послушайте, померите какое нибудь старое радио. Там у почти всех АРУ с детекция с помощью ПЧ сигнала.
Всплеск началной нет. Мгновенно.

Точно "удар по ушам" мне не нравится в АРУ по НЧ, и он только при НЧ-АРУ, где сигнал для рег. цепь взят через детекция НЧ.

(при детектор по ПЧ: "есть много полу-синусоид за эти напр. 0,1 микросекунды".
при детектор по НЧ (300-3000 Hz) полу-синусоид для детекции примерно 1000...3000 раза меньше)
А если предположить, что энергия больше в басах, отношение становится довольно грубо.

[ra0ahc]

Немного истории 
Всё-таки 5 вариантов было. Учитывая полное отсутствие практики в математики , пришлось на «пальцах» саму себе помогать