STM32F4 TIM1 PWM funktioniert nicht bei aktivem USART1&6

[Ruphy .. (ruphy)]

Hallo liebe µPC Community,

ich bastel gerade an einem Projekt in dem ich über USART1 eine
Temperatur auslese und über USART6 die RS232 Schnittstelle zum PC
herstelle.
Über ein Protokoll kann ich von meinem Rechner ein PWM Signal auf dem 
µpc erzeugen(TIM1 als PWM). Das bedeutet, ich beschreibe das CCR1 
register. Außerdem wird über RS232 Byteweise eine Temperatur zum Rechner 
übertragen (im Burst Modus).

Nun zu meinem Problem:
Wenn ich die einzelnen Komponente laufen lasse (PWM erzeugen oder
Temperatur auf PC anzeigen lassen) läuft alles super und ohne Probleme.
Sobald ich beide Projekte zusammenfüge, funktioniert die PWM nicht mehr.
Das bedeutet: im Debugging Modus kann ich nachweisen, dass das CCR1
Register beschrieben wird, aber der Timer1 läuft auf unerklärlicherweise
nicht. Sobald ich eines der die USART6 (Temperaturausgabe auf PC) NICHT
initalisiere funktioniert die PWM.

Ich hoffe ihr versteht mein Problem? Kurz: der TIM1 funktioniert nicht!!
RS232 (USART6) und Temperatur lesen(USART1) funktioniert einwandfrei.

Kann jemand Helfen?
Danke.

Schöne Grüßeee

[Ruphy .. (ruphy)]

Problem gelöst:

erst die USART1 und USART6 initialisieren und dann erst den Timer 
initialisieren!

bsp:
FALSCH
  TIM1_PWM_init();
  init_USART6(9600);  // RS232 PWM Empfang
  init_USART1(9600);  // USART for Temp Sensor


RICHTIG
  init_USART6(9600);  // RS232 PWM Empfang
  init_USART1(9600);  // USART for Temp Sensor
  TIM1_PWM_init();


Kann mir jemand erklären warum das so ist?

[Rainer M. (excogitator)]

Poste doch mal den Code deiner drei Init-Funktionen, dann kann man evtl. 
mehr sagen.

Gruß
Rainer

[Ruphy .. (ruphy)]

Den Code habe ich aus dem Internet und dann an meine Bedürfnisse 
angepasst.

/ Temperatur USART Empfang
void init_USART1(uint32_t baudrate)
{

  /* This is a concept that has to do with the libraries provided by ST
   * to make development easier the have made up something similar to
   * classes, called TypeDefs, which actually just define the common
   * parameters that every peripheral needs to work correctly
   *
   * They make our life easier because we don't have to mess around with
   * the low level stuff of setting bits in the correct registers
   */
  GPIO_InitTypeDef GPIO_InitStruct; // this is for the GPIO pins used as TX and RX
  USART_InitTypeDef USART_InitStruct; // this is for the USART6 initilization
  NVIC_InitTypeDef NVIC_InitStructure; // this is used to configure the NVIC (nested vector interrupt controller)

  /* enable APB2 peripheral clock for USART6
   * note that only USART6 and USART6 are connected to APB2
   * the other USARTs are connected to APB1
   */
  RCC_APB2PeriphClockCmd(RCC_APB2Periph_USART1, ENABLE);

  /* enable the peripheral clock for the pins used by
   * USART1, PB6 for TX and PB7 for RX
   */
  RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOB, ENABLE);

  /* This sequence sets up the TX and RX pins
   * so they work correctly with the USART6 peripheral
   */
  GPIO_InitStruct.GPIO_Pin = GPIO_Pin_6 | GPIO_Pin_7; // Pins 6 (TX) and 7 (RX) are used
  GPIO_InitStruct.GPIO_Mode = GPIO_Mode_AF;       // the pins are configured as alternate function so the USART peripheral has access to them
  GPIO_InitStruct.GPIO_Speed = GPIO_Speed_50MHz;    // this defines the IO speed and has nothing to do with the baudrate!
  GPIO_InitStruct.GPIO_OType = GPIO_OType_PP;      // this defines the output type as push pull mode (as opposed to open drain)
  GPIO_InitStruct.GPIO_PuPd = GPIO_PuPd_UP;      // this activates the pullup resistors on the IO pins
  GPIO_Init(GPIOB, &GPIO_InitStruct);          // now all the values are passed to the GPIO_Init() function which sets the GPIO registers

  /* The RX and TX pins are now connected to their AF
   * so that the USART6 can take over control of the
   * pins
   */
  GPIO_PinAFConfig(GPIOB, GPIO_PinSource6, GPIO_AF_USART1);    // Enable Pin 6
  GPIO_PinAFConfig(GPIOB, GPIO_PinSource7, GPIO_AF_USART1);

  /* Now the USART_InitStruct is used to define the
   * properties of USART1
   */
  USART_InitStruct.USART_BaudRate = baudrate;        // the baudrate is set to the value we passed into this init function
  USART_InitStruct.USART_WordLength = USART_WordLength_8b;// we want the data frame size to be 8 bits (standard)
  USART_InitStruct.USART_StopBits = USART_StopBits_1;    // we want 1 stop bit (standard)
  USART_InitStruct.USART_Parity = USART_Parity_No;    // we don't want a parity bit (standard)
  USART_InitStruct.USART_HardwareFlowControl = USART_HardwareFlowControl_None; // we don't want flow control (standard)
  USART_InitStruct.USART_Mode = USART_Mode_Rx | USART_Mode_Tx; // we want to enable the transmitter and the receiver
  USART_Init(USART1, &USART_InitStruct);          // again all the properties are passed to the USART_Init function which takes care of all the bit setting


  /* Here the USART6 receive interrupt is enabled
   * and the interrupt controller is configured
   * to jump to the USART6_IRQHandler() function
   * if the USART1 receive interrupt occurs
   */
  USART_ITConfig(USART1, USART_IT_RXNE, ENABLE);       // enable the USART1 receive interrupt

  NVIC_InitStructure.NVIC_IRQChannel = USART1_IRQn;     // we want to configure the USART6 interrupts
  NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 1;// this sets the priority group of the USART6 interrupts
  NVIC_InitStructure.NVIC_IRQChannelSubPriority = 1;     // this sets the subpriority inside the group
  NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;       // the USART6 interrupts are globally enabled
  NVIC_Init(&NVIC_InitStructure);               // the properties are passed to the NVIC_Init function which takes care of the low level stuff

  // finally this enables the complete USART6 peripheral
  USART_Cmd(USART1, ENABLE);
}

