Smart_Components_Aurus
/
ComIntCmd_Amplifier
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Init

This commit is contained in:
cfif 2025-06-02 13:26:41 +03:00
commit 068147ba5c
7 changed files with 1077 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

18
ComIntAmplifier.c Normal file
View File

@ -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);
}

104
ComIntAmplifier.h Normal file
View File

@ -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

300
ComIntAmplifierChange.c Normal file
View File

@ -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;
}

609
ComIntAmplifierGet.c Normal file
View File

@ -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;
}

19
ComIntAmplifierPlay.c Normal file
View File

@ -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;
}

17
ComIntAmplifierSet.c Normal file
View File

@ -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;
}

10
modular.json Normal file
View File

@ -0,0 +1,10 @@
{
"cmake": {
"inc_dirs": [
"./"
],
"srcs": [
"./**.c"
]
}
}