The UART peripheral is comprised of a receiver and a transmitter, both driven by a baud rate generator. The receiver and the transmitter have their own shift registers, which carry their independent data. These mechanisms allow the UART to receive and transmit data simultaneously. Other components to note are the receive and transmit buffers. In the case of the receive buffer, data received is taken out of the shift register and placed into the buffer. This buffer is essentially a storage queue for unprocessed data. This allows the UART to receive data even if the previous data hasn’t been processed yet. The transmit buffer works similarly, except that data is taken out of the buffer and placed into the shift register. The buffer still acts as a storage queue, but in this case, the queue is full of data to be transmitted and waits until the current transmission is done before loading the next value.

Instead, the Launchpad uses its microUSB port for UART communication. Additionally, in this course, we use MobaXTerm, which is a terminal on our laptop to establish a UART connection with the board. Since most laptops do not have a serial port, MobaXTerm instead uses a serial port driver (a low-level software) to mimic the behavior of a serial port for the user. When you open MobaXTerm on your computer and set up a serial port connection, to you, the USB port works just like a good old serial port. The below figure shows how your laptop and the board get connected using UART. The blue rectangles show hardware components and green ovals represent software programs involved in this transmission.

In this course, we study a simple UART project where pressing a key on your keyboard displays feedback sent from your board. For this to happen, the character has to go through many steps to reach the processor core. The below steps summarize the journey of a character from a laptop to the ARM CPU. In the above figure, the below steps are identified by S1 to S8 in the software or component they happen.

• 1. MobaXTerm reads a character from keyboard (input)

  2. MobaXTerm creates a packet of bits that consists of the UART start bit, 8 data bits representing the character, parity bit and stop bits.

  3. MobaXTerm sends the packet to what it thinks is a serial port.

  4. Another software (the driver) updates the packet to a form that can go through a USB port. The data goes through USB port, cable, and finally the microUSB port and gets inside the Launchpad board. Then, it is routed to the debugger chip, which is the big, black chip at the top of the board.

  5. A software running on the debugger chip unpacks the packet, which is in a USB format, and creates a UART packet of data which is identical to what was created in step 2 by MobaXTerm. This packet is put on a wire that connects to a pin on MCU. The pin is input to a hardware peripheral module called UART.

  6. The UART module samples this serial signal and records the data bits in one of its registers.

  7. The ARM CPU reads the register filled in step 6 using a load instruction. To the ARM CPU, this register is no different from a memory storage. In other words, UART is a memory-mapped peripheral.