USART1 bei STM32 Discovery und Coocox will nicht

[Holger T. (holger1979)]

Hallo,

viele Beiträge in diesem Forum beschäftigen sich mit meinem Problem. 
Doch eine Lösung habe ich nicht gefunden.

Ich habe einen STM32F0-Discovery und möchte einfach ein Byte über USART1 
senden oder empfangen.
Sollte eigentlich kein Problem sein, geht aber nicht.

Als IDE verwende ich Coocox, folgenden Code habe ich momentan:

#include "stm32f0xx.h"
#include "stm32f0xx_usart.h"
#include "stm32f0xx_gpio.h"
#include "stm32f0xx_rcc.h"

void MX_USART1_UART_Init(void)
{
    GPIO_InitTypeDef GPIO_InitStructure;
    USART_InitTypeDef USART_InitStructure;

    USART_InitStructure.USART_BaudRate = 9600;
    USART_InitStructure.USART_WordLength = USART_WordLength_8b;
    USART_InitStructure.USART_StopBits = USART_StopBits_1;
    USART_InitStructure.USART_Parity = USART_Parity_No;
    USART_InitStructure.USART_HardwareFlowControl = USART_HardwareFlowControl_None;
    USART_InitStructure.USART_Mode = USART_Mode_Rx | USART_Mode_Tx;

    /* Enable GPIO clock */
    RCC_AHBPeriphClockCmd(RCC_AHBPeriph_GPIOA, ENABLE);

    /* Enable USART clock */
    RCC_APB2PeriphClockCmd(RCC_APB2Periph_USART1, ENABLE);

    /* Connect PXx to USARTx_Tx */
    GPIO_PinAFConfig(GPIOA, GPIO_PinSource9, GPIO_AF_1);

    /* Connect PXx to USARTx_Rx */
    GPIO_PinAFConfig(GPIOA, GPIO_PinSource10, GPIO_AF_1);

    /* Configure USART Tx, Rx as alternate function push-pull */
    GPIO_InitStructure.GPIO_Pin = GPIO_Pin_9 | GPIO_Pin_10;
    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF;
    GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;
    GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_UP;
    GPIO_Init(GPIOA, &GPIO_InitStructure);

    /* USART configuration */
    USART_Init(USART1, &USART_InitStructure);

    /* Enable USART */
    USART_Cmd(USART1, ENABLE);
}

int main(void)
{
  MX_USART1_UART_Init();

  // Buzzer
    RCC->AHBENR |= RCC_AHBENR_GPIOBEN; // GPIOB Periph clock enable
    GPIOB->PUPDR |= (1 << 24) | (1 << 26); // PB12 und PB13 pull up

    // LD3 LD4
  RCC->AHBENR |= RCC_AHBENR_GPIOCEN; // GPIOC Periph clock enable
  GPIOC->MODER |= (1 << 12) | (1 << 14) | (1 << 16) | (1 << 18); // PC6, PC7, PC8 und PC9 output

    int taste = 0;
    int output = 0;
  int data = 0;
    unsigned char blocked = 0;

    while(1)
    {
      taste = GPIOB->IDR;
      if (!blocked)
      {
        output = 0;
      if (!(taste & (1 << 12)))
      {
        blocked = 1;
        GPIOC->ODR |= ((1 << 7) | (1 << 9));
        output += 1;
      }
      if (!(taste & (1 << 13)))
      {
        blocked = 1;
        GPIOC->ODR |= ((1 << 6) | (1 << 8 ));
        output += 2;
      }
      if (output)
      {
        while(USART_GetFlagStatus(USART1, USART_FLAG_TXE) == RESET);
        USART_SendData(USART1, output + 48);
      }
      }
    if(GPIOA->IDR & GPIO_IDR_0)
    {
      blocked = 0;
      GPIOC->ODR &= ~((1 << 6) | (1 << 7) | (1 << 8) | (1 << 9));
      while(USART_GetFlagStatus(USART1, USART_FLAG_TXE) == RESET);
      USART_SendData(USART1, 48);
    }

    data = 0;
    if(USART_GetITStatus(USART1, USART_IT_RXNE) != 0)
    {
      data = (USART_ReceiveData(USART1) & 0x7F);
    }

      if (data != 0)
      {
      blocked = 0;
      GPIOC->ODR &= ~((1 << 6) | (1 << 7) | (1 << 8) | (1 << 9));
      }
    }
}

Das Ganze lässt sich compilieren und sieht gut aus. Leider kann das 
Programm weder Senden noch Empfangen. Ich weiß einfach nicht mehr 
weiter.
Wer findet einen Fehler?

[dummy (Gast)]

>    GPIO_PinAFConfig(GPIOA, GPIO_PinSource9, GPIO_AF_1);

Heisst das nicht GPIO_AF_USART1

[Holger T. (holger1979)]

Ich habs mal eingegeben. Kennt der aber leider nicht.

[Ingo L. (corrtexx)]

Holger Timm schrieb:
> Kennt der aber leider nicht.
Müsste er aber, Geh mal in die Funktionsdefinition, da steht was dazu 
drin!
Auszug für einen F4:

