void Init_Sound(void)
{
DAC_InitTypeDef DAC_InitStructure;
DMA_InitTypeDef DMA_InitStructure;
TIM_TimeBaseInitTypeDef TIM_TimeBaseStructure;
GPIO_InitTypeDef GPIO_InitStructure;

RCC_AHBPeriphClockCmd(RCC_AHBPeriph_DMA2, ENABLE);
RCC_APB1PeriphClockCmd(RCC_APB1Periph_DAC | RCC_APB1Periph_TIM6, ENABLE);

GPIO_InitStructure.GPIO_Pin = GPIO_Pin_4;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AIN;
GPIO_Init(GPIOA, &GPIO_InitStructure);

TIM_TimeBaseStructInit(&TIM_TimeBaseStructure);
TIM_TimeBaseStructure.TIM_RepetitionCounter = 0;
TIM_TimeBaseStructure.TIM_Period = 72-1; //
TIM_TimeBaseStructure.TIM_Prescaler = 0;
TIM_TimeBaseStructure.TIM_ClockDivision = TIM_CKD_DIV1;
TIM_TimeBaseStructure.TIM_CounterMode = TIM_CounterMode_Up;
TIM_TimeBaseInit(TIM6, &TIM_TimeBaseStructure);

TIM_SelectOutputTrigger(TIM6, TIM_TRGOSource_Update);

DMA_DeInit(DMA2_Channel3);
DMA_InitStructure.DMA_PeripheralBaseAddr = (uint32_t)&DAC->DHR8R1;
DMA_InitStructure.DMA_MemoryBaseAddr = (u32) &WAVBuffer[0];
DMA_InitStructure.DMA_DIR = DMA_DIR_PeripheralDST;
DMA_InitStructure.DMA_BufferSize =512;
DMA_InitStructure.DMA_PeripheralInc = DMA_PeripheralInc_Disable;
DMA_InitStructure.DMA_MemoryInc = DMA_MemoryInc_Enable;
DMA_InitStructure.DMA_PeripheralDataSize = DMA_PeripheralDataSize_Byte;
DMA_InitStructure.DMA_MemoryDataSize = DMA_MemoryDataSize_Byte;
DMA_InitStructure.DMA_Mode = DMA_Mode_Circular;
DMA_InitStructure.DMA_Priority = DMA_Priority_High;
DMA_InitStructure.DMA_M2M = DMA_M2M_Disable;
DMA_Init(DMA2_Channel3, &DMA_InitStructure);

DMA_Cmd(DMA2_Channel3, ENABLE);

DAC_InitStructure.DAC_LFSRUnmask_TriangleAmplitude = 0;
DAC_InitStructure.DAC_Trigger = DAC_Trigger_T6_TRGO;
DAC_InitStructure.DAC_WaveGeneration = DAC_WaveGeneration_None;
DAC_InitStructure.DAC_OutputBuffer = DAC_OutputBuffer_Disable;
DAC_Init(DAC_Channel_1, &DAC_InitStructure);

DAC_Cmd(DAC_Channel_1, ENABLE);

DAC_DMACmd(DAC_Channel_1, ENABLE);

TIM_Cmd(TIM6, DISABLE);
}

if(Kn_a==1)    // Kn_a находится в прерывании
{
   Init_Sound();
   load_header();   // Здесь читаются заголовки WAV и настраивается таймер
   sound();
   Kn_a=0;
}

void sound(void)
{
   while(1)
      {
         TIM_Cmd(TIM6, ENABLE);
      while(!(DMA2->ISR & DMA_ISR_HTIF3)) {}  

     f_read (&fsrc, &WAVBuffer[0], 256, &rb);
       DAC_SetChannel1Data(DAC_Align_8b_R, WAVBuffer[0]);
  

     if(rb < 256) {TIM_Cmd(TIM6, DISABLE); break;}  

     while(!(DMA2->ISR & DMA_ISR_TCIF3)) {}

     f_read (&fsrc, &WAVBuffer[256], 256, &rb);
       DAC_SetChannel1Data(DAC_Align_8b_R, WAVBuffer[256]);

     if(rb < 256) {TIM_Cmd(TIM6, DISABLE); break;}
       }
}

