From 068147ba5c488c8c1a6fd8145948ac2ce75bb7c8 Mon Sep 17 00:00:00 2001 From: cfif Date: Mon, 2 Jun 2025 13:26:41 +0300 Subject: [PATCH] Init --- ComIntAmplifier.c | 18 ++ ComIntAmplifier.h | 104 +++++++ ComIntAmplifierChange.c | 300 ++++++++++++++++++++ ComIntAmplifierGet.c | 609 ++++++++++++++++++++++++++++++++++++++++ ComIntAmplifierPlay.c | 19 ++ ComIntAmplifierSet.c | 17 ++ modular.json | 10 + 7 files changed, 1077 insertions(+) create mode 100644 ComIntAmplifier.c create mode 100644 ComIntAmplifier.h create mode 100644 ComIntAmplifierChange.c create mode 100644 ComIntAmplifierGet.c create mode 100644 ComIntAmplifierPlay.c create mode 100644 ComIntAmplifierSet.c create mode 100644 modular.json diff --git a/ComIntAmplifier.c b/ComIntAmplifier.c new file mode 100644 index 0000000..1ba3ad3 --- /dev/null +++ b/ComIntAmplifier.c @@ -0,0 +1,18 @@ +// +// Created by cfif on 10.07.2024. +// +#include "ComIntAmplifier.h" +#include "XfcProtTable.h" + +void XfcProtMethodsAdd_AmplifierInit(tXfcAmplifier *env, tAmplifier *Amplifier, bool *playMode){ + env->amplifier = Amplifier; + env->playMode = playMode; +} + +void XfcProtMethodsAdd_Amplifier(tXfcProtTable *protTab, tXfcAmplifier *amplifier) { + XfcProtTable_AddStatic(protTab, "GET_AMPLIFIER", XfcProtMethod_AmplifierGet, amplifier); + XfcProtTable_AddStatic(protTab, "SET_AMPLIFIER", XfcProtMethod_AmplifierSet, amplifier); + XfcProtTable_AddStatic(protTab, "SET_CHANGE", XfcProtMethod_AmplifierSetChange, amplifier); + XfcProtTable_AddStatic(protTab, "PLAY_TEST", XfcProtMethod_AmplifierPlay, amplifier); +} + diff --git a/ComIntAmplifier.h b/ComIntAmplifier.h new file mode 100644 index 0000000..6a659c1 --- /dev/null +++ b/ComIntAmplifier.h @@ -0,0 +1,104 @@ +// +// Created by cfif on 10.07.2024. +// + +#ifndef SMART_COMPONENTS_UPDATE_AMPLIFIER_H +#define SMART_COMPONENTS_UPDATE_AMPLIFIER_H + +#include "I2cIO.h" +#include "XfcProtProcessorUtilDefines.h" +#include "Amplifier.h" + +typedef enum { + AMPLIFIER_LEVEL, + AMPLIFIER_VOLTAGE, + AMPLIFIER_AMPER, + BOOST_VTH1, + BOOST_VTH2, + LOW_STEP, + ADP_MODE, + POWER, + AGC3_REL_TIME, + AGC3_ATT_TIME, + AGC1_ATT_TIMEA, + PD_AGC1_STATE, + EN_BOOST, + AGC3_OPR_OUTPUT_POWER_LEVEL, + PD_AGC3_OPR_STATE, + AGC2_OUTPUT_POWER_LEVEL, + AGC2_ATT_TIME_VALUE +} tAmplifierType; + +typedef struct { + uint16_t boost_reg; + uint16_t boost_step; + uint16_t boost_vth1; + uint16_t boost_vth2; +} tAdptBoostVTH; + +typedef struct { + uint16_t level; + uint16_t voltage; + uint16_t amper; +} tGeinControl; + +typedef struct { + uint16_t level; +} tAdpMode; + +typedef struct { + bool state; + uint16_t attackTime; +} tAGC1; + +typedef struct { + bool state; +} tEnBoost; + +typedef struct { + bool state; + uint16_t out_power; +} tAGC3opr; + +typedef struct { + uint16_t out_power; +} tAGC2opr; + +typedef struct { + uint16_t relTime; + uint16_t attTime; +} tAGC3; + +typedef struct { + uint16_t attTime; +} tAGC2; + +typedef struct { + tAmplifier *amplifier; + tAdpMode adpMode; + tGeinControl geinControl; + tAdptBoostVTH adptBoostVTH; + tAGC1 agc1; + tEnBoost enBoost; + tAGC3opr agc3_opr; + tAGC3 aAgc3; + tAGC2opr agc2opr; + tAGC2 aAgc2; + bool powerMode; + bool *playMode; + +} tXfcAmplifier; + +void XfcProtMethodsAdd_Amplifier(tXfcProtTable *protTab, tXfcAmplifier *amplifier); + +void XfcProtMethodsAdd_AmplifierInit(tXfcAmplifier *env, tAmplifier *Amplifier, bool *playMode); + +uint8_t XfcProtMethod_AmplifierSet(tXfcArray *request, tXfcArray *response, tXfcAmplifier *amplifier); + +uint8_t XfcProtMethod_AmplifierGet(tXfcArray *request, tXfcArray *response, tXfcAmplifier *amplifier); + +uint8_t XfcProtMethod_AmplifierSetChange(tXfcArray *request, tXfcArray *response, tXfcAmplifier *amplifier); + +uint8_t XfcProtMethod_AmplifierPlay(tXfcArray *request, tXfcArray *response, tXfcAmplifier *env); + +#endif //SMART_COMPONENTS_UPDATE_AMPLIFIER_H diff --git a/ComIntAmplifierChange.c b/ComIntAmplifierChange.c new file mode 100644 index 0000000..58615d9 --- /dev/null +++ b/ComIntAmplifierChange.c @@ -0,0 +1,300 @@ +// +// Created by cfif on 03.06.2024. +// +#include "ComIntAmplifier.h" +#include "string.h" +#include "Amplifier_AW87579.h" +#include "SystemDelayInterface.h" + +uint16_t XfcArrayGetBytesFrontToSendAmpl(tXfcAmplifier *env, tAmplifierType amplifierType, tXfcArray *array, uint8_t length) { + + uint16_t available = XfcArrayGetDataSize(array); + uint16_t toGet = available > length ? length : available; + + if (amplifierType == AMPLIFIER_LEVEL) { + env->geinControl.level = *(uint16_t *)(array->data + array->begin); + } + + if (amplifierType == AMPLIFIER_VOLTAGE) { + env->geinControl.voltage = *(uint16_t *)(array->data + array->begin); + } + + if (amplifierType == LOW_STEP) { + env->adptBoostVTH.boost_step = *(uint16_t *)(array->data + array->begin); + } + + if (amplifierType == AMPLIFIER_AMPER) { + env->geinControl.amper = *(uint16_t *)(array->data + array->begin); + } + + if (amplifierType == BOOST_VTH1) { + env->adptBoostVTH.boost_vth1 = *(uint16_t *)(array->data + array->begin); + } + + if (amplifierType == BOOST_VTH2) { + env->adptBoostVTH.boost_vth2 = *(uint16_t *)(array->data + array->begin); + } + + if (amplifierType == ADP_MODE) { + env->adpMode.level = *(uint16_t *)(array->data + array->begin); + } + + if (amplifierType == AGC1_ATT_TIMEA) { + env->agc1.attackTime = *(uint16_t *)(array->data + array->begin); + } + + if (amplifierType == EN_BOOST) { + env->enBoost.state = *(uint16_t *)(array->data + array->begin); + } + + if (amplifierType == PD_AGC1_STATE) { + env->agc1.state = *(uint16_t *)(array->data + array->begin); + } + + if (amplifierType == PD_AGC3_OPR_STATE) { + env->agc3_opr.state = *(uint16_t *)(array->data + array->begin); + } + + if (amplifierType == AGC3_OPR_OUTPUT_POWER_LEVEL) { + env->agc3_opr.out_power = *(uint16_t *)(array->data + array->begin); + } + + if (amplifierType == AGC2_OUTPUT_POWER_LEVEL) { + env->agc2opr.out_power = *(uint16_t *)(array->data + array->begin); + } + + if (amplifierType == AGC2_ATT_TIME_VALUE) { + env->aAgc2.attTime = *(uint16_t *)(array->data + array->begin); + } + + if (amplifierType == AGC3_REL_TIME) { + env->aAgc3.relTime = *(uint16_t *)(array->data + array->begin); + } + + if (amplifierType == AGC3_ATT_TIME) { + env->aAgc3.attTime = *(uint16_t *)(array->data + array->begin); + } + + if (amplifierType == POWER) { + env->powerMode = *(uint16_t *)(array->data + array->begin); + } + + array->begin += toGet; + + return toGet; +} + +static uint8_t XfcProtMethod_AmplSetChange(tXfcArray *request, tXfcArray *response, tXfcAmplifier *env) { + + // Запись избранных параметров + uint16_t paramCount = 0; + uint8_t paramValueID_len = 0; + uint8_t paramValueID_text[64]; + + XFC_CMD_RX_GET_RAW(paramCount); + + if (!paramCount) { + return XFC_TRANSPORT_PROTOCOL_RESPONSE_RESULT_OK; + } + + for (uint16_t count = 0; count < paramCount; ++count) { + + // Получение текстового id параметра + XFC_CMD_RX_GET_RAW(paramValueID_len); + XFC_CMD_RX_GET_ARR(paramValueID_text, paramValueID_len); + + uint8_t dataLen; + XFC_CMD_RX_GET_RAW(dataLen); + + ///================= CLASS D GAIN CONTROL REGISTER (ADDRESS: 0x06) ================= + if (memcmp(paramValueID_text, "LEVEL", sizeof("LEVEL") - 1) == 0) { + uint16_t countLen = XfcArrayGetBytesFrontToSendAmpl(env, AMPLIFIER_LEVEL, request, dataLen); + if(env->geinControl.level > 7){ + env->amplifier->confRegs.sysctr.RCV_MODE = false ; + + } else { + env->amplifier->confRegs.sysctr.RCV_MODE = true; + } + + tAW87579_PAGR geinControl; + geinControl = env->amplifier->confRegs.pagr;//env->amplifier->confStr->data[def_pagr]; + geinControl.PA_GAIN = env->amplifier->levels[env->geinControl.level]; + env->amplifier->confRegs.pagr = geinControl; + + if (countLen != dataLen) { + return XFC_TRANSPORT_PROTOCOL_REQUEST_UNEXPECTEDLY_SHORT; + } + + } + + ///================= BOOST OUTPUT VOLTAGE (BSTVOUT) REGISTER (ADDRESS: 0x03) ================= + if (memcmp(paramValueID_text, "VOLTAGE", sizeof("VOLTAGE") - 1) == 0) { + uint16_t countLen = XfcArrayGetBytesFrontToSendAmpl(env, AMPLIFIER_VOLTAGE, request, dataLen); + env->amplifier->confRegs.bstvout.BST_VOUT = env->amplifier->voltages[env->geinControl.voltage]; + + if (countLen != dataLen) { + return XFC_TRANSPORT_PROTOCOL_REQUEST_UNEXPECTEDLY_SHORT; + } + } + + ///================= BOOSTBOOST CONTROL REGISTER (ADDRESS: 0x05) ================= + if (memcmp(paramValueID_text, "AMPER", sizeof("AMPER") - 1) == 0) { + uint16_t countLen = XfcArrayGetBytesFrontToSendAmpl(env, AMPLIFIER_AMPER, request, dataLen); + env->amplifier->confRegs.bstcpr2.BST_IPEAK = env->amplifier->ampers[env->geinControl.amper]; + + if (countLen != dataLen) { + return XFC_TRANSPORT_PROTOCOL_REQUEST_UNEXPECTEDLY_SHORT; + } + } + + ///================= ADP BOOST PARAMETER REGISTER REGISTER (ADDRESS: 0x0F) ================= + if (memcmp(paramValueID_text, "LOW_STEP", sizeof("LOW_STEP") - 1) == 0) { + uint16_t countLen = XfcArrayGetBytesFrontToSendAmpl(env, LOW_STEP, request, dataLen); + env->amplifier->confRegs.adpbstVth.ADP_LOW_STEP = env->amplifier->boost_steps[env->adptBoostVTH.boost_step]; + + if (countLen != dataLen) { + return XFC_TRANSPORT_PROTOCOL_REQUEST_UNEXPECTEDLY_SHORT; + } + } + + if (memcmp(paramValueID_text, "BOOST_VTH1", sizeof("BOOST_VTH1") - 1) == 0) { + uint16_t countLen = XfcArrayGetBytesFrontToSendAmpl(env, BOOST_VTH1, request, dataLen); + env->amplifier->confRegs.adpbstVth.SET_BOOST_VTH1 = env->amplifier->boost_vths1[env->adptBoostVTH.boost_vth1]; + + if (countLen != dataLen) { + return XFC_TRANSPORT_PROTOCOL_REQUEST_UNEXPECTEDLY_SHORT; + } + } + + if (memcmp(paramValueID_text, "BOOST_VTH2", sizeof("BOOST_VTH2") - 1) == 0) { + uint16_t countLen = XfcArrayGetBytesFrontToSendAmpl(env, BOOST_VTH2, request, dataLen); + env->amplifier->confRegs.adpbstVth.SET_BOOST_VTH2 = env->amplifier->boost_vths2[env->adptBoostVTH.boost_vth2]; + + if (countLen != dataLen) { + return XFC_TRANSPORT_PROTOCOL_REQUEST_UNEXPECTEDLY_SHORT; + } + } + + ///================= ADP MODE PARAMETER REGISTER (ADDRESS: 0x0c) ================= + if (memcmp(paramValueID_text, "ADP_MODE", sizeof("ADP_MODE") - 1) == 0) { + uint16_t countLen = XfcArrayGetBytesFrontToSendAmpl(env, ADP_MODE, request, dataLen); + env->amplifier->confRegs.adpMode.ADPBOOST_MODE = env->amplifier->adp_boostModes[env->adpMode.level]; + + if (countLen != dataLen) { + return XFC_TRANSPORT_PROTOCOL_REQUEST_UNEXPECTEDLY_SHORT; + } + } + + ///================= CLASS D AGC1 PARAMETER (AGC1) REGISTER (ADDRESS: 0x0B) ================= + if (memcmp(paramValueID_text, "AGC1_ATT_TIMEA", sizeof("AGC1_ATT_TIMEA") - 1) == 0) { + uint16_t countLen = XfcArrayGetBytesFrontToSendAmpl(env, AGC1_ATT_TIMEA, request, dataLen); + env->amplifier->confRegs.pagc1Pr.AGC1_ATT_TIME = env->amplifier->agc1_att_times[env->agc1.attackTime]; + + if (countLen != dataLen) { + return XFC_TRANSPORT_PROTOCOL_REQUEST_UNEXPECTEDLY_SHORT; + } + } + + if (memcmp(paramValueID_text, "PD_AGC1_STATE", sizeof("PD_AGC1_STATE") - 1) == 0) { + uint16_t countLen = XfcArrayGetBytesFrontToSendAmpl(env, PD_AGC1_STATE, request, dataLen); + env->amplifier->confRegs.pagc1Pr.PD_AGC1 = env->agc1.state; + + if (countLen != dataLen) { + return XFC_TRANSPORT_PROTOCOL_REQUEST_UNEXPECTEDLY_SHORT; + } + } + + ///================= CLASS D AGC2 OUTPUT POWER (AGC2_Po) REGISTER (ADDRESS: 0x09 DEFAULT:0x03) ================= + if (memcmp(paramValueID_text, "AGC2_OUTPUT_POWER_LEVEL", sizeof("AGC2_OUTPUT_POWER_LEVEL") - 1) == 0) { + uint16_t countLen = XfcArrayGetBytesFrontToSendAmpl(env, AGC2_OUTPUT_POWER_LEVEL, request, dataLen); + env->amplifier->confRegs.pagc2Opr.AGC2_OUTPUT_POWER = env->amplifier->agc2Opr_out_powers[env->agc2opr.out_power]; + + if (countLen != dataLen) { + return XFC_TRANSPORT_PROTOCOL_REQUEST_UNEXPECTEDLY_SHORT; + } + } + + ///================= CLASS D AGC2 PARAMETER (AGC2) REGISTER (ADDRESS: 0x0A DEFAULT:0x08 ================= + if (memcmp(paramValueID_text, "AGC2_ATT_TIME_VALUE", sizeof("AGC2_ATT_TIME_VALUE") - 1) == 0) { + uint16_t countLen = XfcArrayGetBytesFrontToSendAmpl(env, AGC2_ATT_TIME_VALUE, request, dataLen); + env->amplifier->confRegs.pagc2Pr.AGC2_ATT_TIME = env->amplifier->agc2_attTimes[env->aAgc2.attTime]; + + if (countLen != dataLen) { + return XFC_TRANSPORT_PROTOCOL_REQUEST_UNEXPECTEDLY_SHORT; + } + } + + ///================= 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 countLen = XfcArrayGetBytesFrontToSendAmpl(env, AGC3_REL_TIME, request, dataLen); + env->amplifier->confRegs.pagc3Pr.AGC3_REL_TIME = env->amplifier->agc3_relTimes[env->aAgc3.relTime]; + + if (countLen != dataLen) { + return XFC_TRANSPORT_PROTOCOL_REQUEST_UNEXPECTEDLY_SHORT; + } + } + + if (memcmp(paramValueID_text, "AGC3_ATT_TIME", sizeof("AGC3_ATT_TIME") - 1) == 0) { + uint16_t countLen = XfcArrayGetBytesFrontToSendAmpl(env, AGC3_ATT_TIME, request, dataLen); + env->amplifier->confRegs.pagc3Pr.AGC3_ATT_TIME = env->amplifier->agc3_attTimes[env->aAgc3.attTime]; + + if (countLen != dataLen) { + return XFC_TRANSPORT_PROTOCOL_REQUEST_UNEXPECTEDLY_SHORT; + } + } + + ///================= CLASS D AGC3 (AGC3) OUTPUT POWER REGISTER (ADDRESS: 0x07) ================= + if (memcmp(paramValueID_text, "AGC3_OPR_OUTPUT_POWER_LEVEL", sizeof("AGC3_OPR_OUTPUT_POWER_LEVEL") - 1) == 0) { + uint16_t countLen = XfcArrayGetBytesFrontToSendAmpl(env, AGC3_OPR_OUTPUT_POWER_LEVEL, request, dataLen); + env->amplifier->confRegs.pagc3Opr.AGC3_OUTPUT_POWER = env->amplifier->agc3_out_powers[env->agc3_opr.out_power]; + + if (countLen != dataLen) { + return XFC_TRANSPORT_PROTOCOL_REQUEST_UNEXPECTEDLY_SHORT; + } + } + + if (memcmp(paramValueID_text, "PD_AGC3_OPR_STATE", sizeof("PD_AGC3_OPR_STATE") - 1) == 0) { + uint16_t countLen = XfcArrayGetBytesFrontToSendAmpl(env, PD_AGC3_OPR_STATE, request, dataLen); + env->amplifier->confRegs.pagc3Opr.PD_AGC3 = env->agc3_opr.state; + + if (countLen != dataLen) { + return XFC_TRANSPORT_PROTOCOL_REQUEST_UNEXPECTEDLY_SHORT; + } + } + + ///================= EN_BOOST ================= + if (memcmp(paramValueID_text, "EN_BOOST", sizeof("EN_BOOST") - 1) == 0) { + uint16_t countLen = XfcArrayGetBytesFrontToSendAmpl(env, EN_BOOST, request, dataLen); + env->amplifier->confRegs.sysctr.EN_BOOST = env->enBoost.state; + + if (countLen != dataLen) { + return XFC_TRANSPORT_PROTOCOL_REQUEST_UNEXPECTEDLY_SHORT; + } + } + + ///================= CUSTOM COMMAND POWER MANAGMENT ================= + if (memcmp(paramValueID_text, "POWER", sizeof("POWER") - 1) == 0) { + uint16_t countLen = XfcArrayGetBytesFrontToSendAmpl(env, POWER, request, dataLen); + if(env->powerMode == true){ + Amplifier_PowerOn(env->amplifier); + } else { + Amplifier_PowerOff(env->amplifier); + } + if (countLen != dataLen) { + return XFC_TRANSPORT_PROTOCOL_REQUEST_UNEXPECTEDLY_SHORT; + } + } + + Amplifier_ChangeConf(env->amplifier); + + } + return XFC_TRANSPORT_PROTOCOL_RESPONSE_RESULT_OK; +} + + +uint8_t XfcProtMethod_AmplifierSetChange(tXfcArray *request, tXfcArray *response, tXfcAmplifier *env) { + + uint8_t result = XfcProtMethod_AmplSetChange(request, response, env); + + return result; +} \ No newline at end of file diff --git a/ComIntAmplifierGet.c b/ComIntAmplifierGet.c new file mode 100644 index 0000000..b97de80 --- /dev/null +++ b/ComIntAmplifierGet.c @@ -0,0 +1,609 @@ +// +// 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; +} \ No newline at end of file diff --git a/ComIntAmplifierPlay.c b/ComIntAmplifierPlay.c new file mode 100644 index 0000000..1ac04c9 --- /dev/null +++ b/ComIntAmplifierPlay.c @@ -0,0 +1,19 @@ +// +// Created by zemon on 25.07.24. +// + +#include "ComIntAmplifier.h" +#include "string.h" +#include "Amplifier_AW87579.h" + +static uint8_t XfcProtMethod_AmplPlay(tXfcArray *request, tXfcArray *response, tXfcAmplifier *env) { + *env->playMode = true; + return XFC_TRANSPORT_PROTOCOL_RESPONSE_RESULT_OK; +} + +uint8_t XfcProtMethod_AmplifierPlay(tXfcArray *request, tXfcArray *response, tXfcAmplifier *env) { + + uint8_t result = XfcProtMethod_AmplPlay(request, response, env); + + return result; +} \ No newline at end of file diff --git a/ComIntAmplifierSet.c b/ComIntAmplifierSet.c new file mode 100644 index 0000000..c6fe83c --- /dev/null +++ b/ComIntAmplifierSet.c @@ -0,0 +1,17 @@ +// +// Created by cfif on 03.06.2024. +// +#include "ComIntAmplifier.h" +#include "Amplifier_AW87579.h" + +static uint8_t XfcProtMethod_AmplSaveConf(tXfcArray *request, tXfcArray *response, tXfcAmplifier *env) { + Amplifier_DumpConf(env->amplifier); + return XFC_TRANSPORT_PROTOCOL_RESPONSE_RESULT_OK; +} + +uint8_t XfcProtMethod_AmplifierSet(tXfcArray *request, tXfcArray *response, tXfcAmplifier *env) { + + uint8_t result = XfcProtMethod_AmplSaveConf(request, response, env); + + return result; +} \ No newline at end of file diff --git a/modular.json b/modular.json new file mode 100644 index 0000000..0dd1901 --- /dev/null +++ b/modular.json @@ -0,0 +1,10 @@ +{ + "cmake": { + "inc_dirs": [ + "./" + ], + "srcs": [ + "./**.c" + ] + } +} \ No newline at end of file