Lesson UART. Clock Systems and Timing UART (Universal Asynchronous Receiver-Transmitter) Queues Lab Assignment: UART

Transcription

1 Lesson UART Clock Systems and Timing UART (Universal Asynchronous Receiver-Transmitter) Queues Lab Assignment: UART

2 Clock Systems and Timing Clock System & Timing A crystal oscillator is typically used to drive a processor's clock. You will find that many external crystal oscillator clocks are 20Mhz or less. A processor will utilize a "phased-lock-loop" or "PLL" to generate a faster clock than the crystal. So, you could have a 4Mhz crystal, and the PLL can be used to internally multiply the clock to provide 96Mhz to the processor. The same 96Mhz is then fed to microcontroller peripherals. Many of the peripherals have a register that can divide this higher clock to slower peripherals that may not require a high clock rate. Figure 1. Clock system of LPC17xx Phase Locked Loop (PLL)

3 What is a PLL? A PLL is a control system that takes in a reference signal at a particular frequency and creates a higher frequency signal. Technically, they can also be used to make lower frequency signals, but a simple frequency divider could easily accomplish this and a frequency divider is simple hardware. How do PLLs work? Frequency Divider Figure 2. PLL System Diagram If the input is a square wave, this device will reduce the number of edges per second proportional to M. VCO (Voltage Controlled Output) This a voltage to frequency converter. The higher the input voltage, the higher the output frequency will be.

4 Phase Comparator This is used to check if the two frequencies match each other. This device checks for matches by taking two signals and comparing their phase's. Loop Filter This converts the pulse output from the Phase comparator to a DC voltage. Programmable Divider This is frequency divider that divide the frequency of the input signal by the number it is set to. How does everything work together? The Phase Comparator and loop filter will drive the voltage input of VCO up until it begins to see that both signals are synchronized (or locked) with each other. At this point, the PLL has created an output signal with the same frequency as the input reference signal. By dividing the frequency that the Phase Comparator is trying to reach, lets say by 2, it will output a voltage twice the input reference signal, creating a higher frequency clock signal. This is how we are able to use a 12 MHz clock and create a 48 MHz signal clock with it, by multiplying it by 4, or in this case, dividing the feedback frequency by 4. Why use a PLL? Crystals are extremely consistent frequency sources. PLLs are not very stable and need a control loop to keep them on track. So if a circuit to use crystals is very simple, why not simply just use a high frequency crystal oscillator to generate 100 MHz or more clock signals? There are a few reasons: High frequency crystals above 100 Mhz are not common and are hard to find. High frequency signals will be distorted due to: Series inductance of board traces Parallel capacitance due to board copper areas and fiber glass Interference from other external signals like power signals and switching signals Signal distortion may cause the MCU to malfunction. Once the signal is within the chip, the environment is a bit more controlled and higher frequencies can

5 be achieved by using a PLL with a crystal as a reference. Clock Frequency and Power Consumption As you increase the clock of a microprocessors the power consumption of the processor will increase following this formula: P = CV 2 f C is the capacitance of the CPU (typical MOSFET gate transistors capacitance) V CPU core voltage f is the frequency used to drive the CPU and its peripherals Given this information, we can figure out which options will decrease the power consumption of our CPU. We have a few options. Reduce the capacitance of the CPU Which basically means purchasing a CPU or microcontroller with this characteristic. Typically such CPUs will be marked for lower power. If you cannot change your CPU this is not feasible. Reduce the CPU core voltage or supply voltage. Most micro-controllers perform the best at a particular supply voltage and lowering it, even towards the what the datasheet says is its minimum could be problematic. Reduce the CPU and Perpheral frequency In most cases, this is the most practical option. You can reduce the system clock frequency you use by manipulating the PLL's clock divider. You can reduce the power consumption of peripherals by using a lower frequency peripheral clock. Underclocking Advantages Reduced heat generation, which is exactly proportional to the power consumption. Longer hardware lifespan. Increased system stability. Increased battery life.

6 UART (Universal Asynchronous Receiver- Transmitter) Objective The objective of this lesson is to understand UART, and use two boards and setup UART communication between them. UART Figure 1. UART connection between two devices. For Universal Asynchronous Receiver Transmitter. There is one wire for transmitting data (TX), and one wire to receive data (RX).