// RS232 USART Empfang
void init_USART6(uint32_t baudrate)
{

  /* This is a concept that has to do with the libraries provided by ST
   * to make development easier the have made up something similar to
   * classes, called TypeDefs, which actually just define the common
   * parameters that every peripheral needs to work correctly
   *
   * They make our life easier because we don't have to mess around with
   * the low level stuff of setting bits in the correct registers
   */
  GPIO_InitTypeDef GPIO_InitStruct; // this is for the GPIO pins used as TX and RX
  USART_InitTypeDef USART_InitStruct; // this is for the USART6 initilization
  NVIC_InitTypeDef NVIC_InitStructure; // this is used to configure the NVIC (nested vector interrupt controller)

  /* enable APB2 peripheral clock for USART6
   * note that only USART6 and USART6 are connected to APB2
   * the other USARTs are connected to APB1
   */
  RCC_APB2PeriphClockCmd(RCC_APB2Periph_USART6, ENABLE);

  /* enable the peripheral clock for the pins used by
   * USART6, PB6 for TX and PB7 for RX
   */
  RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOC, ENABLE);

  /* This sequence sets up the TX and RX pins
   * so they work correctly with the USART6 peripheral
   */
  GPIO_InitStruct.GPIO_Pin = GPIO_Pin_6 | GPIO_Pin_7; // Pins 6 (TX) and 7 (RX) are used
  GPIO_InitStruct.GPIO_Mode = GPIO_Mode_AF;       // the pins are configured as alternate function so the USART peripheral has access to them
  GPIO_InitStruct.GPIO_Speed = GPIO_Speed_50MHz;    // this defines the IO speed and has nothing to do with the baudrate!
  GPIO_InitStruct.GPIO_OType = GPIO_OType_PP;      // this defines the output type as push pull mode (as opposed to open drain)
  GPIO_InitStruct.GPIO_PuPd = GPIO_PuPd_UP;      // this activates the pullup resistors on the IO pins
  GPIO_Init(GPIOC, &GPIO_InitStruct);          // now all the values are passed to the GPIO_Init() function which sets the GPIO registers

  /* The RX and TX pins are now connected to their AF
   * so that the USART6 can take over control of the
   * pins
   */
  GPIO_PinAFConfig(GPIOC, GPIO_PinSource6, GPIO_AF_USART6); //
  GPIO_PinAFConfig(GPIOC, GPIO_PinSource7, GPIO_AF_USART6);

  /* Now the USART_InitStruct is used to define the
   * properties of USART6
   */
  USART_InitStruct.USART_BaudRate = baudrate;        // the baudrate is set to the value we passed into this init function
  USART_InitStruct.USART_WordLength = USART_WordLength_8b;// we want the data frame size to be 8 bits (standard)
  USART_InitStruct.USART_StopBits = USART_StopBits_1;    // we want 1 stop bit (standard)
  USART_InitStruct.USART_Parity = USART_Parity_No;    // we don't want a parity bit (standard)
  USART_InitStruct.USART_HardwareFlowControl = USART_HardwareFlowControl_None; // we don't want flow control (standard)
  USART_InitStruct.USART_Mode = USART_Mode_Tx | USART_Mode_Rx; // we want to enable the transmitter and the receiver
  USART_Init(USART6, &USART_InitStruct);          // again all the properties are passed to the USART_Init function which takes care of all the bit setting


  /* Here the USART6 receive interrupt is enabled
   * and the interrupt controller is configured
   * to jump to the USART6_IRQHandler() function
   * if the USART6 receive interrupt occurs
   */
  USART_ITConfig(USART6, USART_IT_RXNE, ENABLE);       // enable the USART6 receive interrupt

  NVIC_InitStructure.NVIC_IRQChannel = USART6_IRQn;     // we want to configure the USART6 interrupts
  NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0;// this sets the priority group of the USART6 interrupts
  NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0;     // this sets the subpriority inside the group
  NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;       // the USART6 interrupts are globally enabled
  NVIC_Init(&NVIC_InitStructure);               // the properties are passed to the NVIC_Init function which takes care of the low level stuff

  // finally this enables the complete USART6 peripheral
  USART_Cmd(USART6, ENABLE);
}