f_lseek(&fsrc, 44);                                      // переходим на данные

while(1)
{
f_read (&fsrc, &WAVBuffer[0], 256, &rb);        // загружаем первую часть буфера
if(rb < 256) { break;}
while(!(DMA2->ISR & DMA_ISR_HTIF3)) {}     // ждем флаг
DMA2->IFCR |= DMA_ISR_HTIF3;                  // сбросить флаг

f_read (&fsrc, &WAVBuffer[256], 256, &rb);   // загружаем вторую часть буфера
if(rb < 256) { break;}
while(!(DMA2->ISR & DMA_ISR_TCIF3)) {}    // ждем флаг
DMA2->IFCR |= DMA_ISR_HTIF3;                 //сбросить флаг
}

Если что то не так, или все не так, не надо сразу лицом в грязь.
Просто подскажите как правильно.

void Init_Sound(void)
{
/* const uint16_t sinus_12bit[180]={
2048, 2119, 2191, 2262, 2333, 2404, 2474, 2543, 2613, 2681, 2748, 2815, 2881, 2946, 3009, 3072, 3133, 3193, 3252, 3309,
3364, 3418, 3471, 3521, 3570, 3617, 3662, 3705,
3746, 3785, 3822, 3856, 3889, 3919, 3947, 3972, 3996, 4017, 4035, 4051, 4065, 4076, 4085, 4091, 4095, 4095, 4095, 4091,
4085, 4076, 4065, 4051, 4035, 4017, 3996, 3972,
3947, 3919, 3889, 3856, 3822, 3785, 3746, 3705, 3662, 3617, 3570, 3521, 3471, 3418, 3364, 3309, 3252, 3193, 3133, 3072,
3009, 2946, 2881, 2815, 2748, 2681, 2613, 2543,
2474, 2404, 2333, 2262, 2191, 2119, 2048, 1977, 1905, 1834, 1763, 1692, 1622, 1553, 1483, 1415, 1348, 1281, 1215, 1150,
1087, 1024, 963, 903, 844, 787, 732, 678, 625,
575, 526, 479, 434, 391, 350, 311, 274, 240, 207, 177, 149, 124, 100, 79, 61, 45, 31, 20, 11, 5, 1, 0, 1, 5, 11, 20, 31, 45, 61,
79, 100, 124, 149, 177, 207, 240, 274,
311, 350, 391, 434, 479, 526, 575, 625, 678, 732, 787, 844, 903, 963, 1024, 1087, 1150, 1215, 1281, 1348, 1415, 1483, 1553,
1622, 1692, 1763, 1834, 1905, 1977
};*/


DAC_InitTypeDef DAC_InitStructure;
DMA_InitTypeDef DMA_InitStructure;
TIM_TimeBaseInitTypeDef TIM_TimeBaseStructure;
GPIO_InitTypeDef GPIO_InitStructure;

RCC_AHBPeriphClockCmd(RCC_AHBPeriph_DMA2, ENABLE);
RCC_APB1PeriphClockCmd(RCC_APB1Periph_DAC | RCC_APB1Periph_TIM2, ENABLE);

GPIO_InitStructure.GPIO_Pin = GPIO_Pin_4;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AIN;
GPIO_Init(GPIOA, &GPIO_InitStructure);

TIM_TimeBaseStructInit(&TIM_TimeBaseStructure);
TIM_TimeBaseStructure.TIM_RepetitionCounter = 0;
TIM_TimeBaseStructure.TIM_Period = (72000000/8000)-1;
TIM_TimeBaseStructure.TIM_Prescaler = 0;
TIM_TimeBaseStructure.TIM_ClockDivision = TIM_CKD_DIV1;
TIM_TimeBaseStructure.TIM_CounterMode = TIM_CounterMode_Up;
TIM_TimeBaseInit(TIM2, &TIM_TimeBaseStructure);

TIM_SelectOutputTrigger(TIM2, TIM_TRGOSource_Update);

DMA_DeInit(DMA2_Channel3);
DMA_InitStructure.DMA_PeripheralBaseAddr = (uint32_t)&DAC->DHR8R1; // (uint32_t) & DAC->DHR12R1
DMA_InitStructure.DMA_MemoryBaseAddr = (u32) &WAVBuffer[0]; // sinus_12bit
DMA_InitStructure.DMA_DIR = DMA_DIR_PeripheralDST;
DMA_InitStructure.DMA_BufferSize = 512; // (sizeof(sinus_12bit) / sizeof(sinus_12bit[0]))
DMA_InitStructure.DMA_PeripheralInc = DMA_PeripheralInc_Disable;
DMA_InitStructure.DMA_MemoryInc = DMA_MemoryInc_Enable;
DMA_InitStructure.DMA_PeripheralDataSize = DMA_PeripheralDataSize_Byte; // DMA_PeripheralDataSize_HalfWord
DMA_InitStructure.DMA_MemoryDataSize = DMA_MemoryDataSize_Byte; // DMA_MemoryDataSize_HalfWord
DMA_InitStructure.DMA_Mode = DMA_Mode_Circular;
DMA_InitStructure.DMA_Priority = DMA_Priority_High;
DMA_InitStructure.DMA_M2M = DMA_M2M_Disable;
DMA_Init(DMA2_Channel3, &DMA_InitStructure);

DAC_InitStructure.DAC_Trigger = DAC_Trigger_T2_TRGO;
DAC_InitStructure.DAC_WaveGeneration = DAC_WaveGeneration_None;
DAC_InitStructure.DAC_OutputBuffer = DAC_OutputBuffer_Enable; // DAC_OutputBuffer_Disable;
DAC_Init(DAC_Channel_1, &DAC_InitStructure);

DAC_DMACmd(DAC_Channel_1, ENABLE);
DAC_Cmd(DAC_Channel_1, ENABLE);
DMA_Cmd(DMA2_Channel3, ENABLE);

TIM_Cmd(TIM2, ENABLE); //TIM_Cmd(TIM2, DISABLE);
}

