bartool/PortableFuncGen
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

[refactor] prepare for link gen

Browse Source
This commit is contained in:
bartool
2023-08-15 16:18:48 +02:00
parent 76ba24e527
commit 3e7c5c5089
30 changed files with 1387 additions and 1076 deletions
Download Patch File Download Diff File Expand all files Collapse all files

633
firmware/shared_libs/controllers/ctrl_app.c
View File

@@ -1,14 +1,14 @@
#include "main.h"
#include "tim.h"
#include "hw_button.h"
#include "ctrl_bottom_button.h"
#include "ctrl_channel_button.h"
#include "ctrl_encoder.h"
#include "ctrl_generator.h"
#include "ctrl_disp_button.h"
#include "ctrl_signal_gen.h"
#include "ctrl_app.h"
typedef void (*btn_action_t)(void);
typedef void (*btn_action_t)(APP_data_t *app_data);
typedef struct
{
@@ -16,69 +16,46 @@ typedef struct
BITMAP_buttonName_t bitmap_name;
} CMD_button_t;
static GEN_fg_t func_gen[3];
static GEN_pwm_t pwm_gen[3];
static const CMD_button_t btn_command[BTN_STATE_MAX][DISP_BTN_MAX];
static const LAY_dispBtn_t btn_hw_to_disp[BTN_BOT_MAX] = {DISP_BTN_1, DISP_BTN_2, DISP_BTN_3, DISP_BTN_4, DISP_BTN_5};
static const GEN_channel_t btn_ch_to_chan[CHANNEL_MAX] = {CHANNEL1, CHANNEL2, CHANNEL3, CHANNEL4, CHANNEL5, CHANNEL6};
static const uint32_t pow_of_10[7] = {1, 10, 100, 1000, 10000, 100000, 1000000};
static HW_BotBtnName_t last_key;
static APP_data_t *_app_data;
static GEN_sig_t signal_gen[CHANNEL_MAX] = {
{.type = GEN_FG_TYPE, .gen = &func_gen[0]},
{.type = GEN_FG_TYPE, .gen = &func_gen[1]},
{.type = GEN_FG_TYPE, .gen = &func_gen[2]},
{.type = GEN_PWM_TYPE, .gen = &pwm_gen[0]},
{.type = GEN_PWM_TYPE, .gen = &pwm_gen[1]},
{.type = GEN_PWM_TYPE, .gen = &pwm_gen[2]},
static dds_gen_t dds_gen[DDS_CH_MAX] = {
{.super.type = GEN_FG_TYPE, .dds_ch = DDS_CH1},
{.super.type = GEN_FG_TYPE, .dds_ch = DDS_CH2},
{.super.type = GEN_FG_TYPE, .dds_ch = DDS_CH3},
};
static pwm_gen_t pwm_gen[PWM_CH_MAX] = {
{.super.type = GEN_PWM_TYPE, .pwm_ch = PWM_CH1},
{.super.type = GEN_PWM_TYPE, .pwm_ch = PWM_CH2},
{.super.type = GEN_PWM_TYPE, .pwm_ch = PWM_CH3},
};
void _signalGenDefaultValues(void)
{
for (GEN_channel_t channel = 0; channel < CHANNEL_MAX; channel++)
{
switch (signal_gen[channel].type)
{
case GEN_FG_TYPE:
{
GEN_fg_t *gen = signal_gen[channel].gen;
gen->frequency = 1000;
gen->amplitude = 100;
gen->offset = 165;
gen->phase = 0;
gen->wave = GEN_SIN;
gen->enabled = FALSE;
gen->link = 0;
break;
}
case GEN_PWM_TYPE:
{
GEN_pwm_t *gen = signal_gen[channel].gen;
gen->frequency = 1000;
gen->amplitude = 0;
gen->offset = 0;
gen->phase = 0;
gen->duty = 50;
gen->enabled = FALSE;
break;
}
default:
break;
}
}
}
static signal_gen_t *signal_gen[CHANNEL_MAX] = {
&dds_gen[DDS_CH1].super,
&dds_gen[DDS_CH2].super,
&dds_gen[DDS_CH3].super,
&pwm_gen[PWM_CH1].super,
&pwm_gen[PWM_CH2].super,
&pwm_gen[PWM_CH3].super,
};
void _setGenInitailState(GEN_channel_t channel)
static void _setGenInitailState(GEN_channel_t channel);
static void _signalGenDefaultValues(void);
static void _changeValueDdsGen(int8_t dir);
static void _changeValuePwmGen(int8_t dir);
//****************************
// Initialization
//****************************
void CTRL_buttonsInit(void)
{
setFreq(&signal_gen[channel], channel);
setWave(&signal_gen[channel], channel);
setPhase(&signal_gen[channel], channel);
setAmplitude(&signal_gen[channel], channel);
setEnabled(&signal_gen[channel], channel);
// setOfsset(&signal_gen[channel], channel);
CTRL_bottomButtonInit();
CTRL_channelButtonInit();
}
void APP_init(APP_data_t *app_data)
@@ -90,32 +67,29 @@ void APP_init(APP_data_t *app_data)
_app_data->phas_focus_digit = 0;
_app_data->duty_focus_digit = 0;
_app_data->curr_gen_type = signal_gen[CHANNEL1].type;
_app_data->curr_gen = signal_gen[CHANNEL1].gen;
_app_data->curr_gen = signal_gen[CHANNEL1];
_app_data->curr_state_lay = LAY_MAIN;
_app_data->curr_state_btn = BTN_MAIN_FG;
_app_data->curr_channel = CHANNEL1;
_app_data->isChannelChange = 1;
_app_data->isGraphChange = 1;
_app_data->isValueChange = 1;
_app_data->isButtonChange = 1;
_app_data->isButtonBlink = 1;
// _app_data->isChannelChange = 1;
// _app_data->isGraphChange = 1;
// _app_data->isValueChange = 1;
// _app_data->isButtonChange = 1;
// _app_data->isButtonBlink = 1;
_app_data->disp_update |= UPDATE_BUTTON | UPDATE_GRAPH | UPDATE_VALUE | UPDATE_CHANNEL;
_signalGenDefaultValues();
CTRL_buttonsInit();
gen_init();
_signalGenDefaultValues();
GEN_init(signal_gen);
_setGenInitailState(CHANNEL1);
_setGenInitailState(CHANNEL2);
}
void CTRL_buttonsInit(void)
{
CTRL_bottomButtonInit();
CTRL_channelButtonInit();
}
//****************************
// Handlers
//****************************
void CTRL_buttonsHandler(void)
{
@@ -124,11 +98,33 @@ void CTRL_buttonsHandler(void)
CTRL_encoderHandler();
}
//****************************
// Events
//****************************
void CTRL_pushedDispBtnEvent(ButtonKey_t *key)
{
ULOG_TRACE("Disp btn: %d", key->instance);
last_key = btn_hw_to_disp[key->instance];
btn_command[_app_data->curr_state_btn][last_key].command();
_app_data->last_key = btn_hw_to_disp[key->instance];
btn_command[_app_data->curr_state_btn][_app_data->last_key].command(_app_data);
}
void CTRL_encoderEvent(int8_t enc)
{
ULOG_TRACE("Enco event: %i", enc);
switch (_app_data->curr_gen->type)
{
case GEN_FG_TYPE:
_changeValueDdsGen(enc / 2);
break;
case GEN_PWM_TYPE:
_changeValuePwmGen(enc / 2);
break;
default:
ULOG_ERROR("%s:%d: Unknown generator type: %d", __FILE__, __LINE__, _app_data->curr_gen->type);
break;
}
}
void CTRL_pushedChanBtnEvent(ButtonKey_t *key)
@@ -136,18 +132,18 @@ void CTRL_pushedChanBtnEvent(ButtonKey_t *key)
ULOG_TRACE("Chan btn: %d", key->instance);
GEN_channel_t channel = btn_ch_to_chan[key->instance];
_app_data->curr_gen_type = signal_gen[channel].type;
_app_data->curr_gen = signal_gen[channel].gen;
_app_data->curr_gen = signal_gen[channel];
_app_data->curr_state_lay = LAY_MAIN;
_app_data->curr_state_btn = BTN_MAIN_FG;
_app_data->curr_channel = channel;
_app_data->isChannelChange = 1;
_app_data->isGraphChange = 1;
_app_data->isValueChange = 1;
_app_data->isButtonChange = 1;
_app_data->isButtonBlink = 1;
// _app_data->isChannelChange = 1;
// _app_data->isGraphChange = 1;
// _app_data->isValueChange = 1;
// _app_data->isButtonChange = 1;
// _app_data->isButtonBlink = 1;
_app_data->disp_update |= UPDATE_BUTTON | UPDATE_GRAPH | UPDATE_VALUE | UPDATE_CHANNEL;
}
void CTRL_longPushedChanBtnEvent(ButtonKey_t *key)
@@ -155,87 +151,82 @@ void CTRL_longPushedChanBtnEvent(ButtonKey_t *key)
ULOG_TRACE("Chan btn(long): %d", key->instance);
GEN_channel_t channel = btn_ch_to_chan[key->instance];
if (channel == CHANNEL2)
{
if (HAL_TIM_PWM_Start(&htim17, TIM_CHANNEL_1) == HAL_ERROR)
{
HAL_TIM_PWM_Stop(&htim17, TIM_CHANNEL_1);
}
}
switch (signal_gen[channel].type)
switch (signal_gen[channel]->type)
{
case GEN_FG_TYPE:
{
GEN_fg_t *gen = signal_gen[channel].gen;
gen->enabled = gen->enabled ? FALSE : TRUE;
setEnabled(&signal_gen[channel], channel);
dds_gen_t *dds_gen = (dds_gen_t *)signal_gen[channel];
dds_gen->settings.enabled = dds_gen->settings.enabled ? FALSE : TRUE;
setEnabled(signal_gen[channel]);
break;
}
case GEN_PWM_TYPE:
{
GEN_pwm_t *gen = signal_gen[channel].gen;
gen->enabled = gen->enabled ? FALSE : TRUE;
setEnabled(&signal_gen[channel], channel);
pwm_gen_t *pwm_gen = (pwm_gen_t *)signal_gen[channel];
pwm_gen->settings.enabled = pwm_gen->settings.enabled ? FALSE : TRUE;
setEnabled(signal_gen[channel]);
break;
}
default:
ULOG_ERROR("%s:%d: Unknown generator type: %d", __FILE__, __LINE__, _app_data->curr_gen->type);
break;
}
}
static void _changeValueFunGen(int8_t dir)
//*******************************************************************
static void _changeValueDdsGen(int8_t dir)
{
GEN_fg_t *gen = (GEN_fg_t *)_app_data->curr_gen;
dds_gen_t *dds_gen = (dds_gen_t *)_app_data->curr_gen;
switch (_app_data->curr_state_lay)
{
case LAY_FREQ:
{
uint32_t new_freq = dir * pow_of_10[_app_data->freq_focus_digit] + gen->frequency;
uint32_t new_freq = dir * pow_of_10[_app_data->freq_focus_digit] + dds_gen->settings.frequency;
ULOG_DEBUG("<FG> New freq: %lu", new_freq);
if (new_freq > MAX_FREQ)
{
return;
}
gen->frequency = new_freq;
setFreq(&signal_gen[_app_data->curr_channel], _app_data->curr_channel);
dds_gen->settings.frequency = new_freq;
setFrequency(&dds_gen->super);
break;
}
case LAY_AMPL:
{
uint16_t new_ampl = dir * pow_of_10[_app_data->ampl_focus_digit] + gen->amplitude;
uint16_t new_ampl = dir * pow_of_10[_app_data->ampl_focus_digit] + dds_gen->settings.amplitude;
ULOG_DEBUG("<FG> New ampl: %u", new_ampl);
if (gen->offset + new_ampl > MAX_VOLT_POS || gen->offset - new_ampl < MAX_VOLT_NEG)
if (dds_gen->settings.offset + new_ampl > MAX_VOLT_POS || dds_gen->settings.offset - new_ampl < MAX_VOLT_NEG)
{
return;
}
gen->amplitude = new_ampl;
setAmplitude(&signal_gen[_app_data->curr_channel], _app_data->curr_channel);
dds_gen->settings.amplitude = new_ampl;
setAmplitude(&dds_gen->super);
break;
}
case LAY_OFFS:
{
int16_t new_offs = dir * pow_of_10[_app_data->offs_focus_digit] + gen->offset;
int16_t new_offs = dir * pow_of_10[_app_data->offs_focus_digit] + dds_gen->settings.offset;
ULOG_DEBUG("<FG> New offs: %i", new_offs);
if (new_offs + gen->amplitude > MAX_VOLT_POS || new_offs - gen->amplitude < MAX_VOLT_NEG)
if (new_offs + dds_gen->settings.amplitude > MAX_VOLT_POS || new_offs - dds_gen->settings.amplitude < MAX_VOLT_NEG)
{
return;
}
gen->offset = new_offs;
setOfsset(&signal_gen[_app_data->curr_channel], _app_data->curr_channel);
dds_gen->settings.offset = new_offs;
setOfsset(&dds_gen->super);
break;
}
case LAY_PHAS:
{
uint16_t new_phas = dir * pow_of_10[_app_data->phas_focus_digit] + gen->phase;
uint16_t new_phas = dir * pow_of_10[_app_data->phas_focus_digit] + dds_gen->settings.phase;
ULOG_DEBUG("<FG> New phas: %u", new_phas);
if (new_phas > MAX_PHAS)
{
return;
}
gen->phase = new_phas;
setPhase(&signal_gen[_app_data->curr_channel], _app_data->curr_channel);
dds_gen->settings.phase = new_phas;
setPhase(&dds_gen->super);
break;
}
default:
@@ -243,72 +234,73 @@ static void _changeValueFunGen(int8_t dir)
return;
}
_app_data->isValueChange = 1;
_app_data->isGraphChange = 1;
// _app_data->isValueChange = 1;
// _app_data->isGraphChange = 1;
_app_data->disp_update |= UPDATE_GRAPH | UPDATE_VALUE;
}
static void _changeValuePwmGen(int8_t dir)
{
GEN_pwm_t *gen = (GEN_pwm_t *)_app_data->curr_gen;
pwm_gen_t *pwm_gen = (pwm_gen_t *)_app_data->curr_gen;
switch (_app_data->curr_state_lay)
{
case LAY_FREQ:
{
uint32_t new_freq = dir * pow_of_10[_app_data->freq_focus_digit] + gen->frequency;
uint32_t new_freq = dir * pow_of_10[_app_data->freq_focus_digit] + pwm_gen->settings.frequency;
ULOG_DEBUG("<PWM> New freq: %lu", new_freq);
if (new_freq > MAX_FREQ)
{
return;
}
gen->frequency = new_freq;
pwm_gen->settings.frequency = new_freq;
break;
}
case LAY_AMPL:
{
uint16_t new_ampl = dir * pow_of_10[_app_data->ampl_focus_digit] + gen->amplitude;
uint16_t new_ampl = dir * pow_of_10[_app_data->ampl_focus_digit] + pwm_gen->settings.amplitude;
ULOG_DEBUG("<PWM> New ampl: %u", new_ampl);
if (gen->offset + new_ampl > MAX_VOLT_POS || gen->offset - new_ampl < MAX_VOLT_NEG)
if (pwm_gen->settings.offset + new_ampl > MAX_VOLT_POS || pwm_gen->settings.offset - new_ampl < MAX_VOLT_NEG)
{
return;
}
gen->amplitude = new_ampl;
pwm_gen->settings.amplitude = new_ampl;
break;
}
case LAY_OFFS:
{
int16_t new_offs = dir * pow_of_10[_app_data->offs_focus_digit] + gen->offset;
int16_t new_offs = dir * pow_of_10[_app_data->offs_focus_digit] + pwm_gen->settings.offset;
ULOG_DEBUG("<PWM> New offs: %i", new_offs);
if (new_offs + gen->amplitude > MAX_VOLT_POS || new_offs - gen->amplitude < MAX_VOLT_NEG)
if (new_offs + pwm_gen->settings.amplitude > MAX_VOLT_POS || new_offs - pwm_gen->settings.amplitude < MAX_VOLT_NEG)
{
return;
}
gen->offset = new_offs;
pwm_gen->settings.offset = new_offs;
break;
}
case LAY_PHAS:
{
uint16_t new_phas = dir * pow_of_10[_app_data->phas_focus_digit] + gen->phase;
uint16_t new_phas = dir * pow_of_10[_app_data->phas_focus_digit] + pwm_gen->settings.phase;
ULOG_DEBUG("<PWM> New phas: %u", new_phas);
if (new_phas > MAX_PHAS)
{
return;
}
gen->phase = new_phas;
pwm_gen->settings.phase = new_phas;
break;
}
case LAY_DUTY:
{
uint8_t new_duty = dir * pow_of_10[_app_data->duty_focus_digit] + gen->duty;
uint8_t new_duty = dir * pow_of_10[_app_data->duty_focus_digit] + pwm_gen->settings.duty;
ULOG_DEBUG("<PWM> New duty: %u", new_duty);
if (new_duty > MAX_DUTY)
{
return;
}
gen->duty = new_duty;
pwm_gen->settings.duty = new_duty;
break;
}
default:
@@ -316,343 +308,142 @@ static void _changeValuePwmGen(int8_t dir)
return;
}
_app_data->isValueChange = 1;
_app_data->isGraphChange = 1;
// _app_data->isValueChange = 1;
// _app_data->isGraphChange = 1;
_app_data->disp_update |= UPDATE_GRAPH | UPDATE_VALUE;
}
void CTRL_encoderEvent(int8_t enc)
void _signalGenDefaultValues(void)
{
ULOG_TRACE("Enco event: %i", enc);
switch (_app_data->curr_gen_type)
for (GEN_channel_t channel = CHANNEL1; channel < CHANNEL_MAX; channel++)
{
case GEN_FG_TYPE:
_changeValueFunGen(enc / 2);
break;
case GEN_PWM_TYPE:
_changeValuePwmGen(enc / 2);
break;
default:
ULOG_ERROR("%s:%d: Unknown generator type: %d", __FILE__, __LINE__, _app_data->curr_gen_type);
break;
switch (signal_gen[channel]->type)
{
case GEN_FG_TYPE:
{
dds_gen_t *dds_gen = (dds_gen_t *)signal_gen[channel];
dds_gen->settings.frequency = 1000;
dds_gen->settings.amplitude = 100;
dds_gen->settings.offset = 165;
dds_gen->settings.phase = 0;
dds_gen->settings.wave = GEN_SIN;
dds_gen->settings.link = 0;
dds_gen->settings.enabled = FALSE;
break;
}
case GEN_PWM_TYPE:
{
pwm_gen_t *pwm_gen = (pwm_gen_t *)signal_gen[channel];
pwm_gen->settings.frequency = 1000;
pwm_gen->settings.amplitude = 100;
pwm_gen->settings.offset = 0;
pwm_gen->settings.phase = 0;
pwm_gen->settings.duty = 50;
pwm_gen->settings.link = 0;
pwm_gen->settings.enabled = FALSE;
break;
}
default:
break;
}
}
}
void _setGenInitailState(GEN_channel_t channel)
{
setFrequency(signal_gen[channel]);
setWave(signal_gen[channel]);
setPhase(signal_gen[channel]);
setAmplitude(signal_gen[channel]);
setEnabled(signal_gen[channel]);
// setOfsset(signal_gen[channel]);
}
inline BITMAP_buttonName_t CTRL_getBitmapName(LAY_dispBtn_t disp_btn)
{
return btn_command[_app_data->curr_state_btn][disp_btn].bitmap_name;
}
static void _doNoting(void)
{
return;
}
static void _backToMain(void)
{
_app_data->curr_state_lay = LAY_MAIN;
switch (_app_data->curr_gen_type)
{
case GEN_FG_TYPE:
_app_data->curr_state_btn = BTN_MAIN_FG;
break;
case GEN_PWM_TYPE:
_app_data->curr_state_btn = BTN_MAIN_PWM;
break;
default:
break;
}
_app_data->isButtonChange = 1;
_app_data->isGraphChange = 1;
_app_data->isValueChange = 1;
_app_data->isGraphChange = 1;
}
static void _blockFocusAtMaxAndMin(void)
{
switch (_app_data->curr_state_btn)
{
case BTN_FREQ_MIN:
if (_app_data->freq_focus_digit > 0)
{
_app_data->curr_state_btn = BTN_FREQ;
_app_data->isButtonChange = 1;
}
break;
case BTN_FREQ_MAX:
if (_app_data->freq_focus_digit < FUN_GEN_FOCUS_MAX)
{
_app_data->curr_state_btn = BTN_FREQ;
_app_data->isButtonChange = 1;
}
break;
case BTN_FREQ:
if (_app_data->freq_focus_digit == 0)
{
_app_data->curr_state_btn = BTN_FREQ_MIN;
_app_data->isButtonChange = 1;
}
else if (_app_data->freq_focus_digit == FUN_GEN_FOCUS_MAX)
{
_app_data->curr_state_btn = BTN_FREQ_MAX;
_app_data->isButtonChange = 1;
}
break;
default:
break;
}
}
static void _enterToFreqLayout(void)
{
_app_data->curr_state_lay = LAY_FREQ;
_app_data->curr_state_btn = BTN_FREQ;
_blockFocusAtMaxAndMin();
_app_data->isButtonChange = 1;
_app_data->isGraphChange = 1;
_app_data->isValueChange = 1;
}
static void _enterToAmplLayout(void)
{
_app_data->curr_state_lay = LAY_AMPL;
_app_data->curr_state_btn = BTN_AMPL;
_app_data->isButtonChange = 1;
_app_data->isGraphChange = 1;
_app_data->isValueChange = 1;
}
static void _enterToOffslLayout(void)
{
_app_data->curr_state_lay = LAY_OFFS;
_app_data->curr_state_btn = BTN_OFFS;
_app_data->isButtonChange = 1;
_app_data->isGraphChange = 1;
_app_data->isValueChange = 1;
}
static void _enterToPhasLayout(void)
{
_app_data->curr_state_lay = LAY_PHAS;
_app_data->curr_state_btn = BTN_PHAS;
_app_data->isButtonChange = 1;
_app_data->isGraphChange = 1;
_app_data->isValueChange = 1;
}
static void _enterToDutyLayout(void)
{
_app_data->curr_state_lay = LAY_DUTY;
_app_data->curr_state_btn = BTN_DUTY;
_app_data->isButtonChange = 1;
_app_data->isGraphChange = 1;
_app_data->isValueChange = 1;
}
static void _enterToWavelLayout(void)
{
_app_data->curr_state_lay = LAY_WAVE;
_app_data->curr_state_btn = BTN_WAVE;
_app_data->isButtonChange = 1;
_app_data->isGraphChange = 1;
_app_data->isValueChange = 1;
}
static void _moveToLeftFocusFreqNumber(void)
{
_app_data->freq_focus_digit += 1;
_app_data->isValueChange = 1;
_blockFocusAtMaxAndMin();
_app_data->timer_blink[last_key] = 2;
_app_data->isButtonBlink |= (1 << last_key);
}
static void _moveToRighttFocusFreqNumber(void)
{
_app_data->freq_focus_digit -= 1;
_app_data->isValueChange = 1;
_blockFocusAtMaxAndMin();
_app_data->timer_blink[last_key] = 2;
_app_data->isButtonBlink |= (1 << last_key);
}
static void _setTo0_01xFocusNumber(void)
{
switch (_app_data->curr_state_lay)
{
case LAY_AMPL:
_app_data->ampl_focus_digit = 0;
break;
case LAY_OFFS:
_app_data->offs_focus_digit = 0;
break;
default:
break;
}
_app_data->timer_blink[last_key] = 2;
_app_data->isButtonBlink |= (1 << last_key);
_app_data->isValueChange = 1;
}
static void _setTo0_1xFocusNumber(void)
{
switch (_app_data->curr_state_lay)
{
case LAY_AMPL:
_app_data->ampl_focus_digit = 1;
break;
case LAY_OFFS:
_app_data->offs_focus_digit = 1;
break;
default:
break;
}
_app_data->timer_blink[last_key] = 2;
_app_data->isButtonBlink |= (1 << last_key);
_app_data->isValueChange = 1;
}
static void _setTo1xFocusNumber(void)
{
switch (_app_data->curr_state_lay)
{
case LAY_AMPL:
_app_data->ampl_focus_digit = 2;
break;
case LAY_OFFS:
_app_data->offs_focus_digit = 2;
break;
case LAY_PHAS:
_app_data->phas_focus_digit = 0;
break;
case LAY_DUTY:
_app_data->duty_focus_digit = 0;
break;
default:
break;
}
_app_data->timer_blink[last_key] = 2;
_app_data->isButtonBlink |= (1 << last_key);
_app_data->isValueChange = 1;
}
static void _setTo10xFocusNumber(void)
{
switch (_app_data->curr_state_lay)
{
case LAY_AMPL:
_app_data->ampl_focus_digit = 3;
break;
case LAY_OFFS:
_app_data->offs_focus_digit = 3;
break;
case LAY_PHAS:
_app_data->phas_focus_digit = 1;
break;
case LAY_DUTY:
_app_data->duty_focus_digit = 1;
break;
default:
break;
}
_app_data->timer_blink[last_key] = 2;
_app_data->isButtonBlink |= (1 << last_key);
_app_data->isValueChange = 1;
}
static const CMD_button_t btn_command[BTN_STATE_MAX][DISP_BTN_MAX] = {
{
// BTN_MAIN_FG
{_enterToFreqLayout, BITMAP_BTN_FREQ},
{_enterToAmplLayout, BITMAP_BTN_AMPL},
{_enterToOffslLayout, BITMAP_BTN_OFFS},
{_enterToPhasLayout, BITMAP_BTN_PHAS},
{_enterToWavelLayout, BITMAP_BTN_WAVE},
{enterToFreqLayout, BITMAP_BTN_FREQ},
{enterToAmplLayout, BITMAP_BTN_AMPL},
{enterToOffslLayout, BITMAP_BTN_OFFS},
{enterToPhasLayout, BITMAP_BTN_PHAS},
{enterToWavelLayout, BITMAP_BTN_WAVE},
},
{
// BTN_MAIN_PWM
{_enterToFreqLayout, BITMAP_BTN_FREQ},
{_enterToAmplLayout, BITMAP_BTN_AMPL},
{_enterToOffslLayout, BITMAP_BTN_OFFS},
{_enterToPhasLayout, BITMAP_BTN_PHAS},
{_enterToDutyLayout, BITMAP_BTN_NONE},
{enterToFreqLayout, BITMAP_BTN_FREQ},
{enterToAmplLayout, BITMAP_BTN_AMPL},
{enterToOffslLayout, BITMAP_BTN_OFFS},
{enterToPhasLayout, BITMAP_BTN_PHAS},
{enterToDutyLayout, BITMAP_BTN_NONE},
},
{
// BTN_FREQ
{_moveToLeftFocusFreqNumber, BITMAP_BTN_LEFT},
{_moveToRighttFocusFreqNumber, BITMAP_BTN_RIGHT},
{_doNoting, BITMAP_BTN_NONE},
{_doNoting, BITMAP_BTN_NONE},
{_backToMain, BITMAP_BTN_BACK},
{moveToLeftFocusFreqNumber, BITMAP_BTN_LEFT},
{moveToRighttFocusFreqNumber, BITMAP_BTN_RIGHT},
{doNoting, BITMAP_BTN_NONE},
{doNoting, BITMAP_BTN_NONE},
{backToMain, BITMAP_BTN_BACK},
},
{
// BTN_FREQ_MIN
{_moveToLeftFocusFreqNumber, BITMAP_BTN_LEFT},
{_doNoting, BITMAP_BTN_EMPTY},
{_doNoting, BITMAP_BTN_NONE},
{_doNoting, BITMAP_BTN_NONE},
{_backToMain, BITMAP_BTN_BACK},
{moveToLeftFocusFreqNumber, BITMAP_BTN_LEFT},
{doNoting, BITMAP_BTN_EMPTY},
{doNoting, BITMAP_BTN_NONE},
{doNoting, BITMAP_BTN_NONE},
{backToMain, BITMAP_BTN_BACK},
},
{
// BTN_FREQ_MAX
{_doNoting, BITMAP_BTN_EMPTY},
{_moveToRighttFocusFreqNumber, BITMAP_BTN_RIGHT},
{_doNoting, BITMAP_BTN_NONE},
{_doNoting, BITMAP_BTN_NONE},
{_backToMain, BITMAP_BTN_BACK},
{doNoting, BITMAP_BTN_EMPTY},
{moveToRighttFocusFreqNumber, BITMAP_BTN_RIGHT},
{doNoting, BITMAP_BTN_NONE},
{doNoting, BITMAP_BTN_NONE},
{backToMain, BITMAP_BTN_BACK},
},
{
// BTN_AMPL
{_setTo1xFocusNumber, BITMAP_BTN_X1},
{_setTo0_1xFocusNumber, BITMAP_BTN_X0_1},
{_setTo0_01xFocusNumber, BITMAP_BTN_X0_01},
{_doNoting, BITMAP_BTN_NONE},
{_backToMain, BITMAP_BTN_BACK},
{setTo1xFocusNumber, BITMAP_BTN_X1},
{setTo0_1xFocusNumber, BITMAP_BTN_X0_1},
{setTo0_01xFocusNumber, BITMAP_BTN_X0_01},
{doNoting, BITMAP_BTN_NONE},
{backToMain, BITMAP_BTN_BACK},
},
{
// BTN_OFFS
{_setTo1xFocusNumber, BITMAP_BTN_X1},
{_setTo0_1xFocusNumber, BITMAP_BTN_X0_1},
{_setTo0_01xFocusNumber, BITMAP_BTN_X0_01},
{_doNoting, BITMAP_BTN_NONE},
{_backToMain, BITMAP_BTN_BACK},
{setTo1xFocusNumber, BITMAP_BTN_X1},
{setTo0_1xFocusNumber, BITMAP_BTN_X0_1},
{setTo0_01xFocusNumber, BITMAP_BTN_X0_01},
{doNoting, BITMAP_BTN_NONE},
{backToMain, BITMAP_BTN_BACK},
},
{
// BTN_PHAS
{_setTo10xFocusNumber, BITMAP_BTN_X10},
{_setTo1xFocusNumber, BITMAP_BTN_X1},
{_doNoting, BITMAP_BTN_NONE},
{_doNoting, BITMAP_BTN_NONE},
{_backToMain, BITMAP_BTN_BACK},
{setTo10xFocusNumber, BITMAP_BTN_X10},
{setTo1xFocusNumber, BITMAP_BTN_X1},
{doNoting, BITMAP_BTN_NONE},
{doNoting, BITMAP_BTN_NONE},
{backToMain, BITMAP_BTN_BACK},
},
{
// BTN_DUTY
{_setTo10xFocusNumber, BITMAP_BTN_X10},
{_setTo1xFocusNumber, BITMAP_BTN_X1},
{_doNoting, BITMAP_BTN_NONE},
{_doNoting, BITMAP_BTN_NONE},
{_backToMain, BITMAP_BTN_BACK},
{setTo10xFocusNumber, BITMAP_BTN_X10},
{setTo1xFocusNumber, BITMAP_BTN_X1},
{doNoting, BITMAP_BTN_NONE},
{doNoting, BITMAP_BTN_NONE},
{backToMain, BITMAP_BTN_BACK},
},
{
// BTN_WAVE
{_doNoting, BITMAP_BTN_NONE},
{_doNoting, BITMAP_BTN_NONE},
{_doNoting, BITMAP_BTN_NONE},
{_doNoting, BITMAP_BTN_NONE},
{_backToMain, BITMAP_BTN_BACK},
{doNoting, BITMAP_BTN_NONE},
{doNoting, BITMAP_BTN_NONE},
{doNoting, BITMAP_BTN_NONE},
{doNoting, BITMAP_BTN_NONE},
{backToMain, BITMAP_BTN_BACK},
},
};
};

