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

66
firmware/shared_libs/disp_layout/disp_layout.c
View File

@@ -74,7 +74,7 @@ static void _blinkButtons(GFX_display_t *disp, APP_data_t *app_data)
BITMAP_buttonName_t bitmap_idx;
for (LAY_dispBtn_t btn_idx = DISP_BTN_1; btn_idx < DISP_BTN_MAX; btn_idx++)
{
if (!(app_data->isButtonBlink & (1 << btn_idx)))
if (!(app_data->button_blink & (1 << btn_idx)))
{
continue;
}
@@ -88,7 +88,7 @@ static void _blinkButtons(GFX_display_t *disp, APP_data_t *app_data)
else
{
DISP_drawBitmap(disp, &bitmap_btnBottom[bitmap_idx], btn_pos_x[btn_idx], 53, BM_NORMAL);
app_data->isButtonBlink &= ~(1 << btn_idx);
app_data->button_blink &= ~(1 << btn_idx);
}
}
}
@@ -105,7 +105,7 @@ static void _drawButtons(GFX_display_t *disp, APP_data_t *app_data)
DISP_drawBitmap(disp, &bitmap_btnBottom[bitmap_idx], btn_pos_x[btn_idx], 53, BM_NORMAL);
}
app_data->isButtonChange = 0;
app_data->disp_update &= ~(UPDATE_BUTTON);
}
static uint8_t _calcMarkerPos(uint32_t value, uint32_t max)
@@ -180,24 +180,24 @@ static void _drawPhaseValueHelper(GFX_display_t *disp, uint32_t phase, uint8_t f
static void _drawFuncGenValues(GFX_display_t *disp, APP_data_t *app_data)
{
GEN_fg_t *fun_gen = (GEN_fg_t *)app_data->curr_gen;
dds_gen_t *fun_gen = (dds_gen_t *)app_data->curr_gen;
switch (app_data->curr_state_lay)
{
case LAY_FREQ:
_drawFreqValueHelper(disp, fun_gen->frequency, app_data->freq_focus_digit);
_drawMeterHelper(disp, "1", "1M", _calcMarkerPos(fun_gen->frequency, MAX_FREQ));
_drawFreqValueHelper(disp, fun_gen->settings.frequency, app_data->freq_focus_digit);
_drawMeterHelper(disp, "1", "1M", _calcMarkerPos(fun_gen->settings.frequency, MAX_FREQ));
break;
case LAY_AMPL:
_drawAmplValueHelper(disp, fun_gen->amplitude, app_data->ampl_focus_digit);
_drawMeterHelper(disp, "0V", "5V", _calcMarkerPos(fun_gen->amplitude, MAX_VOLT_POS));
_drawAmplValueHelper(disp, fun_gen->settings.amplitude, app_data->ampl_focus_digit);
_drawMeterHelper(disp, "0V", "5V", _calcMarkerPos(fun_gen->settings.amplitude, MAX_VOLT_POS));
break;
case LAY_OFFS:
_drawOffsValueHelper(disp, fun_gen->offset, app_data->offs_focus_digit);
_drawMeterHelper(disp, "-5V", "+5V", _calcMarkerPos(MAX_VOLT_POS + fun_gen->offset, MAX_VOLT_POS * 2));
_drawOffsValueHelper(disp, fun_gen->settings.offset, app_data->offs_focus_digit);
_drawMeterHelper(disp, "-5V", "+5V", _calcMarkerPos(MAX_VOLT_POS + fun_gen->settings.offset, MAX_VOLT_POS * 2));
break;
case LAY_PHAS:
_drawPhaseValueHelper(disp, fun_gen->phase, app_data->phas_focus_digit);
_drawMeterHelper(disp, "0", "360", _calcMarkerPos(fun_gen->phase, MAX_PHAS));
_drawPhaseValueHelper(disp, fun_gen->settings.phase, app_data->phas_focus_digit);
_drawMeterHelper(disp, "0", "360", _calcMarkerPos(fun_gen->settings.phase, MAX_PHAS));
break;
case LAY_MAIN:
DISP_clearRegion(disp, 62, 13, 66, 40);
@@ -206,10 +206,10 @@ static void _drawFuncGenValues(GFX_display_t *disp, APP_data_t *app_data)
DISP_writeString(disp, &font5x7Info, (uint8_t *)"O:", 64, 33, BM_NORMAL);
DISP_writeString(disp, &font5x7Info, (uint8_t *)"P:", 64, 43, BM_NORMAL);
_drawFreqValue(disp, fun_gen->frequency, 13);
_drawAmplValue(disp, fun_gen->amplitude, 23);
_drawOffsValue(disp, fun_gen->offset, 33);
_drawPhasValue(disp, fun_gen->phase, 43);
_drawFreqValue(disp, fun_gen->settings.frequency, 13);
_drawAmplValue(disp, fun_gen->settings.amplitude, 23);
_drawOffsValue(disp, fun_gen->settings.offset, 33);
_drawPhasValue(disp, fun_gen->settings.phase, 43);
break;
default:
@@ -226,7 +226,7 @@ static void _drawPwmGenValues(GFX_display_t *disp, APP_data_t *app_data)
static void _drawValues(GFX_display_t *disp, APP_data_t *app_data)
{
// input: frequency(value), amplitiude(value), offset(value), phase(value), duty(value), invert(info), position(value)
switch (app_data->curr_gen_type)
switch (app_data->curr_gen->type)
{
case GEN_FG_TYPE:
_drawFuncGenValues(disp, app_data);
@@ -239,7 +239,7 @@ static void _drawValues(GFX_display_t *disp, APP_data_t *app_data)
break;
}
app_data->isValueChange = 0;
app_data->disp_update &= ~(UPDATE_VALUE);
}
static void _drawOffsetLine(GFX_display_t *disp, int16_t offs, uint32_t ampl)
@@ -264,26 +264,26 @@ static void _drawOffsetLine(GFX_display_t *disp, int16_t offs, uint32_t ampl)
static void _drawFunGenGraph(GFX_display_t *disp, APP_data_t *app_data)
{
GEN_fg_t *fun_gen = (GEN_fg_t *)app_data->curr_gen;
dds_gen_t *fun_gen = (dds_gen_t *)app_data->curr_gen;
DISP_clearRegion(disp, 3, 12, 57, 40);
switch (fun_gen->wave)
switch (fun_gen->settings.wave)
{
case GEN_SIN:
DISP_drawBitmapShift(disp, &wave[WAVE_SIN], 6, 19, _calcPhaseShiftInPxl(fun_gen->phase, 360), BM_NORMAL);
DISP_drawBitmapShift(disp, &wave[WAVE_SIN], 6, 19, _calcPhaseShiftInPxl(fun_gen->settings.phase, 360), BM_NORMAL);
break;
case GEN_TRI:
DISP_drawBitmapShift(disp, &wave[WAVE_TRI], 6, 19, _calcPhaseShiftInPxl(fun_gen->phase, 360), BM_NORMAL);
DISP_drawBitmapShift(disp, &wave[WAVE_TRI], 6, 19, _calcPhaseShiftInPxl(fun_gen->settings.phase, 360), BM_NORMAL);
break;
case GEN_SQR:
DISP_drawBitmapShift(disp, &wave[WAVE_SQR], 6, 19, _calcPhaseShiftInPxl(fun_gen->phase, 360), BM_NORMAL);
DISP_drawBitmapShift(disp, &wave[WAVE_SQR], 6, 19, _calcPhaseShiftInPxl(fun_gen->settings.phase, 360), BM_NORMAL);
break;
default:
break;
}
_drawOffsetLine(disp, fun_gen->offset, fun_gen->amplitude);
// _drawMaxAmpLine(disp, fun_gen->offset, fun_gen->amplitude);
_drawOffsetLine(disp, fun_gen->settings.offset, fun_gen->settings.amplitude);
// _drawMaxAmpLine(disp, fun_gen->settings.offset, fun_gen->settings.amplitude);
}
static void _drawPwmGenGraph(GFX_display_t *disp, APP_data_t *app_data)
{
@@ -294,7 +294,7 @@ static void _drawGraph(GFX_display_t *disp, APP_data_t *app_data)
// input: graph type(sin, triangle, squere, pwm), frequency(info), amplitiude(value), offset(value), phase(value), invert(pwm),
DISP_drawVerticalLine(disp, 2, 12, 40, GFX_WHITE);
switch (app_data->curr_gen_type)
switch (app_data->curr_gen->type)
{
case GEN_FG_TYPE:
_drawFunGenGraph(disp, app_data);
@@ -307,7 +307,7 @@ static void _drawGraph(GFX_display_t *disp, APP_data_t *app_data)
break;
}
app_data->isGraphChange = 0;
app_data->disp_update &= ~(UPDATE_GRAPH);
}
static void _drawChannels(GFX_display_t *disp, APP_data_t *app_data)
@@ -321,23 +321,23 @@ static void _drawChannels(GFX_display_t *disp, APP_data_t *app_data)
DISP_writeString(disp, &font5x7Info, (uint8_t *)"CH6", 107, 2, CHANNEL6 == app_data->curr_channel ? BM_INVERSE : BM_NORMAL);
DISP_drawHorizontalLine(disp, 0, 10, 127, GFX_WHITE);
app_data->isChannelChange = 0;
app_data->disp_update &= ~(UPDATE_CHANNEL);
}
void LAY_drawDisplayLayout(GFX_display_t *disp, APP_data_t *app_data)
{
if (app_data->isChannelChange)
if (app_data->disp_update & UPDATE_CHANNEL)
_drawChannels(disp, app_data);
if (app_data->isValueChange)
if (app_data->disp_update & UPDATE_VALUE)
_drawValues(disp, app_data);
if (app_data->isGraphChange)
if (app_data->disp_update & UPDATE_GRAPH)
_drawGraph(disp, app_data);
if (app_data->isButtonChange)
if (app_data->disp_update & UPDATE_BUTTON)
_drawButtons(disp, app_data);
if (app_data->isButtonBlink)
if (app_data->button_blink)
_blinkButtons(disp, app_data);
}

16
firmware/shared_libs/drivers/ad9833/ad9833.c
View File

@@ -9,12 +9,14 @@
void ad9833_spi_activate(ad9833_handle_t *hfg)
{
HAL_GPIO_WritePin(hfg->cs_port, hfg->cs_pin, GPIO_PIN_RESET);
// HAL_GPIO_WritePin(hfg->cs_port, hfg->cs_pin, GPIO_PIN_RESET);
hfg->hcs->cs_on(hfg->hcs);
}
void ad9833_spi_deactivate(ad9833_handle_t *hfg)
{
HAL_GPIO_WritePin(hfg->cs_port, hfg->cs_pin, GPIO_PIN_SET);
// HAL_GPIO_WritePin(hfg->cs_port, hfg->cs_pin, GPIO_PIN_SET);
hfg->hcs->cs_off(hfg->hcs);
}
static void ad9833_transmit16(ad9833_handle_t *hfg, uint16_t data)
@@ -41,16 +43,15 @@ void ad9833_reset(ad9833_handle_t *hfg, uint8_t hold)
}
}
void ad9833_init(ad9833_handle_t *hfg, SPI_HandleTypeDef *hspi, GPIO_TypeDef *cs_port, uint16_t cs_pin)
void ad9833_init(ad9833_handle_t *hfg, SPI_HandleTypeDef *hspi, cs_handle_t *hcs)
// Initialise the AD9833 and then set up safe values for the AD9833 device
// Procedure from Figure 27 of in the AD9833 Data Sheet
{
// initialise our preferred CS pin (could be same as SS)
hfg->hspi = hspi;
hfg->cs_port = cs_port;
hfg->cs_pin = cs_pin;
hfg->hcs = hcs;
HAL_GPIO_WritePin(hfg->cs_port, hfg->cs_pin, GPIO_PIN_SET);
hfg->hcs->cs_off(hfg->hcs);
hfg->_regCtl = 0;
hfg->_regCtl |= (1 << AD_B28); // always write 2 words consecutively for frequency
@@ -181,8 +182,6 @@ void ad9833_setFrequency(ad9833_handle_t *hfg, AD_channel_t chan, uint32_t freq)
// PRINT("\nsetFreq CHAN_", chan);
uint16_t freq_channel = 0;
hfg->_freq[chan] = freq;
hfg->_regFreq[chan] = ad9833_calcFreq_uint(freq);
// select the address mask
@@ -215,7 +214,6 @@ void ad9833_setPhase(ad9833_handle_t *hfg, AD_channel_t chan, uint16_t phase)
// PRINT("\nsetPhase CHAN_", chan);
uint16_t phase_channel = 0;
hfg->_phase[chan] = phase;
hfg->_regPhase[chan] = ad9833_calcPhase_uint(phase);
// select the address mask

11
firmware/shared_libs/drivers/ad9833/ad9833.h
View File

@@ -1,5 +1,7 @@
#pragma once
#include "spi_cs_if.h"
#define AD_DEFAULT_FREQ 1000U ///< Default initialisation frequency (Hz)
#define AD_DEFAULT_PHASE 0 ///< Default initialisation phase angle (degrees)
#define AD_MCLK 25000000U ///< Clock speed of the AD9833 reference clock in Hz
@@ -37,16 +39,13 @@ typedef struct
uint32_t _regFreq[2]; // frequency registers
uint32_t _regPhase[2]; // phase registers
AD_mode_t _mode; // last set mode
float _freq[2]; // last frequencies set
uint16_t _phase[2]; // last phase setting
AD_mode_t _mode; // last set mode
SPI_HandleTypeDef *hspi;
GPIO_TypeDef *cs_port;
uint16_t cs_pin;
cs_handle_t *hcs;
} ad9833_handle_t;
void ad9833_init(ad9833_handle_t *hfg, SPI_HandleTypeDef *hspi, GPIO_TypeDef *cs_port, uint16_t cs_pin);
void ad9833_init(ad9833_handle_t *hfg, SPI_HandleTypeDef *hspi, cs_handle_t *hcs);
void ad9833_spi_activate(ad9833_handle_t *hfg);
void ad9833_spi_deactivate(ad9833_handle_t *hfg);
void ad9833_reset(ad9833_handle_t *hfg, uint8_t hold);