void TIM1_PWM_init(void)
{
  // GPIO Config: PA8 als PWM Ausgang: TIM1_CH1
  GPIO_InitTypeDef GPIO_InitStructure;
  RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOA, ENABLE);
  GPIO_InitStructure.GPIO_Pin = GPIO_Pin_8;
  GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF;
  GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;
  GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_DOWN;
  GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
  GPIO_Init(GPIOA, &GPIO_InitStructure);
  // Connect TIM1 pins to AF
  GPIO_PinAFConfig(GPIOA,GPIO_PinSource8,GPIO_AF_TIM1);


  //timer 1 is clocked by APB2 at 84MHz, prescale by 42000 to get 2kHz clock
  //use a period of 100 cycles to get 0..100% granularity and 20Hz frequency
  TIM_TimeBaseInitTypeDef TIM_TimebaseStructure;
  TIM_OCInitTypeDef TIM_OCStructure;

  RCC_APB2PeriphClockCmd(RCC_APB2Periph_TIM1, ENABLE);

  TIM_TimeBaseStructInit(&TIM_TimebaseStructure);
  TIM_TimebaseStructure.TIM_ClockDivision = TIM_CKD_DIV1;  // Time Base initialisieren
  TIM_TimebaseStructure.TIM_CounterMode = TIM_CounterMode_Up;
  TIM_TimebaseStructure.TIM_Prescaler= 840-1; // 84MHz / 840 = 100 kHz nach Prescaler
  TIM_TimebaseStructure.TIM_Period= 1000-1;   //  100 khz / 1000 = 1 Hz -> endgültige Updaterate des Timers
//  TIM_TimebaseStructure.TIM_Period= 42000-1;  //  84 khz /42k = 2 Hz
  TIM_TimeBaseInit(TIM1, &TIM_TimebaseStructure);


  //Output Compare Modus Config Channel1
  TIM_OCStructure.TIM_OCMode=TIM_OCMode_PWM1;
  TIM_OCStructure.TIM_OutputState=TIM_OutputState_Enable;
  TIM_OCStructure.TIM_Pulse=CCR1_Val;
  TIM_OCStructure.TIM_OCPolarity=TIM_OCPolarity_Low;
  TIM_OC1Init(TIM1, &TIM_OCStructure);            // TIM_OC1Init => Channel 1 aktivieren
  TIM_OC1PreloadConfig(TIM1, TIM_OCPreload_Enable);



  TIM_ARRPreloadConfig(TIM1, ENABLE);
    //required for timers 1 or 8
    TIM_CtrlPWMOutputs(TIM1, ENABLE);

  TIM_Cmd(TIM1,ENABLE); // timer starts
}