void sound(void)
{
  
   disk_initialize(0);
   f_mount(0,&fs);
   f_open( &fsrc, "200.wav", FA_READ );
        f_read (&fsrc, &WAVBuffer, 512, &rb);
   f_lseek(&fsrc, 44);
  
   while(1)
      {
         while(!(DMA2->ISR & DMA_ISR_HTIF3)) {}
         f_read (&fsrc, &WAVBuffer[0], 256, &rb);
         DMA2->IFCR |= DMA_ISR_HTIF3;  
         if(rb < 256) {TIM_Cmd(TIM2, DISABLE); break;}
        
         while(!(DMA2->ISR & DMA_ISR_TCIF3)) {}
         f_read (&fsrc, &WAVBuffer[256], 256, &rb);  
         DMA2->IFCR |= DMA_ISR_HTIF3;
         if(rb < 256) {TIM_Cmd(TIM2, DISABLE); break;}
       }
}

static  void  Task_AudioOUT (void *p_arg)
{
    (void)p_arg;
    OSTimeDlyHMSM(0, 0, 2, 250);
    Status = SD_Init();
    Status = SD_GetCardInfo(&SDCardInfo);
    Status = SD_SelectDeselect((uint32_t) (SDCardInfo.RCA << 16));
    Status = SD_EnableWideBusOperation(SDIO_BusWide_4b);
    Status = SD_SetDeviceMode(SD_DMA_MODE);
  
   while(1)
  {  
      if(Kn_a==1)                  // Флаг кнопки меняется в прерывании
      {
        
         Init_Sound();
        
         sound();
         Kn_a=0;
      }
      
      OSTimeDlyHMSM(0, 0, 1, 250);
   }
}