7 BAUD Rate A common parameter is the baud rate known as "bps" which stands for bits per second. If a transmitter is configured with 9600bps, then the receiver must be listening on the other end at the same speed. UART Frame UART is a serial communication, so bits must travel on a single wire. If you wish to send a 8-bit byte ( uint8_t) over UART, the byte is enclosed within a start and a stop bit. To send a byte, it would require 2-bits of overhead; this 10-bit of information is called a UART frame. Let's take a look at how the character 'A' is sent over UART. In ASCII table, the character 'A' has the value of 65, which in binary is: 0100_0001. If you inform your UART hardware that you wish to send this data at 9600bps, here is how the frame would appear on an oscilloscope : UART Ports Figure 2. UART Frame sending letter 'A' A micrcontroller can have multiple UARTs. Typically, the UART0 peripheral is interfaced to with a USB to serial port converter which allows users to communicate between the computer and microcontroller. This port is used to program your microcontroller. Benefits Hardware complexity is low. No clock signal needed Has a parity bit to allow for error checking As this is one to one connection between two devices, device addressing is not required. Drawbacks The size of the data frame is limited to a maximum of 8 bits (some micros may support non-standard

8 data bits) Doesn t support multiple slave or multiple master systems The baud rates of each UART must be within 10% (or lower, depending on device tolerance) of each other Hardware Design Figure 3. Simplified UART peripheral design for the STM32F429. SCLK is used for USART. WARNING: The above is missing a common ground connection Software Driver? The UART chapter on LPC17xx has a really good summary page on how to write a UART driver. Read the register description of each UART register to understand how to write a driver. Memory Shadowing in UART driver

9 Figure 4. Memory Shadowing using DLAB Bit Register In figure 4, you will see that registers RBR/THR and DLM have the same address 0x4000C000. These registers are shadowed using the DLAB control bit. Setting DLAB bit to 1 allows the user to manipulate DLL and DLM, and clearing DLAB to 0 will allow you to manipulate the THR and RBR registers. The reason that the DLL register shares the same memory address as the RBR/THR may be historic. My guess is that it was intentionally hidden such that a user cannot accidentally modify the DLL register. Even if this case is not very significant present day, the manufacturer is probably using the same UART verilog code from many decades ago. Control Space Divergence (CSD) in UART driver In figure 4, you will see that register RBR and THR have the same address 0x4000C000. But also notice that access to each respective register is only from read or write operations. For example, if you read from memory location 0x4000C000, you will get the information from receive buffer and if you write to memory location 0x4000C000, you will write to a separate register which the transmit holding register. We call this Control Space Diverence since access of two separate registers or devices is done on a single address using the read/write control signal is used to multiplex between them. That address is considered to be Control Space Diverent. Typically, the control space aligns with its respective memory or io space.

10 Note that Control Space Divergence does not have a name outside of this course. It is Khalil Estell's phrase for this phenomenon. (Its my word... mine!) BAUD Rate Formula Figure 5. Baud rate formula To set the baud rate you will need to manipulate the DLM and DLL registers. Notice the 256*UnDLM in the equation. That is merely another way to write the following (DLM << 8). Shifting a number is akin to multiplying it by 2 to the power of the number of shifts. DLM and DLL are the lower and higher 8-bits of a 16 bit number that divides the UART baudrate clock. DivAddVal and MulVal are used to fine tune the BAUD rate, but for this class, you can simply get "close enough" and ignore these values. Take these into consideration when you need an extremely close baudrate.? Advanced Design If you used 9600bps, and sent 1000 characters, your processor would basically enter a "busy-wait" loop and spend 1040ms to send 1000 bytes of data. You can enhance this behavior by allowing your uart send function to enter data to a queue, and return immediately, and you can use the THRE or "Transmitter Holding Register Empty" interrupt indicator to remove your busy-wait loop while you wait for a character to be sent.

11 Queues RTOS Queues There are standard queues, or <vector> in C++, but RTOS queues should almost always be used in your application because they are thread-safe (no race conditions with multiple tasks), and they cooperate with your RTOS to schedule the tasks. For instance, your task could optionally sleep while receiving data if the queue is empty, or it can sleep while sending the data if the queue is full. Queues vs. Semaphore for "Signalling" Semaphores may be used to "signal" between two contexts (tasks or interrupts), but they do not contain any payload. For example, for an application that captures a keystroke inside of an interrupt, it could "signal" the data processing task to awake upon the semaphore, however, there is no payload associated with it to identify what keystroke was input. With an RTOS queue, the data processing task can wake upon a payload and process a particular keystroke. The data-gathering tasks can simply send the key-press detected to the queue, and the processing task can receive items from the queue, and perform the corresponding action. Moreover, if there are no items in the queue, the consumer task (the processing one) can sleep until data becomes available. You can see how this scheme lends itself well to having multiple ISRs queue up data for a task (or multiple tasks) to handle. Example Queue usage for Tasks After looking through the sample code below, you should then watch this video. Let's study an example of two tasks communicating to each other over a queue. QueueHandle_t q; void producer(void *p)