50
firmware/shared_libs/controllers/ctrl_app.h
View File

@@ -3,56 +3,6 @@
#include "bitmap_disp_buttons.h"
#include "ctrl_app_types.h"
typedef struct
{
uint32_t frequency;
uint16_t amplitude;
int16_t offset;
uint16_t phase;
uint8_t duty;
uint8_t enabled;
} GEN_pwm_t;
typedef struct
{
uint32_t frequency;
uint16_t amplitude;
int16_t offset;
uint16_t phase;
uint8_t wave;
uint8_t enabled;
uint8_t link;
} GEN_fg_t;
typedef struct
{
GEN_type_t type;
void *const gen;
} GEN_sig_t;
typedef struct
{
uint8_t freq_focus_digit;
uint8_t ampl_focus_digit;
uint8_t offs_focus_digit;
uint8_t phas_focus_digit;
uint8_t duty_focus_digit;
GEN_type_t curr_gen_type;
void *curr_gen;
GEN_channel_t curr_channel;
STATE_layout_t curr_state_lay;
STATE_button_t curr_state_btn;
uint8_t isChannelChange;
uint8_t isGraphChange;
uint8_t isValueChange;
uint8_t isButtonChange;
uint8_t isButtonBlink;
uint8_t timer_blink[DISP_BTN_MAX];
} APP_data_t;
void APP_init(APP_data_t *app_data);
void CTRL_buttonsInit(void);

