STM32F4 Discovery Audio CS43L22 I2C Problem

[BK (Gast)]

Hallo,

Ich versuche den CS43L22 Audio chip meines STM32F4 Discovery Audio mit 
Hilfe des internen Beep Generators Töne ausgeben zu lassen.
Die I2C Kommunikation habe ich bereits implementiert. I2S werde ich noch 
hinzufügen.
Bei der Kommunikation über I2C treten Fehler auf. Im meinem Code main.c 
hängt sich das Programm bei dem zweiten Schreiben eines Registers auf. 
Bei Zeile 130:

 while(HAL_I2C_Master_Transmit(&I2C_Params, 0x94, send_data_array, 2, 1000) != HAL_OK){}; // write power register 1

Wenn ich debugge und schrittweise durchgehe funktioniert der Code.
Beim Debuggen und einem run von Breakpoint zu Breakpoint tritt der 
Fehler wiederrum auf. Ich konne das Hängen auf die Zeilen 5084 bis 5122 
in stm32f4xx_hal_i2c.c eingrenzen:

static HAL_StatusTypeDef I2C_WaitOnMasterAddressFlagUntilTimeout(I2C_HandleTypeDef *hi2c, uint32_t Flag, uint32_t Timeout, uint32_t Tickstart)
{
  while(__HAL_I2C_GET_FLAG(hi2c, Flag) == RESET)
  {
    if(__HAL_I2C_GET_FLAG(hi2c, I2C_FLAG_AF) == SET)
    {
      /* Generate Stop */
      hi2c->Instance->CR1 |= I2C_CR1_STOP;

      /* Clear AF Flag */
      __HAL_I2C_CLEAR_FLAG(hi2c, I2C_FLAG_AF);

      hi2c->ErrorCode = HAL_I2C_ERROR_AF;
      hi2c->PreviousState = I2C_STATE_NONE;
      hi2c->State= HAL_I2C_STATE_READY;

      /* Process Unlocked */
      __HAL_UNLOCK(hi2c);

      return HAL_ERROR;
    }

    /* Check for the Timeout */
    if(Timeout != HAL_MAX_DELAY)
    {
      if((Timeout == 0U)||((HAL_GetTick() - Tickstart ) > Timeout))
      {
        hi2c->PreviousState = I2C_STATE_NONE;
        hi2c->State= HAL_I2C_STATE_READY;

        /* Process Unlocked */
        __HAL_UNLOCK(hi2c);

        return HAL_TIMEOUT;
      }
    }
  }
  return HAL_OK;
}

Ich benutze Keil µVision 5.15 und würde gerne die HAL Treiber benutzen, 
da ich den Code später in einem RTOS einsetzen möchte. Nach vielen 
Versuchen den Chip zum laufen zu bringen bin ich nun etwas am 
verzweifeln und bin über jede Hilfe dankbar. Falls noch Informationen 
fehlen stelle ich die gerne zur Verfügung.

Hat jemand eine Idee worin das komische Verhalten begründet ist und wie 
man es vielleicht behebt?

Mein main.c:

// main.c

#include "stm32f4xx.h"
#include "my_header.h"


int main(void){
  
  I2C_HandleTypeDef I2C_Params; // declare Parameter Handle
  HAL_StatusTypeDef I2C_State; // declare State handle
  GPIO_InitTypeDef GPIOD_Params; // Declares the structure handle for the parameters of the reset pin on GPIOE
  GPIO_InitTypeDef GPIOB_Params; // Declares the structure handle for the parameters of SCL (PB6) and SDA (PB9) on GPIOB
  uint8_t send_data; // declare send data variable
  uint8_t send_data_array[2]; // declare send data variable
  uint8_t received_data; // declare received data variable
  
  HAL_Init(); // Initialise  Hal driver
  
  
  // configure System Clock
  RCC_ClkInitTypeDef RCC_ClkInitStruct;
  RCC_OscInitTypeDef RCC_OscInitStruct;

  /* Enable Power Control clock */
  __PWR_CLK_ENABLE();
  
  /* The voltage scaling allows optimizing the power consumption when the device is 
     clocked below the maximum system frequency, to update the voltage scaling value 
     regarding system frequency refer to product datasheet.  */
  __HAL_PWR_VOLTAGESCALING_CONFIG(PWR_REGULATOR_VOLTAGE_SCALE1);
  
  /* Enable HSE Oscillator and activate PLL with HSE as source */
  RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_HSE;
  RCC_OscInitStruct.HSEState = RCC_HSE_ON;
  RCC_OscInitStruct.PLL.PLLState = RCC_PLL_ON;
  RCC_OscInitStruct.PLL.PLLSource = RCC_PLLSOURCE_HSE;
  RCC_OscInitStruct.PLL.PLLM = 8;
  RCC_OscInitStruct.PLL.PLLN = 336;
  RCC_OscInitStruct.PLL.PLLP = RCC_PLLP_DIV2;
  RCC_OscInitStruct.PLL.PLLQ = 7;
  HAL_RCC_OscConfig(&RCC_OscInitStruct);
  
  /* Select PLL as system clock source and configure the HCLK, PCLK1 and PCLK2 
     clocks dividers */
  RCC_ClkInitStruct.ClockType = (RCC_CLOCKTYPE_SYSCLK | RCC_CLOCKTYPE_HCLK | RCC_CLOCKTYPE_PCLK1 | RCC_CLOCKTYPE_PCLK2);
  RCC_ClkInitStruct.SYSCLKSource = RCC_SYSCLKSOURCE_PLLCLK;
  RCC_ClkInitStruct.AHBCLKDivider = RCC_SYSCLK_DIV1;
  RCC_ClkInitStruct.APB1CLKDivider = RCC_HCLK_DIV4;  
  RCC_ClkInitStruct.APB2CLKDivider = RCC_HCLK_DIV2;  
  HAL_RCC_ClockConfig(&RCC_ClkInitStruct, FLASH_LATENCY_5);
  
  
  
  // Configure GPIOD for reset pin on CS43L22
  RCC->AHB1ENR |= RCC_AHB1ENR_GPIODEN; //Enable the clock for GPIOD
  GPIOD_Params.Pin = GPIO_PIN_4; // Select pin 4
  GPIOD_Params.Mode = GPIO_MODE_OUTPUT_PP; //Selects normal output push-pull mode
  GPIOD_Params.Speed = GPIO_SPEED_FAST; //Selects fast speed
  GPIOD_Params.Pull = GPIO_PULLDOWN; //Selects pull-down activation
  
  HAL_GPIO_Init(GPIOD, &GPIOD_Params); // Sets GPIOD into the modes specified in GPIOE_Params

  
  // Configure GPIOB for SCL (PB6) and SDA (PB9) on I2C1
  RCC->AHB1ENR |= RCC_AHB1ENR_GPIOBEN; //Enable the clock for GPIOA
  GPIOB_Params.Pin = GPIO_PIN_6 | GPIO_PIN_9; // Selects pins 6 and 9
  GPIOB_Params.Alternate = GPIO_AF4_I2C1; //Selects alternate function (I2C1)
  GPIOB_Params.Mode = GPIO_MODE_AF_OD; //Selects alternate function open drain mode
  GPIOB_Params.Speed = GPIO_SPEED_FAST; //Selects fast speed
  //GPIOB_Params.Speed = GPIO_SPEED_FREQ_VERY_HIGH; //Selects fast speed
  GPIOB_Params.Pull = GPIO_NOPULL; //Selects no pull-up or pull-down activation
  //GPIOB_Params.Pull = GPIO_PULLUP; //Selects no pull-up activation
  
  HAL_GPIO_Init(GPIOB, &GPIOB_Params); // Sets GPIOB into the modes specified in GPIOA_Params
  
  LED_Init(); // initialise LEDs
  Set_State_Rd_LED(1); // turn on red LED
  
  // Configure I2C
  RCC->APB1ENR |= RCC_APB1ENR_I2C1EN  ; // Enables the clock for I2C1
  
  I2C_Params.Instance = I2C1;
  I2C_Params.Init.ClockSpeed = 100000; // Set clock speed to 50 kHz
  I2C_Params.Init.DutyCycle = I2C_DUTYCYCLE_2; // Set duty cycle
  I2C_Params.Init.OwnAddress1 = 0x33; // set own adress 1  
  // I2C_Params.Init.OwnAddress1 = 0x00; // set own adress 1  
  I2C_Params.Init.AddressingMode = I2C_ADDRESSINGMODE_7BIT; // set to 7-Bit adresses
  I2C_Params.Init.DualAddressMode = I2C_DUALADDRESS_DISABLED; // Disabel dual address mode
  I2C_Params.Init.OwnAddress2 = 0; // set own adress 2
  I2C_Params.Init.GeneralCallMode = I2C_GENERALCALL_DISABLED; // General call disabled
  // I2C_Params.Init.NoStretchMode = I2C_NOSTRETCH_DISABLED; // No Stretch disabled
  I2C_Params.Init.NoStretchMode = I2C_NOSTRETCH_ENABLE; // No Stretch enabled
  // I2C_Params.Mode = HAL_I2C_MODE_MASTER; // set I2C to master
  
  // HAL_I2C_MspInit(&I2C_Params); // configure I2C
  I2C_State = HAL_I2C_Init(&I2C_Params); // configure I2C
  
  __HAL_I2C_ENABLE(&I2C_Params); //Enable the SPI
  
  GPIOD->BSRR |= GPIO_PIN_4; //Sets the reset pin of CS43L22 high
  
  I2C_State = HAL_I2C_IsDeviceReady(&I2C_Params, 0x0094, 10, 1000); //
  
  if(I2C_State == HAL_OK){
    Set_State_Gn_LED(1); // turn on green LED
  }
  else{
    Set_State_Gn_LED(0); // turn off green LED
  }
  
  // send new value
  send_data_array[0] = 0x1E; // address of Beep register
  send_data_array[1] = 0xC0; // value for Beep register (contious beep)
  while(HAL_I2C_Master_Transmit(&I2C_Params, 0x94, send_data_array, 2, 1000) != HAL_OK){}; // write Beep register
  
  
  // ceck value
  send_data = 0x1E; // address of Beep register
  while(HAL_I2C_Master_Transmit(&I2C_Params, 0x94, &send_data, 1, 1000) != HAL_OK){}; // Write Address to read
  
  while(HAL_I2C_Master_Receive(&I2C_Params, 0x94, &received_data, 1, 1000) != HAL_OK){}; // read Beep register
  
  if(received_data == 0xC0){
    Set_State_Bl_LED(1); // turn on blue LED
  }
  
  // send new value
  send_data_array[0] = 0x02; // adress of power register 1
  send_data_array[1] = 0x9E; // value for power register 1
  while(HAL_I2C_Master_Transmit(&I2C_Params, 0x94, send_data_array, 2, 1000) != HAL_OK){}; // write power register 1

  
  // ceck value
  send_data = 0x02; // adress of power register 1
  while(HAL_I2C_Master_Transmit(&I2C_Params, 0x94, &send_data, 1, 1000) != HAL_OK){}; // Write Address to read
  
  while(HAL_I2C_Master_Receive(&I2C_Params, 0x94, &received_data, 1, 1000) != HAL_OK){}; // read power register 1
  
  if(received_data == 0x9E){
    Set_State_Or_LED(1); // turn on orange LED
  }
};

