Одним из преимуществ отладочной платы STM32F4Discovery является наличие аудио-ЦАП со встроенным усилителем. Эту роль выполняет замечательная микросхема CS43L22. Так что на основе Discovery можно сделать кучу разнообразных аудио-девайсов! Мы сегодня, для начала, просто разберемся, как произвести инициализацию и первоначальную настройку всего этого добра, ну и попробуем что-нибудь пропищать )
Микросхема CS43L22 поддерживает несколько интерфейсов для обмена данными с контроллером, и использовать мы их будем совместно. Тут дело в том, что для управления CS43L22 (то есть для отправки управляющих команд) используется I2C, а для передачи аудио данных - I2S. Микроконтроллер STM32F4 поддерживает и то, и другое. Давайте посмотрим на кусок схемы платы Discovery:
Как видно из схемы, для управляющих команд используются выводы PB9 и PB6. А это у нас I2C1. Так что с этим все понятно. А линии I2S подключены к пинам SPI3 контроллера. Это все нам предстоит настроить, когда будем писать пример.
Помимо инициализации периферии и портов ввода-вывода необходимо произвести начальную конфигурацию CS43L22. Я, пожалуй, не буду останавливаться отдельно на регистрах этой микросхемы - они все описаны в документации на нее, мы лучше уделим больше внимания настройке микроконтроллера.
Время традиционной вставки: поскольку компания STMicroelectronics прекратила поддержку библиотеки SPL, которая использовалась в этом курсе, я создал новый, посвященный работе уже с новыми инструментами, так что буду рад видеть вас там - STM32CubeMx. Кроме того, вот глобальная рубрика по STM32, а также статья на смежную тему из нового курса: Аудио-плеер на STM32. Воспроизведение WAV-файла.
Создаем проект в Keil'е и приступаем. Начинаем, как обычно, с подключения необходимых файлов и переменных (будем использовать библиотеку SPL):
/***************************************************************************************/ #include "stm32f4xx.h" #include "stm32f4xx_gpio.h" #include "stm32f4xx_rcc.h" #include "stm32f4xx_i2c.h" #include "stm32f4xx_spi.h" #include "stm32f4xx_tim.h" /***************************************************************************************/ GPIO_InitTypeDef gpio; I2S_InitTypeDef i2s; I2C_InitTypeDef i2c; TIM_TimeBaseInitTypeDef timer; uint8_t state = 0x00; /***************************************************************************************/
Ну а теперь надо настроить все, что мы будем использовать. И начнем с портов ввода-вывода GPIO:
/***************************************************************************************/
void initGPIO()
{
// Включаем тактирование
RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOA | RCC_AHB1Periph_GPIOD | RCC_AHB1Periph_GPIOB | RCC_AHB1Periph_GPIOC, ENABLE);
RCC_APB1PeriphClockCmd(RCC_APB1Periph_I2C1 | RCC_APB1Periph_SPI3, ENABLE);
// У I2S свой отдельный источник тактирования, имеющий повышенную точность, включаем и его
RCC_PLLI2SCmd(ENABLE);
// Reset сигнал для CS43L22
gpio.GPIO_Pin = GPIO_Pin_4;;
gpio.GPIO_Mode = GPIO_Mode_OUT;
gpio.GPIO_PuPd = GPIO_PuPd_DOWN;
gpio.GPIO_OType = GPIO_OType_PP;
gpio.GPIO_Speed = GPIO_Speed_50MHz;
GPIO_Init(GPIOD, &gpio);
// Выводы I2C1
gpio.GPIO_Mode = GPIO_Mode_AF;
gpio.GPIO_OType = GPIO_OType_OD;
gpio.GPIO_Pin = GPIO_Pin_6 | GPIO_Pin_9;
gpio.GPIO_PuPd = GPIO_PuPd_NOPULL;
gpio.GPIO_Speed = GPIO_Speed_50MHz;
GPIO_Init(GPIOB, &gpio);
GPIO_PinAFConfig(GPIOB, GPIO_PinSource6, GPIO_AF_I2C1);
GPIO_PinAFConfig(GPIOB, GPIO_PinSource9, GPIO_AF_I2C1);
// А теперь настраиваем выводы I2S
gpio.GPIO_OType = GPIO_OType_PP;
gpio.GPIO_Pin = GPIO_Pin_7 | GPIO_Pin_10 | GPIO_Pin_12;
GPIO_Init(GPIOC, &gpio);
gpio.GPIO_Pin = GPIO_Pin_4;
GPIO_Init(GPIOA, &gpio);
GPIO_PinAFConfig(GPIOA, GPIO_PinSource4, GPIO_AF_SPI3);
GPIO_PinAFConfig(GPIOC, GPIO_PinSource7, GPIO_AF_SPI3);
GPIO_PinAFConfig(GPIOC, GPIO_PinSource10, GPIO_AF_SPI3);
GPIO_PinAFConfig(GPIOC, GPIO_PinSource12, GPIO_AF_SPI3);
// Сбрасываем Reset в ноль
GPIO_ResetBits(GPIOD, GPIO_Pin_4);
}
/***************************************************************************************/
Первый шаг позади, продолжаем. На очереди периферийный модуль I2S и его конфигурация:
/***************************************************************************************/
void initI2S()
{
SPI_I2S_DeInit(SPI3);
i2s.I2S_AudioFreq = I2S_AudioFreq_48k;
i2s.I2S_MCLKOutput = I2S_MCLKOutput_Enable;
i2s.I2S_DataFormat = I2S_DataFormat_16b;
i2s.I2S_Mode = I2S_Mode_MasterTx;
i2s.I2S_Standard = I2S_Standard_Phillips;
i2s.I2S_CPOL = I2S_CPOL_Low;
I2S_Init(SPI3, &i2s);
}
/***************************************************************************************/
Осталось только произвести настройку I2C:
/***************************************************************************************/
void initI2C()
{
I2C_DeInit(I2C1);
i2c.I2C_ClockSpeed = 100000;
i2c.I2C_Mode = I2C_Mode_I2C;
i2c.I2C_OwnAddress1 = 0x33;
i2c.I2C_Ack = I2C_Ack_Enable;
i2c.I2C_AcknowledgedAddress = I2C_AcknowledgedAddress_7bit;
i2c.I2C_DutyCycle = I2C_DutyCycle_2;
I2C_Cmd(I2C1, ENABLE);
I2C_Init(I2C1, &i2c);
}
/***************************************************************************************/
Для того, чтобы проинициализировать микросхему CS43L22 мы будем посылать ей управляющие команды по I2C - а точнее два байта, в первом адрес регистра, во втором значение, которое в него записывается. Для того, чтобы это осуществить, напишем функцию, которая в качестве аргументов будет принимать массив данных, который необходимо передать, а также количество байт данных:
/***************************************************************************************/
void writeI2CData(uint8_t bytesToSend[], uint8_t numOfBytesToSend)
{
uint8_t currentBytesValue = 0;
// Ждем пока шина освободится
while (I2C_GetFlagStatus(I2C1, I2C_FLAG_BUSY));
// Генерируем старт
I2C_GenerateSTART(I2C1, ENABLE);
while (!I2C_GetFlagStatus(I2C1, I2C_FLAG_SB));
// Посылаем адрес подчиненному устройству - микросхеме CS43L22
I2C_Send7bitAddress(I2C1, 0x94, I2C_Direction_Transmitter);
while (!I2C_CheckEvent(I2C1, I2C_EVENT_MASTER_TRANSMITTER_MODE_SELECTED));
// И наконец отправляем наши данные
while (currentBytesValue < numOfBytesToSend)
{
I2C_SendData(I2C1, bytesToSend[currentBytesValue]);
currentBytesValue++;
while(!I2C_CheckEvent(I2C1, I2C_EVENT_MASTER_BYTE_TRANSMITTING));
}
while(!I2C_GetFlagStatus(I2C1, I2C_FLAG_BTF));
I2C_GenerateSTOP(I2C1, ENABLE);
}
/***************************************************************************************/
Нам еще понадобится простенькая функция для формирования задержки, ну и заодно напишем инициализацию CS43L22 (задержку необходимо делать с использованием таймеров, я оставляю такой примитивный вариант только чтобы не загромождать пример):
/***************************************************************************************/
void delay(uint32_t delayTime)
{
uint32_t i = 0;
for (i = 0; i < delayTime; i++);
}
/***************************************************************************************/
void initCS43L22()
{
uint8_t sendBuffer[2];
GPIO_SetBits(GPIOD, GPIO_Pin_4);
delay(0x5FFFF);
sendBuffer[0] = 0x0D;
sendBuffer[1] = 0x01;
writeI2CData(sendBuffer, 2);
sendBuffer[0] = 0x00;
sendBuffer[1] = 0x99;
writeI2CData(sendBuffer, 2);
sendBuffer[0] = 0x47;
sendBuffer[1] = 0x80;
writeI2CData(sendBuffer, 2);
sendBuffer[0] = 0x32;
sendBuffer[1] = 0xFF;
writeI2CData(sendBuffer, 2);
sendBuffer[0] = 0x32;
sendBuffer[1] = 0x7F;
writeI2CData(sendBuffer, 2);
sendBuffer[0] = 0x00;
sendBuffer[1] = 0x00;
writeI2CData(sendBuffer, 2);
sendBuffer[0] = 0x04;
sendBuffer[1] = 0xAF;
writeI2CData(sendBuffer, 2);
sendBuffer[0] = 0x0D;
sendBuffer[1] = 0x70;
writeI2CData(sendBuffer, 2);
sendBuffer[0] = 0x05;
sendBuffer[1] = 0x81;
writeI2CData(sendBuffer, 2);
sendBuffer[0] = 0x06;
sendBuffer[1] = 0x07;
writeI2CData(sendBuffer, 2);
sendBuffer[0] = 0x0A;
sendBuffer[1] = 0x00;
writeI2CData(sendBuffer, 2);
sendBuffer[0] = 0x27;
sendBuffer[1] = 0x00;
writeI2CData(sendBuffer, 2);
sendBuffer[0] = 0x1A;
sendBuffer[1] = 0x0A;
writeI2CData(sendBuffer, 2);
sendBuffer[0] = 0x1B;
sendBuffer[1] = 0x0A;
writeI2CData(sendBuffer, 2);
sendBuffer[0] = 0x1F;
sendBuffer[1] = 0x0F;
writeI2CData(sendBuffer, 2);
sendBuffer[0] = 0x02;
sendBuffer[1] = 0x9E;
writeI2CData(sendBuffer, 2);
}
/***************************************************************************************/
Давайте разберемся, как вообще можно добиться воспроизведения звука. Мы хотим услышать какую-нибудь ноту, пусть это будет нота ля первой октавы. Звуковое колебание представляет из себя синусоиду определенной частоты (в данном случае 440 Гц). Как раз такой сигнал нам и надо послать по I2S микросхеме CS43L22.
Мы упростим себе задачу и будем подавать просто прямоугольные импульсы с частотой 440 Гц ) Такой частоте соответствует период 2.272 мс. Настроим таймер на генерацию прерываний каждые 2.27 мс и в прерывании будем менять уровень сигнала. Итак инициализация таймера:
/***************************************************************************************/
void initTimer()
{
RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM2, ENABLE);
TIM_TimeBaseStructInit(&timer);
timer.TIM_Prescaler = 7200;
timer.TIM_Period = 4;
TIM_TimeBaseInit(TIM2, &timer);
}
/***************************************************************************************/
И в прерывании инвертируем значение переменной state:
/***************************************************************************************/
void TIM2_IRQHandler()
{
TIM_ClearITPendingBit(TIM2, TIM_IT_Update);
state ^= 0x01;
}
/***************************************************************************************/
Почти все уже готово, пришло время самого главного - функции main():
/***************************************************************************************/
int main(void)
{
// Разрешаем прерывания
__enable_irq();
// Инициализация
initGPIO();
initTimer();
initI2C();
initI2S();
initCS43L22();
// Включаем SPI3
I2S_Cmd(SPI3, ENABLE);
// настраиваем прерывание по переполнению таймера
TIM_ITConfig(TIM2, TIM_IT_Update, ENABLE);
TIM_Cmd(TIM2, ENABLE);
NVIC_EnableIRQ(TIM2_IRQn);
while(1)
{
// Если флаг выставлен, то можно передавать данные
if (SPI_I2S_GetFlagStatus(SPI3, SPI_I2S_FLAG_TXE))
{
if (state == 0x00)
{
// Если переменная state = 0, то посылаем нули
SPI_I2S_SendData(SPI3, 0x00);
}
else
{
// А если переменная state != 0, то посылаем максимальное значение,
// в итоге получаем прямоугольные импульсы
SPI_I2S_SendData(SPI3, 0xFF);
}
}
}
}
/***************************************************************************************/
Собираем, прошиваем, втыкаем наушники или колонки в специальный разъем на STM32F4Discovery и наслаждаемся ) Если изменить период работы таймера, то изменится частота следования прямоугольных импульсов, а значит и высота звука.
В общем, на этом пока все, но со звуком обязательно еще продолжим в будущих статьях!
