STM32F103ZE UART geht nicht

Man schaltet den Controller erst auf HSE drauf, wenn der auch sicher 
läuft. Nicht schon dann, wenn der ganz sicher noch nicht läuft.

Hilfreich ist auch die Firmware Library von ST.
In dem Paket sind auch einige Beispiele.

http://www.st.com/internet/com/SOFTWARE_RESOURCES/SW_COMPONENT/FIRMWARE/stm32f10x_stdperiph_lib.zip

Müssen RX+TX nicht noch auf die Ports gemapped werden (AFIO)?

#define USART2_TX_BUFFER_SIZE 20
uint8_t usart2_tx_buffer[USART2_TX_BUFFER_SIZE];
//#define USART2_DR_BASE_ADDRESS  0x40013804    //Fall du ein USART1 
Benutzen willst
#define USART2_DR_BASE_ADDRESS  0x40004404

#define USART2_TX_PIN      GPIO_Pin_2
#define USART2_RX_PIN      GPIO_Pin_3
#define USART2_PORT        GPIOA
#define USART2_TX_DMA_CHANNEL  DMA1_Channel7
#define USART2_TX_DMA_FLAG    DMA1_FLAG_TC7
#define USART2_RX_DMA_CHANNEL  DMA1_Channel6
#define USART2_RX_DMA_FLAG    DMA1_FLAG_TC6
//#define USART1_DR_BASE_ADDRESS  0x40013804 
////////////////////////////////////
#define USART2_DR_BASE_ADDRESS  0x40004404




void RCC_Configuration(void)
{

  /* GPIOA clock enable */
  RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA, ENABLE);
  /* GPIOB clock enable */
  RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOB, ENABLE);
  /* GPIOC clock enable */
  RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOC, ENABLE);
  /* GPIOD clock enable */
  RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOD, ENABLE);
  /* GPIOE clock enable */
  RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOE, ENABLE);
  /* GPIOF clock enable */
  RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOF, ENABLE);
  /* GPIOG clock enable */
  RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOG, ENABLE);
  /* Alternate Function I/O clock enable */
  RCC_APB2PeriphClockCmd(RCC_APB2Periph_AFIO, ENABLE);

   /* Enable DMA1 and DMA2 clocks */
  RCC_AHBPeriphClockCmd(RCC_AHBPeriph_DMA1 | RCC_AHBPeriph_DMA2, 
ENABLE);

  /* USART2 clock enable */
  RCC_APB1PeriphClockCmd(RCC_APB1Periph_USART2, ENABLE);

}


void GPIO_Configuration(void)
{
  GPIO_InitStructure.GPIO_Pin = USART2_TX_PIN;
  GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;
  GPIO_InitStructure.GPIO_Speed = GPIO_Speed_10MHz;
  GPIO_Init(USART2_PORT, &GPIO_InitStructure);

  GPIO_InitStructure.GPIO_Pin = USART2_RX_PIN;
  GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;
  GPIO_Init(USART2_PORT, &GPIO_InitStructure);
}


void DMA_Configuration(void)
{
  /* USART1 TX DMA1 Channel (triggered by USARTy Tx event) Config */
  /* Deinitializes the USART1_TX_DMA_CHANNEL registers to their default 
reset values. */
  DMA_DeInit(USART2_TX_DMA_CHANNEL);
  DMA_InitStructure.DMA_PeripheralBaseAddr = USART2_DR_BASE_ADDRESS;
  DMA_InitStructure.DMA_MemoryBaseAddr = (uint32_t)usart2_tx_buffer;
  DMA_InitStructure.DMA_DIR = DMA_DIR_PeripheralDST;
  DMA_InitStructure.DMA_BufferSize = USART2_TX_BUFFER_SIZE;
  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_Normal;
  DMA_InitStructure.DMA_Priority = DMA_Priority_High;
  DMA_InitStructure.DMA_M2M = DMA_M2M_Disable;
  DMA_Init(USART2_TX_DMA_CHANNEL, &DMA_InitStructure);
}

void USART2_Configuration(void)
{
  USART_InitStructure.USART_BaudRate = 115200;
  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;

  /* Initialize USART2 */
  USART_Init(USART2, &USART_InitStructure);

}



//-------------
// Damit kannst du auch ohne DMA USART benutzen.

void USART2_Send_Char(char byte){
  /* wait until transmit buffer is empty */
  while(USART_GetFlagStatus(USART2, USART_FLAG_TXE) == RESET);
  /* send the byte */
  USART_SendData(USART2, (uint8_t) byte);
}


void USART2_Send_String(char *string){
  while(*string){
    USART2_Send_Char(*string);
    string++;
  }
}




// Aufruf in deinem MAIN.C

  /* Clock */
  RCC_Configuration();

  /* General Purpose Inputs and Outputs*/
  GPIO_Configuration();

  /* Direct Memory Access */
  DMA_Configuration();

  USART2_Configuration();

  /* Enable USART2 DMA Rx and TX request */
  USART_DMACmd(USART2, USART_DMAReq_Tx, ENABLE);


  /* Enable the USART2 */
  USART_Cmd(USART2, ENABLE);

//Aufruf ohne DMA
  USART2_Send_Char((char)(DeineVariable1));
  USART2_Send_Char((char)DeineVariable2);
  USART2_Send_String("\r\n");

//Aufruf mit DMA

  while(USART_GetFlagStatus(USART2, USART_FLAG_TXE) == RESET);

  usart2_tx_buffer[1] = 'I';
  memcpy(usart2_tx_buffer + 2, &values.timestamp, 16);
  USART2_TX_DMA_CHANNEL->CCR &= CCR_ENABLE_Reset;
  USART2_TX_DMA_CHANNEL->CMAR = (uint32_t) usart2_tx_buffer;  //Kannst 
du anderen String anhängen
  USART2_TX_DMA_CHANNEL->CNDTR = USART2_TX_BUFFER_SIZE;    //anzahl von 
Elementen, die gesendet werden sollen
  USART2_TX_DMA_CHANNEL->CCR |= CCR_ENABLE_Set;