/**
  * @brief  Changes the mapping of the specified pin.
  * @param  GPIOx: where x can be (A..I) to select the GPIO peripheral.
  * @param  GPIO_PinSource: specifies the pin for the Alternate function.
  *         This parameter can be GPIO_PinSourcex where x can be (0..15).
  * @param  GPIO_AFSelection: selects the pin to used as Alternate function.
  *          This parameter can be one of the following values:
  *            @arg GPIO_AF_RTC_50Hz: Connect RTC_50Hz pin to AF0 (default after reset) 
  *            @arg GPIO_AF_MCO: Connect MCO pin (MCO1 and MCO2) to AF0 (default after reset) 
  *            @arg GPIO_AF_TAMPER: Connect TAMPER pins (TAMPER_1 and TAMPER_2) to AF0 (default after reset) 
  *            @arg GPIO_AF_SWJ: Connect SWJ pins (SWD and JTAG)to AF0 (default after reset) 
  *            @arg GPIO_AF_TRACE: Connect TRACE pins to AF0 (default after reset)
  *            @arg GPIO_AF_TIM1: Connect TIM1 pins to AF1
  *            @arg GPIO_AF_TIM2: Connect TIM2 pins to AF1
  *            @arg GPIO_AF_TIM3: Connect TIM3 pins to AF2
  *            @arg GPIO_AF_TIM4: Connect TIM4 pins to AF2
  *            @arg GPIO_AF_TIM5: Connect TIM5 pins to AF2
  *            @arg GPIO_AF_TIM8: Connect TIM8 pins to AF3
  *            @arg GPIO_AF_TIM9: Connect TIM9 pins to AF3
  *            @arg GPIO_AF_TIM10: Connect TIM10 pins to AF3
  *            @arg GPIO_AF_TIM11: Connect TIM11 pins to AF3
  *            @arg GPIO_AF_I2C1: Connect I2C1 pins to AF4
  *            @arg GPIO_AF_I2C2: Connect I2C2 pins to AF4
  *            @arg GPIO_AF_I2C3: Connect I2C3 pins to AF4
  *            @arg GPIO_AF_SPI1: Connect SPI1 pins to AF5
  *            @arg GPIO_AF_SPI2: Connect SPI2/I2S2 pins to AF5
  *            @arg GPIO_AF_SPI3: Connect SPI3/I2S3 pins to AF6
  *            @arg GPIO_AF_I2S3ext: Connect I2S3ext pins to AF7
  *            @arg GPIO_AF_USART1: Connect USART1 pins to AF7
  *            @arg GPIO_AF_USART2: Connect USART2 pins to AF7
  *            @arg GPIO_AF_USART3: Connect USART3 pins to AF7
  *            @arg GPIO_AF_UART4: Connect UART4 pins to AF8
  *            @arg GPIO_AF_UART5: Connect UART5 pins to AF8
  *            @arg GPIO_AF_USART6: Connect USART6 pins to AF8
  *            @arg GPIO_AF_CAN1: Connect CAN1 pins to AF9
  *            @arg GPIO_AF_CAN2: Connect CAN2 pins to AF9
  *            @arg GPIO_AF_TIM12: Connect TIM12 pins to AF9
  *            @arg GPIO_AF_TIM13: Connect TIM13 pins to AF9
  *            @arg GPIO_AF_TIM14: Connect TIM14 pins to AF9
  *            @arg GPIO_AF_OTG_FS: Connect OTG_FS pins to AF10
  *            @arg GPIO_AF_OTG_HS: Connect OTG_HS pins to AF10
  *            @arg GPIO_AF_ETH: Connect ETHERNET pins to AF11
  *            @arg GPIO_AF_FSMC: Connect FSMC pins to AF12
  *            @arg GPIO_AF_OTG_HS_FS: Connect OTG HS (configured in FS) pins to AF12
  *            @arg GPIO_AF_SDIO: Connect SDIO pins to AF12
  *            @arg GPIO_AF_DCMI: Connect DCMI pins to AF13
  *            @arg GPIO_AF_EVENTOUT: Connect EVENTOUT pins to AF15
  * @retval None
  */
void GPIO_PinAFConfig(GPIO_TypeDef* GPIOx, uint16_t GPIO_PinSource, uint8_t GPIO_AF)
{
  uint32_t temp = 0x00;
  uint32_t temp_2 = 0x00;
  
  /* Check the parameters */
  assert_param(IS_GPIO_ALL_PERIPH(GPIOx));
  assert_param(IS_GPIO_PIN_SOURCE(GPIO_PinSource));
  assert_param(IS_GPIO_AF(GPIO_AF));
  
  temp = ((uint32_t)(GPIO_AF) << ((uint32_t)((uint32_t)GPIO_PinSource & (uint32_t)0x07) * 4)) ;
  GPIOx->AFR[GPIO_PinSource >> 0x03] &= ~((uint32_t)0xF << ((uint32_t)((uint32_t)GPIO_PinSource & (uint32_t)0x07) * 4)) ;
  temp_2 = GPIOx->AFR[GPIO_PinSource >> 0x03] | temp;
  GPIOx->AFR[GPIO_PinSource >> 0x03] = temp_2;
}

[dummy (Gast)]

>Leider kann das Programm weder Senden noch Empfangen.

Dann fang einfach mal mit senden an und lass
den ganzen anderen Klimbim weg.

int main(void)
{
  MX_USART1_UART_Init();
  while(1)
  {
     USART_SendData(USART1, 'U');
     while(USART_GetFlagStatus(USART1, USART_FLAG_TXE) == RESET);
     
     // todo hier vieleicht noch ein bisschen warten, oder auch nicht
  }
}

Da kannst du auch schön dein Osci dranhängen.