Embedded Systems - FS 2018

Transcription

1 Institut für Technische Informatik und Kommunikationsnetze Prof. L. Thiele Embedded Systems - FS 2018 Lab 1 Date : LaunchPad Basic Bare-Metal Programming Goals of this Lab Get to know the MSP-EXP432P401R Learn how to use registers for configuration Get to know and use library functions Implement simple GPIO with peripherals Understand and implement polling Establish a simple UART communication Introduction In this lab session we get to know the development platform MSP-EXP432P401R LaunchPad and the Code Composer Studio (CCS), which are used throughout all ES labs. We will also familiarize ourself with concepts like direct register access, polling and serial communication. The following introduction should give a broad overview of the working environment, but it is not necessary to comprehend all the details to complete this laboratory. The Workspace - Structure and IDE. As a development environment the CCS is used. CCS can be started by typing ccstudio into a terminal. It allows easy integration of the LaunchPad, software, etc. Furthermore, it makes compiling of a whole project a one-click task by generating and executing the necessary makefiles, and features extensive debugging options. CCS Usage The code for the labs can be downloaded from the course website ethz.ch/education/lectures/es/ as zip-file. Figure 4 illustrates how to directly import an existing CCS project from a zip-file into your workspace. Figure 5, 6 and 7 illustrate the most important controls for running and debugging an application. If you are navigating a big project, the context menu allows you to easily find function or variables using the search features of CCS (see Figure 8). Alternatively, you can also use the combination Ctrl+Left Click onto a function or variable name to go to its definition. In addition, CCS includes a terminal (Figure 9, 10 and 11) and several consoles, which give extensive debug and error output. Please always carefully read compile warnings and error messages as they are designed to make development easier and help to identify errors or issues in the code. The features presented here are just a small fraction of the full functionality of the CCS. MSP432P401 The MSP432P401 is a low power mixed signal microprocessor featuring a 32-Bit ARM Cortex M4F CPU. It contains several different memories (flash main memory, information memory, SRAM and ROM) and has the Texas Instruments (TI) MSP432P401 peripherals driver libraries installed. Furthermore, it offers flexible clocking (tune-able clock sources), several timing units (timers, capture and 1

2 compare, Pulse Width Modulation (PWM),...) and serial communication interfaces (Universal Asynchronous Receiver Transmitter (UART), I2C, Serial Peripheral Bus (SPI),...). The MSP432P401 also includes an Analogue to Digital Converter (ADC) unit, analogue comparators and various Input/Output (I/O) pins. MSP-EXP432P401R LaunchPad Development Kit The MSP-EXP432P401R LaunchPad Development Kit is an evaluation module based on the TI MSP432P401 microprocessor. It features simple peripherals (buttons, LEDs, etc.) and the XDS110-ET debug probe. The XDS110-ET debug probe allows direct programming of the target device (in our case the MSP432P401) without the use of an external Figure 1: A basic overview of the MSP-EXP432P401R LaunchPad Development Board (left) and connected to a laptop via USB (right). Figure 2: Block diagrams of the MSP-EXP432P401R LaunchPad Development Board. A general block diagram (left) and one highlighting the XDS110-ET isolation block (right). 2