[W.S. (Gast)]

BK schrieb:
> und würde gerne die HAL Treiber benutzen,
> da ich den Code später in einem RTOS einsetzen möchte. Nach vielen
> Versuchen den Chip zum laufen zu bringen bin ich nun etwas am
> verzweifeln und bin über jede Hilfe dankbar.

Also mal ganz konkret:

Du benutzt dieses unsägliche Zeugs von ST, was nur dann zu funktinieren 
scheint, wenn du deine Aufrufe per Einzelschritt durchwinkst - und das 
alles NUR!, weil du irgend wann mal ein RTOS einsetzen willst.

Aha.

Du kämpfst derzeit vergeblich mit dem I2C-Core deines Chips und mit dem 
Teil der ST-Lib, der angeblich dafür zuständig ist.

Ich würde an deiner Stelle all diesen Kram erstmal komplett bleiben 
lassen, die beiden Pins für SCL und SDA als gewöhnliche Portpins mit 
Open-Collector Ausgang einrichten und die I2C-Signalspiele schlichtweg 
in Software erledigen - ist doch easy. Wenn da etwas nicht geht, dann 
weißt du wenigstens, an welcher Stelle es passiert. Ich hab die 
Erfahrung gemacht, daß die allermeisten I2C-Cores eher mistig 
konstruiert sind und Probleme mit ihrer eigenen Befindlichkeit machen.

Bevor du also dich um den eigentlichen CODEC kümmern kannst, mußt du 
dich um die Befindlichkeiten des I2C kümmern und davor auch noch um die 
Hakeligkeiten des I2C-Cores in deinem µC und in deinem Falle auch noch 
mit der ST-Lib. Prost Mahlzeit.

Also laß die letzteren weg, kümmere dich zu Fuß erstmal um den I2C und 
dann um deinen Audio-IC.

W.S.

[Matthias S. (Firma: matzetronics) (mschoeldgen)]

Du weisst aber schon, das der CS43L22 eine Initialisierung braucht, 
sonst piepst da nix.
Da sind auch noch ein paar undokumentierte Register, die man setzen 
muss. Hier mal frei nach Uwe B. eine brauchbare Initialisierung, 
allerdings in SPL:

/* first the I2C setup  */
uint16_t MS_Init_CS42L22(void) {
int16_t error = 0;
    GPIO_SetBits(DRIVE_GPIO_PORT,CS43_RST_PIN);
    Delay(50);  // lets settle the chip
  error = I2C_WriteByte(CODEC_I2C_ADRESS,0x02, 0x01); // power off
  if (error) return error;
  error = I2C_WriteByte(CODEC_I2C_ADRESS,0x00, 0x99); //  init sequence by datasheet
  if (error) return error;
  error = I2C_WriteByte(CODEC_I2C_ADRESS,0x47, 0x80); //  undocumented registers
  if (error) return error;
  error = I2C_WriteByte(CODEC_I2C_ADRESS,0x32, 0xBB); //  have to be written
  if (error) return error;
  error = I2C_WriteByte(CODEC_I2C_ADRESS,0x32, 0x3B); //
  if (error) return error;
  error = I2C_WriteByte(CODEC_I2C_ADRESS,0x00, 0x00); //  register 0 is not in the datasheet
  if (error) return error;
  return 0;
}
uint16_t MS_Control_CS42L22(void) {
int16_t error = 0;
  error = I2C_WriteByte(CODEC_I2C_ADRESS,0x02, 0x9E); // power on
  if (error) return error;
  error = I2C_WriteByte(CODEC_I2C_ADRESS,0x04, 0xFF); // SPK off , HP off
  if (error) return error;
  error = I2C_WriteByte(CODEC_I2C_ADRESS,0x05, 0x81); // autodetect clock
  if (error) return error;
  error = I2C_WriteByte(CODEC_I2C_ADRESS,0x06, CODEC_STANDARD); // codec used
  if (error) return error;
  error = I2C_WriteByte(CODEC_I2C_ADRESS,0x20, 0xFC); // master volume -2db
  if (error) return error;
  error = I2C_WriteByte(CODEC_I2C_ADRESS,0x21, 0xFC); // master volume -2db
  if (error) return error;
  error = I2C_WriteByte(CODEC_I2C_ADRESS,0x22, 0xF8); // HP volume -4db
  if (error) return error;
  error = I2C_WriteByte(CODEC_I2C_ADRESS,0x23, 0xF8); // HP volume -4db
  if (error) return error;
/* soft on and off ramp disable */
  error = I2C_WriteByte(CODEC_I2C_ADRESS,0x0A, 0x00); // analog soft ramp off
  if (error) return error;
  error = I2C_WriteByte(CODEC_I2C_ADRESS,0x0E, 0x04); // digital soft ramp off
  if (error) return error;
  error = I2C_WriteByte(CODEC_I2C_ADRESS,0x27, 0x00); // limiter attack off
  if (error) return error;
  error = I2C_WriteByte(CODEC_I2C_ADRESS,0x1e, 0x0B); // bass 100hz and treble 7khz tone control on
  if (error) return error;
  error = I2C_WriteByte(CODEC_I2C_ADRESS,0x1F, 0x88); // bass 0db and treble 0db
  if (error) return error;
  error = I2C_WriteByte(CODEC_I2C_ADRESS,0x1A, 0x00); // PCM volume A 0db
  if (error) return error;
  error = I2C_WriteByte(CODEC_I2C_ADRESS,0x1B, 0x00); // PCM volume B 0db
  if (error) return error;

return 0;
}

Nun ist der Chip sowohl für I2S als auch fürs Quäken bereit.

[BK (Gast)]

Vielen Dank für die Hinweise bis hierhin. Durch weitere Versuche hat 
sich gezeigt, dass der Fehler nicht im Zusammenhang mit I2C steht 
sondern anscheinend die Clock oder ein Stystick Interrupt nicht richtig 
funktioniert. Ich mache wohl einen Fehler bei der Initialisierung.

Wenn ich debugge hängt das Programm in startup_stm32f407xx.s bei der 
Zeile mit dem Inhalt "B" unter SysTick_Handler:

; Dummy Exception Handlers (infinite loops which can be modified)

NMI_Handler     PROC
                EXPORT  NMI_Handler                [WEAK]
                B       .
                ENDP
HardFault_Handler\
                PROC
                EXPORT  HardFault_Handler          [WEAK]
                B       .
                ENDP