static
DWORD load_header (void) /* 0:Invalid format, 1:I/O error, >1:Number of samples */
{

DWORD ChunkID, SamplingRate, sz, Length;
char str[20];

//------------------------------------------------
f_mount(0,&fs);
f_open( &fsrc, "200.wav", FA_READ );
//------------------------------------------------
GUI_SetColor(GUI_WHITE); //RED
GUI_SetFont(&GUI_Font24_1);
GUI_DispStringAt(">", 0, 50);

if (f_read(&fsrc, Buff, 12, &rb)) return 1; /* Load file header (12 bytes) */
if (rb != 12 || LD_DWORD(Buff+8) != FCC('W','A','V','E')) return 0;
GUI_DispNextLine(); GUI_DispString("WAV File found:");

while(1) {
f_read(&fsrc, Buff, 8, &rb); /* Get Chunk ID and size */
if (rb != 8) return 0;
ChunkID = LD_DWORD(&Buff[0]);
sz = LD_DWORD(&Buff[4]); /* Chunk size */
//------------------------------
sprintf(str, "%ld", sz);
GUI_DispNextLine();
GUI_DispString(str);
//------------------------------
switch (ChunkID) { /* FCC */
case fmt_chunk: /* 'fmt ' chunk */
if (sz > 100 || sz < 16) return 0; /* Check chunk size */
f_read(&fsrc, Buff, sz, &rb); /* Get content */
if (rb != sz) return 0;
if (Buff[0] != 1) return 0; /* Check coding type (PCM=1) */

NumChannels = Buff[2]; /* Get channel flag */
if (NumChannels != 1 && NumChannels != 2) /* Check channels (1/2) */
return 0;
if(NumChannels == 1) {GUI_DispNextLine(); GUI_DispString("Mono");}
else if(NumChannels == 2) {GUI_DispNextLine(); GUI_DispString("Stereo");}

BitsPerSample = Buff[14]; /* Resolution flag */
if (BitsPerSample != 8 && BitsPerSample != 16) /* Check resolution (8/16) */
return 0;
if(BitsPerSample == 8) {GUI_DispNextLine(); GUI_DispString("8-bits");}
else if(BitsPerSample == 16) {GUI_DispNextLine(); GUI_DispString("16-bits");}

SamplingRate = LD_DWORD(Buff+4);
// set_sampling_rate( SamplingRate ); /* Sampling freq */
sprintf(str, "%ldHz", SamplingRate);
GUI_DispNextLine(); GUI_DispString(str);
break;

case data_chunk: /* 'data' chunk (start to play) */
Length = sz / (SamplingRate * NumChannels * (BitsPerSample>>3) ); // length in seconds
sprintf(str, "%ld:%2ld min", (Length/60), (Length%60));
GUI_DispNextLine(); GUI_DispString(str);
return sz;

case LIST_chunk: /* 'LIST' chunk (skip) */

case fact_chunk: /* 'fact' chunk (skip) */
f_lseek(&fsrc, (fsrc.fptr + sz));

break;

default : /* Unknown chunk (error) */
return 0;
}
}
//return 0;
}

void sound(void)
{
f_read (&fsrc, &WAVBuffer[0], 512, &rb);
    
    while(1)  
        {
            while(!(DMA2->ISR & DMA_ISR_HTIF3)) {}
            f_read (&fsrc, &WAVBuffer[0], 256, &rb);
            DMA2->IFCR |= DMA_ISR_HTIF3;    
            if(rb < 256) {TIM_Cmd(TIM2, DISABLE); break;}
            
            while(!(DMA2->ISR & DMA_ISR_TCIF3)) {}
            f_read (&fsrc, &WAVBuffer[256], 256, &rb);    
            DMA2->IFCR |= DMA_ISR_HTIF3;
            if(rb < 256) {TIM_Cmd(TIM2, DISABLE); break;}
         }
}