AnsweredAssumed Answered

Problem stm32f101x UART4

Question asked by d.tiaan on Nov 5, 2013
Latest reply on Nov 7, 2013 by d.tiaan
The code below works with UART3 (PC10 and PC11), but I am having problems getting the UART4 to work with this code.

Transmit does not work. Output line remains high.


Seems to receive one byte (However it is not the first byte being send ). 




I think I might be missing a set up parameter/s.


Initialization code:




  #define USART_IR                  UART4
  #define USART_IR_IRQHandler       UART4_IRQHandler
  #define USART_IR_IRQChannel       UART4_IRQChannel
  #define RCC_APBxPeriph_USART_IR   RCC_APB1Periph_UART4


void IR_Init(void) {


  u16 temp;
  GPIO_InitTypeDef GPIO_InitStructure;




  RCC_APB1PeriphClockCmd(RCC_APBxPeriph_USART_IR, ENABLE);


  IR_ConfigureUSART('0'); // Default on power up
  


  #ifdef IR_UART3
    // USART_IR_REMAP = "01" (partial remap), meaning PC10 is TX, PC11 is RX
    GPIO_PinRemapConfig(GPIO_PartialRemap_USART3, ENABLE);
  #endif


  GPIO_InitStructure.GPIO_Pin = GPIO_Pin_10;
  GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
  GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;
  GPIO_Init(GPIOC, &GPIO_InitStructure);


  GPIO_InitStructure.GPIO_Pin = GPIO_Pin_11;
  GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
  GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;
  GPIO_Init(GPIOC, &GPIO_InitStructure);


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


  #ifdef IR_UART3
    /* Set the USART_IR prescaler */
    USART_SetPrescaler(USART_IR, 0x1);
  #endif


  USART_ITConfig(USART_IR, USART_IT_TXE, ENABLE);
  USART_ITConfig(USART_IR, USART_IT_TC, ENABLE);
  USART_ITConfig(USART_IR, USART_IT_RXNE, ENABLE);
  USART_ITConfig(USART_IR, USART_IT_PE, ENABLE);
  USART_ITConfig(USART_IR, USART_IT_ERR, ENABLE);


}


void IR_ConfigureUSART(unsigned char baud) {
  // baud gives the baud rate that will be used - see switch statement below
  switch (baud) {
    case '0': USART_InitStructure.USART_BaudRate =    300; break;
    case '1': USART_InitStructure.USART_BaudRate =    600; break;
    case '2': USART_InitStructure.USART_BaudRate =   1200; break;
    case '3': USART_InitStructure.USART_BaudRate =   2400; break;
    case '4': USART_InitStructure.USART_BaudRate =   4800; break;
    case '5': USART_InitStructure.USART_BaudRate =   9600; break;
    case '6': USART_InitStructure.USART_BaudRate =  19200; break;
    case '7': USART_InitStructure.USART_BaudRate =  38400; break;
    case '8': USART_InitStructure.USART_BaudRate =  57600; break;
    case '9': USART_InitStructure.USART_BaudRate = 115200; break; // was 116000
    default:  USART_InitStructure.USART_BaudRate =    300; // Default
  }
  USART_InitStructure.USART_WordLength = USART_WordLength_8b; // No direct support for 7 bit
  USART_InitStructure.USART_StopBits = USART_StopBits_1;
  USART_InitStructure.USART_Parity = USART_Parity_No; // By doing this we can implement 7E1
  USART_InitStructure.USART_HardwareFlowControl = USART_HardwareFlowControl_None;
  USART_InitStructure.USART_Mode = USART_Mode_Rx | USART_Mode_Tx;


  /* Configure the USART_IR */
  USART_Init(USART_IR, &USART_InitStructure);
}




IRQ Handler 