MemManage_Handler\
                PROC
                EXPORT  MemManage_Handler          [WEAK]
                B       .
                ENDP
BusFault_Handler\
                PROC
                EXPORT  BusFault_Handler           [WEAK]
                B       .
                ENDP
UsageFault_Handler\
                PROC
                EXPORT  UsageFault_Handler         [WEAK]
                B       .
                ENDP
SVC_Handler     PROC
                EXPORT  SVC_Handler                [WEAK]
                B       .
                ENDP
DebugMon_Handler\
                PROC
                EXPORT  DebugMon_Handler           [WEAK]
                B       .
                ENDP
PendSV_Handler  PROC
                EXPORT  PendSV_Handler             [WEAK]
                B       .
                ENDP
SysTick_Handler PROC
                EXPORT  SysTick_Handler            [WEAK]
                B       .
                ENDP

Aber anscheinend funktioniert der ganze Aufbau kurzfristig (deshalb 
konnte ich auch über I2C übertragen). Ein neues Minimalbeispiel ist 
hier:

// main.c

#include "stm32f4xx.h"


int main(void){
  
  uint32_t ii;  
  
  RCC_ClkInitTypeDef RCC_ClkInitStruct;
  RCC_OscInitTypeDef RCC_OscInitStruct;
  
  // SystemInit(); // tried with and without no change
  
  // HAL_Init(); // tried with and without no change
  
  /**
  * @brief  System Clock Configuration
  *         The system Clock is configured as follow : 
  *            System Clock source            = PLL (HSE)
  *            SYSCLK(Hz)                     = 168000000
  *            HCLK(Hz)                       = 168000000
  *            AHB Prescaler                  = 1
  *            APB1 Prescaler                 = 4
  *            APB2 Prescaler                 = 2
  *            HSE Frequency(Hz)              = 8000000
  *            PLL_M                          = 8
  *            PLL_N                          = 336
  *            PLL_P                          = 2
  *            PLL_Q                          = 7
  *            VDD(V)                         = 3.3
  *            Main regulator output voltage  = Scale1 mode
  *            Flash Latency(WS)              = 5
  * @param  None
  * @retval None
  */
  
  /* Enable Power Control clock */
  __PWR_CLK_ENABLE();
  
  /* The voltage scaling allows optimizing the power consumption when the device is 
     clocked below the maximum system frequency, to update the voltage scaling value 
     regarding system frequency refer to product datasheet.  */
  __HAL_PWR_VOLTAGESCALING_CONFIG(PWR_REGULATOR_VOLTAGE_SCALE1);
  
  /* Enable HSE Oscillator and activate PLL with HSE as source */
  RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_HSE;
  RCC_OscInitStruct.HSEState = RCC_HSE_ON;
  RCC_OscInitStruct.PLL.PLLState = RCC_PLL_ON;
  RCC_OscInitStruct.PLL.PLLSource = RCC_PLLSOURCE_HSE;
  RCC_OscInitStruct.PLL.PLLM = 8;
  RCC_OscInitStruct.PLL.PLLN = 336;
  RCC_OscInitStruct.PLL.PLLP = RCC_PLLP_DIV2;
  RCC_OscInitStruct.PLL.PLLQ = 7;
  HAL_RCC_OscConfig(&RCC_OscInitStruct);
  
  /* Select PLL as system clock source and configure the HCLK, PCLK1 and PCLK2 
     clocks dividers */
  RCC_ClkInitStruct.ClockType = (RCC_CLOCKTYPE_SYSCLK | RCC_CLOCKTYPE_HCLK | RCC_CLOCKTYPE_PCLK1 | RCC_CLOCKTYPE_PCLK2);
  RCC_ClkInitStruct.SYSCLKSource = RCC_SYSCLKSOURCE_PLLCLK;
  RCC_ClkInitStruct.AHBCLKDivider = RCC_SYSCLK_DIV1;
  RCC_ClkInitStruct.APB1CLKDivider = RCC_HCLK_DIV4;  
  RCC_ClkInitStruct.APB2CLKDivider = RCC_HCLK_DIV2;  
  HAL_RCC_ClockConfig(&RCC_ClkInitStruct, FLASH_LATENCY_5);


  // initialise LEDs
  RCC->AHB1ENR |= RCC_AHB1ENR_GPIODEN; // Enable Port D clock
  GPIOD->MODER |= GPIO_MODER_MODER12_0; // Port D.12 output - green LED
  
  for(ii=0; ii<260000; ii++){} // wait
  //for(ii=0; ii<260; ii++){} // wait
  
  GPIOD->BSRR = 1<<12; // Turn on the green LED
    
};

bei diesem leuchtet die grüne LED für ein wait von 260 Schritten und 
leuchtet nicht für 260000 Schritte (Programm hängt).

Als system_stm32f4xx.c benutze ich die von Keil automatisch generierte 
Datei wenn man im "Manage Run-Time Environment" unter Device --> 
STM32Cube Framwork (API) --> Classic wählt. Diese Datei findet ihr im 
Anhang.

Für vorherige Versuche (z.B. kommunikation mit dem Beschleunigungssensor 
auf dem Board über HAL_SPI) hat eine initalisierung der Clocks in 
system_stm32f4xx.c ausgereicht. hierbei wurde folgender Code nach Zeile 
192 eingefügt:

  
  // Sets PLL to give 168MHz when using HSI
RCC->PLLCFGR = RCC->PLLCFGR & ~0x00007FC0; /*Un-sets all PLLN bits */
RCC->PLLCFGR = RCC->PLLCFGR + (336<<6); /* Sets PLLN to 336 */
RCC->PLLCFGR = RCC->PLLCFGR & ~0x00030000; /*Un-sets all PLLP bits */
RCC->PLLCFGR = RCC->PLLCFGR + (1<<16); /* Sets PLLP to 4 */
RCC->PLLCFGR = RCC->PLLCFGR & ~0x0000003F; /*Un-sets all PLLM bits */
RCC->PLLCFGR = RCC->PLLCFGR + 8; /* Sets PLLM to 8 or can use 8 instead of hex */
// Enables the HSE clock
RCC->CR |= RCC_CR_HSEON;
// Waits for the HSE clock to become stable and ready to use
do
{
} while(((RCC->CR & RCC_CR_HSERDY) == 0));
/* Enables high performance mode, System frequency up to 168 MHz */
RCC->APB1ENR |= RCC_APB1ENR_PWREN;
PWR->CR |= PWR_CR_PMODE;
//RCC->PLLCFGR |= RCC_PLLCFGR_PLLSRC_HSI; // Selects the HSI (internal oscillator) as the PLL source
RCC->PLLCFGR |= RCC_PLLCFGR_PLLSRC_HSE; // Selects the HSE (external oscillator) as the PLL source

/* Enables the main PLL */
RCC->CR |= RCC_CR_PLLON;
/* Waits until the main PLL is ready */
while((RCC->CR & RCC_CR_PLLRDY) == 0)
{
}
/* Configure Flash prefetch, Instruction cache, Data cache and wait state */
FLASH->ACR = FLASH_ACR_ICEN |FLASH_ACR_DCEN |FLASH_ACR_LATENCY_5WS;
/* Selects the main PLL as the system clock source */
RCC->CFGR &= (uint32_t)((uint32_t)~(RCC_CFGR_SW));
RCC->CFGR |= RCC_CFGR_SW_PLL;
/* Waits until the main PLL is used as the system clock source */
while ((RCC->CFGR & (uint32_t)RCC_CFGR_SWS ) != RCC_CFGR_SWS_PLL);
{
}
RCC->CFGR |= RCC_CFGR_PPRE2_DIV2; // Sets the prescaler for the APB2 high speed clock to 2, which gives an APB1 clock frequency of 84MHz if the system clock is 168MHz
RCC->CFGR |= RCC_CFGR_PPRE1_DIV4; // Sets the prescaler for the APB1 low speed clock to 4, which gives an APB1 clock frequency of 42MHz if the system clock is 168MHz

Mit diesem Code funktionierten jedoch die I2C Funktionen nicht.

Nun die Frage was mache ich falsch bei der Initalisierung?

Sollte ich lieber in system_stm32f4xx.c initalisieren? Wenn ja was 
fehlt, dass die I2C Funktionen ausgeführt werden?

Was ist falsch bei der Initalisierung mit den HAL_Funktionen?

Vielen dank für eure Hilfe schon im Vorraus

[Matthias S. (Firma: matzetronics) (mschoeldgen)]

Also, bei HAL bin ich erstmal raus. Ich empfehle dir, mal Beispiel Code 
von STM anzuschauen, um die Initialisierung der Systemtakte und des 
SysTickers hinzukriegen.
Bei der SPL reicht es, system_stm32f4xx.c auf die gewünschten PLL Werte 
einzustellen und dann in main() einmal SystemInit() aufzurufen.
Der Systicker wird danach mit z.B.

  if (SysTick_Config(SystemCoreClock / 1000))
  {
    /* Capture error */
    while (1);
  }

