13 touchscreen ch 004 ds0013 touch screen control of the leds

DS0013 - Touch Screen Control of the LEDs 1

Overview In this session we combine our experience of controlling the RGB LEDs with PWM and a microprocessor, as well as the ability to detect points on the touchscreen. We will control the color of the LEDs by picking a color from a color map displayed on the TFT panel. The final stage (optional) is to load your design in to the NB3000 Flash memory and add the ability to auto-boot your design on power up of the NB3000.

Prerequisites This tutorial assumes you have an elementary understanding of how to create a System-on-FPGA design in Altium Designer using OpenBus and Schematic Documents, how to configure and break-out peripherals and their connections, and how to create a linked embedded project with the Software Platform Builder. In addition, it builds on the work done in the previous tutorial Discovery Session 12. No additional information is required.

Design detail This exercise builds on the design done in Discovery Session 12, adding the following components:

Component Library Name in Library

OpenBus Palette LED controller

LED_R[7..0]LED_G[7..0]LED_B[7..0]

FPGA NB3000 Port Plug-In.IntLib LEDS_RGB

Table 1. List of components required to be added to the design

The design will have the TERMINAL instrument removed as it will no longer be needed.

Discovery Session 13 Touch Screen control of the LEDs


Tutorial steps – preparing the hardware 1. Copy all the files from Discovery Session 12 (Touch Screen Control) into a new folder.

2. Rename the project, OpenBus and Schematic Documents as TFT_LEDs.PrjFpg, TFT_LEDs_TOP.SchDoc, and TFT_LEDs_OB.OpenBus respectively. Also, be sure to rename the matching harness definition files TFT_TOUCH.Harness to TFT_LEDs_TOP.Harness and so on.

3. Upon opening the project, you will have to re-add the schematic and OpenBus documents to the project. You will also have to edit the Filename parameter of the OpenBus sheet symbol to point to the right file – compile the project and Save All.

Figure 1. OpenBus System for the TFT_LEDs project.

4. In your TFT_LEDs_OB.OpenBus document, replace the Terminal Instrument component with the LED Controller from the OpenBus Palette. Name it LEDS on the document. The OpenBus document should then look like Figure 1.

Figure 2. LED Controller Configuration.


5. Referring to Figure 2, configure the LED Controller for 8 LEDs with Bus Enable/Output and RGB boxes both checked, and Pins selected for Interface Type.

6. Open TFT_LEDs_TOP.SchDoc (your top-level schematic) again, and use Design»Synchronize Sheet Entries and Ports to add the three sheet entries for breaking out the RGB LED signals.

7. Add the LEDS_RGB port plug-in component from the FPGA NB3000 Port Plug-In library.

8. Complete TFT_LEDs_TOP.SchDoc to wire up the RGB LEDs, as shown in Figure 3.

Figure 3. Updated top-level schematic including LEDs and RGB controller.

9. In the attached Embedded Project (still named Embedded_TFT_Touch.PrjEmb), open the TFT_TOUCH.SWPlatform document. Delete the Serial Device I/O Context, Virtual Terminal Driver, and Terminal Wrapper from the stacks table.

10. Click Import from FPGA to bring in the wrapper for the LED Controller component, and grow the stack to include the LED Controller Driver – it should appear as shown in Figure 4.

Figure 4. Software Stack for Embedded_TFT_Touch.PrjEmb


11. Open the Embedded Project Options by right-clicking on the embedded project and choosing Project Options from the popup.

12. Drill-down to the Linker\Miscellaneous options, and add the switch --import-object="rgbcolors.bmp" to the Additional linker options section, as shown in Figure 5. This links a file named ‘rgbcolors.bmp’ to the overall project code after compilation so we can access the bitmap directly in our code and display it on the TFT panel.

Figure 5. Linker option to include color bitmap in HEX file.

13. Make sure that ‘rgbcolors.bmp’ is saved in your embedded project folder – otherwise the linker will fail as it won’t find it. This file is the 320 x 240 color palette we will be picking colors from for the LEDs – shown in Figure 6.

Figure 6. ‘rgbcolors.bmp’ - the palette picker we will display on the TFT.


14. As we used the previous tutorial project as the basis for this one, all we should have to do is now add new C code in ‘main.c’. Just to be on the safe side, check the Configure Memory tab as well to make sure it’s configured with the external SRAM split into 512KB of ROM area and 512KB of RAM area.

#include <stdint.h> #include <stdbool.h> #include <string.h> #include <graphics.h> #include <touchscreen.h> #include <pointer.h> #include <drv_led.h> #include "generic_devices.h" #include "devices.h" #include "led_info.h"

#define WIDTH 320 #define HEIGHT 240