19
firmware/shared_libs/drivers/led/led.c Normal file
View File

@@ -0,0 +1,19 @@
#include "led.h"
void led_init(led_handle_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(led_handle_t *hled)
{
HAL_GPIO_WritePin(hled->port, hled->pin, GPIO_PIN_RESET);
}
void led_off(led_handle_t *hled)
{
HAL_GPIO_WritePin(hled->port, hled->pin, GPIO_PIN_SET);
}

8
firmware/shared_libs/drivers/led/led.h Normal file
View File

@@ -0,0 +1,8 @@
#pragma once
#include "gpio.h"
#include "ctrl_app_types.h"
void led_init(led_handle_t *hled, GPIO_TypeDef *port, uint16_t pin);
void led_on(led_handle_t *hled);
void led_off(led_handle_t *hled);

11
firmware/shared_libs/drivers/mcp41x/mcp41x.c
View File

@@ -5,20 +5,19 @@ static uint32_t pot_value[MCP41X_RES_MAX] = {10000, 50000, 100000};
static void mcp41x_transmit(mcp41x_handle_t *hpot, uint8_t *data)
{
HAL_GPIO_WritePin(hpot->cs_port, hpot->cs_pin, GPIO_PIN_RESET);
hpot->hcs->cs_on(hpot->hcs);
HAL_SPI_Transmit(hpot->hspi, data, 2, HAL_MAX_DELAY);
HAL_GPIO_WritePin(hpot->cs_port, hpot->cs_pin, GPIO_PIN_SET);
hpot->hcs->cs_off(hpot->hcs);
}
void mcp41x_init(mcp41x_handle_t *hpot, SPI_HandleTypeDef *hspi, GPIO_TypeDef *cs_port, uint16_t cs_pin, mcp41x_res_t res)
void mcp41x_init(mcp41x_handle_t *hpot, SPI_HandleTypeDef *hspi, cs_handle_t *hcs, mcp41x_res_t res)
{
hpot->hspi = hspi;
hpot->cs_port = cs_port;
hpot->cs_pin = cs_pin;
hpot->hcs = hcs;
hpot->max_res = res;
hpot->dir = MCP41X_ATOB;
HAL_GPIO_WritePin(hpot->cs_port, hpot->cs_pin, GPIO_PIN_SET);
hpot->hcs->cs_off(hcs);
}
void mcp41x_setValue(mcp41x_handle_t *hpot, uint8_t value)

7
firmware/shared_libs/drivers/mcp41x/mcp41x.h
View File

@@ -1,5 +1,7 @@
#pragma once
#include "spi_cs_if.h"
#define MCP41X_C1 5
#define MCP41X_C0 4
#define MCP41X_P1 1
@@ -36,11 +38,10 @@ typedef struct
uint8_t value;
SPI_HandleTypeDef *hspi;
GPIO_TypeDef *cs_port;
uint16_t cs_pin;
cs_handle_t *hcs;
} mcp41x_handle_t;
void mcp41x_init(mcp41x_handle_t *hpot, SPI_HandleTypeDef *hspi, GPIO_TypeDef *cs_port, uint16_t cs_pin, mcp41x_res_t res);
void mcp41x_init(mcp41x_handle_t *hpot, SPI_HandleTypeDef *hspi, cs_handle_t *hcs, mcp41x_res_t res);
void mcp41x_setValue(mcp41x_handle_t *hpot, uint8_t value);
void mcp41x_setVolume(mcp41x_handle_t *hpot, uint8_t volume);
uint8_t mcp41x_getVolume(mcp41x_handle_t *hpot);