void USART_IR_IRQHandler(void) {
  // Interrupt handler for everything to do with USART_IR
  if (USART_GetITStatus(USART_IR, USART_IT_RXNE) == SET) {
    // A byte has just been received...
    IR_RX(USART_ReceiveData(USART_IR));
    // The above line clears the interrupt
  } else
  if (USART_GetITStatus(USART_IR, USART_IT_TXE) == SET) {
    // There is space to transmit another byte...
    if (TXBufferHead != TXBufferTail) {
      // Transmit the next byte...
      USART_SendData(USART_IR, TXBuffer[TXBufferTail]);
      USART_ITConfig(USART_IR, USART_IT_TC, ENABLE); // Needed for half-duplex
      // Remove the byte just transmitted...
      TXBufferTail++;
      TXBufferTail %= TXBufferLength;
    } else {
      // No data available to transmit, disable the TXE interrupt
      USART_ITConfig(USART_IR, USART_IT_TXE, DISABLE);
    }
  } else
  if (USART_GetITStatus(USART_IR, USART_IT_TC) == SET) {
    // Transmission has been completed, and there were no more pending
    // bytes, so we may turn on the receiver...
    USART_IR->CR1 |= USART_Mode_Rx;
    USART_ClearITPendingBit(USART_IR, USART_IT_TC);
    USART_ITConfig(USART_IR, USART_IT_TC, DISABLE);
  } else
  if (USART_GetITStatus(USART_IR, USART_IT_ORE) == SET) {
    // Overrun error was detected
    RXTmpBufferError = 1; // Trash the RX buffer
    USART_ReceiveData(USART_IR); // Clear the error
  } else
  if (USART_GetITStatus(USART_IR, USART_IT_NE) == SET) {
    // Noise error was detected
    RXTmpBufferError = 1; // Trash the RX buffer
    USART_ReceiveData(USART_IR); // Clear the error
  } else
  if (USART_GetITStatus(USART_IR, USART_IT_FE) == SET) {
    // Framing error was detected
    RXTmpBufferError = 1; // Trash the RX buffer
    USART_ReceiveData(USART_IR); // Clear the error
  } else
  if (USART_GetITStatus(USART_IR, USART_IT_PE) == SET) {
    // Parity error was detected
    RXTmpBufferError = 1; // Trash the RX buffer
    USART_ReceiveData(USART_IR); // Clear the error
  }
}




void IR_RX(u8 data) {
  // Receive incoming byte of data
  u8 i, temp, count;
  // Check that the byte has even parity
  count = 0;
  temp = data;
  for (i = 0; i<8; i++) {
    count += ((temp&0x01)?1:0);
    #ifndef SIMULATE
    temp >>= 1;
    #endif
  }
  data &= 0x7F; // Trim off the parity bit for further use...
  if ((count & 0x01) == 0) {
    // Parity was even, so data is valid
    if (RXTmpBufferLen<RXTmpBufferLength) {
      RXTmpBuffer[RXTmpBufferLen] = data;
      RXTmpBufferLen++;
      RXTimeoutms = 1500; // Allow 1500 ms before trashing the buffer
    } else {
      // There is not space in the buffer, so throw the byte away
      // Empty the buffer as we'll never get anywhere unless we do
      RXTmpBufferError = 1;
    }


  } else {
    // Parity was odd, so data is invalid
    // Empty the buffer as the data has been corrupted
    RXTmpBufferError = 1;
  }
}




Start up file code:


;******************** (C) COPYRIGHT 2011 STMicroelectronics ********************
;* File Name          : startup_stm32f10x_hd.s
;* Author             : MCD Application Team
;* Version            : V3.5.0
;* Date               : 11-March-2011
;* Description        : STM32F10x High Density Devices vector table for MDK-ARM 
;*                      toolchain. 
;*                      This module performs:
;*                      - Set the initial SP
;*                      - Set the initial PC == Reset_Handler
;*                      - Set the vector table entries with the exceptions ISR address
;*                      - Configure the clock system and also configure the external 
;*                        SRAM mounted on STM3210E-EVAL board to be used as data 
;*                        memory (optional, to be enabled by user)
;*                      - Branches to __main in the C library (which eventually
;*                        calls main()).
;*                      After Reset the CortexM3 processor is in Thread mode,
;*                      priority is Privileged, and the Stack is set to Main.
;* <<< Use Configuration Wizard in Context Menu >>>   
;*******************************************************************************
; THE PRESENT FIRMWARE WHICH IS FOR GUIDANCE ONLY AIMS AT PROVIDING CUSTOMERS
; WITH CODING INFORMATION REGARDING THEIR PRODUCTS IN ORDER FOR THEM TO SAVE TIME.
; AS A RESULT, STMICROELECTRONICS SHALL NOT BE HELD LIABLE FOR ANY DIRECT,
; INDIRECT OR CONSEQUENTIAL DAMAGES WITH RESPECT TO ANY CLAIMS ARISING FROM THE
; CONTENT OF SUCH FIRMWARE AND/OR THE USE MADE BY CUSTOMERS OF THE CODING
; INFORMATION CONTAINED HEREIN IN CONNECTION WITH THEIR PRODUCTS.
;*******************************************************************************


; Amount of memory (in bytes) allocated for Stack
; Tailor this value to your application needs
; <h> Stack Configuration
;   <o> Stack Size (in Bytes) <0x0-0xFFFFFFFF:8>
; </h>


