heck
/
HeckSTM32F4Playground
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
Browse Source

audio engine start

master
heck 2 years ago
parent
e9fe227a44
commit
c554da4420
5 changed files with 279 additions and 223 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 200
      src/cppmain.cc
  2. 7
      src/cppmain.h
  3. 282
      src/init.c
  4. 7
      src/init.h
  5. 6
      src/main.c

200
src/cppmain.cc
View File

@ -4,15 +4,27 @@
//#include "usb_device.h" //#include "usb_device.h"
//#include "cmsis_os.h" //#include "cmsis_os.h"
#include <cmath> #include <cmath>
#include <bitset>
#include "limits" #include "limits"
#include <sstream>
#define SAMPLE_FREQ 44200
#define SAMPLE_MAX 4096
#define DOUBLE_BUFFER_SIZE 16
#define BUFFER_SIZE 8
const double pi{ std::acos(-1) }; const double pi{ std::acos(-1) };
#define BUFFER_SIZE 512 static u32 double_buffer[DOUBLE_BUFFER_SIZE];
static u64 time{ 0 };
static volatile bool dma_to_dac_half_complete{ false };
static volatile bool dma_to_dac_complete{ false };
static volatile int freq = 100;
namespace Heck { namespace Heck {
bool debug_suspend_active = false; bool debug_suspend_active = false;
void debug_suspend_continue() { void debug_suspend_continue()
{
debug_suspend_active = false; debug_suspend_active = false;
} }
@ -28,37 +40,10 @@ namespace Heck {
// DAC // DAC
// --- // ---
u32 audio_buffer[BUFFER_SIZE];
void dac1_set(u32 val)
{
HAL_DAC_SetValue(&hdac1, DAC_CHANNEL_1, DAC_ALIGN_12B_R, val);
}
void dac1_toggle()
{
static bool dac_state{ 0 };
dac_state = !dac_state;
if (dac_state) {
dac1_set(0b0000111111111111);
} else {
dac1_set(0b0000000000000000);
}
}
void dac_start_dma()
{
HAL_DAC_Start_DMA(&hdac1, DAC_CHANNEL_1, (u32 *)audio_buffer, BUFFER_SIZE, DAC_ALIGN_12B_R);
}
void dac_stop_dma()
{
HAL_DAC_Stop_DMA(&hdac1, DAC_CHANNEL_1);
}
// LED // LED
// --- // ---
void led_green_toggle() void led_green_toggle()
{ {
HAL_GPIO_TogglePin(GPIOD, GPIO_PIN_12); HAL_GPIO_TogglePin(GPIOD, GPIO_PIN_12);
@ -79,15 +64,14 @@ namespace Heck {
void irq1_cb() void irq1_cb()
{ {
debug_suspend_continue(); debug_suspend_continue();
freq += 10;
} }
void timer2_cb() void timer3_cb()
{ {
led_green_toggle(); led_green_toggle();
} }
void timer7_cb() {}
// dont forget to start the DAC // dont forget to start the DAC
// HAL_DAC_Start(&hdac, DAC_CHANNEL_1); // HAL_DAC_Start(&hdac, DAC_CHANNEL_1);
void bytebeat() void bytebeat()
@ -109,68 +93,99 @@ namespace Heck {
ret %= max; ret %= max;
return ret; return ret;
} }
//
void buffer_init_noise() // void buffer_init_noise()
// {
// log("buffer_init_noise()");
// for (int i = 0; i < DOUBLE_BUFFER_SIZE; i++) {
// u32 val = random(SAMPLE_MAX);
// double_buffer[i] = val;
// log(std::to_string(val));
// }
// }
//
// void buffer_init_sin()
// {
// log("buffer_init_sin()");
// for (int i = 0; i < DOUBLE_BUFFER_SIZE; i++) {
// float p = float(i) / (float)DOUBLE_BUFFER_SIZE - 0.5;
// u32 val = sin(p) * SAMPLE_MAX;
// double_buffer[i] = val;
// log(std::to_string(val));
// }
// }
//
// void buffer_div(int div)
// {
// log("init_scale()");
// for (int i = 0; i < DOUBLE_BUFFER_SIZE; i++) {
// u32 val = double_buffer[i] / div;
// double_buffer[i] = val;
// log(std::to_string(val));
// }
// }
//
// void buffer_randomize(int max)
// {
// log("buffer_randomize()");
// u32 buf_index = random(DOUBLE_BUFFER_SIZE);
// u32 buf_val = random(max);
// double_buffer[buf_index] = buf_val;
// log("i:" + std::to_string(buf_index) + " v:" + std::to_string(buf_val));
// }
std::string reg_to_string(uint32_t val)
{ {
log("buffer_init_noise()"); std::stringstream ss{};
for (int i = 0; i < BUFFER_SIZE; i++) { const std::bitset<32> x{ val };
u32 val = random(4096); ss << "0b" << x.to_string();
audio_buffer[i] = val; ss << " - ";
log(std::to_string(val)); ss << std::to_string(val);
} return ss.str();
} }
void buffer_init_sin() u32 hz_to_samps(float hz)
{ {
log("buffer_init_sin()"); return (u32)floor((float)SAMPLE_FREQ / (float)hz);
for (int i = 0; i < BUFFER_SIZE; i++) {
float p = float(i) / (float)BUFFER_SIZE - 0.5;
u32 val = sin(p) * 4096;
audio_buffer[i] = val;
log(std::to_string(val));
}
} }
void buffer_div(int div)
void calculate_audio(u32 *buffer)
{ {
log("init_scale()"); log("calculate_audio time: ");
u64 t = time;
u32 samps = hz_to_samps(freq);
for (int i = 0; i < BUFFER_SIZE; i++) { for (int i = 0; i < BUFFER_SIZE; i++) {
u32 val = audio_buffer[i] / div; buffer[i] = t % samps;
audio_buffer[i] = val; t++;
log(std::to_string(val));
} }
} }
void buffer_randomize(int max)
{
log("buffer_randomize()");
u32 buf_index = random(BUFFER_SIZE);
u32 buf_val = random(max);
audio_buffer[buf_index] = buf_val;
log("i:" + std::to_string(buf_index) + " v:" + std::to_string(buf_val));
}
void main() void main()
{ {
heck_debug_suspend(); heck_debug_suspend();
log("Starting..."); log("Starting...");
dac_start_dma(); HAL_TIM_Base_Start_IT(&htim_blinky_led);
HAL_DAC_Start_DMA(&hdac1, DAC_CHANNEL_1, (u32 *)double_buffer, DOUBLE_BUFFER_SIZE, DAC_ALIGN_12B_R);
HAL_TIM_Base_Start_IT(&htim2); HAL_TIM_Base_Start_IT(&htim_dac1);
HAL_TIM_Base_Start_IT(&htim7);
HAL_TIM_Base_Start(&htim6);
// init_buffer_noise();
buffer_init_sin();
buffer_div(10);
log("Entering MainLoop..."); log("Entering MainLoop...");
while (true) { while (true) {
// buffer_randomize(400); if (dma_to_dac_half_complete) {
HAL_Delay(10); calculate_audio(&double_buffer[0]);
time += BUFFER_SIZE;
dma_to_dac_half_complete = false;
}
if (dma_to_dac_complete) {
calculate_audio(&double_buffer[BUFFER_SIZE]);
time += BUFFER_SIZE;
dma_to_dac_complete = false;
}
} }
} }
} // namespace Heck } // namespace Heck
@ -178,11 +193,12 @@ namespace Heck {
// C Linkage (Bridging) // C Linkage (Bridging)
// ---------------------------------------------------------------------------------------------- // ----------------------------------------------------------------------------------------------
extern "C" void heck_debug_suspend(void) { extern "C" void heck_debug_suspend(void)
{
Heck::debug_suspend_active = true; Heck::debug_suspend_active = true;
while(Heck::debug_suspend_active == true) { while (Heck::debug_suspend_active == true) {
Heck::log("debug_suspend..."); Heck::log("debug_suspend...");
HAL_Delay(1000); HAL_Delay(10);
} }
} }
@ -190,27 +206,21 @@ extern "C" void HAL_GPIO_EXTI_Callback(uint16_t GPIO_Pin)
{ {
if (GPIO_Pin == GPIO_PIN_0) { if (GPIO_Pin == GPIO_PIN_0) {
Heck::irq1_cb(); Heck::irq1_cb();
} else {
__NOP(); // why NOP? i dont know! was from an example
} }
} }
extern "C" void HAL_TIM_PeriodElapsedCallback(TIM_HandleTypeDef *htim) extern "C" void HAL_TIM_PeriodElapsedCallback(TIM_HandleTypeDef *htim)
{ {
if (htim->Instance == TIM2) { if (htim->Instance == TIM2) {
// Heck::log(
// "TIM2 timer: instance: " + std::to_string(reinterpret_cast<u32>(htim->Instance)) +
// " channel: " + std::to_string(htim->Channel));
// Heck::log(std::to_string(time));
} else if (htim->Instance == TIM3) {
Heck::log( Heck::log(
"TIM2 timer: instance: " + std::to_string(reinterpret_cast<u32>(htim->Instance)) + "TIM3 timer: instance: " + std::to_string(reinterpret_cast<u32>(htim->Instance)) +
" channel: " + std::to_string(htim->Channel));
Heck::timer2_cb();
} else if (htim->Instance == TIM6) {
Heck::log(
"TIM6 timer: instance: " + std::to_string(reinterpret_cast<u32>(htim->Instance)) +
" channel: " + std::to_string(htim->Channel));
} else if (htim->Instance == TIM7) {
Heck::log(
"TIM7 timer: instance: " + std::to_string(reinterpret_cast<u32>(htim->Instance)) +
" channel: " + std::to_string(htim->Channel)); " channel: " + std::to_string(htim->Channel));
Heck::timer7_cb(); Heck::timer3_cb();
} else { } else {
Heck::log( Heck::log(
"UNKNOWN timer: instance: " + std::to_string(reinterpret_cast<u32>(htim->Instance)) + "UNKNOWN timer: instance: " + std::to_string(reinterpret_cast<u32>(htim->Instance)) +
@ -219,11 +229,19 @@ extern "C" void HAL_TIM_PeriodElapsedCallback(TIM_HandleTypeDef *htim)
} }
extern "C" void HAL_DAC_ConvHalfCpltCallbackCh1(DAC_HandleTypeDef *hdac)
{
Heck::log("HAL_DAC_ConvHalfCpltCallbackCh1");
dma_to_dac_half_complete = true;
}
extern "C" void HAL_DAC_ConvCpltCallbackCh1(DAC_HandleTypeDef *hdac) extern "C" void HAL_DAC_ConvCpltCallbackCh1(DAC_HandleTypeDef *hdac)
{ {
Heck::dac_start_dma(); Heck::log("HAL_DAC_ConvCpltCallbackCh1");
dma_to_dac_complete = true;
} }
extern "C" void heck_log(char *msg) extern "C" void heck_log(char *msg)
{ {
Heck::log(std::string(msg)); Heck::log(std::string(msg));
@ -247,7 +265,7 @@ extern "C" void assert_failed(uint8_t *file, uint32_t line)
ex: printf("Wrong parameters value: file %s on line %d\r\n", file, line) */ ex: printf("Wrong parameters value: file %s on line %d\r\n", file, line) */
int str_size = 1024; int str_size = 1024;
char str[str_size]; char str[str_size];
snprintf(str, str_size, "assert failed: %s:%d",file,line); snprintf(str, str_size, "assert failed: %s:%d", file, line);
heck_log(str); heck_log(str);
} }

7
src/cppmain.h
View File

@ -31,6 +31,7 @@ extern "C" {
#include <string> #include <string>
using u32 = uint32_t; using u32 = uint32_t;
using u64 = uint64_t;
namespace Heck { namespace Heck {
void debug_suspend_continue(); void debug_suspend_continue();
@ -39,9 +40,6 @@ namespace Heck {
// DAC1 // DAC1
void dac1_set(uint32_t val); void dac1_set(uint32_t val);
void dac1_toggle();
void dac_start_dma();
void dac_stop_dma();
// LED Green // LED Green
void led_green_toggle(); void led_green_toggle();
@ -50,8 +48,7 @@ namespace Heck {
// Callbacks // Callbacks
void irq1_cb(); void irq1_cb();
void timer2_cb(); void timer3_cb();
void timer7_cb();
// misc // misc
void bytebeat(); void bytebeat();

282
src/init.c
View File

@ -2,10 +2,10 @@
#include "usb_device.h" #include "usb_device.h"
DAC_HandleTypeDef hdac1; DAC_HandleTypeDef hdac1;
TIM_HandleTypeDef htim_dac1;
DMA_HandleTypeDef hdma_dac1; DMA_HandleTypeDef hdma_dac1;
TIM_HandleTypeDef htim2; ADC_HandleTypeDef hadc1;
TIM_HandleTypeDef htim6; TIM_HandleTypeDef htim_blinky_led;
TIM_HandleTypeDef htim7;
RNG_HandleTypeDef hrng; RNG_HandleTypeDef hrng;
@ -15,6 +15,10 @@ void sysclk_init(void)
__HAL_RCC_SYSCFG_CLK_ENABLE(); __HAL_RCC_SYSCFG_CLK_ENABLE();
__HAL_RCC_PWR_CLK_ENABLE(); __HAL_RCC_PWR_CLK_ENABLE();
__HAL_RCC_ADC1_CLK_ENABLE();
__HAL_RCC_ADC2_CLK_ENABLE();
__HAL_RCC_ADC3_CLK_ENABLE();
// ALL GPIO Ports // ALL GPIO Ports
__HAL_RCC_GPIOA_CLK_ENABLE(); __HAL_RCC_GPIOA_CLK_ENABLE();
__HAL_RCC_GPIOB_CLK_ENABLE(); __HAL_RCC_GPIOB_CLK_ENABLE();
@ -109,133 +113,96 @@ void debug_init()
MX_USB_DEVICE_Init(); // USB first, for logging over serial port MX_USB_DEVICE_Init(); // USB first, for logging over serial port
} }
void gpio_init(void) void blinky_led_init()
{ {
HAL_GPIO_WritePin(GPIOD, GPIO_PIN_12, GPIO_PIN_RESET); HAL_GPIO_WritePin(GPIOD, GPIO_PIN_12, GPIO_PIN_RESET);
{ // GPIO
// LED Green GPIO_InitTypeDef git = {
GPIO_InitTypeDef conf = { .Pin = GPIO_PIN_12,
.Pin = GPIO_PIN_12, .Mode = GPIO_MODE_OUTPUT_PP,
.Mode = GPIO_MODE_OUTPUT_PP, .Pull = GPIO_NOPULL,
.Pull = GPIO_NOPULL, .Speed = GPIO_SPEED_FREQ_LOW,
.Speed = GPIO_SPEED_FREQ_LOW, };
}; HAL_GPIO_Init(GPIOD, &git);
HAL_GPIO_Init(GPIOD, &conf); // Timer
htim_blinky_led.Instance = TIM3;
htim_blinky_led.Init.Prescaler = 0;
htim_blinky_led.Init.CounterMode = TIM_COUNTERMODE_UP;
htim_blinky_led.Init.Period = 1LL << 32;
htim_blinky_led.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;
htim_blinky_led.Init.AutoReloadPreload = TIM_AUTORELOAD_PRELOAD_DISABLE;
if (HAL_TIM_Base_Init(&htim_blinky_led) != HAL_OK) {
Error_Handler();
} }
{ TIM_ClockConfigTypeDef tcc = {
// DAC1 .ClockSource = TIM_CLOCKSOURCE_INTERNAL,
GPIO_InitTypeDef conf = { };
.Pin = GPIO_PIN_4, if (HAL_TIM_ConfigClockSource(&htim_blinky_led, &tcc) != HAL_OK) {
.Mode = GPIO_MODE_ANALOG, Error_Handler();
.Pull = GPIO_NOPULL, }
.Speed = GPIO_SPEED_FREQ_HIGH,
};
HAL_GPIO_Init(GPIOA, &conf); TIM_MasterConfigTypeDef tmc = {
.MasterOutputTrigger = TIM_TRGO_RESET,
.MasterSlaveMode = TIM_MASTERSLAVEMODE_DISABLE,
};
if (HAL_TIMEx_MasterConfigSynchronization(&htim_blinky_led, &tmc) != HAL_OK) {
Error_Handler();
} }
HAL_NVIC_SetPriority(TIM3_IRQn, 5, 0);
HAL_NVIC_EnableIRQ(TIM3_IRQn);
} }
void timer_init(void) void dac_init(void)
{ {
{ // DAC1
htim2.Instance = TIM2; GPIO_InitTypeDef conf = {
htim2.Init.Prescaler = 0; .Pin = GPIO_PIN_4,
htim2.Init.CounterMode = TIM_COUNTERMODE_UP; .Mode = GPIO_MODE_ANALOG,
htim2.Init.Period = 42949000; .Pull = GPIO_NOPULL,
htim2.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1; .Speed = GPIO_SPEED_FREQ_HIGH,
htim2.Init.AutoReloadPreload = TIM_AUTORELOAD_PRELOAD_DISABLE; };
if (HAL_TIM_Base_Init(&htim2) != HAL_OK) { HAL_GPIO_Init(GPIOA, &conf);
Error_Handler();
} // timer
htim_dac1.Instance = TIM2;
{ htim_dac1.Init.Prescaler = 0;
TIM_ClockConfigTypeDef conf = { htim_dac1.Init.CounterMode = TIM_COUNTERMODE_UP;
.ClockSource = TIM_CLOCKSOURCE_INTERNAL, htim_dac1.Init.Period = 2000;// * 10000;
}; htim_dac1.Init.AutoReloadPreload = TIM_AUTORELOAD_PRELOAD_ENABLE;
if (HAL_TIM_ConfigClockSource(&htim2, &conf) != HAL_OK) { if (HAL_TIM_Base_Init(&htim_dac1) != HAL_OK) {
Error_Handler(); Error_Handler();
}
}
{
TIM_MasterConfigTypeDef conf = {
.MasterOutputTrigger = TIM_TRGO_RESET,
.MasterSlaveMode = TIM_MASTERSLAVEMODE_DISABLE,
};
if (HAL_TIMEx_MasterConfigSynchronization(&htim2, &conf) != HAL_OK) {
Error_Handler();
}
}
HAL_NVIC_SetPriority(TIM2_IRQn, 5, 0);
HAL_NVIC_EnableIRQ(TIM2_IRQn);
} }
HAL_NVIC_SetPriority(TIM2_IRQn, 1, 0);
HAL_NVIC_EnableIRQ(TIM2_IRQn);
{ TIM_MasterConfigTypeDef tmc = {
htim6.Instance = TIM6; .MasterOutputTrigger = TIM_TRGO_UPDATE,
htim6.Init.Prescaler = 0; .MasterSlaveMode = TIM_MASTERSLAVEMODE_DISABLE,
htim6.Init.CounterMode = TIM_COUNTERMODE_UP; };
htim6.Init.Period = 1904; if (HAL_TIMEx_MasterConfigSynchronization(&htim_dac1, &tmc) != HAL_OK) {
htim6.Init.AutoReloadPreload = TIM_AUTORELOAD_PRELOAD_DISABLE; Error_Handler();
if (HAL_TIM_Base_Init(&htim6) != HAL_OK) {
Error_Handler();
}
{
TIM_MasterConfigTypeDef conf = {
.MasterOutputTrigger = TIM_TRGO_UPDATE,
.MasterSlaveMode = TIM_MASTERSLAVEMODE_DISABLE,
};
if (HAL_TIMEx_MasterConfigSynchronization(&htim6, &conf) != HAL_OK) {
Error_Handler();
}
}
} }
{
htim7.Instance = TIM7;
htim7.Init.Prescaler = 10000;
htim7.Init.CounterMode = TIM_COUNTERMODE_UP;
htim7.Init.Period = 429490000;
htim7.Init.AutoReloadPreload = TIM_AUTORELOAD_PRELOAD_ENABLE;
if (HAL_TIM_Base_Init(&htim7) != HAL_OK) {
Error_Handler();
}
{
TIM_MasterConfigTypeDef conf = {
.MasterOutputTrigger = TIM_TRGO_RESET,
.MasterSlaveMode = TIM_MASTERSLAVEMODE_DISABLE,
};
if (HAL_TIMEx_MasterConfigSynchronization(&htim7, &conf) != HAL_OK) {
Error_Handler();
}
}
HAL_NVIC_SetPriority(TIM7_IRQn, 5, 0);
HAL_NVIC_EnableIRQ(TIM7_IRQn);
}
}
void dac_dma_init(void) // DAC
{
hdac1.Instance = DAC1; hdac1.Instance = DAC1;
if (HAL_DAC_Init(&hdac1) != HAL_OK) { if (HAL_DAC_Init(&hdac1) != HAL_OK) {
Error_Handler(); Error_Handler();
} }
DAC_ChannelConfTypeDef conf = { DAC_ChannelConfTypeDef cct = {
.DAC_Trigger = DAC_TRIGGER_T6_TRGO, .DAC_Trigger = DAC_TRIGGER_T2_TRGO,
.DAC_OutputBuffer = DAC_OUTPUTBUFFER_ENABLE, .DAC_OutputBuffer = DAC_OUTPUTBUFFER_ENABLE,
}; };
if (HAL_DAC_ConfigChannel(&hdac1, &conf, DAC_CHANNEL_1) != HAL_OK) { if (HAL_DAC_ConfigChannel(&hdac1, &cct, DAC_CHANNEL_1) != HAL_OK) {
Error_Handler(); Error_Handler();
} }
// DMA
hdma_dac1.Instance = DMA1_Stream5; hdma_dac1.Instance = DMA1_Stream5;
hdma_dac1.Init.Channel = DMA_CHANNEL_7; hdma_dac1.Init.Channel = DMA_CHANNEL_7;
hdma_dac1.Init.Direction = DMA_MEMORY_TO_PERIPH; hdma_dac1.Init.Direction = DMA_MEMORY_TO_PERIPH;
@ -243,25 +210,105 @@ void dac_dma_init(void)
hdma_dac1.Init.MemInc = DMA_MINC_ENABLE; hdma_dac1.Init.MemInc = DMA_MINC_ENABLE;
hdma_dac1.Init.PeriphDataAlignment = DMA_PDATAALIGN_WORD; hdma_dac1.Init.PeriphDataAlignment = DMA_PDATAALIGN_WORD;
hdma_dac1.Init.MemDataAlignment = DMA_MDATAALIGN_WORD; hdma_dac1.Init.MemDataAlignment = DMA_MDATAALIGN_WORD;
hdma_dac1.Init.Mode = DMA_NORMAL; hdma_dac1.Init.Mode = DMA_CIRCULAR;
hdma_dac1.Init.Priority = DMA_PRIORITY_LOW; hdma_dac1.Init.Priority = DMA_PRIORITY_HIGH;
hdma_dac1.Init.FIFOMode = DMA_FIFOMODE_DISABLE; hdma_dac1.Init.FIFOMode = DMA_FIFOMODE_DISABLE;
if (HAL_DMA_Init(&hdma_dac1) != HAL_OK) { if (HAL_DMA_Init(&hdma_dac1) != HAL_OK) {
Error_Handler(); Error_Handler();
} }
// Originally that was: // Originally that was:
// __HAL_LINKDMA(&hdac1, DMA_Handle1, hdma_dac1); __HAL_LINKDMA(&hdac1, DMA_Handle1, hdma_dac1);
// Exapanded to: // Exapanded to:
// hdma_dac1.Parent = &hdac1; // hdma_dac1.Parent = &hdac1;
// hdac1.DMA_Handle1 = &hdma_dac1; // hdac1.DMA_Handle1 = &hdma_dac1;
// But this seems to be enough: // But this seems to be enough:
hdac1.DMA_Handle1 = &hdma_dac1; // hdac1.DMA_Handle1 = &hdma_dac1;
HAL_NVIC_SetPriority(DMA1_Stream5_IRQn, 5, 0); HAL_NVIC_SetPriority(DMA1_Stream5_IRQn, 0, 0);
HAL_NVIC_EnableIRQ(DMA1_Stream5_IRQn); HAL_NVIC_EnableIRQ(DMA1_Stream5_IRQn);
} }
void adc_init(void)
{
// GPIO
GPIO_InitTypeDef conf = {
.Pin = GPIO_PIN_4,
.Mode = GPIO_MODE_ANALOG,
.Pull = GPIO_NOPULL,
.Speed = GPIO_SPEED_FREQ_MEDIUM,
};
HAL_GPIO_Init(GPIOC, &conf);
ADC_Common_TypeDef *adc_common = ADC123_COMMON;
ADC_TypeDef *adc1 = ADC1;
// SET_BIT(adc_common->CCR, ADC_CCR_ADCPRE_0);
// CLEAR_BIT(adc_common->CCR, ADC_CCR_ADCPRE_1);
//
// CLEAR_BIT(adc1->CR1, ~ADC_CR1_RES_0);
// CLEAR_BIT(adc1->CR1, ADC_CR1_RES_1);
// SET_BIT(adc1->CR2, ADC_CR2_CONT);
// CLEAR_BIT(adc1->CR2, ADC_CR2_ALIGN);
// SET_BIT(adc1->CR2, ADC_CR2_ADON);
// SET_BIT(adc1->CR2, ADC_CR2_SWSTART);
//
//
// SET_BIT(adc1->SQR1,ADC_SQR1_L_0);
//// CLEAR_BIT(adc1->SQR1,ADC_SQR1_L_1);
//// CLEAR_BIT(adc1->SQR1,ADC_SQR1_L_2);
//// CLEAR_BIT(adc1->SQR1,ADC_SQR1_L_3);
////
//// ADC_SQR3_RK(1,1);
// SET_BIT(adc1->SQR3,ADC_SQR3_SQ1_0);
//// CLEAR_BIT(adc1->SQR3,ADC_SQR3_SQ1_1);
//// CLEAR_BIT(adc1->SQR3,ADC_SQR3_SQ1_2);
//// CLEAR_BIT(adc1->SQR3,ADC_SQR3_SQ1_3);
//// CLEAR_BIT(adc1->SQR3,ADC_SQR3_SQ1_4);
hadc1.Instance = ADC1;
hadc1.Init.ClockPrescaler = ADC_CLOCK_SYNC_PCLK_DIV4;
hadc1.Init.Resolution = ADC_RESOLUTION_12B;
hadc1.Init.ScanConvMode = DISABLE;
hadc1.Init.ContinuousConvMode = ENABLE;
hadc1.Init.DiscontinuousConvMode = DISABLE;
hadc1.Init.ExternalTrigConvEdge = ADC_EXTERNALTRIGCONVEDGE_NONE;
hadc1.Init.ExternalTrigConv = ADC_SOFTWARE_START;
hadc1.Init.DataAlign = ADC_DATAALIGN_RIGHT;
hadc1.Init.NbrOfConversion = 1;
hadc1.Init.DMAContinuousRequests = DISABLE;
hadc1.Init.EOCSelection = ADC_EOC_SINGLE_CONV;
if (HAL_ADC_Init(&hadc1) != HAL_OK) {
Error_Handler();
}
ADC_ChannelConfTypeDef sConfig = {};
sConfig.Channel = ADC_CHANNEL_14;
sConfig.Rank = 1;
sConfig.SamplingTime = ADC_SAMPLETIME_3CYCLES;
if (HAL_ADC_ConfigChannel(&hadc1, &sConfig) != HAL_OK) {
Error_Handler();
}
// adc1->CR2
while (1) {
// SET_BIT(adc1->CR2, ADC_CR2_ADON);
// SET_BIT(adc1->CR2, ADC_CR2_SWSTART);
HAL_ADC_Start(&hadc1);
// heck_log("ADC123_COMMON->CCR:" + reg_to_string(adc_common->CCR));
// heck_log("ADC1->CR1:" + reg_to_string(adc1->CR1));
// heck_log("ADC1->CR2:" + reg_to_string(adc1->CR2));
// heck_log("ADC1->SQR1:" + reg_to_string(adc1->SQR1));
// heck_log("ADC1->SQR2:" + reg_to_string(adc1->SQR2));
// heck_log("ADC1->SQR3:" + reg_to_string(adc1->SQR3));
// heck_log("ADC1->DR:" + reg_to_string(adc1->DR));
heck_log("\n");
HAL_Delay(100);
}
}
void rng_init(void) void rng_init(void)
{ {
hrng.Instance = RNG; hrng.Instance = RNG;
@ -270,21 +317,14 @@ void rng_init(void)
} }
} }
//void irq_init()
//{
//// This is for RTOS i guess
// HAL_NVIC_SetPriority(PendSV_IRQn, 15, 0);
//}
void heck_init() void heck_init()
{ {
HAL_Init(); HAL_Init();
sysclk_init(); sysclk_init();
debug_init(); debug_init();
heck_debug_suspend(); // heck_debug_suspend();
gpio_init(); blinky_led_init();
timer_init(); dac_init();
dac_dma_init(); adc_init();
rng_init(); rng_init();
} }

7
src/init.h
View File

@ -8,10 +8,11 @@
extern "C" { extern "C" {
#endif #endif
extern DAC_HandleTypeDef hdac1; extern DAC_HandleTypeDef hdac1;
extern TIM_HandleTypeDef htim_dac1;
extern DMA_HandleTypeDef hdma_dac1; extern DMA_HandleTypeDef hdma_dac1;
extern TIM_HandleTypeDef htim2;
extern TIM_HandleTypeDef htim6; extern ADC_HandleTypeDef hadc1;
extern TIM_HandleTypeDef htim7; extern TIM_HandleTypeDef htim_blinky_led;
extern RNG_HandleTypeDef hrng; extern RNG_HandleTypeDef hrng;
void heck_init(); void heck_init();

6
src/main.c
View File

@ -55,12 +55,12 @@ void DMA1_Stream5_IRQHandler(void)
void TIM2_IRQHandler(void) void TIM2_IRQHandler(void)
{ {
HAL_TIM_IRQHandler(&htim2); HAL_TIM_IRQHandler(&htim_dac1);
} }
void TIM7_IRQHandler(void) void TIM3_IRQHandler(void)
{ {
HAL_TIM_IRQHandler(&htim7); HAL_TIM_IRQHandler(&htim_blinky_led);
} }
void OTG_FS_IRQHandler(void) void OTG_FS_IRQHandler(void)

Write Preview
Loading…
Cancel
Save