LABORATORIO DI ARCHITETTURE E PROGRAMMAZIONE DEI SISTEMI ELETTRONICI INDUSTRIALI

Transcription

1 LABORATORIO DI ARCHITETTURE E PROGRAMMAZIONE DEI SISTEMI ELETTRONICI INDUSTRIALI Laboratory Lesson 7: Universal Serial Asynchronous Receiver Transmitter (USART) Prof. Luca Benini <luca.benini@unibo.it> Prof Davide Rossi <davide.rossi@unibo.it> Simone Benatti <simone.benatti@unibo.it> Victor Kartsch<victorjavier.kartsch@unibo.it>

2 Info & Communications

3 Recap LAB1: IDE & Debug LAB2: GPIO & Systick LAB3: Advanced Debug LAB4: EXTI LAB5:TIMERS LAB6:DMA and FLASH LAB7: USART Universal Serial (Asyncronous) Receiver Transmitter

4 Universal Serial Asynchronous Receiver Transmitter (USART)

5 Serial communications Parallel world Serial world Vs Without using a lot of I/O lines I/O lines require I/O pads which cost $$$ and size I/O lines require PCB area which costs $$$ and size connect different systems together Two embedded systems A desktop and an embedded system connect different chips together in the same embedded system MCU to peripheral MCU to MCU

6 USART intuition Easily connect your embedded system with the external world Safe world Non protected world MCU Transceiver 232 Logic levels 0 -> 3.3V

7 USART protocol Send the ASCII letter W ( )

8 USART

9 USART Characteristics The USART is the most used serial communication interface (eg. PC RS232 interface, IC communication interface, BT and WiFi module interface) FEATURES: Full duplex, asynchronous communications Fractional baud rate generator systems A common programmable transmit and receive baud rates up to 4.5 MBits/s Programmable data word length (8 or 9 bits) Configurable stop bits - support for 1 or 2 stop bits Transmitter clock output for synchronous transmission Single wire half duplex communication Configurable multibuffer communication using DMA Buffering of received/transmitted bytes in reserved SRAM using centralized DMA Separate enable bits for Transmitter and Receiver

10 USART Configuration Each character is sent using: a logic low start bit one or more logic high stop bits one optional parity bit number of data bits (usually 8 or 9) bit timing ( baud rate ) N-1

11 USART Characteristics FLAGS: Receive buffer full Transmit buffer empty End of Transmission Parity control: Transmits parity bit Checks parity of received data byte Four error detection: Overrun error Noise error Frame error Parity error Ten interrupt sources with flags: CTS changes Transmit data register empty Transmission complete Receive data register full Idle line received Overrun error Framing error Noise error Parity error Multiprocessor communication - enter into mute mode if address match does not occur

12 USART Block diagram Data registers Interface pins Control registers Baud Rate Generator

13 USART Functional description Any USART bidirectional communication requires a minimum of two pins: Receive Data In (RX): Receive Data Input is the serial data input. Oversampling techniques are used for data recovery by discriminating between valid incoming data and noise. Transmit Data Out (TX): When the transmitter is disabled, the output pin returns to its I/O port configuration. When it is enabled and nothing is to be transmitted, the TX pin is at high level. In single-wire and smartcard modes, this I/O is used to transmit and receive the data. Through these pins, serial data is transmitted and received in normal USART mode as frames comprising: An Idle Line prior to transmission or reception, a start bit, the data word (8 or 9 bits) least significant bit first and stop bits (0.5,1, 1.5 or 2 stop bits) indicating that the frame is complete. The following pin is required to interface in synchronous mode: SCLK: Transmitter clock output. This pin outputs the transmitter data clock for synchronous transmission corresponding to SPI master mode. The following pins are required in Hardware flow control mode: ncts: Clear To Send blocks the data transmission at the end of the current transfer when high nrts: Request to send indicates that the USART is ready to receive a data (when low).