aufgerufen - in diesem Beispiel für eine Granularität von 1 ms.
Meine Werte für die PLL:

/* PLL_VCO = (HSE_VALUE or HSI_VALUE / PLL_M) * PLL_N */
#define PLL_M      4
#define PLL_N      168

/* SYSCLK = PLL_VCO / PLL_P */
#define PLL_P      2

/* USB OTG FS, SDIO and RNG Clock =  PLL_VCO / PLLQ */
#define PLL_Q      7

Die I2S Clock konfiguriere ich dann mit PLL_N = 192 und PLL_R = 3.

[Bülent C. (mirki)]

/**
  ******************************************************************************
  * File Name          : main.c
  * Description        : Main program body
  ******************************************************************************
  *
  * COPYRIGHT(c) 2016 STMicroelectronics
  *
  * Redistribution and use in source and binary forms, with or without modification,
  * are permitted provided that the following conditions are met:
  *   1. Redistributions of source code must retain the above copyright notice,
  *      this list of conditions and the following disclaimer.
  *   2. Redistributions in binary form must reproduce the above copyright notice,
  *      this list of conditions and the following disclaimer in the documentation
  *      and/or other materials provided with the distribution.
  *   3. Neither the name of STMicroelectronics nor the names of its contributors
  *      may be used to endorse or promote products derived from this software
  *      without specific prior written permission.
  *
  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
  * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
  * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
  * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  *
  ******************************************************************************
  */
/* Includes ------------------------------------------------------------------*/
#include "main.h"
#include "stm32f4xx_hal.h"

/* USER CODE BEGIN Includes */

#include "WaveData.h"



#define CORE_I2C_ADDRESS 0x33
#define CODEC_I2C_ADDRESS 0x94

#define CODEC_MAPBYTE_INC 0x80

//register map bytes for CS42L22 (see page 35)
#define CODEC_MAP_CHIP_ID 0x01
#define CODEC_MAP_PWR_CTRL1 0x02
#define CODEC_MAP_PWR_CTRL2 0x04
#define CODEC_MAP_CLK_CTRL  0x05
#define CODEC_MAP_IF_CTRL1  0x06
#define CODEC_MAP_IF_CTRL2  0x07
#define CODEC_MAP_PASSTHROUGH_A_SELECT 0x08
#define CODEC_MAP_PASSTHROUGH_B_SELECT 0x09
#define CODEC_MAP_ANALOG_SET 0x0A
#define CODEC_MAP_PASSTHROUGH_GANG_CTRL 0x0C
#define CODEC_MAP_PLAYBACK_CTRL1 0x0D
#define CODEC_MAP_MISC_CTRL 0x0E
#define CODEC_MAP_PLAYBACK_CTRL2 0x0F
#define CODEC_MAP_PASSTHROUGH_A_VOL 0x14
#define CODEC_MAP_PASSTHROUGH_B_VOL 0x15
#define CODEC_MAP_PCMA_VOL 0x1A
#define CODEC_MAP_PCMB_VOL 0x1B
#define CODEC_MAP_BEEP_FREQ_ONTIME 0x1C
#define CODEC_MAP_BEEP_VOL_OFFTIME 0x1D
#define CODEC_MAP_BEEP_TONE_CFG 0x1E
#define CODEC_MAP_TONE_CTRL 0x1F
#define CODEC_MAP_MASTER_A_VOL 0x20
#define CODEC_MAP_MASTER_B_VOL 0x21
#define CODEC_MAP_HP_A_VOL 0x22
#define CODEC_MAP_HP_B_VOL 0x23
#define CODEC_MAP_SPEAK_A_VOL 0x24
#define CODEC_MAP_SPEAK_B_VOL 0x25
#define CODEC_MAP_CH_MIX_SWAP 0x26
#define CODEC_MAP_LIMIT_CTRL1 0x27
#define CODEC_MAP_LIMIT_CTRL2 0x28
#define CODEC_MAP_LIMIT_ATTACK 0x29
#define CODEC_MAP_OVFL_CLK_STATUS 0x2E
#define CODEC_MAP_BATT_COMP 0x2F
#define CODEC_MAP_VP_BATT_LEVEL 0x30
#define CODEC_MAP_SPEAK_STATUS 0x31
#define CODEC_MAP_CHARGE_PUMP_FREQ 0x34

/* USER CODE END Includes */

/* Private variables ---------------------------------------------------------*/
I2C_HandleTypeDef hi2c1;

I2S_HandleTypeDef hi2s3;
DMA_HandleTypeDef hdma_spi3_tx;

/* USER CODE BEGIN PV */
/* Private variables ---------------------------------------------------------*/

/* USER CODE END PV */

/* Private function prototypes -----------------------------------------------*/
void SystemClock_Config(void);
void Error_Handler(void);
static void MX_GPIO_Init(void);
static void MX_DMA_Init(void);
static void MX_I2C1_Init(void);
static void MX_I2S3_Init(void);

/* USER CODE BEGIN PFP */
/* Private function prototypes -----------------------------------------------*/

/* USER CODE END PFP */

/* USER CODE BEGIN 0 */

void send_codec_ctrl(uint8_t *werte, uint8_t laenge)     
{
  while( HAL_I2C_Master_Transmit(&hi2c1, CODEC_I2C_ADDRESS, werte,  laenge,  1000) !=HAL_OK){}
  
}

uint8_t read_codec_register(uint8_t regValue)
{
  uint8_t RxBuffer[1];
  HAL_I2C_Mem_Read(&hi2c1, CODEC_I2C_ADDRESS, regValue, I2C_MEMADD_SIZE_8BIT, RxBuffer, 1, 10000);
  return RxBuffer[0];
}

void codec_ctrl_init()
{
  
  uint8_t CodecCommandBuffer[5];

  uint8_t regValue = 0xFF;
  HAL_GPIO_WritePin(GPIOD, LD4_Pin|Audio_RST_Pin, GPIO_PIN_SET);
    
  HAL_Delay(1000);
  
  //keep codec OFF
    CodecCommandBuffer[0] = CODEC_MAP_PLAYBACK_CTRL1;
  CodecCommandBuffer[1] = 0x01;
  send_codec_ctrl(CodecCommandBuffer, 2);

  //begin initialization sequence (p. 32)
  CodecCommandBuffer[0] = 0x00;
  CodecCommandBuffer[1] = 0x99;
  send_codec_ctrl(CodecCommandBuffer, 2);

  CodecCommandBuffer[0] = 0x47;
  CodecCommandBuffer[1] = 0x80;
  send_codec_ctrl(CodecCommandBuffer, 2);

  regValue = read_codec_register(0x32);

  CodecCommandBuffer[0] = 0x32;
  CodecCommandBuffer[1] = regValue | 0x80;
  send_codec_ctrl(CodecCommandBuffer, 2);

  regValue = read_codec_register(0x32);

  CodecCommandBuffer[0] = 0x32;
  CodecCommandBuffer[1] = regValue & (~0x80);
  send_codec_ctrl(CodecCommandBuffer, 2);

  CodecCommandBuffer[0] = 0x00;
  CodecCommandBuffer[1] = 0x00;
  send_codec_ctrl(CodecCommandBuffer, 2);
  //end of initialization sequence

  CodecCommandBuffer[0] = CODEC_MAP_PWR_CTRL2;
  CodecCommandBuffer[1] = 0xAF;
  send_codec_ctrl(CodecCommandBuffer, 2);

  CodecCommandBuffer[0] = CODEC_MAP_PLAYBACK_CTRL1;
  CodecCommandBuffer[1] = 0x70;
  send_codec_ctrl(CodecCommandBuffer, 2);

  CodecCommandBuffer[0] = CODEC_MAP_CLK_CTRL;
  CodecCommandBuffer[1] = 0x81; //auto detect clock
  send_codec_ctrl(CodecCommandBuffer, 2);

  CodecCommandBuffer[0] = CODEC_MAP_IF_CTRL1;
  CodecCommandBuffer[1] = 0x07;
  send_codec_ctrl(CodecCommandBuffer, 2);

  CodecCommandBuffer[0] = 0x0A;
  CodecCommandBuffer[1] = 0x00;
  send_codec_ctrl(CodecCommandBuffer, 2);

  CodecCommandBuffer[0] = 0x27;
  CodecCommandBuffer[1] = 0x00;
  send_codec_ctrl(CodecCommandBuffer, 2);

  CodecCommandBuffer[0] = 0x1A | CODEC_MAPBYTE_INC;
  CodecCommandBuffer[1] = 0x0A;
  CodecCommandBuffer[2] = 0x0A;
  send_codec_ctrl(CodecCommandBuffer, 3);

  CodecCommandBuffer[0] = 0x1F;
  CodecCommandBuffer[1] = 0x0F;
  send_codec_ctrl(CodecCommandBuffer, 2);

  CodecCommandBuffer[0] = CODEC_MAP_PWR_CTRL1;
  CodecCommandBuffer[1] = 0x9E;
  send_codec_ctrl(CodecCommandBuffer, 2);
  
  /*
  CodecCommandBuffer[0] = CODEC_MAP_HP_A_VOL;
  CodecCommandBuffer[1] = 0x34;
  send_codec_ctrl(CodecCommandBuffer, 2);
  
  CodecCommandBuffer[0] = CODEC_MAP_HP_B_VOL;
  CodecCommandBuffer[1] = 0x34;
  send_codec_ctrl(CodecCommandBuffer, 2);
  */
  HAL_GPIO_WritePin(GPIOD, LD4_Pin, GPIO_PIN_RESET);
}