Stack_Size      EQU     0x00000400


                AREA    STACK, NOINIT, READWRITE, ALIGN=3
Stack_Mem       SPACE   Stack_Size
__initial_sp
                                                  
; <h> Heap Configuration
;   <o>  Heap Size (in Bytes) <0x0-0xFFFFFFFF:8>
; </h>


Heap_Size       EQU     0x00000200


                AREA    HEAP, NOINIT, READWRITE, ALIGN=3
__heap_base
Heap_Mem        SPACE   Heap_Size
__heap_limit


                PRESERVE8
                THUMB




; Vector Table Mapped to Address 0 at Reset
                AREA    RESET, DATA, READONLY
                EXPORT  __Vectors
                EXPORT  __Vectors_End
                EXPORT  __Vectors_Size


__Vectors       DCD     __initial_sp               ; Top of Stack
                DCD     Reset_Handler              ; Reset Handler
                DCD     NMI_Handler                ; NMI Handler
                DCD     HardFault_Handler          ; Hard Fault Handler
                DCD     MemManage_Handler          ; MPU Fault Handler
                DCD     BusFault_Handler           ; Bus Fault Handler
                DCD     UsageFault_Handler         ; Usage Fault Handler
                DCD     0                          ; Reserved
                DCD     0                          ; Reserved
                DCD     0                          ; Reserved
                DCD     0                          ; Reserved
                DCD     SVC_Handler                ; SVCall Handler
                DCD     DebugMon_Handler           ; Debug Monitor Handler
                DCD     0                          ; Reserved
                DCD     PendSV_Handler             ; PendSV Handler
                DCD     SysTick_Handler            ; SysTick Handler


                ; External Interrupts
                DCD     WWDG_IRQHandler            ; Window Watchdog
                DCD     PVD_IRQHandler             ; PVD through EXTI Line detect
                DCD     TAMPER_IRQHandler          ; Tamper
                DCD     RTC_IRQHandler             ; RTC
                DCD     FLASH_IRQHandler           ; Flash
                DCD     RCC_IRQHandler             ; RCC
                DCD     EXTI0_IRQHandler           ; EXTI Line 0
                DCD     EXTI1_IRQHandler           ; EXTI Line 1
                DCD     EXTI2_IRQHandler           ; EXTI Line 2
                DCD     EXTI3_IRQHandler           ; EXTI Line 3
                DCD     EXTI4_IRQHandler           ; EXTI Line 4
                DCD     DMAChannel1_IRQHandler     ; DMA Channel 1
                DCD     DMAChannel2_IRQHandler     ; DMA Channel 2
                DCD     DMAChannel3_IRQHandler     ; DMA Channel 3
                DCD     DMAChannel4_IRQHandler     ; DMA Channel 4
                DCD     DMAChannel5_IRQHandler     ; DMA Channel 5
                DCD     DMAChannel6_IRQHandler     ; DMA Channel 6
                DCD     DMAChannel7_IRQHandler     ; DMA Channel 7
                DCD     ADC_IRQHandler             ; ADC
                DCD     USB_HP_CAN_TX_IRQHandler   ; USB High Priority or CAN1 TX
                DCD     USB_LP_CAN_RX0_IRQHandler  ; USB Low  Priority or CAN1 RX0
                DCD     CAN_RX1_IRQHandler         ; CAN RX1
                DCD     CAN_SCE_IRQHandler         ; CAN SCE
                DCD     EXTI9_5_IRQHandler         ; EXTI Line 9..5
                DCD     TIM1_BRK_IRQHandler        ; TIM1 Break
                DCD     TIM1_UP_IRQHandler         ; TIM1 Update
                DCD     TIM1_TRG_COM_IRQHandler    ; TIM1 Trigger and Commutation
                DCD     TIM1_CC_IRQHandler         ; TIM1 Capture Compare
                DCD     TIM2_IRQHandler            ; TIM2
                DCD     TIM3_IRQHandler            ; TIM3
                DCD     TIM4_IRQHandler            ; TIM4
                DCD     I2C1_EV_IRQHandler         ; I2C1 Event
                DCD     I2C1_ER_IRQHandler         ; I2C1 Error
                DCD     I2C2_EV_IRQHandler         ; I2C2 Event
                DCD     I2C2_ER_IRQHandler         ; I2C2 Error
                DCD     SPI1_IRQHandler            ; SPI1
                DCD     SPI2_IRQHandler            ; SPI2
                DCD     USART1_IRQHandler          ; USART1
                DCD     USART2_IRQHandler          ; USART2
                DCD     USART3_IRQHandler          ; USART3
                DCD     EXTI15_10_IRQHandler       ; EXTI Line 15..10
                DCD     RTCAlarm_IRQHandler        ; RTC Alarm through EXTI Line
                DCD     USBWakeUp_IRQHandler       ; USB Wakeup from suspend
                DCD     TIM8_BRK_IRQHandler        ; TIM8 Break
                DCD     TIM8_UP_IRQHandler         ; TIM8 Update
                DCD     TIM8_TRG_COM_IRQHandler    ; TIM8 Trigger and Commutation
                DCD     TIM8_CC_IRQHandler         ; TIM8 Capture Compare
                DCD     ADC3_IRQHandler            ; ADC3
                DCD     FSMC_IRQHandler            ; FSMC
                DCD     SDIO_IRQHandler            ; SDIO
                DCD     TIM5_IRQHandler            ; TIM5
                DCD     SPI3_IRQHandler            ; SPI3
                DCD     UART4_IRQHandler           ; UART4
                DCD     UART5_IRQHandler           ; UART5
                DCD     TIM6_IRQHandler            ; TIM6
                DCD     TIM7_IRQHandler            ; TIM7
                DCD     DMA2_Channel1_IRQHandler   ; DMA2 Channel1
                DCD     DMA2_Channel2_IRQHandler   ; DMA2 Channel2
                DCD     DMA2_Channel3_IRQHandler   ; DMA2 Channel3
                DCD     DMA2_Channel4_5_IRQHandler ; DMA2 Channel4 & Channel5