14 USART Tx/Rx Char transmission When the transmit enable bit (TE) is set, the data in the transmit shift register is output on the TX pin and the corresponding clock pulses are output on the CK pin. During a USART transmission, data shifts out least significant bit first on the TX pin. In this mode, the USART_DR register consists of a buffer (TDR) between the internal bus and the transmit shift register. Every character is preceded by a start bit which is a logic level low for one bit period. Every character is terminated by a configurable number of stop bits: 0.5, 1, 1.5 and 2 stop bits. The TE bit should not be reset during transmission of data. Resetting the TE bit during the transmission will corrupt the data on the TX pin as the baud rate counters will get frozen. The current data being transmitted will be lost. An idle frame will be sent after the TE bit is enabled. Char reception The USART can receive data words of either 8 or 9 bits depending on the M bit in the USART_CR1 register. During a USART reception, data shifts in least significant bit first through the RX pin. In this mode, the USART_DR register consists of a buffer (RDR) between the internal bus and the received shift register.

15 USART Registers Status register Data register Baud Rate register Control register 1 Control register 2 Control register 3 Prescaler register

16 USART Interrupts The USART interrupt events are connected to the same interrupt routine During transmission: Transmission Complete, Clear to Send or Transmit Data Register empty interrupt. While receiving: Idle Line detection, Overrun error, Receive Data register not empty, Parity error, LIN break detection, Noise Flag (only in multi buffer communication) and Framing Error (only in multi buffer communication). These events generate an interrupt if the corresponding Enable Control Bit is set.

17 USART Low level procedure TX 1. Enable the USART by writing the UE bit in USART_CR1 register to Program the M bit in USART_CR1 to define the word length. 3. Program the number of stop bits in USART_CR2. 4. Select the desired baud rate using the USART_BRR register. 5. Set the TE bit in USART_CR1 to send an idle frame as first transmission. 6. Write the data to send in the USART_DR register (this clears the TXE bit). Repeat this for each data to be transmitted in case of single buffer. 7. After writing the last data into the USART_DR register, wait until TC=1. This indicates that the transmission of the last frame is complete. This is required for instance when the USART is disabled or enters the Halt mode to avoid corrupting the last transmission. Single byte communication The TXE bit is always cleared by a write to the data register. The TXE bit is set by hardware and it indicates: The data has been moved from TDR to the shift register and the data transmission has started. The TDR register is empty. The next data can be written in the USART_DR register without overwriting the previous data. This flag generates an interrupt if the TXEIE bit is set.

18 USART Low level procedure RX 1. Enable the USART by writing the UE bit in USART_CR1 register to Program the M bit in USART_CR1 to define the word length. 3. Program the number of stop bits in USART_CR2. 4. Select the desired baud rate using the baud rate register USART_BRR 5. Set the RE bit USART_CR1. This enables the receiver which begins searching for a start bit Single byte communication The RXNE bit is set. It indicates that the content of the shift register is transferred to the RDR. In other words, data has been received and can be read (as well as its associated error flags). An interrupt is generated if the RXNEIE bit is set. The error flags can be set if a frame error, noise or an overrun error has been detected during reception. In single buffer mode, clearing the RXNE bit is performed by a software read to the USART_DR register. The RXNE flag can also be cleared by writing a zero to it. In multi-buffer, RXNE is set after every byte received and is cleared by the DMA read to the Data Register.

19 USART (what) I want to use an USART. What do I need to know? Which bus USARTx are connected to? Look at the architecture diagram Which Pin and Port are we going to use? Look at the development board documentation What do I need to do with this USART? (input, output,...) Configure as: Baud Rate 9600, 8 bit data, No Parity, 1 stop bit

20 USART Examples The operation that are needed to use the USART are: Initialization of the USART PINs as Alternate Function (NOT standard GPIO) Initialization of USART Write data in the Data Register / read data from Data Register Example 1: polling Send a character and receive it back (loopback) and check if it is correct Example 2: interrupt Same as Example 1 with RX/TX interrupts

21 Example 1: polling