124
firmware/shared_libs/controllers/ctrl_app_defs.h Normal file
View File

@@ -0,0 +1,124 @@
#pragma once
#define FUN_GEN_FOCUS_MAX 6U
#define PWM_GEN_FOCUS_MAX 4U
#define MAX_FREQ 1000000U
#define MAX_VOLT_POS 360
#define MAX_VOLT_NEG 0
#define MAX_PHAS 360
#define MAX_DUTY 100
typedef enum
{
FALSE,
TRUE
} bool_t;
typedef enum
{
GEN_FG_TYPE,
GEN_PWM_TYPE,
GEN_TYPE_MAX
} GEN_type_t;
typedef enum
{
DDS_CH1,
DDS_CH2,
DDS_CH3,
DDS_CH_MAX,
} DDS_channel_t;
typedef enum
{
PWM_CH1,
PWM_CH2,
PWM_CH3,
PWM_CH_MAX,
} PWM_channel_t;
typedef enum
{
CHANNEL1,
CHANNEL2,
CHANNEL3,
CHANNEL4,
CHANNEL5,
CHANNEL6,
CHANNEL_MAX
} GEN_channel_t;
typedef enum
{
GEN_SIN,
GEN_TRI,
GEN_SQR,
GEN_WAVE_MAX,
} GEN_wave_t;
typedef enum
{
LAY_MAIN,
LAY_FREQ,
LAY_AMPL,
LAY_OFFS,
LAY_PHAS,
LAY_DUTY,
LAY_WAVE,
LAY_STATE_MAX
} STATE_layout_t;
typedef enum
{
BTN_MAIN_FG,
BTN_MAIN_PWM,
BTN_FREQ,
BTN_FREQ_MIN,
BTN_FREQ_MAX,
BTN_AMPL,
BTN_OFFS,
BTN_PHAS,
BTN_DUTY,
BTN_WAVE,
BTN_STATE_MAX
} STATE_button_t;
typedef enum
{
DISP_BTN_1,
DISP_BTN_2,
DISP_BTN_3,
DISP_BTN_4,
DISP_BTN_5,
DISP_BTN_MAX,
} LAY_dispBtn_t;
typedef enum
{
UPDATE_CHANNEL = 1,
UPDATE_GRAPH = 2,
UPDATE_VALUE = 4,
UPDATE_BUTTON = 8,
UPDATE_ALL = 15,
} LAY_update_t;
typedef enum
{
FREQ_LINK1 = 1,
FREQ_LINK2 = 2,
AMPL_LINK1 = 4,
AMPL_LINK2 = 8,
OFFS_LINK1 = 16,
OFFS_LINK2 = 32,
PHAS_LINK1 = 64,
PHAS_LINK2 = 128,
} GEN_linkMask_t;
typedef enum
{
MCU_CS1,
MCU_CS2,
MCU_CS3,
MCU_CS4,
MCU_CS_MAX,
} MCU_cs_count_t;