/* USER CODE END 0 */

int main(void)
{

  /* USER CODE BEGIN 1 */

  /* USER CODE END 1 */

  /* MCU Configuration----------------------------------------------------------*/

  /* Reset of all peripherals, Initializes the Flash interface and the Systick. */
  HAL_Init();

  /* Configure the system clock */
  SystemClock_Config();

  /* Initialize all configured peripherals */
  MX_GPIO_Init();
  MX_DMA_Init();
  MX_I2C1_Init();
  MX_I2S3_Init();

  /* USER CODE BEGIN 2 */
  codec_ctrl_init();
  
  
  /* USER CODE END 2 */

  /* Infinite loop */
  /* USER CODE BEGIN WHILE */
  while (1)
  {
    HAL_I2S_Transmit(&hi2s3,(uint16_t *)sound0,2048,100);
    //HAL_I2S_Transmit(&hi2s3,(uint16_t *)result_sound,2048,100);
    
    
    
  /* USER CODE END WHILE */

  /* USER CODE BEGIN 3 */

  }
  /* USER CODE END 3 */

}

/** System Clock Configuration
*/
void SystemClock_Config(void)
{

  RCC_OscInitTypeDef RCC_OscInitStruct;
  RCC_ClkInitTypeDef RCC_ClkInitStruct;
  RCC_PeriphCLKInitTypeDef PeriphClkInitStruct;

    /**Configure the main internal regulator output voltage 
    */
  __HAL_RCC_PWR_CLK_ENABLE();

  __HAL_PWR_VOLTAGESCALING_CONFIG(PWR_REGULATOR_VOLTAGE_SCALE1);

    /**Initializes the CPU, AHB and APB busses clocks 
    */
  RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_HSE;
  RCC_OscInitStruct.HSEState = RCC_HSE_ON;
  RCC_OscInitStruct.PLL.PLLState = RCC_PLL_ON;
  RCC_OscInitStruct.PLL.PLLSource = RCC_PLLSOURCE_HSE;
  RCC_OscInitStruct.PLL.PLLM = 8;
  RCC_OscInitStruct.PLL.PLLN = 336;
  RCC_OscInitStruct.PLL.PLLP = RCC_PLLP_DIV2;
  RCC_OscInitStruct.PLL.PLLQ = 7;
  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_CLOCKTYPE_PCLK2;
  RCC_ClkInitStruct.SYSCLKSource = RCC_SYSCLKSOURCE_PLLCLK;
  RCC_ClkInitStruct.AHBCLKDivider = RCC_SYSCLK_DIV1;
  RCC_ClkInitStruct.APB1CLKDivider = RCC_HCLK_DIV4;
  RCC_ClkInitStruct.APB2CLKDivider = RCC_HCLK_DIV2;

  if (HAL_RCC_ClockConfig(&RCC_ClkInitStruct, FLASH_LATENCY_5) != HAL_OK)
  {
    Error_Handler();
  }

  PeriphClkInitStruct.PeriphClockSelection = RCC_PERIPHCLK_I2S;
  PeriphClkInitStruct.PLLI2S.PLLI2SN = 352;
  PeriphClkInitStruct.PLLI2S.PLLI2SR = 2;
  if (HAL_RCCEx_PeriphCLKConfig(&PeriphClkInitStruct) != HAL_OK)
  {
    Error_Handler();
  }

    /**Configure the Systick interrupt time 
    */
  HAL_SYSTICK_Config(HAL_RCC_GetHCLKFreq()/1000);

    /**Configure the Systick 
    */
  HAL_SYSTICK_CLKSourceConfig(SYSTICK_CLKSOURCE_HCLK);

  /* SysTick_IRQn interrupt configuration */
  HAL_NVIC_SetPriority(SysTick_IRQn, 0, 0);
}

/* I2C1 init function */
static void MX_I2C1_Init(void)
{

  hi2c1.Instance = I2C1;
  hi2c1.Init.ClockSpeed = 100000;
  hi2c1.Init.DutyCycle = I2C_DUTYCYCLE_2;
  hi2c1.Init.OwnAddress1 = 0;
  hi2c1.Init.AddressingMode = I2C_ADDRESSINGMODE_7BIT;
  hi2c1.Init.DualAddressMode = I2C_DUALADDRESS_DISABLE;
  hi2c1.Init.OwnAddress2 = 0;
  hi2c1.Init.GeneralCallMode = I2C_GENERALCALL_DISABLE;
  hi2c1.Init.NoStretchMode = I2C_NOSTRETCH_DISABLE;
  if (HAL_I2C_Init(&hi2c1) != HAL_OK)
  {
    Error_Handler();
  }

}

/* I2S3 init function */
static void MX_I2S3_Init(void)
{

  hi2s3.Instance = SPI3;
  hi2s3.Init.Mode = I2S_MODE_MASTER_TX;
  hi2s3.Init.Standard = I2S_STANDARD_PHILIPS;
  hi2s3.Init.DataFormat = I2S_DATAFORMAT_16B;
  hi2s3.Init.MCLKOutput = I2S_MCLKOUTPUT_ENABLE;
  hi2s3.Init.AudioFreq = I2S_AUDIOFREQ_8K;
  hi2s3.Init.CPOL = I2S_CPOL_LOW;
  hi2s3.Init.ClockSource = I2S_CLOCK_PLL;
  hi2s3.Init.FullDuplexMode = I2S_FULLDUPLEXMODE_ENABLE;
  if (HAL_I2S_Init(&hi2s3) != HAL_OK)
  {
    Error_Handler();
  }

}

/** 
  * Enable DMA controller clock
  */
static void MX_DMA_Init(void) 
{
  /* DMA controller clock enable */
  __HAL_RCC_DMA1_CLK_ENABLE();

  /* DMA interrupt init */
  /* DMA1_Stream5_IRQn interrupt configuration */
  HAL_NVIC_SetPriority(DMA1_Stream5_IRQn, 0, 0);
  HAL_NVIC_EnableIRQ(DMA1_Stream5_IRQn);

}