24
firmware/shared_libs/drivers/mcu_cs/mcu_cs.c Normal file
View File

@@ -0,0 +1,24 @@
#include "mcu_cs.h"
// static cs_handle_t const _cs_handle = {.cs_on = mcu_cs_on, .cs_off = mcu_cs_off};
void mcu_cs_init(MCU_cs_t *hcs, GPIO_TypeDef *cs_port, uint16_t cs_pin, uint8_t cs_idle)
{
hcs->super.cs_on = mcu_cs_on;
hcs->super.cs_off = mcu_cs_off;
hcs->cs_port = cs_port;
hcs->cs_pin = cs_pin;
hcs->cs_idle = cs_idle;
}
void mcu_cs_on(cs_handle_t *hcs)
{
MCU_cs_t *_hcs = (MCU_cs_t *)hcs;
HAL_GPIO_WritePin(_hcs->cs_port, _hcs->cs_pin, !_hcs->cs_idle);
}
void mcu_cs_off(cs_handle_t *hcs)
{
MCU_cs_t *_hcs = (MCU_cs_t *)hcs;
HAL_GPIO_WritePin(_hcs->cs_port, _hcs->cs_pin, _hcs->cs_idle);
}

16
firmware/shared_libs/drivers/mcu_cs/mcu_cs.h Normal file
View File

@@ -0,0 +1,16 @@
#pragma once
#include "main.h"
#include "spi_cs_if.h"
typedef struct
{
cs_handle_t super;
GPIO_TypeDef *cs_port;
uint16_t cs_pin;
uint8_t cs_idle;
} MCU_cs_t;
void mcu_cs_init(MCU_cs_t *hcs, GPIO_TypeDef *cs_port, uint16_t cs_pin, uint8_t cs_idle);
void mcu_cs_on(cs_handle_t *me);
void mcu_cs_off(cs_handle_t *me);

14
firmware/shared_libs/utils/spi_cs/spi_cs_if.h Normal file
View File

@@ -0,0 +1,14 @@
#pragma once
#include "stdint.h"
typedef struct cs_handle_t cs_handle_t;
typedef void (*cs_on_t)(cs_handle_t *hcs);
typedef void (*cs_off_t)(cs_handle_t *hcs);
struct cs_handle_t
{
cs_on_t cs_on;
cs_off_t cs_off;
};