__Vectors_End


__Vectors_Size  EQU  __Vectors_End - __Vectors


                AREA    |.text|, CODE, READONLY
                
; Reset handler
Reset_Handler   PROC
                EXPORT  Reset_Handler             [WEAK]
                IMPORT  __main              
                LDR     R0, =__main
                BX      R0
                ENDP
                
; 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


Default_Handler PROC


                EXPORT  WWDG_IRQHandler            [WEAK]
                EXPORT  PVD_IRQHandler             [WEAK]
                EXPORT  TAMPER_IRQHandler          [WEAK]
                EXPORT  RTC_IRQHandler             [WEAK]
                EXPORT  FLASH_IRQHandler           [WEAK]
                EXPORT  RCC_IRQHandler             [WEAK]
                EXPORT  EXTI0_IRQHandler           [WEAK]
                EXPORT  EXTI1_IRQHandler           [WEAK]
                EXPORT  EXTI2_IRQHandler           [WEAK]
                EXPORT  EXTI3_IRQHandler           [WEAK]
                EXPORT  EXTI4_IRQHandler           [WEAK]
                EXPORT  DMAChannel1_IRQHandler     [WEAK]
                EXPORT  DMAChannel2_IRQHandler     [WEAK]
                EXPORT  DMAChannel3_IRQHandler     [WEAK]
                EXPORT  DMAChannel4_IRQHandler     [WEAK]
                EXPORT  DMAChannel5_IRQHandler     [WEAK]
                EXPORT  DMAChannel6_IRQHandler     [WEAK]
                EXPORT  DMAChannel7_IRQHandler     [WEAK]
                EXPORT  ADC_IRQHandler             [WEAK]
                EXPORT  USB_HP_CAN_TX_IRQHandler   [WEAK]
                EXPORT  USB_LP_CAN_RX0_IRQHandler  [WEAK]
                EXPORT  CAN_RX1_IRQHandler         [WEAK]
                EXPORT  CAN_SCE_IRQHandler         [WEAK]
                EXPORT  EXTI9_5_IRQHandler         [WEAK]
                EXPORT  TIM1_BRK_IRQHandler        [WEAK]
                EXPORT  TIM1_UP_IRQHandler         [WEAK]
                EXPORT  TIM1_TRG_COM_IRQHandler    [WEAK]
                EXPORT  TIM1_CC_IRQHandler         [WEAK]
                EXPORT  TIM2_IRQHandler            [WEAK]
                EXPORT  TIM3_IRQHandler            [WEAK]
                EXPORT  TIM4_IRQHandler            [WEAK]
                EXPORT  I2C1_EV_IRQHandler         [WEAK]
                EXPORT  I2C1_ER_IRQHandler         [WEAK]
                EXPORT  I2C2_EV_IRQHandler         [WEAK]
                EXPORT  I2C2_ER_IRQHandler         [WEAK]
                EXPORT  SPI1_IRQHandler            [WEAK]
                EXPORT  SPI2_IRQHandler            [WEAK]
                EXPORT  USART1_IRQHandler          [WEAK]
                EXPORT  USART2_IRQHandler          [WEAK]
                EXPORT  USART3_IRQHandler          [WEAK]
                EXPORT  EXTI15_10_IRQHandler       [WEAK]
                EXPORT  RTCAlarm_IRQHandler        [WEAK]
                EXPORT  USBWakeUp_IRQHandler       [WEAK]
                EXPORT  TIM8_BRK_IRQHandler        [WEAK]
                EXPORT  TIM8_UP_IRQHandler         [WEAK]
                EXPORT  TIM8_TRG_COM_IRQHandler    [WEAK]
                EXPORT  TIM8_CC_IRQHandler         [WEAK]
                EXPORT  ADC3_IRQHandler            [WEAK]
                EXPORT  FSMC_IRQHandler            [WEAK]
                EXPORT  SDIO_IRQHandler            [WEAK]
                EXPORT  TIM5_IRQHandler            [WEAK]
                EXPORT  SPI3_IRQHandler            [WEAK]
                EXPORT  UART4_IRQHandler           [WEAK]
                EXPORT  UART5_IRQHandler           [WEAK]
                EXPORT  TIM6_IRQHandler            [WEAK]
                EXPORT  TIM7_IRQHandler            [WEAK]
                EXPORT  DMA2_Channel1_IRQHandler   [WEAK]
                EXPORT  DMA2_Channel2_IRQHandler   [WEAK]
                EXPORT  DMA2_Channel3_IRQHandler   [WEAK]
                EXPORT  DMA2_Channel4_5_IRQHandler [WEAK]