char *cal1 = "Touch screen at marker"; graphics_t * display; canvas_t * canvas; touchscreen_t * tft_touch; touchscreen_data_t * position; touchscreen_callback_t callback; pointer_t * ptr; pointer_state_t * pointer_state; led_t * leds; extern __no_sdata graphics_bitmap_t _lc_ub_rgbcolors_bmp; // linker name for beginning of bitmap block extern __no_sdata graphics_bitmap_t _lc_ue_rgbcolors_bmp; graphics_bitmap_t * bmp = &_lc_ub_rgbcolors_bmp; void update_leds (const uint32_t * col_buff); void set_all_leds (uint32_t value); static void draw_mark(int x, int y, int width, int height, void *vp); void main (void) {

// Connect to our drivers for the TFT, touch sensor.

tft_touch = touchscreen_open(TOUCHSCREEN_1); ptr = pointer_open(POINTER_1); display = graphics_open(GRAPHICS_1); canvas = graphics_get_visible_canvas(display); leds = led_open(DRV_LED_1);

// Clear screen

graphics_fill_canvas(canvas, BLACK); graphics_set_visible_canvas(display, canvas);

// Update display and turn off LEDs

while(!graphics_visible_canvas_is_set(display)); led_turn_all_off(leds);

// Set up and calibrate touch screen.