22 USART GPIO config GPIO_InitTypeDef GPIO_InitStructure; /* Enable GPIO clock */ RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOA, ENABLE); /* Connect PA2 to USART2_Tx*/ GPIO_PinAFConfig(GPIOA, GPIO_PinSource2, GPIO_AF_USART2); /* Connect PA3 to USART2_Rx*/ GPIO_PinAFConfig(GPIOA, GPIO_PinSource3, GPIO_AF_USART2); /* Configure USART Tx as alternate function */ GPIO_InitStructure.GPIO_OType = GPIO_OType_PP; GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_UP; GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF; GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz; Pins are used in Alternate Function: not used as GPIO, but as USART pin GPIO_InitStructure.GPIO_Pin = GPIO_Pin_2; GPIO_Init(GPIOA, &GPIO_InitStructure); /* Configure USART Rx as alternate function */ GPIO_InitStructure.GPIO_Pin = GPIO_Pin_3; GPIO_Init(GPIOA, &GPIO_InitStructure);

23 USART - Initialization USART_InitTypeDef USART_InitStructure; /* Enable UART clock */ RCC_APB1PeriphClockCmd(RCC_APB1Periph_USART2, ENABLE); Structure definition /* USARTx configured as follows: - BaudRate = baud - Word Length = 8 Bits - One Stop Bit - No parity - Hardware flow control disabled (RTS and CTS signals) - Receive and transmit enabled */ USART_InitStructure.USART_BaudRate = ; 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; /* USART initialization */ USART_Init(USART2, &USART_InitStructure); /* Enable USART */ USART_Cmd(USART2, ENABLE);

24 USART - Initialization USART_InitTypeDef USART_InitStructure; /* Enable UART clock */ RCC_APB1PeriphClockCmd(RCC_APB1Periph_USART2, ENABLE); /* USARTx configured as follows: - BaudRate = baud - Word Length = 8 Bits - One Stop Bit - No parity - Hardware flow control disabled (RTS and CTS signals) - Receive and transmit enabled */ USART_InitStructure.USART_BaudRate = ; 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; /* USART initialization */ USART_Init(USART2, &USART_InitStructure); /* Enable USART */ USART_Cmd(USART2, ENABLE); Clock Enable

25 USART - Initialization USART_InitTypeDef USART_InitStructure; /* Enable UART clock */ RCC_APB1PeriphClockCmd(RCC_APB1Periph_USART2, ENABLE); /* USARTx configured as follows: - BaudRate = baud - Word Length = 8 Bits - One Stop Bit - No parity - Hardware flow control disabled (RTS and CTS signals) - Receive and transmit enabled */ USART_InitStructure.USART_BaudRate = ; 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; /* USART initialization */ USART_Init(USART2, &USART_InitStructure); /* Enable USART */ USART_Cmd(USART2, ENABLE); Set the baudrate To communicate, two USART devices connected must have the same baud rate

26 USART - Initialization USART_InitTypeDef USART_InitStructure; /* Enable UART clock */ RCC_APB1PeriphClockCmd(RCC_APB1Periph_USART2, ENABLE); /* USARTx configured as follows: - BaudRate = baud - Word Length = 8 Bits - One Stop Bit - No parity - Hardware flow control disabled (RTS and CTS signals) - Receive and transmit enabled */ USART_InitStructure.USART_BaudRate = ; 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; /* USART initialization */ USART_Init(USART2, &USART_InitStructure); /* Enable USART */ USART_Cmd(USART2, ENABLE); Configure USART for: no parity bit, 1 stop bit and 8 bit word length

27 USART - Initialization USART_InitTypeDef USART_InitStructure; /* Enable UART clock */ RCC_APB1PeriphClockCmd(RCC_APB1Periph_USART2, ENABLE); /* USARTx configured as follows: - BaudRate = baud - Word Length = 8 Bits - One Stop Bit - No parity - Hardware flow control disabled (RTS and CTS signals) - Receive and transmit enabled */ USART_InitStructure.USART_BaudRate = ; 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; /* USART initialization */ USART_Init(USART2, &USART_InitStructure); /* Enable USART */ USART_Cmd(USART2, ENABLE); Do not use hardware flow control (requires two additional lines for handshaking)

