jan-henrik/eurorack
1
0
Fork 0
mirror of https://github.com/jhbruhn/eurorack.git synced 2025-03-14 18:55:48 +00:00
Code Issues Projects Releases Packages Wiki Activity

Migrate stereo_mix to HAL

Browse source
This commit is contained in:
Jan-Henrik 2020-04-10 20:21:18 +02:00
parent 57ad4b8372
commit 561197c493
5 changed files with 192 additions and 142 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

144
stereo_mix/drivers/adc.cc
View file

@ -1,81 +1,92 @@
#include "stereo_mix/drivers/adc.h"
#include "stm32f030x8.h"
#include "stm32f0xx_hal_dma.h"
#include "stm32f0xx_hal_dma_ex.h"
#include <stm32f0xx.h>
#include <stm32f0xx_hal.h>
extern "C" {
void DMA_TransferComplete(DMA_HandleTypeDef* dma); // declared in stereo_mix.cc
}
namespace stereo_mix {
void Adc::Init()
{
RCC_AHBPeriphClockCmd(RCC_AHBPeriph_DMA1, ENABLE);
RCC_AHBPeriphClockCmd(RCC_AHBPeriph_GPIOA, ENABLE);
RCC_AHBPeriphClockCmd(RCC_AHBPeriph_GPIOB, ENABLE);
RCC_APB2PeriphClockCmd(RCC_APB2Periph_ADC1, ENABLE);
__HAL_RCC_DMA1_CLK_ENABLE();
__HAL_RCC_GPIOA_CLK_ENABLE();
__HAL_RCC_GPIOB_CLK_ENABLE();
__HAL_RCC_ADC1_CLK_ENABLE();
ADC_InitTypeDef adc_init;
GPIO_InitTypeDef gpio_init;
gpio_init.GPIO_Pin = GPIO_Pin_0 | GPIO_Pin_1;
gpio_init.GPIO_Pin |= GPIO_Pin_2 | GPIO_Pin_3 | GPIO_Pin_4 | GPIO_Pin_5;
gpio_init.GPIO_Pin |= GPIO_Pin_6 | GPIO_Pin_7;
gpio_init.GPIO_PuPd = GPIO_PuPd_NOPULL;
gpio_init.GPIO_Mode = GPIO_Mode_AN;
GPIO_Init(GPIOA, &gpio_init);
gpio_init.Pin = GPIO_PIN_0 | GPIO_PIN_1;
gpio_init.Pin |= GPIO_PIN_2 | GPIO_PIN_3 | GPIO_PIN_4 | GPIO_PIN_5;
gpio_init.Pin |= GPIO_PIN_6 | GPIO_PIN_7;
gpio_init.Mode = GPIO_MODE_ANALOG;
HAL_GPIO_Init(GPIOA, &gpio_init);
gpio_init.GPIO_Pin = GPIO_Pin_0;
gpio_init.GPIO_PuPd = GPIO_PuPd_NOPULL;
gpio_init.GPIO_Mode = GPIO_Mode_AN;
GPIO_Init(GPIOB, &gpio_init);
gpio_init.Pin = GPIO_PIN_0;
gpio_init.Mode = GPIO_MODE_ANALOG;
HAL_GPIO_Init(GPIOB, &gpio_init);
// Configure the address lines for the MUX.
gpio_init.GPIO_Pin = GPIO_Pin_12 | GPIO_Pin_13 | GPIO_Pin_14;
gpio_init.GPIO_Mode = GPIO_Mode_OUT;
gpio_init.GPIO_OType = GPIO_OType_PP;
gpio_init.GPIO_Speed = GPIO_Speed_2MHz;
gpio_init.GPIO_PuPd = GPIO_PuPd_NOPULL;
GPIO_Init(GPIOB, &gpio_init);
GPIO_ResetBits(GPIOB, GPIO_Pin_12 | GPIO_Pin_13 | GPIO_Pin_14);
gpio_init.Pin = GPIO_PIN_12 | GPIO_PIN_13 | GPIO_PIN_14;
gpio_init.Mode = GPIO_MODE_OUTPUT_PP;
gpio_init.Speed = GPIO_SPEED_FREQ_LOW;
HAL_GPIO_Init(GPIOB, &gpio_init);
HAL_GPIO_WritePin(GPIOB, GPIO_PIN_12 | GPIO_PIN_13 | GPIO_PIN_14, GPIO_PIN_RESET);
this->mux_index_ = 0;
adc_init.ADC_Resolution = ADC_Resolution_12b;
adc_init.ADC_ContinuousConvMode = ENABLE;
adc_init.ADC_DataAlign = ADC_DataAlign_Left;
adc_init.ADC_ScanDirection = ADC_ScanDirection_Upward;
ADC_Init(ADC1, &adc_init);
adc.Init.Resolution = ADC_RESOLUTION_12B;
adc.Init.ContinuousConvMode = ENABLE;
adc.Init.DiscontinuousConvMode = DISABLE;
adc.Init.DataAlign = ADC_DATAALIGN_LEFT;
adc.Init.ScanConvMode = ADC_SCAN_ENABLE;
adc.Init.ExternalTrigConv = ADC_SOFTWARE_START;
adc.Init.ClockPrescaler = ADC_CLOCK_SYNC_PCLK_DIV2;
adc.Init.DMAContinuousRequests = DISABLE;
adc.Instance = ADC1;
HAL_ADC_Init(&adc);
HAL_NVIC_SetPriority(ADC1_IRQn, 0, 0);
HAL_NVIC_EnableIRQ(ADC1_IRQn);
ADC_ClockModeConfig(ADC1, ADC_ClockMode_SynClkDiv2);
ADC_ChannelConfig(ADC1, ADC_Channel_0, ADC_SampleTime_239_5Cycles);
ADC_ChannelConfig(ADC1, ADC_Channel_1, ADC_SampleTime_239_5Cycles);
ADC_ChannelConfig(ADC1, ADC_Channel_2, ADC_SampleTime_239_5Cycles);
ADC_ChannelConfig(ADC1, ADC_Channel_3, ADC_SampleTime_239_5Cycles);
ADC_ChannelConfig(ADC1, ADC_Channel_4, ADC_SampleTime_239_5Cycles);
ADC_ChannelConfig(ADC1, ADC_Channel_5, ADC_SampleTime_239_5Cycles);
ADC_ChannelConfig(ADC1, ADC_Channel_6, ADC_SampleTime_239_5Cycles);
ADC_ChannelConfig(ADC1, ADC_Channel_7, ADC_SampleTime_239_5Cycles);
ADC_ChannelConfig(ADC1, ADC_Channel_8, ADC_SampleTime_239_5Cycles);
ADC_ChannelConfTypeDef sConfig;
sConfig.Channel = ADC_CHANNEL_0;
sConfig.Rank = ADC_RANK_CHANNEL_NUMBER;
sConfig.SamplingTime = ADC_SAMPLETIME_239CYCLES_5;
HAL_ADC_ConfigChannel(&adc, &sConfig);
sConfig.Channel = ADC_CHANNEL_1;
HAL_ADC_ConfigChannel(&adc, &sConfig);
sConfig.Channel = ADC_CHANNEL_2;
HAL_ADC_ConfigChannel(&adc, &sConfig);
sConfig.Channel = ADC_CHANNEL_3;
HAL_ADC_ConfigChannel(&adc, &sConfig);
sConfig.Channel = ADC_CHANNEL_4;
HAL_ADC_ConfigChannel(&adc, &sConfig);
sConfig.Channel = ADC_CHANNEL_5;
HAL_ADC_ConfigChannel(&adc, &sConfig);
sConfig.Channel = ADC_CHANNEL_6;
HAL_ADC_ConfigChannel(&adc, &sConfig);
sConfig.Channel = ADC_CHANNEL_7;
HAL_ADC_ConfigChannel(&adc, &sConfig);
sConfig.Channel = ADC_CHANNEL_8;
HAL_ADC_ConfigChannel(&adc, &sConfig);
ADC_Cmd(ADC1, ENABLE);
ADC_DMACmd(ADC1, ENABLE);
DMA_InitTypeDef dma_init;
DMA_StructInit(&dma_init);
dma_init.DMA_DIR = DMA_DIR_PeripheralSRC;
dma_init.DMA_PeripheralBaseAddr = (uint32_t)&ADC1->DR;
dma_init.DMA_MemoryBaseAddr = (uint32_t)&values_[0];
dma_init.DMA_MemoryDataSize = DMA_MemoryDataSize_HalfWord;
dma_init.DMA_PeripheralDataSize = DMA_PeripheralDataSize_HalfWord;
dma_init.DMA_BufferSize = ADC_CHANNEL_NUM_DIRECT;
dma_init.DMA_PeripheralInc = DMA_PeripheralInc_Disable;
dma_init.DMA_MemoryInc = DMA_MemoryInc_Enable;
dma_init.DMA_Mode = DMA_Mode_Circular;
dma_init.DMA_Priority = DMA_Priority_High;
dma_init.DMA_M2M = DMA_M2M_Disable;
DMA_Init(DMA1_Channel1, &dma_init);
dma.Init.Direction = DMA_PERIPH_TO_MEMORY;
dma.Init.PeriphInc = DMA_PINC_DISABLE;
dma.Init.MemInc = DMA_MINC_ENABLE;
dma.Init.MemDataAlignment = DMA_MDATAALIGN_HALFWORD;
dma.Init.PeriphDataAlignment = DMA_PDATAALIGN_HALFWORD;
dma.Init.Mode = DMA_CIRCULAR;
dma.Init.Priority = DMA_PRIORITY_LOW;
dma.Instance = DMA1_Channel1;
HAL_DMA_Init(&dma);
__HAL_LINKDMA(&adc, DMA_Handle, dma);
NVIC_EnableIRQ(DMA1_Channel1_IRQn);
NVIC_SetPriority(DMA1_Channel1_IRQn, 0);
DMA_ITConfig(DMA1_Channel1, DMA_IT_TC, ENABLE);
DMA_Cmd(DMA1_Channel1, ENABLE);
ADC_DMARequestModeConfig(ADC1, ADC_DMAMode_OneShot);
HAL_NVIC_EnableIRQ(DMA1_Channel1_IRQn);
HAL_NVIC_SetPriority(DMA1_Channel1_IRQn, 0, 0);
/*NVIC_InitTypeDef NVIC_InitStructure;
NVIC_InitStructure.NVIC_IRQChannel = DMA1_Channel1_IRQn;
@ -83,16 +94,15 @@ void Adc::Init()
NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
NVIC_Init(&NVIC_InitStructure);
*/
ADC_StartOfConversion(ADC1);
HAL_ADC_Start_DMA(&adc, (uint32_t*)values_, ADC_CHANNEL_NUM_DIRECT);
}
void Adc::DeInit()
{
ADC_Cmd(ADC1, DISABLE);
ADC_DeInit(ADC1);
HAL_ADC_DeInit(&adc);
}
void Adc::OnDMAFinish()
void Adc::OnDMATransferComplete()
{
this->values_[ADC_CHANNEL_FIRST_MUXED + this->mux_index_] = this->values_[ADC_CHANNEL_MUX];
@ -100,10 +110,10 @@ void Adc::OnDMAFinish()
uint8_t address = this->mux_index_;
// Write the mux address.
GPIO_WriteBit(GPIOB, GPIO_Pin_12, static_cast<BitAction>(address & 1));
GPIO_WriteBit(GPIOB, GPIO_Pin_13, static_cast<BitAction>(address & 2));
GPIO_WriteBit(GPIOB, GPIO_Pin_14, static_cast<BitAction>(address & 4));
ADC_StartOfConversion(ADC1);
HAL_GPIO_WritePin(GPIOB, GPIO_PIN_12, static_cast<GPIO_PinState>(address & 1));
HAL_GPIO_WritePin(GPIOB, GPIO_PIN_13, static_cast<GPIO_PinState>(address & 2));
HAL_GPIO_WritePin(GPIOB, GPIO_PIN_14, static_cast<GPIO_PinState>(address & 4));
HAL_ADC_Start_DMA(&adc, (uint32_t*)values_, ADC_CHANNEL_NUM_DIRECT);
}
} // namespace rings