154
firmware/shared_libs/controllers/ctrl_app_types.h
View File

@@ -1,78 +1,106 @@
#pragma once
#include "main.h"
#include "ad9833.h"
#include "mcp41x.h"
#include "ltc2631.h"
#include "ctrl_app_defs.h"
#define FUN_GEN_FOCUS_MAX 6U
#define PWM_GEN_FOCUS_MAX 4U
#define MAX_FREQ 1000000U
#define MAX_VOLT_POS 360
#define MAX_VOLT_NEG 0
#define MAX_PHAS 360
#define MAX_DUTY 100
typedef enum
typedef struct
{
FALSE,
TRUE
} bool_t;
uint32_t frequency;
uint16_t amplitude;
int16_t offset;
uint16_t phase;
uint8_t duty;
uint8_t link;
bool_t enabled;
} pwm_settings_t;
typedef enum
typedef struct
{
GEN_FG_TYPE,
GEN_PWM_TYPE,
GEN_TYPE_MAX
} GEN_type_t;
uint32_t frequency;
uint16_t amplitude;
int16_t offset;
uint16_t phase;
uint8_t wave;
uint8_t link;
uint8_t enabled;
} dds_settings_t;
typedef enum
typedef struct
{
CHANNEL1,
CHANNEL2,
CHANNEL3,
CHANNEL4,
CHANNEL5,
CHANNEL6,
CHANNEL_MAX
} GEN_channel_t;
GPIO_TypeDef *port;
uint16_t pin;
} led_handle_t;
typedef enum
typedef struct FG_handle_s
{
GEN_SIN,
GEN_TRI,
GEN_SQR,
GEN_WAVE_MAX,
} GEN_wave_t;
ad9833_handle_t hdds;
ltc2631_handle_t hoffs;
mcp41x_handle_t hampl;
led_handle_t hled;
} dds_handle_t;
typedef enum
typedef uint8_t timer_handle_t;
typedef struct
{
LAY_MAIN,
LAY_FREQ,
LAY_AMPL,
LAY_OFFS,
LAY_PHAS,
LAY_DUTY,
LAY_WAVE,
LAY_STATE_MAX
} STATE_layout_t;
timer_handle_t hpwm;
ltc2631_handle_t hoffs;
mcp41x_handle_t hampl;
led_handle_t hled;
} pwm_handle_t;
typedef enum
typedef struct
{
BTN_MAIN_FG,
BTN_MAIN_PWM,
BTN_FREQ,
BTN_FREQ_MIN,
BTN_FREQ_MAX,
BTN_AMPL,
BTN_OFFS,
BTN_PHAS,
BTN_DUTY,
BTN_WAVE,
BTN_STATE_MAX
} STATE_button_t;
GEN_type_t const type;
} signal_gen_t;
typedef enum
typedef struct
{
DISP_BTN_1,
DISP_BTN_2,
DISP_BTN_3,
DISP_BTN_4,
DISP_BTN_5,
DISP_BTN_MAX,
} LAY_dispBtn_t;
signal_gen_t *next;
signal_gen_t *prev;
} link_t;
typedef struct
{
signal_gen_t super;
DDS_channel_t const dds_ch;
dds_settings_t settings;
dds_handle_t handle;
link_t link;
} dds_gen_t;
typedef struct
{
signal_gen_t super;
PWM_channel_t const pwm_ch;
pwm_settings_t settings;
pwm_handle_t handle;
link_t link;
} pwm_gen_t;
typedef struct
{
uint8_t freq_focus_digit;
uint8_t ampl_focus_digit;
uint8_t offs_focus_digit;
uint8_t phas_focus_digit;
uint8_t duty_focus_digit;
signal_gen_t *curr_gen;
GEN_channel_t curr_channel;
STATE_layout_t curr_state_lay;
STATE_button_t curr_state_btn;
// uint8_t isChannelChange;
// uint8_t isGraphChange;
// uint8_t isValueChange;
// uint8_t isButtonChange;
LAY_update_t disp_update;
uint8_t button_blink;
uint8_t timer_blink[DISP_BTN_MAX];
LAY_dispBtn_t last_key;
} APP_data_t;