/** Configure pins as 
        * Analog 
        * Input 
        * Output
        * EVENT_OUT
        * EXTI
     PC3   ------> I2S2_SD
     PA5   ------> SPI1_SCK
     PA6   ------> SPI1_MISO
     PA7   ------> SPI1_MOSI
     PB10   ------> I2S2_CK
     PA9   ------> USB_OTG_FS_VBUS
     PA10   ------> USB_OTG_FS_ID
     PA11   ------> USB_OTG_FS_DM
     PA12   ------> USB_OTG_FS_DP
*/
static void MX_GPIO_Init(void)
{

  GPIO_InitTypeDef GPIO_InitStruct;

  /* GPIO Ports Clock Enable */
  __HAL_RCC_GPIOE_CLK_ENABLE();
  __HAL_RCC_GPIOC_CLK_ENABLE();
  __HAL_RCC_GPIOH_CLK_ENABLE();
  __HAL_RCC_GPIOA_CLK_ENABLE();
  __HAL_RCC_GPIOB_CLK_ENABLE();
  __HAL_RCC_GPIOD_CLK_ENABLE();

  /*Configure GPIO pin Output Level */
  HAL_GPIO_WritePin(CS_I2C_SPI_GPIO_Port, CS_I2C_SPI_Pin, GPIO_PIN_RESET);

  /*Configure GPIO pin Output Level */
  HAL_GPIO_WritePin(OTG_FS_PowerSwitchOn_GPIO_Port, OTG_FS_PowerSwitchOn_Pin, GPIO_PIN_SET);

  /*Configure GPIO pin Output Level */
  HAL_GPIO_WritePin(GPIOD, LD4_Pin|LD3_Pin|LD5_Pin|LD6_Pin 
                          |Audio_RST_Pin, GPIO_PIN_RESET);

  /*Configure GPIO pin : CS_I2C_SPI_Pin */
  GPIO_InitStruct.Pin = CS_I2C_SPI_Pin;
  GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
  GPIO_InitStruct.Pull = GPIO_NOPULL;
  GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
  HAL_GPIO_Init(CS_I2C_SPI_GPIO_Port, &GPIO_InitStruct);

  /*Configure GPIO pin : OTG_FS_PowerSwitchOn_Pin */
  GPIO_InitStruct.Pin = OTG_FS_PowerSwitchOn_Pin;
  GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
  GPIO_InitStruct.Pull = GPIO_NOPULL;
  GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
  HAL_GPIO_Init(OTG_FS_PowerSwitchOn_GPIO_Port, &GPIO_InitStruct);

  /*Configure GPIO pin : PDM_OUT_Pin */
  GPIO_InitStruct.Pin = PDM_OUT_Pin;
  GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
  GPIO_InitStruct.Pull = GPIO_NOPULL;
  GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
  GPIO_InitStruct.Alternate = GPIO_AF5_SPI2;
  HAL_GPIO_Init(PDM_OUT_GPIO_Port, &GPIO_InitStruct);

  /*Configure GPIO pins : PA5 PA6 PA7 */
  GPIO_InitStruct.Pin = GPIO_PIN_5|GPIO_PIN_6|GPIO_PIN_7;
  GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
  GPIO_InitStruct.Pull = GPIO_NOPULL;
  GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
  GPIO_InitStruct.Alternate = GPIO_AF5_SPI1;
  HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);

  /*Configure GPIO pin : BOOT1_Pin */
  GPIO_InitStruct.Pin = BOOT1_Pin;
  GPIO_InitStruct.Mode = GPIO_MODE_INPUT;
  GPIO_InitStruct.Pull = GPIO_NOPULL;
  HAL_GPIO_Init(BOOT1_GPIO_Port, &GPIO_InitStruct);

  /*Configure GPIO pin : CLK_IN_Pin */
  GPIO_InitStruct.Pin = CLK_IN_Pin;
  GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
  GPIO_InitStruct.Pull = GPIO_NOPULL;
  GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
  GPIO_InitStruct.Alternate = GPIO_AF5_SPI2;
  HAL_GPIO_Init(CLK_IN_GPIO_Port, &GPIO_InitStruct);

  /*Configure GPIO pins : LD4_Pin LD3_Pin LD5_Pin LD6_Pin 
                           Audio_RST_Pin */
  GPIO_InitStruct.Pin = LD4_Pin|LD3_Pin|LD5_Pin|LD6_Pin 
                          |Audio_RST_Pin;
  GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
  GPIO_InitStruct.Pull = GPIO_NOPULL;
  GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
  HAL_GPIO_Init(GPIOD, &GPIO_InitStruct);

  /*Configure GPIO pin : VBUS_FS_Pin */
  GPIO_InitStruct.Pin = VBUS_FS_Pin;
  GPIO_InitStruct.Mode = GPIO_MODE_INPUT;
  GPIO_InitStruct.Pull = GPIO_NOPULL;
  HAL_GPIO_Init(VBUS_FS_GPIO_Port, &GPIO_InitStruct);

  /*Configure GPIO pins : OTG_FS_ID_Pin OTG_FS_DM_Pin OTG_FS_DP_Pin */
  GPIO_InitStruct.Pin = OTG_FS_ID_Pin|OTG_FS_DM_Pin|OTG_FS_DP_Pin;
  GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
  GPIO_InitStruct.Pull = GPIO_NOPULL;
  GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
  GPIO_InitStruct.Alternate = GPIO_AF10_OTG_FS;
  HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);

  /*Configure GPIO pin : OTG_FS_OverCurrent_Pin */
  GPIO_InitStruct.Pin = OTG_FS_OverCurrent_Pin;
  GPIO_InitStruct.Mode = GPIO_MODE_INPUT;
  GPIO_InitStruct.Pull = GPIO_NOPULL;
  HAL_GPIO_Init(OTG_FS_OverCurrent_GPIO_Port, &GPIO_InitStruct);

  /*Configure GPIO pin : MEMS_INT1_Pin */
  GPIO_InitStruct.Pin = MEMS_INT1_Pin;
  GPIO_InitStruct.Mode = GPIO_MODE_IT_RISING;
  GPIO_InitStruct.Pull = GPIO_NOPULL;
  HAL_GPIO_Init(MEMS_INT1_GPIO_Port, &GPIO_InitStruct);

  /*Configure GPIO pin : MEMS_INT2_Pin */
  GPIO_InitStruct.Pin = MEMS_INT2_Pin;
  GPIO_InitStruct.Mode = GPIO_MODE_EVT_RISING;
  GPIO_InitStruct.Pull = GPIO_NOPULL;
  HAL_GPIO_Init(MEMS_INT2_GPIO_Port, &GPIO_InitStruct);

}

/* USER CODE BEGIN 4 */

/* USER CODE END 4 */

/**
  * @brief  This function is executed in case of error occurrence.
  * @param  None
  * @retval None
  */
void Error_Handler(void)
{
  /* USER CODE BEGIN Error_Handler */
  /* User can add his own implementation to report the HAL error return state */
  while(1) 
  {
  }
  /* USER CODE END Error_Handler */ 
}

#ifdef USE_FULL_ASSERT

/**
   * @brief Reports the name of the source file and the source line number
   * where the assert_param error has occurred.
   * @param file: pointer to the source file name
   * @param line: assert_param error line source number
   * @retval None
   */
void assert_failed(uint8_t* file, uint32_t line)
{
  /* USER CODE BEGIN 6 */
  /* User can add his own implementation to report the file name and line number,
    ex: printf("Wrong parameters value: file %s on line %d\r\n", file, line) */
  /* USER CODE END 6 */

}

#endif

/**
  * @}
  */ 

/**
  * @}
*/ 