12 { int x = 0; while (1) { vtaskdelay(100); xqueuesend(q, &x, 0); // TODO: Find out the significance of the parameters of xqueuesend() ++x; void consumer(void *p) { while (1) { // We do not need vtaskdelay() because this task will sleep for up to 100ms until there is an item if (xqueuereceive(q, &x, 100)) { printf("got %i\n", x); else { puts("timeout --> No data received"); void main(void) { // Queue handle is not valid until you create it q = xqueuecreate(10, sizeof(int)); Example Queue usage with Interrupts // Queue API is special if you are inside an ISR void uart_rx_isr(void) { xqueuesendfromisr(q, &x, NULL); // TODO: Find out the significance of the parameters void queue_rx_task(void *p)

13 { int x; // Receive is the usual receive because we are not inside an ISR while (1) { xqueuereceive(q, &x, portmax_delay); Additional Information Queue Management (Amazon Docs) Queue API (FreeRTOS Docs)

14 Lab Assignment: UART Objective To learn how to communicate between two master devices using UART. Assignment This assignment will require a partner. The overall idea is to interface two boards using your UART driver. It may be best to test a single UART driver using loopback (tie your own RX and TX wires together) in order to ensure that your driver is functional before trying to put two boards together. Part 0: Get the simplest UART driver to function correctly First, individually, get the simplest UART driver to work. Here is the rough skeleton: // WARNING: Some of this is psuedocode, so you figure it out ;) void my_uart2_rx_intr(void) { // TODO: Queue your data and clear UART Rx interrupt void init_my_uart2(void) { // Init PINSEL, baud rate, frame size, etc. // Init UART Rx interrupt (TX interrupt is optional) isr_register(uart2, my_uart2_rx_intr); void my_task(void *p) { while (1) {

15 if (xqueuereceive(..., portmax_delay)) { printf("got %c char from my UART... job is half done!"); void main(void) { init_my_uart2(); create_task(my_task); HINT: You can test that your transmit and receive are working with only one SJOne board if you use a jumper to connect your UART TX and RX together. This is called a loopback test. Part 1: Design UART driver Using the following class template 1. Design a UART driver as you have the previous drivers. 2. Implement any functionality you deem useful for a general purpose UART driver. 3. Document/comment each method and variable within the class template.? #pragma once class LabUart { public: LabUart(); ~LabUart(); // TODO: Fill in methods for Initialize(), Transmit(), Receive() etc. // Optional: For the adventurous types, you may inherit from "CharDev" class // to get a lot of functionality for free private:;

16 Code Block 1. UART Driver Template Class Part 2: Serial Application For this application, one device will ask the other device to calculate the result of two numbers and an operation. Figure 1 Think about it like this, using figure 1 as a guide: 1. Device 1 sends a single digit '5', Device 2 receives single digit '5' 2. Device 1 sends another single digit '7', device 2 receives single digit '7' 3. Device 1 sends an operator '+', device 2 receives operator '+' and computes the result. 4. Device 2 sends result back to device 1. When the result is calculated, both the devices 7-segment displays should show that resultant. You MAY use the pre-written 7-segment display driver for this lab. Requirements? Design UART driver to work with both UART2 and UART3 UART receive should be interrupt driven When data arrives, store it to a FreeRTOS queue inside of the UART RX interrupt UART receive function should dequeue the data ALU application must be able to support the following operators + Addition

17 - Subtraction * Multiplication What to turn in: Submit all relevant files and files used (includes previous lab code used). Turn in any the screenshots of terminal output. Logic Analyzer Screenshots Waveform of device 1 UART TX sending a digits and operator to device 2. These can be in separate images if you can't fit everything in one image. Waveform of device 2 UART TX sending result back to device 1. Whole window screenshot with the Decoded Protocols (lower right hand side of window) clearly legible. Extra Credit Use the on-board buttons and 7-segment display as human interface devices (HID) so that the user can punch in which two numbers and the operation should perform and some way to send it. Be creative about this. If you are doing the extra credit, you may use the the button driver.?