ComIntCmd_Amplifier/ComIntAmplifierGet.c

//
// Created by cfif on 03.06.2024.
//
#include "ComIntAmplifier.h"
#include "string.h"
#include "Amplifier_AW87579.h"



uint8_t XfcProtMethod_GetAmplVar(tXfcArray *request, tXfcArray *response, tXfcAmplifier *env, char *paramValueID_text, uint8_t paramValueID_len) {
    // Текстовый вид ID
    XFC_CMD_TX_ADD_RAW(paramValueID_len);
    XFC_CMD_TX_ADD_ARR(paramValueID_text, paramValueID_len);

    if (memcmp(paramValueID_text, "POWER", sizeof("POWER") - 1) == 0) {
        uint8_t len = 2;
        uint16_t index;
        if(*env->amplifier->speakTestAcsess == true){
            env->powerMode = false;
            index = 0;
        } else {
            env->powerMode = true;
            index = 1;
        }
        // Размер данных
        XFC_CMD_TX_ADD_RAW(len);
        // Данные
        XFC_CMD_TX_ADD_ARR(&index, len);

        return true;
    }

    if (memcmp(paramValueID_text, "LEVEL", sizeof("LEVEL") - 1) == 0) {
        uint16_t index;
        if(*env->amplifier->speakTestAcsess == true){
            uint8_t len = 2;
            index = 0;
            // Размер данных
            XFC_CMD_TX_ADD_RAW(len);
            // Данные
            XFC_CMD_TX_ADD_ARR(&index, len);
        } else {
            uint8_t len = 2;
            // Размер данных
            XFC_CMD_TX_ADD_RAW(len);
            // Данные
            index = ProtMethods_AmplGetLvlVolumeIndex(env->amplifier,env->geinControl.level);
            XFC_CMD_TX_ADD_ARR(&index, len);
        }
        return true;
    }

    if (memcmp(paramValueID_text, "VOLTAGE", sizeof("VOLTAGE") - 1) == 0) {
        uint16_t index;
        if(*env->amplifier->speakTestAcsess == true){
            uint8_t len = 2;
            index = 0;
            // Размер данных
            XFC_CMD_TX_ADD_RAW(len);
            // Данные
            XFC_CMD_TX_ADD_ARR(&index, len);
        } else {
            uint8_t len = 2;
            // Размер данных
            XFC_CMD_TX_ADD_RAW(len);
            // Данные
            index = ProtMethods_AmplGetLvlVoltIndex(env->amplifier,env->geinControl.voltage);
            XFC_CMD_TX_ADD_ARR(&index, len);
        }
        return true;
    }

    if (memcmp(paramValueID_text, "AMPER", sizeof("AMPER") - 1) == 0) {
        int16_t index;
        if(*env->amplifier->speakTestAcsess == true){
            uint8_t len = 2;
            // Размер данных
            XFC_CMD_TX_ADD_RAW(len);
            // Данные
            index = 1;
            XFC_CMD_TX_ADD_ARR(&index, len);
        } else {
            uint8_t len = 2;
            // Размер данных
            XFC_CMD_TX_ADD_RAW(len);
            // Данные
            index = ProtMethods_AmplGetLvlAmperIndex(env->amplifier,env->geinControl.amper);
            XFC_CMD_TX_ADD_ARR(&index, len);
        }
        return true;
    }

    if (memcmp(paramValueID_text, "LOW_STEP", sizeof("LOW_STEP") - 1) == 0) {
        uint16_t index;
        if(*env->amplifier->speakTestAcsess == true){
            index = 0;
            uint8_t len = 2;
            // Размер данных
            XFC_CMD_TX_ADD_RAW(len);
            // Данные
            XFC_CMD_TX_ADD_ARR(&index, len);
        } else {
            uint8_t len = 2;
            // Размер данных
            XFC_CMD_TX_ADD_RAW(len);
            // Данные
            index = ProtMethods_AmplGetADP_BoostStep(env->amplifier,env->adptBoostVTH.boost_step);
            XFC_CMD_TX_ADD_ARR(&index, len);
        }
        return true;
    }

    if (memcmp(paramValueID_text, "BOOST_VTH1", sizeof("BOOST_VTH1") - 1) == 0) {
        uint16_t index;
        if(*env->amplifier->speakTestAcsess == true){
            uint8_t len = 2;
            index = 0;
            // Размер данных
            XFC_CMD_TX_ADD_RAW(len);
            // Данные
            XFC_CMD_TX_ADD_ARR(&index, len);
        } else {
            uint8_t len = 2;
            // Размер данных
            XFC_CMD_TX_ADD_RAW(len);
            // Данные
            index = ProtMethods_AmplGetADP_BoostVTH1(env->amplifier,env->adptBoostVTH.boost_vth1);
            XFC_CMD_TX_ADD_ARR(&index, len);
        }
        return true;
    }

    if (memcmp(paramValueID_text, "BOOST_VTH2", sizeof("BOOST_VTH2") - 1) == 0) {
        uint16_t index;
        if(*env->amplifier->speakTestAcsess == true){
            uint8_t len = 2;
            index = 0;
            // Размер данных
            XFC_CMD_TX_ADD_RAW(len);
            // Данные
            XFC_CMD_TX_ADD_ARR(&index, len);
        } else {
            uint8_t len = 2;
            // Размер данных
            XFC_CMD_TX_ADD_RAW(len);
            // Данные
            index = ProtMethods_AmplGetADP_BoostVTH2(env->amplifier,env->adptBoostVTH.boost_vth2);
            XFC_CMD_TX_ADD_ARR(&index, len);
        }
        return true;
    }

    if (memcmp(paramValueID_text, "ADP_MODE", sizeof("ADP_MODE") - 1) == 0) {
        uint16_t index;
        if(*env->amplifier->speakTestAcsess == true){
            uint8_t len = 2;
            index = 0;
            // Размер данных
            XFC_CMD_TX_ADD_RAW(len);
            // Данные
            XFC_CMD_TX_ADD_ARR(&index, len);
        } else {
            uint8_t len = 2;
            // Размер данных
            XFC_CMD_TX_ADD_RAW(len);
            // Данные
            index = ProtMethods_AmplGetADP_BoostMode(env->amplifier,env->adpMode.level);
            XFC_CMD_TX_ADD_ARR(&index, len);
        }
        return true;
    }

    ///================= CLASS D AGC2 OUTPUT POWER (AGC2_Po) REGISTER (ADDRESS: 0x09 DEFAULT:0x03) =================
    if (memcmp(paramValueID_text, "PD_AGC3_OPR_STATE", sizeof("PD_AGC3_OPR_STATE") - 1) == 0) {
        uint16_t index;
        if(*env->amplifier->speakTestAcsess == true){
            uint8_t len = 2;
            index = 0;
            // Размер данных
            XFC_CMD_TX_ADD_RAW(len);
            // Данные
            XFC_CMD_TX_ADD_ARR(&index, len);
        } else {
            uint8_t len = 2;
            // Размер данных
            XFC_CMD_TX_ADD_RAW(len);
            // Данные
            index = env->agc3_opr.state;
            XFC_CMD_TX_ADD_ARR(&index, len);
        }
        return true;
    }

    if (memcmp(paramValueID_text, "AGC3_OPR_OUTPUT_POWER_LEVEL", sizeof("AGC3_OPR_OUTPUT_POWER_LEVEL") - 1) == 0) {
        uint16_t index;
        if(*env->amplifier->speakTestAcsess == true){
            uint8_t len = 2;
            index = 0;
            // Размер данных
            XFC_CMD_TX_ADD_RAW(len);
            // Данные
            XFC_CMD_TX_ADD_ARR(&index, len);
        } else {
            uint8_t len = 2;
            // Размер данных
            XFC_CMD_TX_ADD_RAW(len);
            // Данные
            index = ProtMethods_AmplGetAGC3_OutPower(env->amplifier,env->agc3_opr.out_power);
            XFC_CMD_TX_ADD_ARR(&index, len);
        }
        return true;
    }

    ///================= CLASS D AGC3 PARAMETER (AGC3) REGISTER (ADDRESS: 0x08 DEFAULT:0x4E) =================
    if (memcmp(paramValueID_text, "AGC3_REL_TIME", sizeof("AGC3_REL_TIME") - 1) == 0) {
        uint16_t index;
        if(*env->amplifier->speakTestAcsess == true){
            uint8_t len = 2;
            index = 0;
            // Размер данных
            XFC_CMD_TX_ADD_RAW(len);
            // Данные
            XFC_CMD_TX_ADD_ARR(&index, len);
        } else {
            uint8_t len = 2;
            // Размер данных
            XFC_CMD_TX_ADD_RAW(len);
            // Данные
            index = ProtMethods_AmplGetAGC3_RelTime(env->amplifier,env->aAgc3.relTime);
            XFC_CMD_TX_ADD_ARR(&index, len);
        }
        return true;
    }

    if (memcmp(paramValueID_text, "AGC3_ATT_TIME", sizeof("AGC3_ATT_TIME") - 1) == 0) {
        uint16_t index;
        if(*env->amplifier->speakTestAcsess == true){
            uint8_t len = 2;
            index = 0;
            // Размер данных
            XFC_CMD_TX_ADD_RAW(len);
            // Данные
            XFC_CMD_TX_ADD_ARR(&index, len);
        } else {
            uint8_t len = 2;
            // Размер данных
            XFC_CMD_TX_ADD_RAW(len);
            // Данные
            index = ProtMethods_AmplGetAGC3_AttTime(env->amplifier,env->aAgc3.attTime);
            XFC_CMD_TX_ADD_ARR(&index, len);
        }
        return true;
    }

    ///================= AGC1 PARAMETER (AGC1) REGISTER (ADDRESS: 0x0B) =================
    if (memcmp(paramValueID_text, "AGC1_ATT_TIMEA", sizeof("AGC1_ATT_TIMEA") - 1) == 0) {
        uint16_t index;
        if(*env->amplifier->speakTestAcsess == true){
            uint8_t len = 2;
            index = 0;
            // Размер данных
            XFC_CMD_TX_ADD_RAW(len);
            // Данные
            XFC_CMD_TX_ADD_ARR(&index, len);
        } else {
            uint8_t len = 2;
            // Размер данных
            XFC_CMD_TX_ADD_RAW(len);
            // Данные
            index = ProtMethods_AmplGetAGC1_AttackTime(env->amplifier,env->agc1.attackTime);
            XFC_CMD_TX_ADD_ARR(&index, len);
        }
        return true;
    }

    if (memcmp(paramValueID_text, "PD_AGC1_STATE", sizeof("PD_AGC1_STATE") - 1) == 0) {
        uint16_t index;
        if(*env->amplifier->speakTestAcsess == true){
            uint8_t len = 2;
            index = 0;
            // Размер данных
            XFC_CMD_TX_ADD_RAW(len);
            // Данные
            XFC_CMD_TX_ADD_ARR(&index, len);
        } else {
            uint8_t len = 2;
            // Размер данных
            XFC_CMD_TX_ADD_RAW(len);
            // Данные
            index = env->agc1.state;
            XFC_CMD_TX_ADD_ARR(&index, len);
        }
        return true;
    }

    if (memcmp(paramValueID_text, "AGC2_OUTPUT_POWER_LEVEL", sizeof("AGC2_OUTPUT_POWER_LEVEL") - 1) == 0) {
        uint16_t index;
        if(*env->amplifier->speakTestAcsess == true){
            uint8_t len = 2;
            index = 0;
            // Размер данных
            XFC_CMD_TX_ADD_RAW(len);
            // Данные
            XFC_CMD_TX_ADD_ARR(&index, len);
        } else {
            uint8_t len = 2;
            // Размер данных
            XFC_CMD_TX_ADD_RAW(len);
            // Данные
            index = ProtMethods_AmplGetAGC2_OutPower(env->amplifier,env->agc2opr.out_power);
            XFC_CMD_TX_ADD_ARR(&index, len);
        }
        return true;
    }

    if (memcmp(paramValueID_text, "AGC2_ATT_TIME_VALUE", sizeof("AGC2_ATT_TIME_VALUE") - 1) == 0) {
        uint16_t index;
        if(*env->amplifier->speakTestAcsess == true){
            uint8_t len = 2;
            index = 0;
            // Размер данных
            XFC_CMD_TX_ADD_RAW(len);
            // Данные
            XFC_CMD_TX_ADD_ARR(&index, len);
        } else {
            uint8_t len = 2;
            // Размер данных
            XFC_CMD_TX_ADD_RAW(len);
            // Данные
            index = ProtMethods_AmplGetAGC2_AttTime(env->amplifier,env->aAgc2.attTime);
            XFC_CMD_TX_ADD_ARR(&index, len);
        }
        return true;
    }

    if (memcmp(paramValueID_text, "EN_BOOST", sizeof("EN_BOOST") - 1) == 0) {
        uint16_t index;
        if(env->enBoost.state){
            index = 1;
        } else {
            index = 0;
        }

        if(*env->amplifier->speakTestAcsess == true){
            uint8_t len = 2;
            index = 0;
            // Размер данных
            XFC_CMD_TX_ADD_RAW(len);
            // Данные
            XFC_CMD_TX_ADD_ARR(&index, len);
        } else {
            uint8_t len = 2;
            // Размер данных
            XFC_CMD_TX_ADD_RAW(len);
            // Данные
//            index = env->enBoost.state;// ProtMethods_AmplGetEN_Boost(env->amplifier,env->enBoost.state);
            XFC_CMD_TX_ADD_ARR(&index, len);
        }
        return true;
    }

    return false;
}