/************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/

[BK (Gast)]

Vielen dank für die Hilfe.
Ich bin einen Schritt weiter. die Kommunikation via I2C funktioniert 
jetzt ohne Probleme.
Der Grund für den Fehler war das SysTick_Handler() nicht automatisch 
erstellt wurde. Ich habe diese Funktion jetzt selbst implementiert:

void SysTick_Handler(void){
  HAL_IncTick(); // increase Tick counter for HAL driver
};

Mein neues Programm intialisert den CS43L22 via I2C. So weit ich aber 
rausgefunden habe muss ich Etwas über I2S Übertragen damit der Beep 
Generator startet. Leider scheitert die Übertragung mit I2S und endet 
mit einem Timeout da die flag von __HAL_I2S_GET_FLAG auf Reset bleibt.

Ich habe den Code von Bülent C angeschaut. Soweit ich das gesehen hab 
nutze ich die gleichen Einstellungen. Nur bei den GPIO intialsiere ich 
weniger. Jedoch braucht man da auch nicht alle oder?

Anbei mein Code. Für Tips was ich noch falsch mache wäre ich sehr 
dankbar.

// main.c

#include "stm32f4xx.h"
#include "my_header.h"



int main(void){
  
  I2C_HandleTypeDef I2C_Params; // declare Parameter Handle
  I2S_HandleTypeDef I2S_Params; // declare Parameter Handle
  HAL_StatusTypeDef I2C_State; // declare State handle
  HAL_StatusTypeDef I2S_State; // declare State handle
  GPIO_InitTypeDef GPIOA_Params; // Declares the structure handle for the parameters of I2S on GPIOA
  GPIO_InitTypeDef GPIOD_Params; // Declares the structure handle for the parameters of the reset pin on GPIOE
  GPIO_InitTypeDef GPIOB_Params; // Declares the structure handle for the parameters of I2C on GPIOB
  GPIO_InitTypeDef GPIOC_Params; // Declares the structure handle for the parameters of I2S on GPIOC
  uint8_t send_data; // declare send data variable
  uint8_t send_data_array[2]; // declare send data variable
  uint8_t received_data; // declare received data variable
  RCC_ClkInitTypeDef RCC_ClkInitStruct; // configure System Clock
  uint16_t I2S_Data[10]; //
  
  I2S_Data[0] = 15000;
  I2S_Data[1] = 16498;
  I2S_Data[2] = 17980;
  I2S_Data[3] = 19433;
  I2S_Data[4] = 20841;
  I2S_Data[5] = 22191;
  I2S_Data[6] = 23470;
  I2S_Data[7] = 24663;
  I2S_Data[8] = 25760;
  I2S_Data[9] = 26750;
  
  HAL_Init(); // Initialise  Hal driver
  
  // configure the HCLK, PCLK1 and PCLK2 
  RCC_ClkInitStruct.ClockType = (RCC_CLOCKTYPE_SYSCLK | RCC_CLOCKTYPE_HCLK | RCC_CLOCKTYPE_PCLK1 | RCC_CLOCKTYPE_PCLK2);
  HAL_RCC_ClockConfig(&RCC_ClkInitStruct, FLASH_LATENCY_5);
  
  LED_Init(); // initialise LEDs
  Set_State_Rd_LED(1); // turn on red LED
  
  
  // Configure GPIOD for reset pin on CS43L22
  RCC->AHB1ENR |= RCC_AHB1ENR_GPIODEN; //Enable the clock for GPIOD
  GPIOD_Params.Pin = GPIO_PIN_4; // Select pin 4
  GPIOD_Params.Mode = GPIO_MODE_OUTPUT_PP; //Selects normal output push-pull mode
  GPIOD_Params.Speed = GPIO_SPEED_FAST; //Selects fast speed
  GPIOD_Params.Pull = GPIO_PULLDOWN; //Selects pull-down activation
  HAL_GPIO_Init(GPIOD, &GPIOD_Params); // Sets GPIOD into the modes specified in GPIOE_Params

  
  // Configure GPIOB for SCL (PB6) and SDA (PB9) on I2C1
  RCC->AHB1ENR |= RCC_AHB1ENR_GPIOBEN; //Enable the clock for GPIOB
  GPIOB_Params.Pin = GPIO_PIN_6 | GPIO_PIN_9; // Selects pins 6 and 9
  GPIOB_Params.Alternate = GPIO_AF4_I2C1; //Selects alternate function (I2C1)
  GPIOB_Params.Mode = GPIO_MODE_AF_OD; //Selects alternate function open drain mode
  GPIOB_Params.Speed = GPIO_SPEED_FAST; //Selects fast speed
  //GPIOB_Params.Speed = GPIO_SPEED_FREQ_VERY_HIGH; //Selects fast speed
  GPIOB_Params.Pull = GPIO_NOPULL; //Selects no pull-up or pull-down activation
  //GPIOB_Params.Pull = GPIO_PULLUP; //Selects no pull-up activation
  HAL_GPIO_Init(GPIOB, &GPIOB_Params); // Sets GPIOB into the modes specified in GPIOA_Params
  
  
  RCC->APB1ENR |= RCC_APB1ENR_I2C1EN  ; // Enables the clock for I2C1
  RCC->APB1ENR |= RCC_APB1ENR_SPI3EN  ; // Enables the clock for SPI3 (I2S)
  
  
  // Configure GPIOC for 7(MCLK), 10(SCLK) and 12(SDIN) on I2S
  RCC->AHB1ENR |= RCC_AHB1ENR_GPIOCEN; //Enable the clock for GPIOB
  GPIOC_Params.Pin = GPIO_PIN_7 | GPIO_PIN_10 | GPIO_PIN_12; // Selects pins 7(MCLK), 10(SCLK) and 12(SDIN)
  GPIOC_Params.Alternate = GPIO_AF6_SPI3; //Selects alternate function (I2C1)
  GPIOC_Params.Mode = GPIO_MODE_AF_PP; //Selects alternate function open drain mode
  GPIOC_Params.Speed = GPIO_SPEED_FAST; //Selects fast speed
  GPIOC_Params.Pull = GPIO_NOPULL; //Selects no pull-up or pull-down activation
  HAL_GPIO_Init(GPIOC, &GPIOC_Params); // Sets GPIOB into the modes specified in GPIOA_Params
  
  // Configure GPIOA for 4(WS)on I2S
  RCC->AHB1ENR |= RCC_AHB1ENR_GPIOAEN; //Enable the clock for GPIOA
  GPIOA_Params.Pin = GPIO_PIN_4; // Selects pins 4(WS)
  GPIOA_Params.Alternate = GPIO_AF6_SPI3; //Selects alternate function (I2C1)
  GPIOC_Params.Mode = GPIO_MODE_AF_PP; //Selects alternate function open drain mode
  GPIOC_Params.Speed = GPIO_SPEED_FAST; //Selects fast speed
  GPIOC_Params.Pull = GPIO_NOPULL; //Selects no pull-up or pull-down activation
  HAL_GPIO_Init(GPIOA, &GPIOA_Params); // Sets GPIOA into the modes specified in GPIOA_Params
  
  
  // HAL_I2S_DeInit(&I2S_Params);
  I2S_Params.Instance = SPI3; 
  I2S_Params.Init.Mode = I2S_MODE_MASTER_TX;
  I2S_Params.Init.Standard = I2S_STANDARD_PHILIPS;
  I2S_Params.Init.DataFormat = I2S_DATAFORMAT_16B;
  I2S_Params.Init.MCLKOutput = I2S_MCLKOUTPUT_ENABLE;
  I2S_Params.Init.AudioFreq = I2S_AUDIOFREQ_48K;
  // I2S_Params.Init.AudioFreq = I2S_AUDIOFREQ_8K;
  I2S_Params.Init.CPOL = I2S_CPOL_LOW;
  I2S_Params.Init.ClockSource = I2S_CLOCK_PLL;
  // I2S_Params.Init.FullDuplexMode = I2S_FULLDUPLEXMODE_DISABLE;
  I2S_Params.Init.FullDuplexMode = I2S_FULLDUPLEXMODE_ENABLE;
  HAL_I2S_Init(&I2S_Params);
  __HAL_I2S_ENABLE(&I2S_Params);
  
  // Configure I2C
  I2C_Params.Instance = I2C1;
  I2C_Params.Init.ClockSpeed = 100000; // Set clock speed to 50 kHz
  I2C_Params.Init.DutyCycle = I2C_DUTYCYCLE_2; // Set duty cycle
  I2C_Params.Init.OwnAddress1 = 0x33; // set own adress 1  
  // I2C_Params.Init.OwnAddress1 = 0x00; // set own adress 1  
  I2C_Params.Init.AddressingMode = I2C_ADDRESSINGMODE_7BIT; // set to 7-Bit adresses
  I2C_Params.Init.DualAddressMode = I2C_DUALADDRESS_DISABLED; // Disabel dual address mode
  I2C_Params.Init.OwnAddress2 = 0; // set own adress 2
  I2C_Params.Init.GeneralCallMode = I2C_GENERALCALL_DISABLED; // General call disabled
  I2C_Params.Init.NoStretchMode = I2C_NOSTRETCH_DISABLED; // No Stretch disabled
  // I2C_Params.Init.NoStretchMode = I2C_NOSTRETCH_ENABLE; // No Stretch enabled
  // I2C_Params.Mode = HAL_I2C_MODE_MASTER; // set I2C to master
  // HAL_I2C_MspInit(&I2C_Params); // configure I2C
  __HAL_I2C_ENABLE(&I2C_Params); // Enable the I2C1
  I2C_State = HAL_I2C_Init(&I2C_Params); // configure I2C
  
  
  GPIOD->BSRR |= GPIO_PIN_4; //Sets the reset pin of CS43L22 high
  
  HAL_Delay(1000); // wait 1s for startup of CS43L22 
  
  
  // Init prozedure from Datasheet of CS43L22 page 32
  send_data_array[0] = 0x00; // adress of register
  send_data_array[1] = 0x99; // value for register
  I2C_State = HAL_I2C_Master_Transmit(&I2C_Params, 0x94, send_data_array, 2, 10000); // set register
  
  send_data_array[0] = 0x47; // adress of register
  send_data_array[1] = 0x80; // value for register
  I2C_State = HAL_I2C_Master_Transmit(&I2C_Params, 0x94, send_data_array, 2, 10000); // set register
  
  send_data = 0x32; // adress of register to read
  I2C_State = HAL_I2C_Master_Transmit(&I2C_Params, 0x94, &send_data, 1, 1000); // Write Address to read
  I2C_State = HAL_I2C_Master_Receive(&I2C_Params, 0x95, &received_data, 1, 1000); // read register
  
  send_data_array[0] = 0x32; // adress of register
  send_data_array[1] = received_data | 0x80; // value for register => set MSB
  I2C_State = HAL_I2C_Master_Transmit(&I2C_Params, 0x94, send_data_array, 2, 10000); // set register
  
  send_data = 0x32; // adress of register to read
  I2C_State = HAL_I2C_Master_Transmit(&I2C_Params, 0x94, &send_data, 1, 1000); // Write Address to read
  I2C_State = HAL_I2C_Master_Receive(&I2C_Params, 0x95, &received_data, 1, 1000); // read register
  
  send_data_array[0] = 0x32; // adress of register
  send_data_array[1] = received_data & (~0x80); // value for register => reset MSB
  I2C_State = HAL_I2C_Master_Transmit(&I2C_Params, 0x94, send_data_array, 2, 10000); // set register
  
  send_data_array[0] = 0x00; // adress of register
  send_data_array[1] = 0x00; // value for register
  I2C_State = HAL_I2C_Master_Transmit(&I2C_Params, 0x94, send_data_array, 2, 10000); // set register
  
  //end of initialization sequence

  send_data_array[0] = 0x1E; // address of Beep register
  send_data_array[1] = 0xC0; // value for Beep register (contious beep)
  I2C_State = HAL_I2C_Master_Transmit(&I2C_Params, 0x94, send_data_array, 2, 1000); // write Beep register
  
  send_data_array[0] = CODEC_MAP_PWR_CTRL2; // adress of register to write
  send_data_array[1] = 0xAF; // value for register
  I2C_State = HAL_I2C_Master_Transmit(&I2C_Params, 0x94, send_data_array, 2, 1000); // write power register 1
  
  send_data_array[0] = CODEC_MAP_PLAYBACK_CTRL1; // adress of register to write
  send_data_array[1] = 0x70; // value for register
  I2C_State = HAL_I2C_Master_Transmit(&I2C_Params, 0x94, send_data_array, 2, 1000); // write power register 1
  
  send_data_array[0] = CODEC_MAP_CLK_CTRL; // adress of register to write
  send_data_array[1] = 0x81; // value for register => automatic detection of Clock
  I2C_State = HAL_I2C_Master_Transmit(&I2C_Params, 0x94, send_data_array, 2, 1000); // write power register 1
  
  send_data_array[0] = CODEC_MAP_IF_CTRL1; // adress of register to write
  send_data_array[1] = 0x07; // value for register
  I2C_State = HAL_I2C_Master_Transmit(&I2C_Params, 0x94, send_data_array, 2, 1000); // write power register 1

  send_data_array[0] = CODEC_MAP_ANALOG_SET; // adress of register to write
  send_data_array[1] = 0x00; // value for register => analog settings
  I2C_State = HAL_I2C_Master_Transmit(&I2C_Params, 0x94, send_data_array, 2, 1000); // write power register 1
  
  send_data_array[0] = CODEC_MAP_LIMIT_CTRL1; // adress of register to write
  send_data_array[1] = 0x00; // value for register
  I2C_State = HAL_I2C_Master_Transmit(&I2C_Params, 0x94, send_data_array, 2, 1000); // write power register 1

  send_data_array[0] = CODEC_MAP_PCMA_VOL; // adress of register to write
  send_data_array[1] = 0x0A; // value for register
  I2C_State = HAL_I2C_Master_Transmit(&I2C_Params, 0x94, send_data_array, 2, 1000); // write power register 1

  send_data_array[0] = CODEC_MAP_PCMB_VOL; // adress of register to write
  send_data_array[1] = 0x0A; // value for register
  I2C_State = HAL_I2C_Master_Transmit(&I2C_Params, 0x94, send_data_array, 2, 1000); // write power register 1

  send_data_array[0] = CODEC_MAP_TONE_CTRL; // adress of register to write
  send_data_array[1] = 0x0F; // value for register
  I2C_State = HAL_I2C_Master_Transmit(&I2C_Params, 0x94, send_data_array, 2, 1000); // write power register 1
  
  /*
  send_data_array[0] = CODEC_MAP_BEEP_TONE_CFG; // adress of register to write
  send_data_array[1] = 0xC0; // value for register => continous beep
  I2C_State = HAL_I2C_Master_Transmit(&I2C_Params, 0x94, send_data_array, 2, 1000); // write register
  */
  
  send_data_array[0] = CODEC_MAP_PWR_CTRL1; // adress of register to write
  send_data_array[1] = 0x9E; // value for register => power up
  I2C_State = HAL_I2C_Master_Transmit(&I2C_Params, 0x94, send_data_array, 2, 1000); // write register
  
  // GPIOD->BSRR |= (GPIO_PIN_4+16); // Sets the reset pin of CS43L22 low
  
  
  while(1){  
    I2S_State = HAL_I2S_Transmit(&I2S_Params, I2S_Data, 10, 1000);
    Set_State_Or_LED(1); // turn on orange LED
  }  
  
};