touchscreen_set_callback(tft_touch, draw_mark, canvas); while(!touchscreen_calibrate(tft_touch, 320, 240)) { set_all_leds(0xFF0000); // If Touchscreen can't calibrate RED ALERT! } led_turn_all_off(leds);

// Put colormap on TFT

graphics_draw_bitmap(canvas, bmp, 0, 0, 320, 240, 0); graphics_set_visible_canvas(display, canvas);


// Start picking colors!

while(1) { if (pointer_update(ptr, pointer_state)) { set_all_leds(graphics_get_pixel(canvas, pointer_state->x, pointer_state->y)); } } } void set_all_leds (uint32_t value) { for(int i = 0; i < LEDS_NUM_LED_IDS; ) { led_set_intensity(leds, i++, (uint8_t)(value>>16)); // Red led_set_intensity(leds, i++, (uint8_t)(value>>8)); // Green led_set_intensity(leds, i++, (uint8_t)value); // Blue } } static void draw_mark(int x, int y, int width, int height, void *vp) { graphics_draw_circle(canvas, x, y, 10, 0xff00ff); graphics_draw_line(canvas, x - 15, y, x + 15, y, 0x00ffff); graphics_draw_line(canvas, x, y - 15, x, y + 15, 0x00ffff); graphics_draw_string(canvas, 50, 110, cal1, NULL, 0xffffff, 0); graphics_set_visible_canvas(display, canvas); }

Table 2. Code listing for TFT_LEDs

15. Replace the C code in ‘main.c’ from Discovery Session 12 with the code listed in Table 2 – save your work.

16. Flip to Devices View, and rebuild and download your updated design. You will be prompted to calibrate the TFT touch panel first, and then you can pick a color for the LEDs from the palette on the TFT panel.

Something more for you to try • Extend the design to allow control of each individual LED, using the alternative palette bitmap ‘palette.bmp’

as shown in Figure 7.

• Make it such that you can touch an LED number on the display to select that LED, and then pick a color for the LED in the palette. This file is located in the tutorial folder also.

Figure 7. The ‘palette.bmp’ file for extending project capability.


Optional: configuring your design for auto-boot This optional add-on exercise builds on the design work done above, adding the following components:

Component Library Name in Library

OpenBus Palette SPI Bootloader

SPI_DOUTSPI_DIN

SPI_SELSPI_MODE

SPI_CLK

SPI

FPGA NB3000 Port Plug-In.IntLib SPI Bus

Table 3 List of components required to be added to the design.

Figure 8. OpenBus System for the TFT_LEDs project with SPI Bootloader added.


Tutorial steps – preparing the hardware 17. Open your TFT_LEDs_OB.OpenBus document, and add the SPI Bootloader component (refer to Table 3)

from the OpenBus Palette.

18. Add an extra port to the WB_MULTIMASTER (Arbiter) component, and link in the SPI Bootloader as shown in Figure 8.

19. Referring to Figure 9, configure the SPI Bootloader component to load 512KB from SPI FLASH start address zero, to destination address 0x0100_0000 in the RAM – we are setting it up this way because the XRAM code memory region we defined in our embedded project starts at this address. Code that executed from RAM that previously had to be downloaded using Up to Date Download, will now be loaded on startup by this IP core from the NB3000’s SPI FLASH chip.

20. Click the Manage Signals button to open the OpenBus Signal Manager shown in Figure 10. Click in the Net to connect to field beside the TSK3000A(TSK3000A_1) component entry, and type in the net name for the reset line for the CPU – we will call this CPU_RST. Likewise, re-name the reset nets for the Arbiter(WB_MULTIMASTER_1) and the SRAM Controller(XRAM) to MM_RST – this gives the memory and memory access component (the Arbiter) their own reset signal. The CPU_RST signal can be used by the bootloader to give it exclusive access to the memory on start-up. Click OK to accept the changes, and save your work.

21. Open the TFT_LEDs_TOP.SchDoc schematic and use Design»Synchronize Sheet Entries and Ports to update the U_TFT_LEDs_OB sheet symbol shown in Figure 3. Note that you will remove the RST_I sheet entry and add the WB_BOOTLOADER_V2_1, CPU_RST and MM_RST sheet entries.

Figure 9. SPI Bootloader Config.

Figure 10. OpenBus Resets


22. Place the SPI Bus port plug-in component on the sheet, as well as the necessary pre-defined WB_BOOTLOADER harness connector (found in Place»Harness»Pre-defined Harness Connector).

23. Wire up the new connections as shown in Figure 11, paying particular attention to the order of the harness entries, and the reset signals. The SPI Bootloader component uses the CPU_HOLD signal to hold the CPU and other components in a RESET state while it uploads the content of the SPI FLASH into XRAM. If these signals aren’t wired correctly, the circuit will not boot.

Figure 11. Updated top-level schematic (lower section only shown).

24. Save your changes to the schematic then switch Devices View to build and download the updated hardware design to the NB3000 – you should note that so far it does not operate any differently than before. The next step is to use the NB3000 Instrument to download our FPGA bit file and embedded code HEX files to the FLASH boot ROMs on the NB3000.


Tutorial Steps – Downloading the boot images to FLASH 25. Right-click on the NB3000 icon in Devices View, and choose Instrument from the popup menu. The NB3000

Nanoboard Controller will be shown as in Figure 12. Note that the FPGA Boot FLASH and Embedded FLASH controls are highlighted with the red rounded square.

Figure 12. Nanoboard Controller (FLASH control buttons highlighted).

26. Click the FPGA Boot button to bring up the Flash RAM Controller For FPGA Boot dialog. At the right of the dialog’s File Name field, click the ellipsis to browse for the FPGA bit file we will use. The file needed (assuming previously used names were kept) will be under your \Project folder path as \Project Outputs\NB3000XN_04\tft_leds_cclk.bit – this is the bit file used to program the FPGA itself. This dialog should now look like Figure 13. Do not click OK yet!

Figure 13. Flash RAM Controller dialog.

27. Next, click the Program to Flash button to download the bit file selected. It could take a minute or two (or more) depending on your system. The status of the download is shown in the lower left border of Altium Designer’s main window. Click OK once the download is complete to close the notification message, and again to close the Flash controller dialog.

28. Now we need to do the same with our embedded code, to allow the SPI bootloader to copy it from startup from the FLASH to the XRAM memory. Click the Embedded button on the FLASH RAM control section. You will see the same dialog open, but this time we will be browsing for the embedded program HEX file. The HEX file needed will be in the path \Embedded\Output\embedded_tft_leds_system_ROM_XMEM.hex. Once you have selected this file for download, click the Save File to Flash button as done before, then OK and OK again.


29. Referring to Figure 14, click the Settings button on the Nanoboard Controllers instrument. You will see the Firmware Options dialog appear (see Figure 15). Set the Auto-boot option to use Serial Flash, and click OK.

30. We are now ready to perform a hard reboot of the NB3000. Power off the NB3000 with the power switch at the rear right, wait a second or two, and then power it up again. You will notice a delay while the FPGA bit file is loaded into the FPGA, then the SPI Bootloader – part of the FPGA design itself – loads the code from the FLASH to XRAM, and releases the CPU from reset to allow the design to run. Try timing this entire process from the flick of the power switch – approximately how long does it take to boot?

Figure 14. Getting to the NB3000 Boot Options.

Figure 15. NB3000 Firmware Options.


Revision History

Date Revision No. Changes

29-Jul-2009 1.0 New document release

Software, hardware, documentation and related materials:

Copyright © 2009 Altium Limited.

All rights reserved. You are permitted to print this document provided that (1) the use of such is for personal use only and will not be copied or posted on any network computer or broadcast in any media, and (2) no modifications of the document is made. Unauthorized duplication, in whole or part, of this document by any means, mechanical or electronic, including translation into another language, except for brief excerpts in published reviews, is prohibited without the express written permission of Altium Limited. Unauthorized duplication of this work may also be prohibited by local statute. Violators may be subject to both criminal and civil penalties, including fines and/or imprisonment. Altium, Altium Designer, Board Insight, Design Explorer, DXP, LiveDesign, NanoBoard, NanoTalk, P-CAD, SimCode, Situs, TASKING, and Topological Autorouting and their respective logos are trademarks or registered trademarks of Altium Limited or its subsidiaries. All other registered or unregistered trademarks referenced herein are the property of their respective owners and no trademark rights to the same are claimed.

13 touchscreen ch 004 ds0013 touch screen control of the leds

Documents

rgb leds

leds project

intlib leds

open tft

openbus documents

tft panel

complete tft

rgb controller