void XfcProtMethod_GetADPBoostVTH(tXfcAmplifier *env) {
    tAW87579_ADPBST_VTH adpbstVth;
    uint8_t tmp;
    xAmplifierAW87579_GetADPBoostVthReg(env->amplifier->amplIoBus, &tmp);
    adpbstVth.data = tmp;
    env->adptBoostVTH.boost_step = adpbstVth.ADP_LOW_STEP;
    env->adptBoostVTH.boost_vth1 = adpbstVth.SET_BOOST_VTH1;
    env->adptBoostVTH.boost_vth2 = adpbstVth.SET_BOOST_VTH2;
}

void XfcProtMethod_GetADPMode(tXfcAmplifier *env) {
    tAW87579_ADP_MODE adpbstMode;
    uint8_t tmp;
    xAmplifierAW87579_GetADPBoostModeReg(env->amplifier->amplIoBus, &tmp);
    adpbstMode.data = tmp;
    env->adpMode.level  = adpbstMode.ADPBOOST_MODE;
}

void XfcProtMethod_GetAGC1ParamReg(tXfcAmplifier *env) {
    tAW87579_PAGC1PR Agc1Mode;
    uint8_t tmp;
    xAmplifierAW87579_GetADG1ModeReg(env->amplifier->amplIoBus, &tmp);
    Agc1Mode.data = tmp;
    env->agc1.attackTime = Agc1Mode.AGC1_ATT_TIME;
    env->agc1.state = Agc1Mode.PD_AGC1;
}