WWDG_IRQHandler
PVD_IRQHandler
TAMPER_IRQHandler
RTC_IRQHandler
FLASH_IRQHandler
RCC_IRQHandler
EXTI0_IRQHandler
EXTI1_IRQHandler
EXTI2_IRQHandler
EXTI3_IRQHandler
EXTI4_IRQHandler
DMAChannel1_IRQHandler
DMAChannel2_IRQHandler
DMAChannel3_IRQHandler
DMAChannel4_IRQHandler
DMAChannel5_IRQHandler
DMAChannel6_IRQHandler
DMAChannel7_IRQHandler
ADC_IRQHandler
USB_HP_CAN_TX_IRQHandler
USB_LP_CAN_RX0_IRQHandler
CAN_RX1_IRQHandler
CAN_SCE_IRQHandler
EXTI9_5_IRQHandler
TIM1_BRK_IRQHandler
TIM1_UP_IRQHandler
TIM1_TRG_COM_IRQHandler
TIM1_CC_IRQHandler
TIM2_IRQHandler
TIM3_IRQHandler
TIM4_IRQHandler
I2C1_EV_IRQHandler
I2C1_ER_IRQHandler
I2C2_EV_IRQHandler
I2C2_ER_IRQHandler
SPI1_IRQHandler
SPI2_IRQHandler
USART1_IRQHandler
USART2_IRQHandler
USART3_IRQHandler
EXTI15_10_IRQHandler
RTCAlarm_IRQHandler
USBWakeUp_IRQHandler
TIM8_BRK_IRQHandler
TIM8_UP_IRQHandler
TIM8_TRG_COM_IRQHandler
TIM8_CC_IRQHandler
ADC3_IRQHandler
FSMC_IRQHandler
SDIO_IRQHandler
TIM5_IRQHandler
SPI3_IRQHandler
UART4_IRQHandler
UART5_IRQHandler
TIM6_IRQHandler
TIM7_IRQHandler
DMA2_Channel1_IRQHandler
DMA2_Channel2_IRQHandler
DMA2_Channel3_IRQHandler
DMA2_Channel4_5_IRQHandler


                B       .


                ENDP


                ALIGN


;*******************************************************************************
; User Stack and Heap initialization
;*******************************************************************************
                 IF      :DEF:__MICROLIB
                
                 EXPORT  __initial_sp
                 EXPORT  __heap_base
                 EXPORT  __heap_limit
                
                 ELSE
                
                 IMPORT  __use_two_region_memory
                 EXPORT  __user_initial_stackheap
                 
__user_initial_stackheap


                 LDR     R0, =  Heap_Mem
                 LDR     R1, =(Stack_Mem + Stack_Size)
                 LDR     R2, = (Heap_Mem +  Heap_Size)
                 LDR     R3, = Stack_Mem
                 BX      LR


                 ALIGN


                 ENDIF


                 END


;******************* (C) COPYRIGHT 2011 STMicroelectronics *****END OF FILE*****

Outcomes