28 USART - Initialization USART_InitTypeDef USART_InitStructure; /* Enable UART clock */ RCC_APB1PeriphClockCmd(RCC_APB1Periph_USART2, ENABLE); /* USARTx configured as follows: - BaudRate = baud - Word Length = 8 Bits - One Stop Bit - No parity - Hardware flow control disabled (RTS and CTS signals) - Receive and transmit enabled */ USART_InitStructure.USART_BaudRate = ; 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; /* USART initialization */ USART_Init(USART2, &USART_InitStructure); /* Enable USART */ USART_Cmd(USART2, ENABLE); Enable TX and RX

29 USART - Initialization USART_InitTypeDef USART_InitStructure; /* Enable UART clock */ RCC_APB1PeriphClockCmd(RCC_APB1Periph_USART2, ENABLE); /* USARTx configured as follows: - BaudRate = baud - Word Length = 8 Bits - One Stop Bit - No parity - Hardware flow control disabled (RTS and CTS signals) - Receive and transmit enabled */ USART_InitStructure.USART_BaudRate = ; 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; /* USART initialization */ USART_Init(USART2, &USART_InitStructure); /* Enable USART */ USART_Cmd(USART2, ENABLE); Initialize and enable USART2

30 USART main while(1) if (readytosend == 1) /* Send one byte */ USART_SendData(USART2, chartosend); In this example we enable the data transmission every 1s (look in the systick) /* Loop until the end of transmission */ while (USART_GetFlagStatus(USART2, USART_FLAG_TC) == RESET) /* Loop until a character is received */ while (USART_GetFlagStatus(USART2, USART_FLAG_RXNE) == RESET) /* Read one byte */ chartoread = USART_ReceiveData(USART2); if (chartoread == chartosend) STM_EVAL_LEDOn(LED4); else STM_EVAL_LEDOn(LED5); chartosend++; readytosend = 0;

31 USART main while(1) if (readytosend == 1) /* Send one byte */ USART_SendData(USART2, chartosend); Send one Byte /* Loop until the end of transmission */ while (USART_GetFlagStatus(USART2, USART_FLAG_TC) == RESET) /* Loop until a character is received */ while (USART_GetFlagStatus(USART2, USART_FLAG_RXNE) == RESET) /* Read one byte */ chartoread = USART_ReceiveData(USART2); if (chartoread == chartosend) STM_EVAL_LEDOn(LED4); else STM_EVAL_LEDOn(LED5); chartosend++; readytosend = 0;

32 USART main while(1) if (readytosend == 1) /* Send one byte */ USART_SendData(USART2, chartosend); /* Loop until the end of transmission */ while (USART_GetFlagStatus(USART2, USART_FLAG_TC) == RESET) /* Loop until a character is received */ while (USART_GetFlagStatus(USART2, USART_FLAG_RXNE) == RESET) /* Read one byte */ chartoread = USART_ReceiveData(USART2); if (chartoread == chartosend) STM_EVAL_LEDOn(LED4); else STM_EVAL_LEDOn(LED5); Wait until the end of transmission Polling = active wait chartosend++; readytosend = 0;

33 USART main while(1) if (readytosend == 1) /* Send one byte */ USART_SendData(USART2, chartosend); /* Loop until the end of transmission */ while (USART_GetFlagStatus(USART2, USART_FLAG_TC) == RESET) /* Loop until a character is received */ while (USART_GetFlagStatus(USART2, USART_FLAG_RXNE) == RESET) /* Read one byte */ chartoread = USART_ReceiveData(USART2); if (chartoread == chartosend) STM_EVAL_LEDOn(LED4); else STM_EVAL_LEDOn(LED5); Wait until something is received Polling = active wait chartosend++; readytosend = 0;

34 USART main while(1) if (readytosend == 1) /* Send one byte */ USART_SendData(USART2, chartosend); /* Loop until the end of transmission */ while (USART_GetFlagStatus(USART2, USART_FLAG_TC) == RESET) /* Loop until a character is received */ while (USART_GetFlagStatus(USART2, USART_FLAG_RXNE) == RESET) /* Read one byte */ chartoread = USART_ReceiveData(USART2); if (chartoread == chartosend) STM_EVAL_LEDOn(LED4); else STM_EVAL_LEDOn(LED5); Read one Byte chartosend++; readytosend = 0;