2
firmware/shared_libs/controllers/ctrl_bottom_button.c
View File

@@ -1,6 +1,4 @@
#include "main.h"
#include "hw_button.h"
// #include "ctrl_app.h"
#include "ctrl_bottom_button.h"
static ButtonKey_t bottom_buttons[BTN_BOT_MAX];

2
firmware/shared_libs/controllers/ctrl_bottom_button.h
View File

@@ -1,5 +1,7 @@
#pragma once
#include "hw_button.h"
typedef enum
{
BTN_BOT_1,

1
firmware/shared_libs/controllers/ctrl_channel_button.c
View File

@@ -1,5 +1,4 @@
#include "main.h"
#include "hw_button.h"
#include "ctrl_channel_button.h"
#define DUMMY_GPIO_Port B1_GPIO_Port

2
firmware/shared_libs/controllers/ctrl_channel_button.h
View File

@@ -1,5 +1,7 @@
#pragma once
#include "hw_button.h"
typedef enum
{
BTN_CH_1,

244
firmware/shared_libs/controllers/ctrl_disp_button.c Normal file
View File

@@ -0,0 +1,244 @@
#include "ctrl_disp_button.h"
void doNoting(APP_data_t *app_data)
{
return;
}
void backToMain(APP_data_t *app_data)
{
app_data->curr_state_lay = LAY_MAIN;
switch (app_data->curr_gen->type)
{
case GEN_FG_TYPE:
app_data->curr_state_btn = BTN_MAIN_FG;
break;
case GEN_PWM_TYPE:
app_data->curr_state_btn = BTN_MAIN_PWM;
break;
default:
break;
}
// app_data->isButtonChange = 1;
// app_data->isGraphChange = 1;
// app_data->isValueChange = 1;
// app_data->isGraphChange = 1;
app_data->disp_update = UPDATE_ALL;
}
void blockFocusAtMaxAndMin(APP_data_t *app_data)
{
switch (app_data->curr_state_btn)
{
case BTN_FREQ_MIN:
if (app_data->freq_focus_digit > 0)
{
app_data->curr_state_btn = BTN_FREQ;
app_data->disp_update |= UPDATE_BUTTON;
}
break;
case BTN_FREQ_MAX:
if (app_data->freq_focus_digit < FUN_GEN_FOCUS_MAX)
{
app_data->curr_state_btn = BTN_FREQ;
app_data->disp_update |= UPDATE_BUTTON;
}
break;
case BTN_FREQ:
if (app_data->freq_focus_digit == 0)
{
app_data->curr_state_btn = BTN_FREQ_MIN;
app_data->disp_update |= UPDATE_BUTTON;
}
else if (app_data->freq_focus_digit == FUN_GEN_FOCUS_MAX)
{
app_data->curr_state_btn = BTN_FREQ_MAX;
app_data->disp_update |= UPDATE_BUTTON;
}
break;
default:
break;
}
}
void enterToFreqLayout(APP_data_t *app_data)
{
app_data->curr_state_lay = LAY_FREQ;
app_data->curr_state_btn = BTN_FREQ;
blockFocusAtMaxAndMin(app_data);
// app_data->isButtonChange = 1;
// app_data->isGraphChange = 1;
// app_data->isValueChange = 1;
app_data->disp_update |= UPDATE_BUTTON | UPDATE_GRAPH | UPDATE_VALUE;
}
void enterToAmplLayout(APP_data_t *app_data)
{
app_data->curr_state_lay = LAY_AMPL;
app_data->curr_state_btn = BTN_AMPL;
// app_data->isButtonChange = 1;
// app_data->isGraphChange = 1;
// app_data->isValueChange = 1;
app_data->disp_update |= UPDATE_BUTTON | UPDATE_GRAPH | UPDATE_VALUE;
}
void enterToOffslLayout(APP_data_t *app_data)
{
app_data->curr_state_lay = LAY_OFFS;
app_data->curr_state_btn = BTN_OFFS;
// app_data->isButtonChange = 1;
// app_data->isGraphChange = 1;
// app_data->isValueChange = 1;
app_data->disp_update |= UPDATE_BUTTON | UPDATE_GRAPH | UPDATE_VALUE;
}
void enterToPhasLayout(APP_data_t *app_data)
{
app_data->curr_state_lay = LAY_PHAS;
app_data->curr_state_btn = BTN_PHAS;
// app_data->isButtonChange = 1;
// app_data->isGraphChange = 1;
// app_data->isValueChange = 1;
app_data->disp_update |= UPDATE_BUTTON | UPDATE_GRAPH | UPDATE_VALUE;
}
void enterToDutyLayout(APP_data_t *app_data)
{
app_data->curr_state_lay = LAY_DUTY;
app_data->curr_state_btn = BTN_DUTY;
// app_data->isButtonChange = 1;
// app_data->isGraphChange = 1;
// app_data->isValueChange = 1;
app_data->disp_update |= UPDATE_BUTTON | UPDATE_GRAPH | UPDATE_VALUE;
}
void enterToWavelLayout(APP_data_t *app_data)
{
app_data->curr_state_lay = LAY_WAVE;
app_data->curr_state_btn = BTN_WAVE;
// app_data->isButtonChange = 1;
// app_data->isGraphChange = 1;
// app_data->isValueChange = 1;
app_data->disp_update |= UPDATE_BUTTON | UPDATE_GRAPH | UPDATE_VALUE;
}
void moveToLeftFocusFreqNumber(APP_data_t *app_data)
{
app_data->freq_focus_digit += 1;
// app_data->isValueChange = 1;
app_data->disp_update |= UPDATE_VALUE;
blockFocusAtMaxAndMin(app_data);
app_data->timer_blink[app_data->last_key] = 2;
app_data->button_blink |= (1 << app_data->last_key);
}
void moveToRighttFocusFreqNumber(APP_data_t *app_data)
{
app_data->freq_focus_digit -= 1;
// app_data->isValueChange = 1;
app_data->disp_update |= UPDATE_VALUE;
blockFocusAtMaxAndMin(app_data);
app_data->timer_blink[app_data->last_key] = 2;
app_data->button_blink |= (1 << app_data->last_key);
}
void setTo0_01xFocusNumber(APP_data_t *app_data)
{
switch (app_data->curr_state_lay)
{
case LAY_AMPL:
app_data->ampl_focus_digit = 0;
break;
case LAY_OFFS:
app_data->offs_focus_digit = 0;
break;
default:
break;
}
app_data->timer_blink[app_data->last_key] = 2;
app_data->button_blink |= (1 << app_data->last_key);
// app_data->isValueChange = 1;
app_data->disp_update |= UPDATE_VALUE;
}
void setTo0_1xFocusNumber(APP_data_t *app_data)
{
switch (app_data->curr_state_lay)
{
case LAY_AMPL:
app_data->ampl_focus_digit = 1;
break;
case LAY_OFFS:
app_data->offs_focus_digit = 1;
break;
default:
break;
}
app_data->timer_blink[app_data->last_key] = 2;
app_data->button_blink |= (1 << app_data->last_key);
// app_data->isValueChange = 1;
app_data->disp_update |= UPDATE_VALUE;
}
void setTo1xFocusNumber(APP_data_t *app_data)
{
switch (app_data->curr_state_lay)
{
case LAY_AMPL:
app_data->ampl_focus_digit = 2;
break;
case LAY_OFFS:
app_data->offs_focus_digit = 2;
break;
case LAY_PHAS:
app_data->phas_focus_digit = 0;
break;
case LAY_DUTY:
app_data->duty_focus_digit = 0;
break;
default:
break;
}
app_data->timer_blink[app_data->last_key] = 2;
app_data->button_blink |= (1 << app_data->last_key);
// app_data->isValueChange = 1;
app_data->disp_update |= UPDATE_VALUE;
}
void setTo10xFocusNumber(APP_data_t *app_data)
{
switch (app_data->curr_state_lay)
{
case LAY_AMPL:
app_data->ampl_focus_digit = 3;
break;
case LAY_OFFS:
app_data->offs_focus_digit = 3;
break;
case LAY_PHAS:
app_data->phas_focus_digit = 1;
break;
case LAY_DUTY:
app_data->duty_focus_digit = 1;
break;
default:
break;
}
app_data->timer_blink[app_data->last_key] = 2;
app_data->button_blink |= (1 << app_data->last_key);
// app_data->isValueChange = 1;
app_data->disp_update |= UPDATE_VALUE;
}

18
firmware/shared_libs/controllers/ctrl_disp_button.h Normal file
View File

@@ -0,0 +1,18 @@
#pragma once
#include "ctrl_app_types.h"
void doNoting(APP_data_t *app_data);
void backToMain(APP_data_t *app_data);
void blockFocusAtMaxAndMin(APP_data_t *app_data);
void enterToFreqLayout(APP_data_t *app_data);
void enterToAmplLayout(APP_data_t *app_data);
void enterToOffslLayout(APP_data_t *app_data);
void enterToPhasLayout(APP_data_t *app_data);
void enterToDutyLayout(APP_data_t *app_data);
void enterToWavelLayout(APP_data_t *app_data);
void moveToLeftFocusFreqNumber(APP_data_t *app_data);
void moveToRighttFocusFreqNumber(APP_data_t *app_data);
void setTo0_01xFocusNumber(APP_data_t *app_data);
void setTo0_1xFocusNumber(APP_data_t *app_data);
void setTo1xFocusNumber(APP_data_t *app_data);
void setTo10xFocusNumber(APP_data_t *app_data);

306
firmware/shared_libs/controllers/ctrl_generator.c
View File

@@ -1,306 +0,0 @@
#include "main.h"
#include "spi.h"
#include "i2c.h"
#include "ctrl_app_types.h"
#include "ad9833.h"
#include "ltc2631.h"
#include "mcp41x.h"
#include "ctrl_generator.h"
typedef struct FG_handle_s FG_handle_t;
typedef struct
{
GPIO_TypeDef *port;
uint16_t pin;
} GEN_led_t;
struct FG_handle_s
{
ad9833_handle_t hdds;
ltc2631_handle_t hoffs;
mcp41x_handle_t hampl;
FG_handle_t *link[2];
GEN_led_t hled;
};
typedef uint8_t timer_handle_t;
typedef struct
{
timer_handle_t hpwm;
ltc2631_handle_t hoffs;
mcp41x_handle_t hampl;
GEN_led_t hled;
} PWM_handle_t;
typedef enum
{
FG_CHAN1,
FG_CHAN2,
FG_CHAN3,
FG_CHAN_MAX,
} FG_channel_t;
typedef enum
{
PWM_CHAN1,
PWM_CHAN2,
PWM_CHAN3,
PWM_CHAN_MAX,
} PWM_channel_t;
FG_handle_t dds_gen[FG_CHAN_MAX];
PWM_handle_t pwm_gen[PWM_CHAN_MAX];
uint8_t ch_to_gen_ch[CHANNEL_MAX] = {FG_CHAN1, FG_CHAN2, FG_CHAN3, PWM_CHAN1, PWM_CHAN2, PWM_CHAN3};
// #define DDS1_CS_PORT GPIOC
// #define DDS2_CS_PORT GPIOC
// #define DDS3_CS_PORT GPIOC
// #define DDS1_CS_PIN GPIO_PIN_0
// #define DDS2_CS_PIN GPIO_PIN_0
// #define DDS3_CS_PIN GPIO_PIN_0
// #define AMP1_CS_PORT GPIOC
// #define AMP2_CS_PORT GPIOC
// #define AMP3_CS_PORT GPIOC
// #define AMP1_CS_PIN GPIO_PIN_0
// #define AMP2_CS_PIN GPIO_PIN_0
// #define AMP3_CS_PIN GPIO_PIN_0
void led_init(GEN_led_t *hled, GPIO_TypeDef *port, uint16_t pin)
{
hled->port = port;
hled->pin = pin;
HAL_GPIO_WritePin(port, pin, GPIO_PIN_SET);
}
void led_on(GEN_led_t *hled)
{
HAL_GPIO_WritePin(hled->port, hled->pin, GPIO_PIN_RESET);
}
void led_off(GEN_led_t *hled)
{
HAL_GPIO_WritePin(hled->port, hled->pin, GPIO_PIN_SET);
}
void gen_init()
{
ad9833_init(&dds_gen[FG_CHAN1].hdds, &hspi2, DDS1_CS_GPIO_Port, DDS1_CS_Pin);
ad9833_init(&dds_gen[FG_CHAN2].hdds, &hspi2, DDS2_CS_GPIO_Port, DDS2_CS_Pin);
// ad9833_init(&dds_gen[FG_CHAN3].hdds, &hspi2, DDS3_CS_PORT, DDS3_CS_PIN);
// ltc2631_init(&dds_gen[FG_CHAN1].hoffs, &hi2c1, 0x00, LTC2631_8BIT, LTC_REF_2V5);
// ltc2631_init(&dds_gen[FG_CHAN2].hoffs, &hi2c1, 0x01, LTC2631_8BIT, LTC_REF_2V5);
// ltc2631_init(&dds_gen[FG_CHAN3].hoffs, &hi2c1, 0x02, LTC2631_8BIT, LTC_REF_2V5);
mcp41x_init(&dds_gen[FG_CHAN1].hampl, &hspi2, AMP1_CS_GPIO_Port, AMP1_CS_Pin, MCP41X_10K);
mcp41x_init(&dds_gen[FG_CHAN2].hampl, &hspi2, AMP2_CS_GPIO_Port, AMP2_CS_Pin, MCP41X_10K);
// mcp41x_init(&dds_gen[FG_CHAN3].hampl, &hspi2, AMP3_CS_PORT, AMP3_CS_PIN, MCP41X_10K);
led_init(&dds_gen[FG_CHAN1].hled, LED_CH1_GPIO_Port, LED_CH1_Pin);
led_init(&dds_gen[FG_CHAN2].hled, LED_CH2_GPIO_Port, LED_CH2_Pin);
}
static void _setAmpliude(mcp41x_handle_t *hampl, uint16_t ampl_x100)
{
uint8_t value = (ampl_x100 * UINT8_MAX) / MAX_VOLT_POS;
ULOG_DEBUG("(%d:_setAmplitude) ampl_x100: %d, value: %d", __LINE__, ampl_x100, value);
mcp41x_setValue(hampl, value);
}
static void _setOffset(ltc2631_handle_t *hoffs, int16_t offs_x100)
{
uint32_t value = (offs_x100 + MAX_VOLT_POS) * LTC_REF_2V5;
ULOG_DEBUG("(%d:_setOffset) offs_x100: %d, value: %d", __LINE__, offs_x100, value);
ltc2631_setOutputVoltage_u(hoffs, value);
}
static void _setFreqDdsGen(ad9833_handle_t *hdds, uint32_t freq)
{
ULOG_DEBUG("(%d:_setFreqDdsGen) freq: %d", __LINE__, freq);
ad9833_setFrequency(hdds, CHAN_0, freq);
}
static void _setPhaseDdsGen(ad9833_handle_t *hdds, uint32_t phas)
{
ULOG_DEBUG("(%d:_setPhaseDdsGen) phase: %d", __LINE__, phas);
ad9833_setPhase(hdds, CHAN_0, phas);
}
static void _setWaveDdsGen(ad9833_handle_t *hdds, GEN_wave_t wave)
{
ULOG_DEBUG("(%d:_setWaveDdsGen) wave: %d", __LINE__, wave);
switch (wave)
{
case GEN_SIN:
ad9833_setMode(hdds, MODE_SINE);
break;
case GEN_TRI:
ad9833_setMode(hdds, MODE_TRIANGLE);
break;
case GEN_SQR:
ad9833_setMode(hdds, MODE_SQUARE1);
break;
default:
ULOG_ERROR("%s:%d: Unknown wave type: %d", __FILE__, __LINE__, wave);
break;
}
}
static void _setEnabledDdsGen(FG_handle_t *hfg, GEN_fg_t *gen)
{
ULOG_DEBUG("(%d:_setEnabledDdsGen) enabled: %d", __LINE__, gen->enabled);
switch (gen->enabled)
{
case FALSE:
ad9833_setMode(&hfg->hdds, MODE_OFF);
led_off(&hfg->hled);
break;
case TRUE:
_setWaveDdsGen(&hfg->hdds, gen->wave);
led_on(&hfg->hled);
break;
default:
ULOG_ERROR("%s:%d: Value out of range: %d", __FILE__, __LINE__, gen->enabled);
break;
}
}
static void _setFreqPwmGen(timer_handle_t *hpwm, uint32_t freq)
{
}
static void _setPhasePwmGen(timer_handle_t *hpwm, uint16_t phas)
{
}
static void _setDutyPwmGen(timer_handle_t *hpwm, uint8_t duty)
{
}
static void _setEnabledPwmGen(PWM_handle_t *hpwm, bool_t en)
{
}
void setFreq(GEN_sig_t *gen, GEN_channel_t channel)
{
switch (gen->type)
{
case GEN_FG_TYPE:
_setFreqDdsGen(&dds_gen[ch_to_gen_ch[channel]].hdds, ((GEN_fg_t *)gen->gen)->frequency);
break;
case GEN_PWM_TYPE:
_setFreqPwmGen(&pwm_gen[ch_to_gen_ch[channel]].hpwm, ((GEN_pwm_t *)gen->gen)->frequency);
break;
default:
ULOG_ERROR("%s:%d: Unknown generator type: %d", __FILE__, __LINE__, gen->type);
break;
}
}
void setAmplitude(GEN_sig_t *gen, GEN_channel_t channel)
{
switch (gen->type)
{
case GEN_FG_TYPE:
_setAmpliude(&dds_gen[ch_to_gen_ch[channel]].hampl, ((GEN_fg_t *)gen->gen)->amplitude);
break;
case GEN_PWM_TYPE:
_setAmpliude(&pwm_gen[ch_to_gen_ch[channel]].hampl, ((GEN_pwm_t *)gen->gen)->amplitude);
break;
default:
ULOG_ERROR("%s:%d: Unknown generator type: %d", __FILE__, __LINE__, gen->type);
break;
}
}
void setOfsset(GEN_sig_t *gen, GEN_channel_t channel)
{
switch (gen->type)
{
case GEN_FG_TYPE:
_setOffset(&dds_gen[ch_to_gen_ch[channel]].hoffs, ((GEN_fg_t *)gen->gen)->offset);
break;
case GEN_PWM_TYPE:
_setOffset(&pwm_gen[ch_to_gen_ch[channel]].hoffs, ((GEN_pwm_t *)gen->gen)->offset);
break;
default:
ULOG_ERROR("%s:%d: Unknown generator type: %d", __FILE__, __LINE__, gen->type);
break;
}
}
void setPhase(GEN_sig_t *gen, GEN_channel_t channel)
{
switch (gen->type)
{
case GEN_FG_TYPE:
_setPhaseDdsGen(&dds_gen[ch_to_gen_ch[channel]].hdds, ((GEN_fg_t *)gen->gen)->phase);
break;
case GEN_PWM_TYPE:
_setPhasePwmGen(&pwm_gen[ch_to_gen_ch[channel]].hpwm, ((GEN_pwm_t *)gen->gen)->phase);
break;
default:
ULOG_ERROR("%s:%d: Unknown generator type: %d", __FILE__, __LINE__, gen->type);
break;
}
}
void setWave(GEN_sig_t *gen, GEN_channel_t channel)
{
switch (gen->type)
{
case GEN_FG_TYPE:
_setWaveDdsGen(&dds_gen[ch_to_gen_ch[channel]].hdds, ((GEN_fg_t *)gen->gen)->wave);
break;
default:
ULOG_ERROR("%s:%d: Unknown generator type: %d", __FILE__, __LINE__, gen->type);
break;
}
}
void setDuty(GEN_sig_t *gen, GEN_channel_t channel)
{
switch (gen->type)
{
case GEN_PWM_TYPE:
_setDutyPwmGen(&pwm_gen[ch_to_gen_ch[channel]].hpwm, ((GEN_pwm_t *)gen->gen)->duty);
break;
default:
ULOG_ERROR("%s:%d: Unknown generator type: %d", __FILE__, __LINE__, gen->type);
break;
}
}
void setEnabled(GEN_sig_t *gen, GEN_channel_t channel)
{
switch (gen->type)
{
case GEN_FG_TYPE:
_setEnabledDdsGen(&dds_gen[ch_to_gen_ch[channel]], ((GEN_fg_t *)gen->gen));
break;
case GEN_PWM_TYPE:
_setEnabledPwmGen(&pwm_gen[ch_to_gen_ch[channel]], ((GEN_pwm_t *)gen->gen)->enabled);
break;
default:
ULOG_ERROR("%s:%d: Unknown generator type: %d", __FILE__, __LINE__, gen->type);
break;
}
}
void setLink(GEN_sig_t *source_gen, GEN_channel_t source_ch, GEN_sig_t *dest_gen, GEN_channel_t dest_ch)
{
}

12
firmware/shared_libs/controllers/ctrl_generator.h
View File

@@ -1,12 +0,0 @@
#pragma once
#include "ctrl_app.h"
void setLink(GEN_sig_t *source_gen, GEN_channel_t source_ch, GEN_sig_t *dest_gen, GEN_channel_t dest_ch);
void setEnabled(GEN_sig_t *gen, GEN_channel_t channel);
void setDuty(GEN_sig_t *gen, GEN_channel_t channel);
void setWave(GEN_sig_t *gen, GEN_channel_t channel);
void setPhase(GEN_sig_t *gen, GEN_channel_t channel);
void setOfsset(GEN_sig_t *gen, GEN_channel_t channel);
void setAmplitude(GEN_sig_t *gen, GEN_channel_t channel);
void setFreq(GEN_sig_t *gen, GEN_channel_t channel);
void gen_init();

478
firmware/shared_libs/controllers/ctrl_signal_gen.c Normal file
View File

@@ -0,0 +1,478 @@
#include "spi.h"
#include "ctrl_app_types.h"
#include "mcu_cs.h"
#include "led.h"
static MCU_cs_t mcu_cs[MCU_CS_MAX];
// ************************
// INITIALIZATION
// ************************
static void _dds_init(dds_gen_t *dds_gen)
{
dds_gen->link.next = &dds_gen->super;
dds_gen->link.prev = &dds_gen->super;
switch (dds_gen->dds_ch)
{
case DDS_CH1:
mcu_cs_init(&mcu_cs[MCU_CS1], DDS1_CS_GPIO_Port, DDS1_CS_Pin, GPIO_PIN_SET);
ad9833_init(&dds_gen->handle.hdds, &hspi2, &mcu_cs[MCU_CS1].super);
mcu_cs_init(&mcu_cs[MCU_CS2], AMP1_CS_GPIO_Port, AMP1_CS_Pin, GPIO_PIN_SET);
mcp41x_init(&dds_gen->handle.hampl, &hspi2, &mcu_cs[MCU_CS2].super, MCP41X_10K);
led_init(&dds_gen->handle.hled, LED_CH1_GPIO_Port, LED_CH1_Pin);
break;
case DDS_CH2:
mcu_cs_init(&mcu_cs[MCU_CS3], DDS2_CS_GPIO_Port, DDS2_CS_Pin, GPIO_PIN_SET);
ad9833_init(&dds_gen->handle.hdds, &hspi2, &mcu_cs[MCU_CS3].super);
mcu_cs_init(&mcu_cs[MCU_CS4], AMP2_CS_GPIO_Port, AMP2_CS_Pin, GPIO_PIN_SET);
mcp41x_init(&dds_gen->handle.hampl, &hspi2, &mcu_cs[MCU_CS4].super, MCP41X_10K);
led_init(&dds_gen->handle.hled, LED_CH2_GPIO_Port, LED_CH2_Pin);
break;
case DDS_CH3:
break;
default:
break;
}
}
static void _pwm_init(pwm_gen_t *pwm_gen)
{
switch (pwm_gen->pwm_ch)
{
case PWM_CH1:
break;
case PWM_CH2:
break;
case PWM_CH3:
break;
default:
break;
}
}
void GEN_init(signal_gen_t **signal_gen)
{
for (GEN_channel_t channel = CHANNEL1; channel < CHANNEL_MAX; channel++)
{
switch (signal_gen[channel]->type)
{
case GEN_FG_TYPE:
_dds_init((dds_gen_t *)signal_gen[channel]);
case GEN_PWM_TYPE:
_pwm_init((pwm_gen_t *)signal_gen[channel]);
default:
break;
}
}
// ad9833_init(&dds_gen[FG_CHAN3].hdds, &hspi2, DDS3_CS_PORT, DDS3_CS_PIN);
// ltc2631_init(&dds_gen[FG_CHAN1].hoffs, &hi2c1, 0x00, LTC2631_8BIT, LTC_REF_2V5);
// ltc2631_init(&dds_gen[FG_CHAN2].hoffs, &hi2c1, 0x01, LTC2631_8BIT, LTC_REF_2V5);
// ltc2631_init(&dds_gen[FG_CHAN3].hoffs, &hi2c1, 0x02, LTC2631_8BIT, LTC_REF_2V5);
// mcp41x_init(&dds_gen[FG_CHAN3].hampl, &hspi2, AMP3_CS_PORT, AMP3_CS_PIN, MCP41X_10K);
}
// ************************
// AMPLITIUDE
// ************************
static void _setAmpliude(mcp41x_handle_t *hampl, uint16_t ampl_x100)
{
uint8_t value = (ampl_x100 * UINT8_MAX) / MAX_VOLT_POS;
ULOG_DEBUG("(%d:_setAmplitude) ampl_x100: %d, value: %d", __LINE__, ampl_x100, value);
mcp41x_setValue(hampl, value);
}
void setAmplitude(signal_gen_t *sig_gen)
{
static signal_gen_t *curr_sig_gen = NULL;
if (curr_sig_gen == NULL)
{
curr_sig_gen = sig_gen;
}
switch (sig_gen->type)
{
case GEN_FG_TYPE:
{
dds_gen_t *dds_gen = (dds_gen_t *)sig_gen;
signal_gen_t *next_sig_gen = dds_gen->link.next;
_setAmpliude(&dds_gen->handle.hampl, dds_gen->settings.amplitude);
if (next_sig_gen != curr_sig_gen)
{
setAmplitude(next_sig_gen);
}
else
{
curr_sig_gen = NULL;
}
break;
}
case GEN_PWM_TYPE:
{
pwm_gen_t *pwm_gen = (pwm_gen_t *)sig_gen;
signal_gen_t *next_sig_gen = pwm_gen->link.next;
_setAmpliude(&pwm_gen->handle.hampl, pwm_gen->settings.amplitude);
if (next_sig_gen != curr_sig_gen)
{
setAmplitude(next_sig_gen);
}
else
{
curr_sig_gen = NULL;
}
break;
}
default:
ULOG_ERROR("%s:%d: Unknown generator type: %d", __FILE__, __LINE__, sig_gen->type);
break;
}
}
// ************************
// OFFSET
// ************************
static void _setOffset(ltc2631_handle_t *hoffs, int16_t offs_x100)
{
uint32_t value = (offs_x100 + MAX_VOLT_POS) * LTC_REF_2V5;
ULOG_DEBUG("(%d:_setOffset) offs_x100: %d, value: %d", __LINE__, offs_x100, value);
ltc2631_setOutputVoltage_u(hoffs, value);
}
void setOfsset(signal_gen_t *sig_gen)
{
static signal_gen_t *curr_sig_gen = NULL;
if (curr_sig_gen == NULL)
{
curr_sig_gen = sig_gen;
}
switch (sig_gen->type)
{
case GEN_FG_TYPE:
{
dds_gen_t *dds_gen = (dds_gen_t *)sig_gen;
signal_gen_t *next_sig_gen = dds_gen->link.next;
_setOffset(&dds_gen->handle.hoffs, dds_gen->settings.offset);
if (next_sig_gen != curr_sig_gen)
{
setOfsset(next_sig_gen);
}
else
{
curr_sig_gen = NULL;
}
break;
}
case GEN_PWM_TYPE:
{
pwm_gen_t *pwm_gen = (pwm_gen_t *)sig_gen;
signal_gen_t *next_sig_gen = pwm_gen->link.next;
_setOffset(&pwm_gen->handle.hoffs, pwm_gen->settings.offset);
if (next_sig_gen != curr_sig_gen)
{
setOfsset(next_sig_gen);
}
else
{
curr_sig_gen = NULL;
}
break;
}
default:
ULOG_ERROR("%s:%d: Unknown generator type: %d", __FILE__, __LINE__, sig_gen->type);
break;
}
}
// ************************
// FREQUENCY
// ************************
static void _setFreqDdsGen(ad9833_handle_t *hdds, uint32_t freq)
{
ULOG_DEBUG("(%d:_setFreqDdsGen) freq: %d", __LINE__, freq);
ad9833_setFrequency(hdds, CHAN_0, freq);
}
static void _setFreqPwmGen(timer_handle_t *hpwm, uint32_t freq)
{
}
void setFrequency(signal_gen_t *sig_gen)
{
static signal_gen_t *curr_sig_gen = NULL;
if (curr_sig_gen == NULL)
{
curr_sig_gen = sig_gen;
}
switch (sig_gen->type)
{
case GEN_FG_TYPE:
{
dds_gen_t *dds_gen = (dds_gen_t *)sig_gen;
signal_gen_t *next_sig_gen = dds_gen->link.next;
ad9833_spi_activate(&dds_gen->handle.hdds);
if (next_sig_gen != curr_sig_gen)
{
setFrequency(next_sig_gen);
}
else
{
_setFreqDdsGen(&dds_gen->handle.hdds, dds_gen->settings.frequency);
curr_sig_gen = NULL;
}
ad9833_spi_deactivate(&dds_gen->handle.hdds);
break;
}
case GEN_PWM_TYPE:
{
pwm_gen_t *pwm_gen = (pwm_gen_t *)sig_gen;
signal_gen_t *next_sig_gen = pwm_gen->link.next;
_setFreqPwmGen(&pwm_gen->handle.hpwm, pwm_gen->settings.frequency);
if (next_sig_gen != curr_sig_gen)
{
setFrequency(next_sig_gen);
}
else
{
curr_sig_gen = NULL;
}
break;
}
default:
ULOG_ERROR("%s:%d: Unknown generator type: %d", __FILE__, __LINE__, sig_gen->type);
break;
}
}
// ************************
// PHASE
// ************************
static void _setPhaseDdsGen(ad9833_handle_t *hdds, uint32_t phas)
{
ULOG_DEBUG("(%d:_setPhaseDdsGen) phase: %d", __LINE__, phas);
ad9833_setPhase(hdds, CHAN_0, phas);
}
static void _setPhasePwmGen(timer_handle_t *hpwm, uint16_t phas)
{
}
void setPhase(signal_gen_t *sig_gen)
{
static signal_gen_t *curr_sig_gen = NULL;
if (curr_sig_gen == NULL)
{
curr_sig_gen = sig_gen;
}
switch (sig_gen->type)
{
case GEN_FG_TYPE:
{
dds_gen_t *dds_gen = (dds_gen_t *)sig_gen;
signal_gen_t *next_sig_gen = dds_gen->link.next;
ad9833_spi_activate(&dds_gen->handle.hdds);
if (next_sig_gen != curr_sig_gen)
{
setPhase(next_sig_gen);
}
else
{
_setPhaseDdsGen(&dds_gen->handle.hdds, dds_gen->settings.phase);
curr_sig_gen = NULL;
}
ad9833_spi_deactivate(&dds_gen->handle.hdds);
break;
}
case GEN_PWM_TYPE:
{
pwm_gen_t *pwm_gen = (pwm_gen_t *)sig_gen;
signal_gen_t *next_sig_gen = pwm_gen->link.next;
_setPhasePwmGen(&pwm_gen->handle.hpwm, pwm_gen->settings.phase);
if (next_sig_gen != curr_sig_gen)
{
setPhase(next_sig_gen);
}
else
{
curr_sig_gen = NULL;
}
break;
}
default:
ULOG_ERROR("%s:%d: Unknown generator type: %d", __FILE__, __LINE__, sig_gen->type);
break;
}
}
// ************************
// DUTY
// ************************
static void _setDutyPwmGen(timer_handle_t *hpwm, uint8_t duty)
{
}
void setDuty(signal_gen_t *sig_gen)
{
switch (sig_gen->type)
{
case GEN_PWM_TYPE:
{
pwm_gen_t *pwm_gen = (pwm_gen_t *)sig_gen;
_setDutyPwmGen(&pwm_gen->handle.hpwm, pwm_gen->settings.duty);
break;
}
default:
ULOG_ERROR("%s:%d: Unknown generator type: %d", __FILE__, __LINE__, sig_gen->type);
break;
}
}
// ************************
// WAVE
// ************************
static void _setWaveDdsGen(ad9833_handle_t *hdds, GEN_wave_t wave)
{
ULOG_DEBUG("(%d:_setWaveDdsGen) wave: %d", __LINE__, wave);
switch (wave)
{
case GEN_SIN:
ad9833_setMode(hdds, MODE_SINE);
break;
case GEN_TRI:
ad9833_setMode(hdds, MODE_TRIANGLE);
break;
case GEN_SQR:
ad9833_setMode(hdds, MODE_SQUARE1);
break;
default:
ULOG_ERROR("%s:%d: Unknown wave type: %d", __FILE__, __LINE__, wave);
break;
}
}
void setWave(signal_gen_t *sig_gen)
{
switch (sig_gen->type)
{
case GEN_FG_TYPE:
{
dds_gen_t *dds_gen = (dds_gen_t *)sig_gen;
_setWaveDdsGen(&dds_gen->handle.hdds, dds_gen->settings.wave);
break;
}
default:
ULOG_ERROR("%s:%d: Unknown generator type: %d", __FILE__, __LINE__, sig_gen->type);
break;
}
}
// ************************
// ENABLE
// ************************
static void _setEnabledDdsGen(dds_handle_t *hfg, dds_settings_t *settings)
{
ULOG_DEBUG("(%d:_setEnabledDdsGen) enabled: %d", __LINE__, settings->enabled);
switch (settings->enabled)
{
case FALSE:
ad9833_setMode(&hfg->hdds, MODE_OFF);
led_off(&hfg->hled);
break;
case TRUE:
_setWaveDdsGen(&hfg->hdds, settings->wave);
led_on(&hfg->hled);
break;
default:
ULOG_ERROR("%s:%d: Value out of range: %d", __FILE__, __LINE__, settings->enabled);
break;
}
}
static void _setEnabledPwmGen(timer_handle_t *hpwm, bool_t en)
{
}
void setEnabled(signal_gen_t *sig_gen)
{
switch (sig_gen->type)
{
case GEN_FG_TYPE:
{
dds_gen_t *dds_gen = (dds_gen_t *)sig_gen;
_setEnabledDdsGen(&dds_gen->handle, &dds_gen->settings);
break;
}
case GEN_PWM_TYPE:
{
pwm_gen_t *pwm_gen = (pwm_gen_t *)sig_gen;
_setEnabledPwmGen(&pwm_gen->handle.hpwm, pwm_gen->settings.enabled);
break;
}
default:
ULOG_ERROR("%s:%d: Unknown generator type: %d", __FILE__, __LINE__, sig_gen->type);
break;
}
}
// ************************
// LINK
// ************************
void setLink(signal_gen_t *source_gen, signal_gen_t *dest_gen)
{
}

12
firmware/shared_libs/controllers/ctrl_signal_gen.h Normal file
View File

@@ -0,0 +1,12 @@
#pragma once
#include "ctrl_app_types.h"
void setLink(signal_gen_t *source_gen, signal_gen_t *dest_gen);
void setEnabled(signal_gen_t *gen);
void setDuty(signal_gen_t *gen);
void setWave(signal_gen_t *gen);
void setPhase(signal_gen_t *gen);
void setOfsset(signal_gen_t *gen);
void setAmplitude(signal_gen_t *gen);
void setFrequency(signal_gen_t *gen);
void GEN_init(signal_gen_t **signal_gen);