3 programming device and also gives the opportunity to debug an application and direct communication with the PC. The block diagrams in Figure 2 illustrate the basic structure of the MSP-EXP432P401R. All debug and communication signals run through the XDS110-ET debug probe, therefore there is never a direct connection between the target and the computer. A direct connection between the computer and the MSP432P401 is only possible using an external setup. Furthermore, for high precision tests, it is possible to isolate the target through the J101 Isolation block (jumpers). Embedded System Documentation The most important documents of an embedded system are, among others, Datasheets, Users Guides, Technical Reference Manuals, Application Notes, Erratas or Schematics. These documents are available for... the microprocessor at the manufacturers website, e. g. TI ( components of the microprocessor, e. g. Arm microprocessors IP 1 documentation, hardware boards, e. g. the TI MSP-EXP432P401R LaunchPad, extension peripherals, e. g. the TI BoostXL Sensors booster pack, and its components, for example sensors like the Bosch BMM150 Geomagnetic Sensor, as well as software, e. g. the TI MSP432P401 Peripheral Driver Library, or complementary information in wikis or online fora Therefore, every embedded system comes with a large number of documentation files. For this lab, all the necessary files are provided on the course website lectures/es/ as zip-file. The documentation is needed to determine the pins peripherals are connected to, register addresses and memory mapped peripherals, configuration values for modules, bit masks and their meaning, functionality of modules (e. g. serial communication modules,...) Therefore, often it is essential to have access to all parts of the documentation to be able to use the functionality of an embedded system to its fullest extent.... Bare-Metal Programming Programming bare-metal means to program an embedded system without the use of an underlying Operating System (OS) like Linux, FreeRTOS or similar. Watchdog Timer The watchdog timer is an internal timer unit of an embedded system that will reset the system if it times out. Under normal operation, the system will reset the watchdog timer regularly to prevent it from timing out, but in case of an error, the watchdog timer will reset the device. This is used to prevent a deployed embedded system which cannot be accessed easily (e.g. Mars Rover) from being stuck if an error occurs. In laboratory exercises, the watchdog timer is disabled as the embedded system is easily accessible. Defines, Macros and in-line Functions Preprocessor directives like defines and macros, as well as inline functions, are often used when programming embedded systems to make the code more readable and easier to maintain. Examples for a define, macro and in-line function are given in Snippet 1 and 2. The #define directive, used for defines and macros, is a preprocessor directve that instructs the compiler to replace certain code parts as defined. In contrast to that, the in-line function is just a request to the 1 IP is (in this case) short for Intellectual Property and refers to a ready to use component of a System-on-Chip (SoC), for example a microprocessor, that is provided by a third party vendor (e.g. Arm) and can be integrated by chip manufacturers (e.g. TI). 3

4 compiler. This means, depending on the optimization configuration of the compiler, function calls to inline functions can be replaced with the function body or are treated like normal function calls. However, in contrast to macros, in-line functions are subject to strict parameter checking and are therefore considered to be safer. 0 # define GPIO_PIN0 (0 x0001 ) Snippet 1: Example for a define. 1 inline void lab1_configureuart ( 2 const eusci_uart_config * config 3 ) 4 { 5 // Selecting P1.2 and P1.3 in UART 6 // mode 7 GPIO_setAsPeripheralModuleFunctionOutputPin 8 ( 9 GPIO_PORT_P1, 10 GPIO_PIN2 GPIO_PIN3, 11 GPIO_PRIMARY_MODULE_FUNCTION 12 ); 13 // Configuring UART Module 14 UART_initModule ( UART_INTERFACE, config ); 15 // Enable UART module 16 UART_enableModule ( UART_INTERFACE ); 17 } 1 # define MACRO_lab1_configureUART ( \ 2 config \ 3 ) \ 4 { \ 5 /* Selecting P1.2 and P1.3 in UART */ \ 6 /* mode */ \ 7 GPIO_setAsPeripheralModuleFunctionOutputPin \ 8 ( \ 9 GPIO_PORT_P1, \ 10 GPIO_PIN2 GPIO_PIN3, \ 11 GPIO_PRIMARY_MODULE_FUNCTION \ 12 ); \ 13 /* Configuring UART Module */ \ 14 UART_initModule ( EUSCI_A0_BASE, config ); \ 15 /* Enable UART module \ 16 UART_enableModule ( EUSCI_A0_BASE ); */ \ 17 } Snippet 2: Examples for an in-line function (left) and a macro (right). Clicker Questions 1. To which General Purpose Input Output (GPIO) Port are the LED1 and LED2 connected? (Hint: Check the Schematic Pages 1 and 2) (a) Port 1 & Port 3 (b) Port 2 & Port 4 (c) Port 1 & Port 2 (d) Port 3 & Port 4 2. Using C, which of the following operation allows toggling of the LSB of an 8-bit integer X? (a) X ˆ 0x01 (b) X & 0x01 (c) X 0x01 (d) X && 0x01 3. What is the declaration of the function I2C_initSlave()? (Hint: DriverLib Users Guide Section ) (a) I2C_initSlave( uint16_t moduleinstance, uint_16_t slaveaddress, uint_8_t slaveaddressoffset, uint32_t slaveownaddressenable ) (b) void I2C_initSlave( uint32_t slaveownaddressenable, uint_fast16_t slaveaddress, uint_fast8_t slaveaddressoffset, uint32_t moduleinstance ) 4

5 (c) void I2C_initSlave( uint_fast16_t slaveaddress, uint_fast8_t slaveaddressoffset, uint_fast32_t moduleinstance, uint_fast32_t slaveownaddressenable ) (d) void I2C_initSlave( uint32_t moduleinstance, uint_fast16_t slaveaddress, uint_fast8_t slaveaddressoffset, uint32_t slaveownaddressenable ) 4. What is the UART module baud rate divider (BRDIV) for a baud rate of 4800 at low frequency baud rate generation, using the default setting of SMCLK as Clock Source? (Hint: LaunchPad Users Guide Section 2, Mode_Selection) (a) 312 (b) 625 (c) 39 (d) Which of the following statements is not zero, when for the pins 5 or 7 of Port 2 the primary or tertiary module function is enabled? (Hint: Datasheet Table 6-1 & Technical Reference Manual Chapter 10 on PxSEL0 and PxSEL1) (a) HWREG8(0x40004C00 + 0x0C) & 0x75 (b) HWREG8(0x x2B) & 0xA0 (c) HWREG8(0x40004C00 + 0x0B) & 0xA0 (d) HWREG8(0x x4A) & 0x75 Task 1: Flashing, Library Usage and Simple I/O Using the CCS we can easily establish the connection to a MSP-EXP432P401R connected via USB and program it. In this task you will learn how to flash a functioning application using GPIO functions onto the chip. Furthermore, you will learn how to alter and extend the application using library functions. Recap 1: General Purpose Input Output (GPIO) The GPIO pins can be configured either as input or output. GPIO pins can be used to drive peripherals (i.e. LEDs, small actuators, switches) or read inputs (i.e. sensors, buttons). Task 1.1: Flashing an Application Download lab1.zip from the course website. Open the CCS and import lab1.zip to your workspace (see Figure 4). Connect the LaunchPad to the computer. Build and flash the application using the Debug button. Any warnings can be ignored at this point as they are only relevant in Task 3. Note that the CCS is changing to the debug view. Start the execution and observe the functionality of the program. What is the purpose of the application? 5

6 Task 1.2: Using Library Functions instead of Hard-Coded Register Access In this task we want to use library functions instead of any hard-coded register access. Please follow the instructions below: 1 # define REGBASEADR (( uint32_t )(0 x40004c00 )) // Base addr. of Port 1 configuration register 2 # define REGOFS_SEL0 (( uint32_t )(0 x a )) // Addr. Offset for Select0 - Register in Port 1 3 # define REGOFS_SEL1 (( uint32_t )(0 x c )) // Select1 offset in Port 1 conf. reg. 4 # define REGOFS_DIR (( uint32_t )(0 x )) // Direction offset in Port 1 conf. reg. 5 # define REGOFS_OUTV (( uint32_t )(0 x )) // Output Value offset in Port 1 conf. reg. Snippet 3: Defines used in Task 1.1 which cannot be used anymore in Task 1.2. Recap 2: Register Access When programming embedded systems it is possible to directly access special registers to allow low level hardware configurations. This can either be done through macros using addresses (see Snippet 4) or predefined structs (see Snippet 5). In many cases, manufacturers provide so called Hardware Abstraction Layer (HAL) or drivers to make register access easier when doing bare-metal programming or using an OS. Create a file called task_1_2.c and copy the code from task_1_1.c to task_1_2.c. Change the function name in task_1_2.c from task_1_1() to task_1_2(). Change the function call in main() to call task_1_2(). A declaration of the function is already provided in lab1.h. Add the include for the ESLab1driverLib (#include "ESLab1driverLib/driverlib.h") in task_1_2.c. Open the gpio.h and gpio.c files in the ESLab1driverLib directory. In these files you can search for the corresponding library functions and defines to replace the direct register access commands (HWREG16()) in task_1_2.c with the right library function calls. The function task_1_2() has to have exactly the same functionality as task_1_1(), without using any of the defines used in Task 1.1 (see Snippet 3) or direct calls to the HWREGXX macros from task_1_1(). What is the advantage of using library functions and defines instead of direct register access? Task 1.3: Adding a blinking LED Now we want to use LED2, which is a RGB LED. This means, in contrast to LED1, the RGB LED has three inputs which can be activated separately to get red, green, blue or any mix of these three colours. Please follow the instructions below: Create a file called task_1_3.c and copy the code from task_1_2.c to task_1_3.c. Change the function name in task_1_3.c from task_1_2() to task_1_3(). Change the function call in main() to call task_1_3(). A declaration of the function is already provided in lab1.h. Identify the ports and pins, the RGB LED is connected to, in the LaunchPad schematics. Configure the pin connected to red of the RGB LED as output. Implement the blinking, such that the red of the RGB LED blinks alternating to LED1. 6

7 Figure 3: Schematic of a pull-up (left) and pull-down resistor. Task 2: GPIO Pins as Inputs with Polling GPIO pins can also be used for input. In this task, we want to configure multiple GPIO inputs to enable user interaction using the two buttons S1 and S2 on the MSP-EXP432P401R. In order to avoid a so Recap 3: Polling Continuously sampling a certain information (i. e. register or input) is called polling. This can be used to assess the status of a peripheral or internal status informations or simply read information. called floating pin, pull-up or pull-down resistors are used. A pin is called floating when there is no fixed voltage level connected to the pin, which can lead to unexpected behaviour if the pin is read. In Figure 3 the two concepts of pull-up and pull-down resistors are illustrated. A pull-up resistor will make sure the pin is on high voltage level when the button is not pressed (open circuit) and on low if the button is pressed (short circuit). The pull-down resistor works vice versa. Task 2.1: Identifying the GPIO Configuration Create a file called task_2_2.c and copy the code from task_1_3.c to task_2_2.c. Change the function name in task_2_2.c from task_1_3() to task_2_2(). Change the function call in main() to call task_2_2(). A declaration of the function is already provided in lab1.h. Check the LaunchPad schematics and identify the ports and pins the buttons S1 and S2 are connected to. Configure the pins connected to the buttons S1 and S2 as inputs. Consider whether to use Pull-Up, Pull-Down or no pulling resistor (Hint: Schematic). Task 2.2: Implement Button Polling Use polling inside the while-loop (placeholder 1) to read the button status. 7

8 If button S1 is pressed the green RGB LED has to be on and if S2 is pressed the blue RGB LED has to be on. The red LED1 and red RGB LED must still blink alternatingly. Can you observe any difference in terms of blinking frequency compared to task_1_3.c? What about the reaction time of the buttons S1 and S2? Task 2.3: When should we Poll? Create a file called task_2_3.c and copy the code from task_2_2.c to task_2_3.c. Change the function name in task_2_3.c from task_2_2() to task_2_3(). Change the function call in main() to call task_2_3(). A declaration of the function is already provided in lab1.h. Move the polling into the for-loop (placeholder 2). Rebuild, flash and start the program. Which changes in terms of blinking frequency and button reaction time can you observe now, compared to task_1_3.c and task_2_2.c? What are the upsides of the implementations in Task 2.2 and Task 2.3? Can you think of a way to implement polling sucht that there is no influence on the blinking frequency and the button reaction time is minimized? Task 3: Simple UART output (Optional) Recap 4: Universal Asynchronous Receiver Transmitter (UART) UART is an asynchronous serial communication protocol. The sender and the receiver have to agree on a transmission rate and packet format before any communication can happen. The data is transmitted in packets of 6 to 9 bits per packet. Additionally, a packet consist of a start bit, one or two stop bits and optionally parity bits (see Figure 12). Figure 13 shows the block diagram of the transmit part of one of the MSP432P401 peripheral modules capable of UART communication. It allows clock source selection, clock sub-sampling to generate the proper baud rate clock and output data buffers. As a final task we will use UART to send a message to the Computer whenever one of the buttons is pressed. Task 3.1: Calculating the UART Parameters Recap 5: UART Configuration Shorthand Notation The most common UART configuration is often given with its shorthand notation 8N1. It defines the packet structure as follows: (a) 8 Bits per Packet (b) No Parity bits (c) 1 Stop bit 8

9 HINT: The calculations done in this tasks are similar to the ones in the clicker question. However, the parameters are NOT the same. Create a file called task_3.c and copy the code from task_2_3.c to task_3.c. Change the function name in task_3.c from task_2_3() to task_3(). Change the function call in main() to call task_3(). A declaration of the function is already provided in lab1.h. Use the datasheet to identify whether eusci_a, eusci_b or either of the two module types could be used for the UART connection. (Hint: check the eusci modules in the MSP432P401 Reference Manual Chapters 22 to 24) Determine the default setting for the SMCLK as clock source (Hint: MSP-EXP432P401R User Manual Chapter 2). Get the SMCLK frequency from the LaunchPad User Guide and calculate the UART parameters for a baud rate of 4800 using Rate_Gen_Mode_Selection. Task 3.2: Implementing UART Output Insert the parameters determined in Task 3.1 into the prepared struct in lab1.h (lines 83 to 94) and set following configuration: 8N1 with LSB first. Insert the necessary commands to enable the UART output. You can use the provided lab1_configureuart() and uart_println inline functions from lab1.h to configure and use the UART interface. Start the program and open a terminal in CCS to observe the UART input (see Figure 9, 11 and 10). Can you think of a better method to register button presses instead of polling to save resources and avoid duplicated output messages? 9

10 Appendix Figure 4: How to import a CCS project into your workspace in the CCS using the Import Wizard (File Import). If the source code should be copied to the workspace, the corresponding check mark has to be set. Figure 5: The standard view of the CCS. The button to build and start debugging a project is marked with a blue circle. 10

11 Figure 6: The debug view of the CCS. Figure 7: Control buttons for debugging in the CCS Debug View. From left to right: Start/Continue Execution, Pause Execution, Terminate Execution, Step In, Step Over, Step Out. 0 /* ***************************************************************************** 1 * Definitions for 8/16/32 - bit wide memory access * 2 ***************************************************************************** */ 3 # define HWREG8 (x) (*(( volatile uint8_t *)(x))) 4 # define HWREG16 (x) (*(( volatile uint16_t *)(x))) 5 # define HWREG32 (x) (*(( volatile uint32_t *)(x))) 6 # define HWREG (x) ( HWREG16 (x)) 7 # define HWREG8_L (x) (*(( volatile uint8_t *) (( uint8_t *)&x))) 8 # define HWREG8_H (x) (*(( volatile uint8_t *) ((( uint8_t *)&x) +1) )) 9 # define HWREG16_L (x) (*(( volatile uint16_t *) (( uint16_t *)&x))) 10 # define HWREG16_H (x) (*(( volatile uint16_t *) ((( uint16_t *)&x) +1) )) Snippet 4: Examples for register access macros using addresses. 11

12 Figure 8: The context menu in CCS allows easy code browsing with searches (Declarations, References, Search Text) or other commands (i.e. Open Declaration). It opens by right-clicking a function or a variable. Alternatively, one can also use the sequence Ctrl+Left Click. Figure 9: To open the terminal view, go to View Terminal. Figure 10: The terminal view opens in the lower right corner where a new terminal view can be opened. Figure 11: The menu opened after pressing the new terminal button allows the configuration of the serial connection. 12

13 0 typedef struct { 1 IO uint16_t CTLW0 ; /*! < eusci_ax Control Word Register 0 */ 2 IO uint16_t CTLW1 ; /*! < eusci_ax Control Word Register 1 */ 3 uint16_t RESERVED0 ; 4 IO uint16_t BRW ; /*! < eusci_ax Baud Rate Control Word Register */ 5 IO uint16_t MCTLW ; /*! < eusci_ax Modulation Control Word Register */ 6 IO uint16_t STATW ; /*! < eusci_ax Status Register */ 7 I uint16_t RXBUF ; /*! < eusci_ax Receive Buffer Register */ 8 IO uint16_t TXBUF ; /*! < eusci_ax Transmit Buffer Register */ 9 IO uint16_t ABCTL ; /*! < eusci_ax Auto Baud Rate Control Register */ 10 IO uint16_t IRCTL ; /*! < eusci_ax IrDA Control Word Register */ 11 uint16_t RESERVED1 [3]; 12 IO uint16_t IE; /*! < eusci_ax Interrupt Enable Register */ 13 IO uint16_t IFG ; /*! < eusci_ax Interrupt Flag Register */ 14 I uint16_t IV; /*! < eusci_ax Interrupt Vector Register */ 15 } EUSCI_A_Type ; 0 return EUSCI_A_CMSIS ( moduleinstance ) -> RXBUF ; Snippet 5: Examples for an register access struct and its usage taken from the UART_receiveData() function. Figure 12: UART Packet Structure. Figure 13: Block diagram of the receive part of a UART module of MSP432P