35 USART main while(1) if (readytosend == 1) /* Send one byte */ USART_SendData(USART2, chartosend); /* Loop until the end of transmission */ while (USART_GetFlagStatus(USART2, USART_FLAG_TC) == RESET) /* Loop until a character is received */ while (USART_GetFlagStatus(USART2, USART_FLAG_RXNE) == RESET) /* Read one byte */ chartoread = USART_ReceiveData(USART2); if (chartoread == chartosend) STM_EVAL_LEDOn(LED4); else STM_EVAL_LEDOn(LED5); Check if received is equal to sent and turn on led chartosend++; readytosend = 0;

36 Example 2: interrupt

37 USART Interrupts In Example 1 we have active waiting for data reception and transmission -> NOT efficient Interrupt can signal when new data is available (RX) or when to write new data to send (TX). One shared handler: check which flag is active Flags to be enabled: RXNE: Received Data Ready to Read TXE: Transmit Data Register Empty

38 Code - NVIC NVIC_InitTypeDef NVIC_InitStructure; /* Enable the USART2 RX Interrupt */ NVIC_InitStructure.NVIC_IRQChannel = USART2_IRQn; NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0x01; NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0x01; NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE; NVIC_Init(&NVIC_InitStructure); /* Enable the RX Interrupt */ USART_ITConfig(USART2, USART_IT_RXNE, ENABLE); Configure Interrupt for USART2

39 Code - NVIC NVIC_InitTypeDef NVIC_InitStructure; /* Enable the USART2 RX Interrupt */ NVIC_InitStructure.NVIC_IRQChannel = USART2_IRQn; NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0x01; NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0x01; NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE; NVIC_Init(&NVIC_InitStructure); /* Enable the RX Interrupt */ USART_ITConfig(USART2, USART_IT_RXNE, ENABLE); Enable RX Interrupt for USART2

40 Code USART ISR void USART2_IRQHandler(void) /* RX interrupt */ if (USART_GetITStatus(USART2, USART_IT_RXNE)!= RESET) /* Read data and store in RX buffer */ bufferrx[idxrx++] = USART_ReceiveData(USART2); datareceived = 1; Check if RXNE flag caused interrupt /* check index and buffer size */ if (idxrx >= RX_BUFFER_SIZE) idxrx = 0; /* TX Data Register Empty interrupt */ if (USART_GetITStatus(USART2, USART_IT_TXE)!= RESET) if (idxtx < nbytestx) /* there are still bytes to send */ USART_SendData(USART2, (u8)buffertx[idxtx++]); else /* All bytes sent, disable TX interrupt */ USART_ITConfig(USART2, USART_IT_TXE, DISABLE);

41 Code USART ISR void USART2_IRQHandler(void) /* RX interrupt */ if (USART_GetITStatus(USART2, USART_IT_RXNE)!= RESET) /* Read data and store in RX buffer */ bufferrx[idxrx++] = USART_ReceiveData(USART2); datareceived = 1; /* check index and buffer size */ if (idxrx >= RX_BUFFER_SIZE) idxrx = 0; Every time a new character is received, it is copied into a buffer /* TX Data Register Empty interrupt */ if (USART_GetITStatus(USART2, USART_IT_TXE)!= RESET) if (idxtx < nbytestx) /* there are still bytes to send */ USART_SendData(USART2, (u8)buffertx[idxtx++]); else /* All bytes sent, disable TX interrupt */ USART_ITConfig(USART2, USART_IT_TXE, DISABLE);