void XfcProtMethod_GetAGC3OprParamReg(tXfcAmplifier *env) {
    tAW87579_PAGC3OPR Agc3Mode;
    uint8_t tmp;
    xAmplifierAW87579_GetADG3ModeOpReg(env->amplifier->amplIoBus, &tmp);
    Agc3Mode.data = tmp;
    env->agc3_opr.out_power = Agc3Mode.AGC3_OUTPUT_POWER;
    env->agc3_opr.state  = Agc3Mode.PD_AGC3;
}

void XfcProtMethod_GetAGC2OprParamReg(tXfcAmplifier *env) {
    tAW87579_PAGC2OPR  Agc2OprMode;
    uint8_t tmp;
    XfcProtMethod_GetAGC2OprParamModeReg(env->amplifier->amplIoBus, &tmp);
    Agc2OprMode.data = tmp;
    env->agc2opr.out_power = Agc2OprMode.AGC2_OUTPUT_POWER;
}

void XfcProtMethod_GetEnBoost(tXfcAmplifier *env) {
    tAW87579_SYSCTR SysCtrl;
    uint8_t tmp;
    XfcProtMethod_GetEnBoostReg(env->amplifier->amplIoBus, &tmp);
    SysCtrl.data = tmp;
    env->enBoost.state = SysCtrl.EN_BOOST;
}

