2020-04-01 10:04:42 +00:00
|
|
|
#include "drivers/adc.h"
|
2020-03-27 21:36:04 +00:00
|
|
|
#include "drivers/dac.h"
|
2020-04-23 20:06:40 +00:00
|
|
|
#include "drivers/leds.h"
|
2020-04-13 13:39:01 +00:00
|
|
|
#include "drivers/peripherals.h"
|
2020-04-24 09:48:19 +00:00
|
|
|
#include "drivers/switches.h"
|
2020-04-01 10:04:42 +00:00
|
|
|
#include "resources.h"
|
2020-04-24 09:48:19 +00:00
|
|
|
#include "stmlib/ui/event_queue.h"
|
2020-04-10 18:21:18 +00:00
|
|
|
#include <stm32f0xx_hal.h>
|
2020-04-01 10:04:42 +00:00
|
|
|
|
|
|
|
using namespace stereo_mix;
|
2020-04-24 09:48:19 +00:00
|
|
|
using namespace stmlib;
|
2020-04-01 10:04:42 +00:00
|
|
|
|
2020-04-13 13:39:01 +00:00
|
|
|
Dac dacs[8] = {
|
|
|
|
{ GPIOB, GPIO_PIN_8 }, { GPIOB, GPIO_PIN_9 }, { GPIOB, GPIO_PIN_10 }, { GPIOB, GPIO_PIN_11 },
|
|
|
|
{ GPIOA, GPIO_PIN_8 }, { GPIOA, GPIO_PIN_9 }, { GPIOA, GPIO_PIN_10 }, { GPIOA, GPIO_PIN_11 }
|
|
|
|
};
|
2020-04-01 10:04:42 +00:00
|
|
|
Adc adc;
|
2020-04-23 20:06:40 +00:00
|
|
|
Leds leds;
|
2020-04-24 09:48:19 +00:00
|
|
|
Switches switches;
|
|
|
|
|
|
|
|
const int32_t kLongPressDuration = 2000;
|
|
|
|
EventQueue<> queue;
|
|
|
|
uint32_t press_time[SWITCH_COUNT];
|
|
|
|
bool ignore_release[SWITCH_COUNT];
|
|
|
|
|
|
|
|
bool mute[4];
|
2019-12-03 23:00:54 +00:00
|
|
|
|
2020-03-27 21:36:04 +00:00
|
|
|
// Default interrupt handlers.
|
|
|
|
extern "C" {
|
2020-04-23 20:06:40 +00:00
|
|
|
void NMI_Handler() { }
|
2020-04-10 18:21:18 +00:00
|
|
|
void Error_Handler()
|
|
|
|
{
|
|
|
|
while (1)
|
|
|
|
;
|
|
|
|
}
|
2020-03-27 21:36:04 +00:00
|
|
|
void HardFault_Handler()
|
|
|
|
{
|
|
|
|
while (1)
|
|
|
|
;
|
|
|
|
}
|
|
|
|
void MemManage_Handler()
|
|
|
|
{
|
|
|
|
while (1)
|
|
|
|
;
|
|
|
|
}
|
|
|
|
void BusFault_Handler()
|
|
|
|
{
|
|
|
|
while (1)
|
|
|
|
;
|
|
|
|
}
|
|
|
|
void UsageFault_Handler()
|
|
|
|
{
|
|
|
|
while (1)
|
|
|
|
;
|
|
|
|
}
|
2020-04-23 20:06:40 +00:00
|
|
|
void SVC_Handler() { }
|
|
|
|
void DebugMon_Handler() { }
|
|
|
|
void PendSV_Handler() { }
|
2019-12-03 23:00:54 +00:00
|
|
|
|
2020-03-27 21:36:04 +00:00
|
|
|
// called every 1ms
|
|
|
|
void SysTick_Handler()
|
|
|
|
{
|
2020-04-10 18:21:18 +00:00
|
|
|
HAL_IncTick();
|
2020-04-24 09:48:19 +00:00
|
|
|
|
|
|
|
system_clock.Tick();
|
|
|
|
|
|
|
|
switches.Debounce();
|
|
|
|
|
|
|
|
for (size_t i = 0; i < SWITCH_COUNT; i++) {
|
|
|
|
if (switches.just_pressed(Switch(i))) {
|
|
|
|
queue.AddEvent(CONTROL_SWITCH, i, 0);
|
|
|
|
press_time[i] = HAL_GetTick();
|
|
|
|
ignore_release[i] = false;
|
|
|
|
}
|
|
|
|
if (switches.pressed(Switch(i)) && !ignore_release[i]) {
|
|
|
|
int32_t pressed_time = HAL_GetTick() - press_time[i];
|
|
|
|
if (pressed_time > kLongPressDuration) {
|
|
|
|
queue.AddEvent(CONTROL_SWITCH, i, pressed_time);
|
|
|
|
ignore_release[i] = true;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (switches.released(Switch(i)) && !ignore_release[i]) {
|
|
|
|
queue.AddEvent(
|
|
|
|
CONTROL_SWITCH,
|
|
|
|
i,
|
|
|
|
system_clock.milliseconds() - press_time[i] + 1);
|
|
|
|
ignore_release[i] = true;
|
|
|
|
}
|
|
|
|
}
|
2020-03-27 21:36:04 +00:00
|
|
|
}
|
2019-12-03 23:00:54 +00:00
|
|
|
|
2020-04-10 18:21:18 +00:00
|
|
|
void SystemClock_Config(void)
|
2020-04-01 10:04:42 +00:00
|
|
|
{
|
2020-04-10 18:21:18 +00:00
|
|
|
RCC_OscInitTypeDef RCC_OscInitStruct = { 0 };
|
|
|
|
RCC_ClkInitTypeDef RCC_ClkInitStruct = { 0 };
|
|
|
|
|
|
|
|
/** Initializes the CPU, AHB and APB busses clocks
|
|
|
|
*/
|
|
|
|
RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_HSI14 | RCC_OSCILLATORTYPE_HSE;
|
|
|
|
RCC_OscInitStruct.HSEState = RCC_HSE_ON;
|
|
|
|
RCC_OscInitStruct.HSI14State = RCC_HSI14_ON;
|
|
|
|
RCC_OscInitStruct.HSI14CalibrationValue = 16;
|
|
|
|
RCC_OscInitStruct.PLL.PLLState = RCC_PLL_ON;
|
|
|
|
RCC_OscInitStruct.PLL.PLLSource = RCC_PLLSOURCE_HSE;
|
|
|
|
RCC_OscInitStruct.PLL.PLLMUL = RCC_PLL_MUL6;
|
|
|
|
RCC_OscInitStruct.PLL.PREDIV = RCC_PREDIV_DIV1;
|
|
|
|
if (HAL_RCC_OscConfig(&RCC_OscInitStruct) != HAL_OK) {
|
|
|
|
Error_Handler();
|
|
|
|
}
|
|
|
|
/** Initializes the CPU, AHB and APB busses clocks
|
|
|
|
*/
|
|
|
|
RCC_ClkInitStruct.ClockType = RCC_CLOCKTYPE_HCLK | RCC_CLOCKTYPE_SYSCLK
|
|
|
|
| RCC_CLOCKTYPE_PCLK1;
|
|
|
|
RCC_ClkInitStruct.SYSCLKSource = RCC_SYSCLKSOURCE_PLLCLK;
|
|
|
|
RCC_ClkInitStruct.AHBCLKDivider = RCC_SYSCLK_DIV1;
|
|
|
|
RCC_ClkInitStruct.APB1CLKDivider = RCC_HCLK_DIV1;
|
|
|
|
|
|
|
|
if (HAL_RCC_ClockConfig(&RCC_ClkInitStruct, FLASH_LATENCY_1) != HAL_OK) {
|
|
|
|
Error_Handler();
|
2020-04-01 10:04:42 +00:00
|
|
|
}
|
|
|
|
}
|
2019-12-03 23:00:54 +00:00
|
|
|
|
2020-04-10 18:21:18 +00:00
|
|
|
void HAL_ADC_ConvCpltCallback(ADC_HandleTypeDef* hadc)
|
2019-12-03 23:00:54 +00:00
|
|
|
{
|
2020-04-10 18:21:18 +00:00
|
|
|
adc.OnDMATransferComplete();
|
|
|
|
}
|
2020-04-23 20:06:40 +00:00
|
|
|
void HAL_TIM_PeriodElapsedCallback(TIM_HandleTypeDef* htim) // called with 1kHz (OPTIMIZE!) the display should get its own spi bus
|
|
|
|
{
|
|
|
|
if (htim != &htim3) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
leds.Write();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void Init(void)
|
|
|
|
{
|
|
|
|
HAL_NVIC_SetPriority(TIM3_IRQn, 0, 0);
|
|
|
|
HAL_NVIC_EnableIRQ(TIM3_IRQn);
|
|
|
|
__HAL_RCC_TIM3_CLK_ENABLE();
|
2020-04-23 22:56:39 +00:00
|
|
|
htim3.Init.Prescaler = 14;
|
2020-04-23 20:06:40 +00:00
|
|
|
htim3.Init.CounterMode = TIM_COUNTERMODE_UP;
|
2020-04-23 22:15:32 +00:00
|
|
|
htim3.Init.Period = 128;
|
2020-04-23 20:06:40 +00:00
|
|
|
htim3.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;
|
|
|
|
htim3.Init.RepetitionCounter = 0;
|
|
|
|
HAL_TIM_Base_Init(&htim3);
|
|
|
|
HAL_TIM_Base_Start_IT(&htim3);
|
2020-04-24 09:48:19 +00:00
|
|
|
system_clock.Init();
|
|
|
|
queue.Init();
|
|
|
|
}
|
|
|
|
|
|
|
|
void WriteOutputs(void)
|
|
|
|
{
|
|
|
|
for (int i = 0; i < 4; i++) {
|
|
|
|
uint32_t value_l;
|
|
|
|
uint32_t value_r;
|
|
|
|
|
|
|
|
uint16_t pan_pot = adc.value(ADC_GROUP_POT + ADC_CHANNEL_PAN_1 + i) >> (16 - 12); // adc is only 12 bit anyways
|
|
|
|
uint16_t vol_pot = adc.value(ADC_GROUP_POT + ADC_CHANNEL_VOL_1 + i) >> (16 - 12);
|
|
|
|
int16_t pan_cv = (adc.value(ADC_GROUP_CV + ADC_CHANNEL_PAN_1 + i) - 32768) >> (16 - 12);
|
|
|
|
uint16_t vol_cv = adc.value(ADC_GROUP_CV + ADC_CHANNEL_VOL_1 + i) >> (16 - 12);
|
|
|
|
int32_t pan = pan_pot + pan_cv;
|
|
|
|
int32_t vol = vol_pot + vol_cv;
|
|
|
|
|
|
|
|
if (mute[i])
|
|
|
|
vol = 0;
|
|
|
|
|
|
|
|
CONSTRAIN(pan, 0, (1 << 12) - 1);
|
|
|
|
CONSTRAIN(vol, 0, (1 << 12) - 1);
|
|
|
|
leds.set_intensity(i, vol >> 4);
|
|
|
|
value_l = (lut_left_sin_pan[pan] * lut_linear_to_exp[vol]) >> 16;
|
|
|
|
value_r = (lut_right_cos_pan[pan] * lut_linear_to_exp[vol]) >> 16;
|
|
|
|
|
|
|
|
dacs[i].Write16(0, value_r);
|
|
|
|
dacs[i + 4].Write16(0, value_r);
|
|
|
|
dacs[i].Write16(1, value_l);
|
|
|
|
dacs[i + 4].Write16(1, value_l);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void HandleEvent(void)
|
|
|
|
{
|
|
|
|
while (queue.available()) {
|
|
|
|
Event ev = queue.PullEvent();
|
|
|
|
switch (ev.control_type) {
|
|
|
|
case CONTROL_SWITCH:
|
|
|
|
if (ev.data != 0) { // switch released
|
|
|
|
mute[ev.control_id] = !mute[ev.control_id];
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
2020-04-10 18:21:18 +00:00
|
|
|
}
|
2020-04-01 10:04:42 +00:00
|
|
|
|
2020-04-10 18:21:18 +00:00
|
|
|
int main(void)
|
|
|
|
{
|
|
|
|
HAL_Init();
|
|
|
|
SystemClock_Config();
|
|
|
|
__HAL_RCC_SYSCFG_CLK_ENABLE();
|
|
|
|
__HAL_RCC_PWR_CLK_ENABLE();
|
2020-04-23 20:06:40 +00:00
|
|
|
__HAL_RCC_GPIOB_CLK_ENABLE();
|
|
|
|
__HAL_RCC_GPIOF_CLK_ENABLE();
|
|
|
|
|
|
|
|
Init();
|
2020-04-01 10:04:42 +00:00
|
|
|
|
2019-12-03 23:00:54 +00:00
|
|
|
while (true) {
|
2020-04-24 09:48:19 +00:00
|
|
|
|
|
|
|
HandleEvent();
|
|
|
|
|
|
|
|
WriteOutputs();
|
2019-12-03 23:00:54 +00:00
|
|
|
}
|
|
|
|
}
|