42 Code USART ISR void USART2_IRQHandler(void) /* RX interrupt */ if (USART_GetITStatus(USART2, USART_IT_RXNE)!= RESET) /* Read data and store in RX buffer */ bufferrx[idxrx++] = USART_ReceiveData(USART2); datareceived = 1; /* check index and buffer size */ if (idxrx >= RX_BUFFER_SIZE) idxrx = 0; We set a flag to signal the data has been received /* TX Data Register Empty interrupt */ if (USART_GetITStatus(USART2, USART_IT_TXE)!= RESET) if (idxtx < nbytestx) /* there are still bytes to send */ USART_SendData(USART2, (u8)buffertx[idxtx++]); else /* All bytes sent, disable TX interrupt */ USART_ITConfig(USART2, USART_IT_TXE, DISABLE);

43 Code USART ISR void USART2_IRQHandler(void) /* RX interrupt */ if (USART_GetITStatus(USART2, USART_IT_RXNE)!= RESET) /* Read data and store in RX buffer */ bufferrx[idxrx++] = USART_ReceiveData(USART2); datareceived = 1; /* check index and buffer size */ if (idxrx >= RX_BUFFER_SIZE) idxrx = 0; Check index to not exceed buffer size /* TX Data Register Empty interrupt */ if (USART_GetITStatus(USART2, USART_IT_TXE)!= RESET) if (idxtx < nbytestx) /* there are still bytes to send */ USART_SendData(USART2, (u8)buffertx[idxtx++]); else /* All bytes sent, disable TX interrupt */ USART_ITConfig(USART2, USART_IT_TXE, DISABLE);

44 Code USART ISR void USART2_IRQHandler(void) /* RX interrupt */ if (USART_GetITStatus(USART2, USART_IT_RXNE)!= RESET) /* Read data and store in RX buffer */ bufferrx[idxrx++] = USART_ReceiveData(USART2); datareceived = 1; /* check index and buffer size */ if (idxrx >= RX_BUFFER_SIZE) idxrx = 0; /* TX Data Register Empty interrupt */ if (USART_GetITStatus(USART2, USART_IT_TXE)!= RESET) if (idxtx < nbytestx) /* there are still bytes to send */ USART_SendData(USART2, (u8)buffertx[idxtx++]); else /* All bytes sent, disable TX interrupt */ USART_ITConfig(USART2, USART_IT_TXE, DISABLE); Check if TXE flag caused interrupt

45 Code USART ISR void USART2_IRQHandler(void) /* RX interrupt */ if (USART_GetITStatus(USART2, USART_IT_RXNE)!= RESET) /* Read data and store in RX buffer */ bufferrx[idxrx++] = USART_ReceiveData(USART2); datareceived = 1; /* check index and buffer size */ if (idxrx >= RX_BUFFER_SIZE) idxrx = 0; /* TX Data Register Empty interrupt */ if (USART_GetITStatus(USART2, USART_IT_TXE)!= RESET) if (idxtx < nbytestx) /* there are still bytes to send */ USART_SendData(USART2, (u8)buffertx[idxtx++]); else /* All bytes sent, disable TX interrupt */ USART_ITConfig(USART2, USART_IT_TXE, DISABLE); If index has not reached number of bytes to send: send one byte from TX buffer and increase index

46 Code USART ISR void USART2_IRQHandler(void) /* RX interrupt */ if (USART_GetITStatus(USART2, USART_IT_RXNE)!= RESET) /* Read data and store in RX buffer */ bufferrx[idxrx++] = USART_ReceiveData(USART2); datareceived = 1; /* check index and buffer size */ if (idxrx >= RX_BUFFER_SIZE) idxrx = 0; /* TX Data Register Empty interrupt */ if (USART_GetITStatus(USART2, USART_IT_TXE)!= RESET) if (idxtx < nbytestx) /* there are still bytes to send */ USART_SendData(USART2, (u8)buffertx[idxtx++]); else /* All bytes sent, disable TX interrupt */ USART_ITConfig(USART2, USART_IT_TXE, DISABLE); When finished disable TX interrupt

47 Code - globals #define RX_BUFFER_SIZE 64 #define TX_BUFFER_SIZE 64 void USART_Config(void); Function declarations u8 bufferrx[rx_buffer_size]; u8 buffertx[tx_buffer_size]; u8 idxrx = 0; u8 idxtx = 0; u8 nbytestx = 0; u8 readytosend = 0; u8 datareceived = 0; Buffer and index for TX and RX. Exchange data between main and ISR State variables