[Matthias S. (Firma: matzetronics) (mschoeldgen)]

Du musst noch die I2S PLL initialisieren.

[BK (Gast)]

Nach vielen Versuchen habe ich den Chip dazu gebracht Geräusche 
auszugeben. Jedoch gibt er keine sauberen Beep-Signale aus sondern eher 
Rauschen. Und beim ersten Ansteuern dauert es einige Sekunden bis ein 
Geräusch erzeugt wird. Anbei meine finale Version einer Ampelsteuerung 
im RTOS für Keil µVision. Hoffe es hilft jemandem.

[dasrotemopped (Gast)]

das mit dem Quellcode posten geht auch kompakter:
http://www.dasrotemopped.de/dateien/STM32F407VGT-DISCO_BSP_SSD1963_20170417.zip

So macht ST das Initialisieren der Komponenten,
von mir in ein SW4STM32 Projekt gepackt, wen es interessiert.

Gruß,
dasrotemopped.

[pitschu (Gast)]

An dem Ding habe ich auch lange rumgerätselt. Entscheidend war, dass der 
Chip immer einen Masterclkock braucht, selbst dann wenn er keinen Ton 
von sich geben soll. Ansonsten kommt Rauchen, Zirpen und Knacken. Auch 
der Beep-Generator benötigt den Clock. Auf dem STM4discovery, welches 
ich nutze, gebe ich dauerhaft eine leere DMA- Dauerschleife an das 
WAV-Interface aus, wenn Ruhe sein soll. Seit dem funktionieren sowohl 
WAV-Files als auch Beeps vollkommen OK.

pitschu

[chris (Gast)]

Auf dem STM32F4 Discovery ist das Mikrofon und DAC1 direkt an den Mixer 
des CS43L22 angeschlossen.
Als einfachster Test, um überhaupt einmal einen Ton zu bekommen, habe 
ich mal versucht, am DAC1 Anschluss ( PA4 ) ein Rechtecksignal zu 
erzeugen das Routing des CS43L22 so einzustellen, dass es durchkommt.

Leider hat es nicht funktioniert. Hat jemand eine Idee, wie man die 
Register einstellen muss?

[chris (Gast)]

Hier hat sich zumindest schon mal jemand mit einem ähnlichen Problem 
herum geschlagen:

Beitrag "STM32F4 Discovery audio passtrough (MP45DT02 --> CS43L22)"

[Matthias S. (Firma: matzetronics) (mschoeldgen)]

BK schrieb:
> Und beim ersten Ansteuern dauert es einige Sekunden bis ein
> Geräusch erzeugt wird.

Das scheint immer so zu sein. Und obwohl ich mit dem Mixer noch nicht 
rumgespielt habe, erscheint es logisch, das zumindest die Masterclock 
anliegen muss, die intern anscheinend immer gebraucht wird.
Denkt dran, ohne die undokumentierten I2C Kommandos geht nix so richtig. 
Siehe in meinem  Beitrag von oben - dank Uwe B. und seiner Library.
Beitrag "Re: STM32F4 Discovery Audio CS43L22 I2C Problem"

Übrigens hatte SPL einen kleinen Bug und hat die Masterclock trotz 
richtigem Parameter nicht ausgegeben. Es lohnt sich evtl., HAL mal 
darauf abzuklopfen und auch mal zu messen, ob sie nun anliegt.

[Markus (Gast)]

Danke, dass Du den Thread etwas weiter führst. Der Chip ist wirklich 
nicht einfach in den Griff zu kriegen.

[V12Vinnie (Gast)]

Mich hat es jedefalls geholfen! Ich hatte bis jetzt noch keinen einzigen 
ton aus meinem CS43L22 gehört, mit deinem Projekt bin ich selber 
mindestens einen Schritt weiter. Ich werde jetzt probieren, mich nochmal 
mit diesem Beep-Generator auseinanderzusetzen.

Was aber schon zu bemerken ist, falls es noch jemanden gibt der sucht: 
ich musste in system_stm32f4xx.c dieses noch reinschreiben

const uint8_t APBPrescTable[8]  = {0, 0, 0, 0, 1, 2, 3, 4};

Sonst hat das ganze sich nicht kompiliert (ich hoffe, das sagt mann so 
auf Deutsch, es ist nicht meine muttersprache).

Ich hab's auf line 140, da da auch AHBPrescTable definiert wird, aber 
keine ahnung ob dass dahin gehört, gibt es jemanden hier der das besser 
erklären könnte?

[V12Vinnie (Gast)]

BK schrieb:
> Nach vielen Versuchen habe ich den Chip dazu gebracht Geräusche
> auszugeben. Jedoch gibt er keine sauberen Beep-Signale aus sondern eher
> Rauschen. Und beim ersten Ansteuern dauert es einige Sekunden bis ein
> Geräusch erzeugt wird. Anbei meine finale Version einer Ampelsteuerung
> im RTOS für Keil µVision. Hoffe es hilft jemandem.

Meinen letzten Kommentar war als Antwort auf diesen Beitrag, das habe 
ich das erste mal irgendwie nicht hinbekommen.

[Test (Gast)]

pitschu schrieb:
> Entscheidend war, dass der
> Chip immer einen Masterclkock braucht, selbst dann wenn er keinen Ton
> von sich geben soll. Ansonsten kommt Rauchen, Zirpen und Knacken. Auch
> der Beep-Generator benötigt den Clock.

Erscheint ja auch prinzipiell logisch, das Ding hat ja keine internen 
Taktgenerator und auch extern keinen Quarz o.Ä. Und ganz ohne Takt ist 
die Generierung von Audio irgendwie kompliziert (auch ein einfaches 
Beep). Nur wirklich erwähnt wird das nicht im Datenblatt ...