Iwwww/sound-analyze
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

fix(mic): исправлен таймер на TIM3

Browse Source
This commit is contained in:
Михаил Ёлгин
2025-12-25 23:17:39 +03:00
parent 3306b8083b
commit 063cced2a5
7 changed files with 223 additions and 213 deletions
Download Patch File Download Diff File Expand all files Collapse all files

220
firmware/App/Src/main.c
View File

@@ -2,35 +2,48 @@
#include <string.h>
#include "FreeRTOS.h"
#include "audio_adc.h"
#include "queue.h"
#include "stm32f1xx.h"
#include "task.h"
#include "tusb.h"
// System Clock Configuration
void vApplicationStackOverflowHook(TaskHandle_t xTask, char *pcTaskName) {
(void)xTask;
(void)pcTaskName;
// Мигаем LED очень быстро при переполнении стека
while (1) {
GPIOC->ODR ^= GPIO_ODR_ODR13;
for (volatile int i = 0; i < 50000; i++);
}
}
// === Структура данных для очереди ===
typedef struct {
uint16_t min_val;
uint16_t max_val;
uint16_t avg_val;
uint32_t buffer_num;
} audio_stats_packet_t;
static QueueHandle_t audio_stats_queue = NULL;
// === System Clock ===
void SystemClock_Config(void) {
// Настройка на 72 MHz через HSE + PLL
// 1. Включаем HSE (внешний кварц 8 МГц)
RCC->CR |= RCC_CR_HSEON;
while (!(RCC->CR & RCC_CR_HSERDY));
// 2. Настраиваем Flash: 2 цикла ожидания для 72 MHz
FLASH->ACR = FLASH_ACR_LATENCY_2;
// 3. Настраиваем PLL: 8 MHz * 9 = 72 MHz
RCC->CFGR &= ~RCC_CFGR_PLLMULL;
RCC->CFGR |= RCC_CFGR_PLLMULL9;
RCC->CFGR |= RCC_CFGR_PLLSRC; // Источник PLL = HSE
RCC->CFGR |= RCC_CFGR_PLLSRC;
RCC->CFGR &= ~RCC_CFGR_USBPRE;
// 4. USB делитель: 72 MHz / 1.5 = 48 MHz
RCC->CFGR &= ~RCC_CFGR_USBPRE; // USBPRE = 0 (делитель 1.5)
// 5. Включаем PLL
RCC->CR |= RCC_CR_PLLON;
while (!(RCC->CR & RCC_CR_PLLRDY));
// 6. Переключаем системную частоту на PLL
RCC->CFGR &= ~RCC_CFGR_SW;
RCC->CFGR |= RCC_CFGR_SW_PLL;
while ((RCC->CFGR & RCC_CFGR_SWS) != RCC_CFGR_SWS_PLL);
@@ -38,19 +51,15 @@ void SystemClock_Config(void) {
SystemCoreClock = 72000000;
}
// Audio Processing Callback
// Буфер для отправки статистики через USB
static char usb_tx_buffer[128];
static volatile uint32_t total_samples = 0;
// === Audio Callback ===
void audio_buffer_ready(audio_sample_t *buffer, uint32_t size) {
// Эта функция вызывается из прерывания DMA
// Не делать тяжелых операций здесь
static uint32_t buffer_counter = 0;
buffer_counter++;
total_samples += size;
// Мигаем LED при каждом вызове
if (buffer_counter % 5 == 0) { GPIOC->ODR ^= GPIO_ODR_ODR13; }
// мин/макс значения
uint16_t min_val = 4095;
uint16_t max_val = 0;
uint32_t sum = 0;
@@ -62,27 +71,23 @@ void audio_buffer_ready(audio_sample_t *buffer, uint32_t size) {
sum += val;
}
uint16_t avg = sum / size;
if (buffer_counter % 10 == 0) {
audio_stats_packet_t packet = {
.min_val = min_val,
.max_val = max_val,
.avg_val = (uint16_t)(max_val - min_val),
.buffer_num = buffer_counter};
// Каждые 2 секунды отправляем статистику: каждый 100-й буфер
static uint32_t report_counter = 0;
report_counter++;
if (report_counter >= 100) {
report_counter = 0;
snprintf(
usb_tx_buffer,
sizeof(usb_tx_buffer),
"ADC Stats - Min: %4u, Max: %4u, Avg: %4u, Total samples: %lu\r\n",
min_val,
max_val,
avg,
total_samples);
BaseType_t xHigherPriorityTaskWoken = pdFALSE;
xQueueSendFromISR(
audio_stats_queue,
&packet,
&xHigherPriorityTaskWoken);
portYIELD_FROM_ISR(xHigherPriorityTaskWoken);
}
}
// FreeRTOS Tasks
// === Tasks ===
void usb_device_task(void *param) {
(void)param;
@@ -94,44 +99,115 @@ void usb_device_task(void *param) {
void cdc_task(void *param) {
(void)param;
char tx_buffer[256];
uint32_t heartbeat_counter = 0;
uint32_t last_buffer_count = 0;
while (1) {
if (tud_cdc_connected()) {
// Отправка статистики если есть данные
if (usb_tx_buffer[0] != '\0') {
size_t len = strlen(usb_tx_buffer);
if (tud_cdc_write_available() >= len) {
tud_cdc_write(usb_tx_buffer, len);
tud_cdc_write_flush();
usb_tx_buffer[0] = '\0'; // Очищаем буфер
}
heartbeat_counter++;
// Heartbeat + ДИАГНОСТИКА регистров каждые 100 циклов
if (heartbeat_counter % 100 == 0 && tud_cdc_connected()) {
uint32_t current_buffer_count = audio_adc_get_buffer_count();
int len = snprintf(
tx_buffer,
sizeof(tx_buffer),
"HB:%lu Q:%u BC:%lu | "
"TIM3_CR1:%lX TIM3_CNT:%lu | "
"ADC1_CR2:%lX ADC1_SR:%lX | "
"DMA_CCR:%lX DMA_CNDTR:%lu\r\n",
heartbeat_counter,
(unsigned)uxQueueMessagesWaiting(audio_stats_queue),
current_buffer_count,
TIM3->CR1,
TIM3->CNT,
ADC1->CR2,
ADC1->SR,
DMA1_Channel1->CCR,
DMA1_Channel1->CNDTR);
if (tud_cdc_write_available() >= len) {
tud_cdc_write(tx_buffer, len);
tud_cdc_write_flush();
}
// Echo для тестирования
if (tud_cdc_available()) {
uint8_t buf[64];
uint32_t count = tud_cdc_read(buf, sizeof(buf));
tud_cdc_write(buf, count);
last_buffer_count = current_buffer_count;
}
// Остальной код без изменений
audio_stats_packet_t packet;
if (xQueueReceive(audio_stats_queue, &packet, pdMS_TO_TICKS(10)) ==
pdPASS) {
int len = snprintf(
tx_buffer,
sizeof(tx_buffer),
"Buf:%lu Min:%u Max:%u Avg:%u\r\n",
packet.buffer_num,
packet.min_val,
packet.max_val,
packet.avg_val);
if (tud_cdc_connected() && len > 0 &&
tud_cdc_write_available() >= len) {
tud_cdc_write(tx_buffer, len);
tud_cdc_write_flush();
}
}
vTaskDelay(pdMS_TO_TICKS(10));
// Echo
if (tud_cdc_available()) {
uint8_t buf[64];
uint32_t count = tud_cdc_read(buf, sizeof(buf));
if (tud_cdc_connected() && count > 0) {
tud_cdc_write(buf, count);
tud_cdc_write_flush();
}
}
}
}
void led_task(void *param) {
(void)param;
while (1) {
GPIOC->BSRR = GPIO_BSRR_BR13; // LED ON
vTaskDelay(pdMS_TO_TICKS(100));
GPIOC->BSRR = GPIO_BSRR_BS13; // LED OFF
vTaskDelay(pdMS_TO_TICKS(900));
GPIOC->BSRR = GPIO_BSRR_BR13;
vTaskDelay(pdMS_TO_TICKS(500));
GPIOC->BSRR = GPIO_BSRR_BS13;
vTaskDelay(pdMS_TO_TICKS(500));
}
}
// USB Reset
// === Задача инициализации аудио ===
void audio_init_task(void *param) {
(void)param;
// Индикация старта инициализации (мигнем 3 раза быстро)
for (int i = 0; i < 3; i++) {
GPIOC->ODR ^= GPIO_ODR_ODR13;
vTaskDelay(pdMS_TO_TICKS(100));
}
if (!audio_adc_init(audio_buffer_ready)) {
// Ошибка: мигаем очень быстро
while (1) {
GPIOC->ODR ^= GPIO_ODR_ODR13;
vTaskDelay(pdMS_TO_TICKS(50));
}
}
// Запускаем ADC после старта FreeRTOS
audio_adc_start();
// Индикация успешного запуска (мигнем 5 раз медленно)
for (int i = 0; i < 5; i++) {
GPIOC->ODR ^= GPIO_ODR_ODR13;
vTaskDelay(pdMS_TO_TICKS(200));
}
vTaskDelete(NULL);
}
// === USB Reset ===
void force_usb_reset(void) {
RCC->APB2ENR |= RCC_APB2ENR_IOPAEN;
@@ -143,19 +219,19 @@ void force_usb_reset(void) {
GPIOA->CRH |= GPIO_CRH_CNF12_0;
}
// Main
// === Main ===
int main(void) {
SystemClock_Config();
// Настройка LED (PC13)
// LED
RCC->APB2ENR |= RCC_APB2ENR_IOPCEN;
GPIOC->CRH &= ~GPIO_CRH_CNF13;
GPIOC->CRH |= GPIO_CRH_MODE13_1;
force_usb_reset();
// Включаем USB
// USB
RCC->APB2ENR |= RCC_APB2ENR_IOPAEN;
RCC->APB1ENR |= RCC_APB1ENR_USBEN;
@@ -169,21 +245,16 @@ int main(void) {
tusb_init();
// Инициализация Audio ADC
if (!audio_adc_init(audio_buffer_ready)) {
// Ошибка инициализации - быстро мигаем LED
// Очередь создаем ДО старта планировщика
audio_stats_queue = xQueueCreate(10, sizeof(audio_stats_packet_t));
if (audio_stats_queue == NULL) {
while (1) {
GPIOC->BSRR = GPIO_BSRR_BR13;
for (volatile int i = 0; i < 100000; i++);
GPIOC->BSRR = GPIO_BSRR_BS13;
GPIOC->ODR ^= GPIO_ODR_ODR13;
for (volatile int i = 0; i < 100000; i++);
}
}
// Запускаем захват аудио
audio_adc_start();
// Создаем задачи FreeRTOS
// Задачи
xTaskCreate(
usb_device_task,
"usbd",
@@ -191,15 +262,16 @@ int main(void) {
NULL,
configMAX_PRIORITIES - 1,
NULL);
xTaskCreate(cdc_task, "cdc", 256, NULL, configMAX_PRIORITIES - 2, NULL);
xTaskCreate(cdc_task, "cdc", 320, NULL, configMAX_PRIORITIES - 2, NULL);
xTaskCreate(led_task, "led", 128, NULL, 1, NULL);
xTaskCreate(audio_init_task, "audio_init", 128, NULL, 2, NULL);
vTaskStartScheduler();
while (1);
}
// USB Interrupt Handlers
// === USB Handlers ===
void USB_HP_CAN1_TX_IRQHandler(void) {
tud_int_handler(0);