void XfcProtMethod_GetAGC2ParamReg(tXfcAmplifier *env) {
    tAW87579_PAGC2PR Agc2Mode;
    uint8_t tmp;
    XfcProtMethod_GetAGC2ParamModeReg(env->amplifier->amplIoBus, &tmp);
    Agc2Mode.data = tmp;
    env->aAgc2.attTime = Agc2Mode.AGC2_ATT_TIME;
}

void XfcProtMethod_GetAGC3ParamReg(tXfcAmplifier *env) {
    tAW87579_PAGC3PR Agc3Mode;
    uint8_t tmp;
    xAmplifierAW87579_GetADG3ModeReg(env->amplifier->amplIoBus, &tmp);
    Agc3Mode.data = tmp;
    env->aAgc3.relTime  = Agc3Mode.AGC3_REL_TIME;
    env->aAgc3.attTime   = Agc3Mode.AGC3_ATT_TIME;
}

uint8_t XfcProtMethod_AmplifierGet(tXfcArray *request, tXfcArray *response, tXfcAmplifier *env) {
    xAmplifierAW87579_GetGainControlReg(env->amplifier->amplIoBus, (uint8_t*)&env->geinControl.level);
    xAmplifierAW87579_GetBoostControlReg(env->amplifier->amplIoBus, (uint8_t*)&env->geinControl.amper);
    xAmplifierAW87579_GetBoostOutputVoltageReg(env->amplifier->amplIoBus, (uint8_t*)&env->geinControl.voltage);

    XfcProtMethod_GetADPBoostVTH(env);
    XfcProtMethod_GetADPMode(env);
    XfcProtMethod_GetAGC1ParamReg(env);
    XfcProtMethod_GetAGC3OprParamReg(env);
    XfcProtMethod_GetAGC3ParamReg(env);
    XfcProtMethod_GetAGC2OprParamReg(env);
    XfcProtMethod_GetAGC2ParamReg(env);
    XfcProtMethod_GetEnBoost(env);

    // Чтение всех параметров
    if (XfcArrayGetDataSize(request) == 0) {

        uint16_t paramCount = 16;
        // Количество параметров
        XFC_CMD_TX_ADD_RAW(paramCount);

        uint8_t paramValueID_len;
        char paramValueID_text[30];

        ///================================= POWER MODE =================================
        paramValueID_len = sizeof("POWER") - 1;
        paramValueID_text[0] = '\0';
        strcat(paramValueID_text, "POWER");
        if (!XfcProtMethod_GetAmplVar(request, response, env, paramValueID_text, paramValueID_len)) {
            return XFC_TRANSPORT_PROTOCOL_RESPONSE_RESULT_EXECUTION_ERROR;
        }

        ///================================= VOLTS - AMPERS - LEVEL _ CONTROLS ==========
        paramValueID_len = sizeof("LEVEL") - 1;
        paramValueID_text[0] = '\0';
        strcat(paramValueID_text, "LEVEL");
        if (!XfcProtMethod_GetAmplVar(request, response, env, paramValueID_text, paramValueID_len)) {
            return XFC_TRANSPORT_PROTOCOL_RESPONSE_RESULT_EXECUTION_ERROR;
        }

        paramValueID_len = sizeof("VOLTAGE") - 1;
        paramValueID_text[0] = '\0';
        strcat(paramValueID_text, "VOLTAGE");
        if (!XfcProtMethod_GetAmplVar(request, response, env, paramValueID_text, paramValueID_len)) {
            return XFC_TRANSPORT_PROTOCOL_RESPONSE_RESULT_EXECUTION_ERROR;
        }

        paramValueID_len = sizeof("AMPER") - 1;
        paramValueID_text[0] = '\0';
        strcat(paramValueID_text, "AMPER");
        if (!XfcProtMethod_GetAmplVar(request, response, env, paramValueID_text, paramValueID_len)) {
            return XFC_TRANSPORT_PROTOCOL_RESPONSE_RESULT_EXECUTION_ERROR;
        }

        ///================================= ADP BOOST MODE =================================
        paramValueID_len = sizeof("LOW_STEP") - 1;
        paramValueID_text[0] = '\0';
        strcat(paramValueID_text, "LOW_STEP");
        if (!XfcProtMethod_GetAmplVar(request, response, env, paramValueID_text, paramValueID_len)) {
            return XFC_TRANSPORT_PROTOCOL_RESPONSE_RESULT_EXECUTION_ERROR;
        }

        paramValueID_len = sizeof("BOOST_VTH1") - 1;
        paramValueID_text[0] = '\0';
        strcat(paramValueID_text, "BOOST_VTH1");
        if (!XfcProtMethod_GetAmplVar(request, response, env, paramValueID_text, paramValueID_len)) {
            return XFC_TRANSPORT_PROTOCOL_RESPONSE_RESULT_EXECUTION_ERROR;
        }

        paramValueID_len = sizeof("BOOST_VTH2") - 1;
        paramValueID_text[0] = '\0';
        strcat(paramValueID_text, "BOOST_VTH2");
        if (!XfcProtMethod_GetAmplVar(request, response, env, paramValueID_text, paramValueID_len)) {
            return XFC_TRANSPORT_PROTOCOL_RESPONSE_RESULT_EXECUTION_ERROR;
        }

        ///================================= ADP MODE =================================
        paramValueID_len = sizeof("ADP_MODE") - 1;
        paramValueID_text[0] = '\0';
        strcat(paramValueID_text, "ADP_MODE");
        if (!XfcProtMethod_GetAmplVar(request, response, env, paramValueID_text, paramValueID_len)) {
            return XFC_TRANSPORT_PROTOCOL_RESPONSE_RESULT_EXECUTION_ERROR;
        }

        ///================= AGC1 PARAMETER (AGC1) REGISTER (ADDRESS: 0x0B) =================
        paramValueID_len = sizeof("AGC1_ATT_TIMEA") - 1;
        paramValueID_text[0] = '\0';
        strcat(paramValueID_text, "AGC1_ATT_TIMEA");
        if (!XfcProtMethod_GetAmplVar(request, response, env, paramValueID_text, paramValueID_len)) {
            return XFC_TRANSPORT_PROTOCOL_RESPONSE_RESULT_EXECUTION_ERROR;
        }

        paramValueID_len = sizeof("PD_AGC1_STATE") - 1;
        paramValueID_text[0] = '\0';
        strcat(paramValueID_text, "PD_AGC1_STATE");
        if (!XfcProtMethod_GetAmplVar(request, response, env, paramValueID_text, paramValueID_len)) {
            return XFC_TRANSPORT_PROTOCOL_RESPONSE_RESULT_EXECUTION_ERROR;
        }

        ///================= CLASS D AGC2 OUTPUT POWER (AGC2_Po) REGISTER (ADDRESS: 0x09 DEFAULT:0x03) =================
        paramValueID_len = sizeof("AGC2_OUTPUT_POWER_LEVEL") - 1;
        paramValueID_text[0] = '\0';
        strcat(paramValueID_text, "AGC2_OUTPUT_POWER_LEVEL");
        if (!XfcProtMethod_GetAmplVar(request, response, env, paramValueID_text, paramValueID_len)) {
            return XFC_TRANSPORT_PROTOCOL_RESPONSE_RESULT_EXECUTION_ERROR;
        }

        paramValueID_len = sizeof("AGC2_ATT_TIME_VALUE") - 1;
        paramValueID_text[0] = '\0';
        strcat(paramValueID_text, "AGC2_ATT_TIME_VALUE");
        if (!XfcProtMethod_GetAmplVar(request, response, env, paramValueID_text, paramValueID_len)) {
            return XFC_TRANSPORT_PROTOCOL_RESPONSE_RESULT_EXECUTION_ERROR;
        }

        ///================= CLASS D AGC3 PARAMETER (AGC3) REGISTER (ADDRESS: 0x08 DEFAULT:0x4E) =================
        paramValueID_len = sizeof("PD_AGC3_OPR_STATE") - 1;
        paramValueID_text[0] = '\0';
        strcat(paramValueID_text, "PD_AGC3_OPR_STATE");
        if (!XfcProtMethod_GetAmplVar(request, response, env, paramValueID_text, paramValueID_len)) {
            return XFC_TRANSPORT_PROTOCOL_RESPONSE_RESULT_EXECUTION_ERROR;
        }

        paramValueID_len = sizeof("AGC3_OPR_OUTPUT_POWER_LEVEL") - 1;
        paramValueID_text[0] = '\0';
        strcat(paramValueID_text, "AGC3_OPR_OUTPUT_POWER_LEVEL");
        if (!XfcProtMethod_GetAmplVar(request, response, env, paramValueID_text, paramValueID_len)) {
            return XFC_TRANSPORT_PROTOCOL_RESPONSE_RESULT_EXECUTION_ERROR;
        }

        ///================= CLASS D AGC3 PARAMETER (AGC3) REGISTER (ADDRESS: 0x08 DEFAULT:0x4E) =================
        paramValueID_len = sizeof("AGC3_REL_TIME") - 1;
        paramValueID_text[0] = '\0';
        strcat(paramValueID_text, "AGC3_REL_TIME");
        if (!XfcProtMethod_GetAmplVar(request, response, env, paramValueID_text, paramValueID_len)) {
            return XFC_TRANSPORT_PROTOCOL_RESPONSE_RESULT_EXECUTION_ERROR;
        }

        paramValueID_len = sizeof("AGC3_ATT_TIME") - 1;
        paramValueID_text[0] = '\0';
        strcat(paramValueID_text, "AGC3_ATT_TIME");
        if (!XfcProtMethod_GetAmplVar(request, response, env, paramValueID_text, paramValueID_len)) {
            return XFC_TRANSPORT_PROTOCOL_RESPONSE_RESULT_EXECUTION_ERROR;
        }

        ///================= EN_BOOST =================
        paramValueID_len = sizeof("EN_BOOST") - 1;
        paramValueID_text[0] = '\0';
        strcat(paramValueID_text, "EN_BOOST");
        if (!XfcProtMethod_GetAmplVar(request, response, env, paramValueID_text, paramValueID_len)) {
            return XFC_TRANSPORT_PROTOCOL_RESPONSE_RESULT_EXECUTION_ERROR;
        }
        return XFC_TRANSPORT_PROTOCOL_RESPONSE_RESULT_OK;
    }

    // Чтение избранных параметров
    uint16_t paramCount;
    XFC_CMD_RX_GET_RAW(paramCount);

    // Количество параметров
    XFC_CMD_TX_ADD_RAW(paramCount);

    for (uint16_t count = 0; count < paramCount; ++count) {
        // Получение текстового id параметра
        uint8_t paramValueID_len;
        XFC_CMD_RX_GET_RAW(paramValueID_len);
        char paramValueID_text[paramValueID_len];
        XFC_CMD_RX_GET_ARR(paramValueID_text, paramValueID_len);

        if (!XfcProtMethod_GetAmplVar(request, response, env, paramValueID_text, paramValueID_len)) {
            return XFC_TRANSPORT_PROTOCOL_RESPONSE_RESULT_EXECUTION_ERROR;
        }

    }

    return XFC_TRANSPORT_PROTOCOL_RESPONSE_RESULT_OK;
}