48 Code - main while (1) if (readytosend == 1) buffertx[0] = chartosend; nbytestx = 1; idxtx = 0; As in Example 1, we send a Byte every 1s NO active wait, just check flag /* Enable TX interrupt */ USART_ITConfig(USART2, USART_IT_TXE, ENABLE); readytosend = 0;...

49 Code - main while (1) if (readytosend == 1) buffertx[0] = chartosend; nbytestx = 1; idxtx = 0; Copy data to send in TX buffer Set #Bytes to send and init index = 0 /* Enable TX interrupt */ USART_ITConfig(USART2, USART_IT_TXE, ENABLE); readytosend = 0;...

50 Code - main while (1) if (readytosend == 1) buffertx[0] = chartosend; nbytestx = 1; idxtx = 0; /* Enable TX interrupt */ USART_ITConfig(USART2, USART_IT_TXE, ENABLE);... readytosend = 0; Enable TX interrupt. NOTE: TX interrupt is usually disabled, only when the buffer to send is ready we enable it

51 Code - main while (1) if (readytosend == 1) buffertx[0] = chartosend; nbytestx = 1; idxtx = 0; /* Enable TX interrupt */ USART_ITConfig(USART2, USART_IT_TXE, ENABLE);... readytosend = 0; We clear our Flag

52 Code - main while (1)... if (datareceived == 1) chartoread = bufferrx[idxrx-1]; if (chartoread == chartosend) STM_EVAL_LEDOn(LED4); STM_EVAL_LEDOff(LED5); else STM_EVAL_LEDOff(LED4); STM_EVAL_LEDOn(LED5); Check the flag for data received. NO active wait, just check flag chartosend++; idxrx = 0; datareceived = 0;

53 Code - main while (1)... if (datareceived == 1) chartoread = bufferrx[idxrx-1]; if (chartoread == chartosend) STM_EVAL_LEDOn(LED4); STM_EVAL_LEDOff(LED5); else STM_EVAL_LEDOff(LED4); STM_EVAL_LEDOn(LED5); Get data from RX buffer. chartosend++; idxrx = 0; datareceived = 0;

54 Code - main while (1)... if (datareceived == 1) chartoread = bufferrx[idxrx-1]; if (chartoread == chartosend) STM_EVAL_LEDOn(LED4); STM_EVAL_LEDOff(LED5); else STM_EVAL_LEDOff(LED4); STM_EVAL_LEDOn(LED5); Check if received is equal to sent and turn on led. chartosend++; idxrx = 0; datareceived = 0;

55 Code - main while (1)... if (datareceived == 1) chartoread = bufferrx[idxrx-1]; if (chartoread == chartosend) STM_EVAL_LEDOn(LED4); STM_EVAL_LEDOff(LED5); else STM_EVAL_LEDOff(LED4); STM_EVAL_LEDOn(LED5); chartosend++; idxrx = 0; datareceived = 0; Change Byte to send; reset index and flag.

56 Weekly Assignments

57 USART Exercises 1. Starting from example 1 send an array of characters periodically each 50ms using polling The array should end with character \r and you should use this to know when to stop sending. Example: char chartosend[] = 'c', 'i', 'a', 'o', '\r'; hint: use systick to periodically enable the data transmission hint: you send and receive one character at a time untill you reach the end character 2. Starting from example 2 send and receive an array of character periodically each 50ms using the interrupts. Same as es. 1 but with interrupts 3. (Optional and Extra fun!) Starting from example 2 send and receive an array of 4 to 10 characters periodically each 50ms using the interrupts. Once you receive the n-char packet you add +1 to the last element and you duplicate it in the n+1 position, and then you resend it (see next page) hint: try a FSM 4 char 5 char 6 char 7 char 4 char 5 char 6 char 7 char

58 USART Exercises

59 USART Questions 1. Which flags must be checked and which registers must be written to send something via USART? 2. Describe the following flags: TXE, TC e RXNE (look at the reference manual)