28
stereo_mix/drivers/adc.h
View file

@ -2,18 +2,20 @@
#include "stmlib/stmlib.h"
#include <stm32f0xx_hal.h>
namespace stereo_mix {
enum AdcChannel {
ADC_CHANNEL_MUX,
ADC_CHANNEL_CV_PAN_4,
ADC_CHANNEL_CV_PAN_3,
ADC_CHANNEL_CV_PAN_2,
ADC_CHANNEL_CV_PAN_1,
ADC_CHANNEL_CV_VOL_4,
ADC_CHANNEL_CV_VOL_3,
ADC_CHANNEL_CV_VOL_2,
ADC_CHANNEL_CV_VOL_1,
ADC_CHANNEL_CV_VOL_2,
ADC_CHANNEL_CV_VOL_3,
ADC_CHANNEL_CV_VOL_4,
ADC_CHANNEL_CV_PAN_1,
ADC_CHANNEL_CV_PAN_2,
ADC_CHANNEL_CV_PAN_3,
ADC_CHANNEL_CV_PAN_4,
ADC_CHANNEL_MUX,
ADC_CHANNEL_POT_VOL_1,
ADC_CHANNEL_POT_VOL_2,
ADC_CHANNEL_POT_VOL_3,
@ -24,11 +26,11 @@ enum AdcChannel {
ADC_CHANNEL_POT_PAN_4,
ADC_CHANNEL_LAST,
ADC_CHANNEL_FIRST_DIRECT = ADC_CHANNEL_MUX,
ADC_CHANNEL_LAST_DIRECT = ADC_CHANNEL_CV_VOL_1,
ADC_CHANNEL_FIRST_DIRECT = ADC_CHANNEL_CV_PAN_4,
ADC_CHANNEL_LAST_DIRECT = ADC_CHANNEL_MUX,
ADC_CHANNEL_FIRST_MUXED = ADC_CHANNEL_POT_VOL_1,
ADC_CHANNEL_LAST_MUXED = ADC_CHANNEL_POT_PAN_4,
ADC_CHANNEL_NUM_DIRECT = ADC_CHANNEL_CV_VOL_1 + 1,
ADC_CHANNEL_NUM_DIRECT = ADC_CHANNEL_MUX + 1,
ADC_CHANNEL_NUM_MUXED = ADC_CHANNEL_LAST - ADC_CHANNEL_FIRST_MUXED,
};
@ -39,7 +41,7 @@ class Adc {
void Init();
void DeInit();
void OnDMAFinish();
void OnDMATransferComplete();
inline const uint16_t* values() { return &values_[0]; }
inline int32_t value(int32_t channel) const
{
@ -49,6 +51,8 @@ class Adc {
{
return static_cast<float>(values_[index]) / 65536.0f;
}
DMA_HandleTypeDef dma;
ADC_HandleTypeDef adc;
private:
uint16_t values_[ADC_CHANNEL_LAST];

78
stereo_mix/drivers/dac.h
View file

@ -1,10 +1,11 @@
#pragma once
#include "stmlib/stmlib.h"
#include <stm32f0xx.h>
#include <stm32f0xx_hal.h>
namespace stereo_mix {
class Dac { // MCP4xx2 dac implementation
public:
void Init(GPIO_TypeDef* ssGpioPort_, uint16_t ssGpioPin_)
@ -12,52 +13,43 @@ class Dac { // MCP4xx2 dac implementation
ssGpioPort = ssGpioPort_;
ssGpioPin = ssGpioPin_;
// init SS/CS/RST GPIO
RCC_AHBPeriphClockCmd(RCC_AHBPeriph_GPIOB, ENABLE);
RCC_AHBPeriphClockCmd(RCC_AHBPeriph_GPIOA, ENABLE);
__HAL_RCC_GPIOA_CLK_ENABLE();
__HAL_RCC_GPIOB_CLK_ENABLE();
GPIO_InitTypeDef gpio_init;
GPIO_StructInit(&gpio_init);
gpio_init.GPIO_Mode = GPIO_Mode_OUT;
gpio_init.GPIO_OType = GPIO_OType_PP;
gpio_init.GPIO_Speed = GPIO_Speed_50MHz;
gpio_init.GPIO_PuPd = GPIO_PuPd_NOPULL;
gpio_init.GPIO_Pin = ssGpioPin;
GPIO_Init(ssGpioPort, &gpio_init);
gpio_init.Mode = GPIO_MODE_OUTPUT_PP;
gpio_init.Speed = GPIO_SPEED_FREQ_HIGH;
gpio_init.Pull = GPIO_NOPULL;
gpio_init.Pin = ssGpioPin;
HAL_GPIO_Init(ssGpioPort, &gpio_init);
GPIO_SetBits(ssGpioPort, ssGpioPin);
HAL_GPIO_WritePin(ssGpioPort, ssGpioPin, GPIO_PIN_SET);
// init AF GPIO
RCC_AHBPeriphClockCmd(RCC_AHBPeriph_GPIOB, ENABLE);
RCC_APB2PeriphClockCmd(RCC_APB2Periph_SPI1 | RCC_APB2Periph_SYSCFG, ENABLE);
GPIO_StructInit(&gpio_init);
gpio_init.GPIO_Mode = GPIO_Mode_AF;
gpio_init.GPIO_OType = GPIO_OType_PP;
gpio_init.GPIO_Speed = GPIO_Speed_50MHz;
gpio_init.GPIO_PuPd = GPIO_PuPd_NOPULL;
gpio_init.GPIO_Pin = GPIO_Pin_3 | GPIO_Pin_4 | GPIO_Pin_5;
GPIO_Init(GPIOB, &gpio_init);
GPIO_PinAFConfig(GPIOB, GPIO_PinSource3, GPIO_AF_0);
GPIO_PinAFConfig(GPIOB, GPIO_PinSource4, GPIO_AF_0);
GPIO_PinAFConfig(GPIOB, GPIO_PinSource5, GPIO_AF_0);
gpio_init.Mode = GPIO_MODE_AF_PP;
gpio_init.Speed = GPIO_SPEED_FREQ_HIGH;
gpio_init.Pull = GPIO_NOPULL;
gpio_init.Pin = GPIO_PIN_3 | GPIO_PIN_4 | GPIO_PIN_5;
gpio_init.Alternate = GPIO_AF0_SPI1;
HAL_GPIO_Init(GPIOB, &gpio_init);
// init SPI
SPI_I2S_DeInit(SPI1);
__HAL_RCC_SPI1_CLK_ENABLE();
// HAL_SPI_DeInit(&spi);
// Initialize SPI TODO: check which config we need
SPI_InitTypeDef spi_init;
SPI_StructInit(&spi_init);
spi_init.SPI_Direction = SPI_Direction_2Lines_FullDuplex;
spi_init.SPI_Mode = SPI_Mode_Master;
spi_init.SPI_DataSize = SPI_DataSize_16b;
spi_init.SPI_CPOL = SPI_CPOL_High;
spi_init.SPI_CPHA = SPI_CPHA_1Edge;
spi_init.SPI_NSS = SPI_NSS_Soft;
spi_init.SPI_BaudRatePrescaler = SPI_BaudRatePrescaler_2;
spi_init.SPI_FirstBit = SPI_FirstBit_MSB;
spi_init.SPI_CRCPolynomial = 7;
SPI_Init(SPI1, &spi_init);
SPI_Cmd(SPI1, ENABLE);
spi.Init.Direction = SPI_DIRECTION_2LINES;
spi.Init.Mode = SPI_MODE_MASTER;
spi.Init.DataSize = SPI_DATASIZE_16BIT;
spi.Init.CLKPolarity = SPI_POLARITY_HIGH;
spi.Init.CLKPhase = SPI_PHASE_1EDGE;
spi.Init.NSS = SPI_NSS_SOFT;
spi.Init.BaudRatePrescaler = SPI_BAUDRATEPRESCALER_4;
spi.Init.FirstBit = SPI_FIRSTBIT_MSB;
spi.Init.CRCPolynomial = 7;
spi.Instance = SPI1;
HAL_SPI_Init(&spi);
};
void Write16(uint8_t channel, uint16_t value, uint8_t gain, uint8_t buffered)
@ -78,16 +70,13 @@ class Dac { // MCP4xx2 dac implementation
value |= gain << 13; // set gain
value |= 1 << 12; // shutdown always set to 1
GPIO_ResetBits(ssGpioPort, ssGpioPin);
SPI_I2S_SendData16(SPI1, value);
HAL_GPIO_WritePin(ssGpioPort, ssGpioPin, GPIO_PIN_RESET);
HAL_SPI_Transmit(&spi, (uint8_t*) &value, 1, 1000);
//SPI_I2S_SendData16(SPI1, value); // MSB first, specified in config
while (SPI_I2S_GetFlagStatus(SPI1, SPI_I2S_FLAG_TXE) == RESET) {
while (HAL_SPI_GetState(&spi) == HAL_SPI_STATE_BUSY) {
asm("nop");
}
while (SPI_I2S_GetFlagStatus(SPI1, SPI_I2S_FLAG_BSY) == SET) {
asm("nop");
}
GPIO_SetBits(ssGpioPort, ssGpioPin);
HAL_GPIO_WritePin(ssGpioPort, ssGpioPin, GPIO_PIN_SET);
};
void Write16(uint8_t channel, uint16_t value)
@ -96,6 +85,7 @@ class Dac { // MCP4xx2 dac implementation
};
private:
SPI_HandleTypeDef spi;
GPIO_TypeDef* ssGpioPort;
uint16_t ssGpioPin;
};

82
stereo_mix/stereo_mix.cc
View file

@ -1,6 +1,9 @@
#include "drivers/adc.h"
#include "drivers/dac.h"
#include "resources.h"
#include "stm32f030x8.h"
#include "stm32f0xx_hal_adc.h"
#include <stm32f0xx_hal.h>
using namespace stereo_mix;
@ -10,6 +13,11 @@ Adc adc;
// Default interrupt handlers.
extern "C" {
void NMI_Handler() {}
void Error_Handler()
{
while (1)
;
}
void HardFault_Handler()
{
while (1)
@ -37,42 +45,80 @@ void PendSV_Handler() {}
// called every 1ms
void SysTick_Handler()
{
HAL_IncTick();
}
void SystemClock_Config(void)
{
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();
}
}
void DMA1_Channel1_IRQHandler(void)
{
if (DMA_GetITStatus(DMA1_IT_TC1) == SET) /* Test if transfer completed on DMA channel 1 */
{
adc.OnDMAFinish();
DMA_ClearITPendingBit(DMA1_IT_TC1);
}
HAL_DMA_IRQHandler(&adc.dma);
}
void ADC1_IRQHandler(void)
{
HAL_ADC_IRQHandler(&adc.adc);
}
void HAL_ADC_ConvCpltCallback(ADC_HandleTypeDef* hadc)
{
adc.OnDMATransferComplete();
}
}
int main(void)
{
SystemInit();
HAL_Init();
SystemClock_Config();
__HAL_RCC_SYSCFG_CLK_ENABLE();
__HAL_RCC_PWR_CLK_ENABLE();
dacs[0].Init(GPIOB, GPIO_Pin_8);
dacs[1].Init(GPIOB, GPIO_Pin_9);
dacs[2].Init(GPIOB, GPIO_Pin_10);
dacs[3].Init(GPIOB, GPIO_Pin_11);
dacs[4].Init(GPIOA, GPIO_Pin_8);
dacs[5].Init(GPIOA, GPIO_Pin_9);
dacs[6].Init(GPIOA, GPIO_Pin_10);
dacs[7].Init(GPIOA, GPIO_Pin_11);
dacs[0].Init(GPIOB, GPIO_PIN_8);
dacs[1].Init(GPIOB, GPIO_PIN_9);
dacs[2].Init(GPIOB, GPIO_PIN_10);
dacs[3].Init(GPIOB, GPIO_PIN_11);
dacs[4].Init(GPIOA, GPIO_PIN_8);
dacs[5].Init(GPIOA, GPIO_PIN_9);
dacs[6].Init(GPIOA, GPIO_PIN_10);
dacs[7].Init(GPIOA, GPIO_PIN_11);
adc.Init();
while (true) {
for(int i = 0; i < 4; i++) {
for (int i = 0; i < 4; i++) {
uint32_t value_l;
uint32_t value_r;
uint16_t pan_pot = adc.value(ADC_CHANNEL_POT_PAN_1 + i) >> (16 - 12); // adc is only 12 bit anyways
uint16_t vol_pot = adc.value(ADC_CHANNEL_POT_VOL_1 + i) >> (16 - 12);
int16_t pan_cv = (adc.value(ADC_CHANNEL_CV_PAN_1 - i) - 32768) >> (16 - 12);
uint16_t vol_cv = adc.value(ADC_CHANNEL_CV_VOL_1 - i) >> (16 - 12);
int16_t pan_cv = (adc.value(ADC_CHANNEL_CV_PAN_1 + i) - 32768) >> (16 - 12);
uint16_t vol_cv = adc.value(ADC_CHANNEL_CV_VOL_1 + i) >> (16 - 12);
int32_t pan = pan_pot + pan_cv;
int32_t vol = vol_pot + vol_cv;

2
stmlib

@ -1 +1 @@
Subproject commit db9d616841851a2560d918752faef59d6365de84
Subproject commit 51c959664d64fcd6ef583e29ea68cddc6a8f88b5