Multi-UART Module Usage Manual

Transcription

1 Multi-UART Module Usage Manual Publication Date: 2012/10/15 XMOS 2012, All Rights Reserved.

2 Multi-UART Module Usage Manual 2/31 Table of Contents 1 Overview Features Slicekit Compatibility (XA-SK-UART8) Resource Requirements Ports Logical Cores Memory Channel Usage Client Timing Requirements Evaluation Platforms Recommended Hardware XA-SK-UART8 Slice Card Demonstration Application Module Description Cores Buffering Communication Model Clocking Multi-UART Common API Enum Definitions Combined RX & TX Server Launch Functions Multi-UART Transmit API Configuration Defines Data Structures Configuration Functions Transmission Functions Multi-UART TX Server Multi-UART Receive API Configuration Defines Data Structures Configuration Functions Data Validation Functions Data Fetch Functions Multi-UART RX Server Multi-UART Helper API 19 9 Programming Guide Structure Source Code Configuration of Multi-UART component Static configuration of UART TX Static configuration of UART RX

3 Multi-UART Module Usage Manual 3/ Initialisation Interfacing to the TX Server Interfacing to the RX Server Reconfiguration of RX & TX Server Example Applications app_sk_muart_com_demo Application Required Software Tools Build options Hardware Settings Application Description Quick Start Guide Interacting with the Application Makefiles Using Command Line Tools

4 1 Overview IN THIS CHAPTER Features Slicekit Compatibility (XA-SK-UART8) This module provides a software library that allows multiple uarts to share 8 bit ports for multiple channel UART communication. It is dynamically re-configurable for applications that require a level of flexibility during operation. 1.1 Features Multi-UART component provides the following functionality. All options are dynamically reconfigurable via the API. Function Operational Range Notes Baud Rate 150 to bps Dependent on clocking (see 4.4) Parity None, Mark, Space, Odd, Even Stop Bits 1,2 Data Length 1 to 30 bits Max 30 bits assumes 1 stop bit and no parity. 1.2 Slicekit Compatibility (XA-SK-UART8) This module is designed to work with the XA-SK-UART8 Slice Card which has the slot compatitbility shown above.

5 2 Resource Requirements IN THIS CHAPTER Ports Logical Cores Memory Channel Usage Client Timing Requirements This section provides an overview of the required resources of sc_multi_uart component so that the application designer can operate within these constraints accordingly. 2.1 Ports The following ports are required for each of the receive and transmit functions - Operation Port Type Number required Direction Port purpose / Notes Transmit 8 bit port 1 Output Data transmission Transmit 1 bit port 1 Input Optional External clocking (see 4.4) Receive 8 bit port 1 Input Data Receive 2.2 Logical Cores Operation Logical Core Count Notes Receive 1 Single logical core server, may require application defined buffering logical core - requires 62.5MIPS per logical core Transmit 1 Single logical core server - requires 62.5MIPS per logical core 2.3 Memory The following is a summary of memory usage of the component for all functionality utilised by the echo test application when compiled at optimisation level 3. It assumes a TX buffer of 16 slots and operating at the maximum of 8 UART channels.

6 Multi-UART Module Usage Manual 6/31 This is deemed to be a guide only and memory usage may differ according how much of the API is utilised. Stack usage is estimated at 460 bytes. Operation Code (bytes) Data (bytes) Total Usage (bytes) Receive Logical Core Receive API Transmit Logical Core Transmit API Total Channel Usage Operation Receive Transmit Channel Usage & Type 1 x Streaming Chanend 1 x Streaming Chanend 2.5 Client Timing Requirements The application that interfaces to the receive side of UART component must meet the following timing requirement. This requirement is dependent on configuration so the worst case configuration must be accounted for - this means the shortest UART word (length of the start, data parity and stop bits combined). 1 ( UART _CHAN_COUNT MAX_BAUD MIN_BIT _COUNT ) Taking an example where the following values are applied - UART_CHAN_COUNT = 8 MAX_BAUD = bps MIN_BIT_COUNT = 10 (i.e 1 Start Bit, 8 data bits and 1 stop bit) The resultant timing requirement is µs. This would be defined and constrained using the XTA tool.

7 3 Evaluation Platforms IN THIS CHAPTER Recommended Hardware XA-SK-UART8 Slice Card Demonstration Application 3.1 Recommended Hardware This module may be evaluated using the Slicekit Modular Development Platform, available from digikey. Required board SKUs are: XP-SKC-L2 (Slicekit L2 Core Board) plus XA-SK-UART8 plus XA-SK-ATAG2 (Slicekit XTAG adaptor) plus XTAG2 (debug adaptor), OR 3.2 XA-SK-UART8 Slice Card 3.3 Demonstration Application Example usage of this module can be found within the XSoftIP suite as follows: Package: sc_multi_uart Application: app_sk_muart_com_demo

8 4 Module Description IN THIS CHAPTER Cores Buffering Communication Model Clocking The Multi-UART module consists of Transmit and Receive servers. These can be employed independently or together based on the application needs. 4.1 Cores The multi-uart component comprises two logical cores, one acting as a transmit (TX) server for up to 8 uarts, and the other acting as a receive (RX) server for up to 8 uarts. 4.2 Buffering Buffering for the TX server is handled within the UART TX logical core. The buffer is configurable allowing the number of buffer slots that are available to be configured, subject only to available memory. Data is transferred to the UART TX logical core via a shared memory interface and therefore any client logical core must be on the same tile as the UART logical core. There is no buffering provided by the RX server. The application must provide a logical core that is able to respond to received characters in real time and handle any buffering requirements for the application that is being developed. 4.3 Communication Model The module utilises a combination of shared memory and channel communication. Channel communication is used on both the RX and TX servers to pause the logical core and subsequently release the logical core when required for reconfiguration. The primary means of data transfer for both the RX and TX logical cores is shared memory. The RX logical core utilises a channel to notify any client of available data - this means that events can be utilised within an application to avoid the requirement for polling for received data.

9 Multi-UART Module Usage Manual 9/ Clocking The module can be configured to either use an external clock source or an internal clock source. External clock source only applies to the TX portion of the component (see 9.2.1). The advantage of using an external clock source is that an exact baud rate can be achieved by dividing down a master clock such as MHz. This is a typical method that standard RS232 devices will use. Using internal clocking is possible, but for TX the implementation currently limits the application to configuring baud rates that divide exactly into the internal clock. So if the system reference runs at 100MHz the maximum baud rate is 100kbaud. The RX implementation uses the internal clock under all circumstances. Clock drift is handled by the implementation utilising oversampling to ensure that the bit is sampled as close to the centre of the bit time as possible. This minimises error due to the small drift that is encountered. The syncronisation of the sampling is also reset on every start bit so drift is minimised in a stream of data. It should be noted that if extremely long data lengths are used the drift encountered may become large as the fractional error will accumulate over the length of the UART word. By taking the fractional error (say for an internal clock of 100MHz and a baud rate of bps we have a fractional error of 0.055) and multiplying it by the number of bits in a UART word (for 8 data bits, 1 parity and one stop bit we have a word length of 11 bits). Thus for the described configuration a drift of 0.61 clock ticks is encountered. This equates to 0.07%.

10 5 Multi-UART Common API IN THIS CHAPTER Enum Definitions Combined RX & TX Server Launch Functions The following describes the shared API between the UART RX Server and UART TX Server code. 5.1 Enum Definitions ENUM_UART_CONFIG_PARITY Define the parity configuration. This type has the following values: odd even mark space none Odd parity. Even parity. Mark (always 1) parity bit. Space (always 0) parity bit. No parity bit. ENUM_UART_CONFIG_STOP_BITS Configure the number of stop bits. This type has the following values: sb_1 sb_2 Single stop bit. Two stop bits. ENUM_UART_CONFIG_POLARITY Start bit polarity configuration (currently unused). This type has the following values: start_1 Start bit is a 1, implies stop bit/idle is a 0. start_0 Start bit is a 0, implies stop bit/idle is a 1.

11 Multi-UART Module Usage Manual 11/ Combined RX & TX Server Launch Functions void run_multi_uart_rxtx_int_clk(streaming chanend ctxuart, s_multi_uart_tx_ports &uart_tx_ports, streaming chanend crxuart, s_multi_uart_rx_ports &uart_rx_ports, clock uart_clock_rx, clock uart_clock_tx) Configure and run the Multi-UART TX & RX server threads using internal clocks for TX & RX. ctxuart TX Server Channel uart_tx_ports TX Ports structure crxuart RX Server Channel uart_rx_ports RX Ports structure uart_clock_rx Clock block to run the RX port from uart_clock_tx Clock block to run the TX port from void run_multi_uart_rxtx(streaming chanend ctxuart, s_multi_uart_tx_ports &uart_tx_ports, streaming chanend crxuart, s_multi_uart_rx_ports &uart_rx_ports, clock uart_clock_rx, in port uart_ext_clk_pin, clock uart_clock_tx) Configure and run the Multi-UART TX & RX server threads using an external clock for TX. ctxuart TX Server Channel uart_tx_ports TX Ports structure (reference parameter) crxuart RX Server Channel uart_rx_ports RX Ports structure (reference parameter)

12 Multi-UART Module Usage Manual 12/31 uart_clock_rx Clock block to run the RX port from uart_ext_clk_pin External clock reference input pin uart_clock_tx Clock block to run the TX port from

13 6 Multi-UART Transmit API IN THIS CHAPTER Configuration Defines Data Structures Configuration Functions Transmission Functions Multi-UART TX Server The following describes the public API for use in applications and the API s usage. 6.1 Configuration Defines The file multi_uart_tx_conf.h must be provided in the application source code. This file should comprise of the following defines: UART_TX_USE_EXTERNAL_CLOCK Define whether to use an external clock reference for transmit - do not define this if using the internal clocking UART_TX_CHAN_COUNT Define the number of channels that are to be supported, must fit in the port. Also, must be a power of 2 (i.e. 1,2,4,8) - not all channels have to be utilised UART_TX_CLOCK_RATE_HZ This defines the master clock rate - if using an external clock then set this appropriately (e.g for a MHz external clock) UART_TX_MAX_BAUD Define the maximum application baud rate - this implementation is validated to baud UART_TX_CLOCK_DIVIDER This should be defined as (UART_TX_CLOCK_RATE_HZ/UART_TX_MAX_BAUD_RATE). But some use cases may require a custom divide. UART_TX_OVERSAMPLE Define the oversampling of the clock - this is where the UART_TX_CLOCK_DIVIDER is > 255 (otherwise set to 1) - only used when using an internal clock reference

14 Multi-UART Module Usage Manual 14/31 UART_TX_BUF_SIZE Define the buffer size in UART word entries - needs to be a power of 2 (i.e. 1,2,4,8,16,32) UART_TX_IFB Define the number of interframe bits 6.2 Data Structures STRUCT_MULTI_UART_TX_PORTS Structure used to hold ports - used to enable extensibility in the future. This structure has the following members: buffered out port STRUCT_MULTI_UART_TX_CHANNEL Structure to hold configuration information and data for the UART channel TX side - this should only be interacted with via the API and not accessed directly. 6.3 Configuration Functions int uart_tx_initialise_channel(int channel_id, e_uart_config_parity parity, e_uart_config_stop_bits stop_bits, e_uart_config_polarity polarity, int baud, int char_len) Configure the UART channel. channel_id parity stop_bits polarity baud Channel Identifier Parity configuration Stop bit configuration Start/Stop bit polarity setting Required baud rate char_len Length of a character in bits (e.g. 8 bits) This function returns: Return 0 on success

15 Multi-UART Module Usage Manual 15/31 void uart_tx_reconf_pause(streaming chanend cuart, timer t) Pause the Multi-UART TX task for reconfiguration. cuart chanend to UART TX thread t timer for running buffer clearance pause void uart_tx_reconf_enable(streaming chanend cuart) Release the UART into normal operation - must be called after uart_tx_reconf_pause. cuart channel end to TX UART 6.4 Transmission Functions unsigned int uart_tx_assemble_word(int channel_id, unsigned int uart_char) Assemble full word for transmission. channel_id Channel identifier uart_char This function returns: The character being sent Full UART word in the format (msb -> lsb) STOP PARITY DATA START int uart_tx_put_char(int channel_id, unsigned int uart_char) Assemble UART word from UART Character and insert into the appropriate UART buffer. channel_id Channel identifier uart_char Character to be sent over UART This function returns: 0 for OK, -1 for buffer full 6.5 Multi-UART TX Server void run_multi_uart_tx(streaming chanend cuart, s_multi_uart_tx_ports &tx_ports, clock uart_clock) Multi UART Transmit function.

16 7 Multi-UART Receive API IN THIS CHAPTER Configuration Defines Data Structures Configuration Functions Data Validation Functions Data Fetch Functions Multi-UART RX Server The following describes the public API for use in applications and the API s usage. 7.1 Configuration Defines The file multi_uart_rx_conf.h must be provided in the application source code. This file should comprise of the following defines: UART_RX_CHAN_COUNT Define the number of channels that are to be supported, must fit in the port. Also, must be a power of 2 (i.e. 1,2,4,8) - not all channels have to be utilised UART_RX_CLOCK_RATE_HZ This defines the master clock rate - in this implementation this is the system clock in Hertz. This should be UART_RX_MAX_BAUD Define the maximum application baud rate - this implementation is validated to baud UART_RX_CLOCK_DIVIDER This should be defined as (UART_RX_CLOCK_RATE_HZ/UART_RX_MAX_BAUD). But some use cases may require a custom divide. UART_RX_OVERSAMPLE Define receive oversample for maximum baud rate. This should be left at Data Structures STRUCT_MULTI_UART_RX_PORTS

17 Multi-UART Module Usage Manual 17/31 Structure used to hold ports - used to enable extensibility in the future. This structure has the following members: buffered in port STRUCT_MULTI_UART_RX_CHANNEL Structure to hold configuration information and data for the UART channel RX side - this should only be interacted with via the API and not accessed directly. This structure has the following members: int uart_char_len length of the UART character int uart_word_len number of bits in UART word e.g. Start bit + 8 bit data + parity + 2 stop bits is a 12 bit UART word int clocks_per_bit define baud rate in relation to max baud rate int invert_output define if output is inverted (set to 1) int use_sample sample in bit stream to use e_uart_config_stop_bits sb_mode Stop bit configuration. e_uart_config_parity parity_mode Parity mode configuration. e_uart_config_polarity polarity_mode Polarity mode of start/stop bits. 7.3 Configuration Functions int uart_rx_initialise_channel(int channel_id, e_uart_config_parity parity, e_uart_config_stop_bits stop_bits, e_uart_config_polarity polarity, int baud, int char_len) Configure the UART channel.

18 Multi-UART Module Usage Manual 18/31 channel_id parity stop_bits polarity baud Channel Identifier Parity configuration Stop bit configuration Polarity configuration of start/stop bits Required baud rate char_len This function returns: Return 0 on success Length of a character in bits (e.g. 8 bits) void uart_rx_reconf_pause(streaming chanend cuart) Pause the UART via channel for reconfiguration. cuart streaming channel end to RX server void uart_rx_reconf_enable(streaming chanend cuart) Release the UART into normal operation - must be called after uart_rx_reconf_pause. cuart channel end to RX UART 7.4 Data Validation Functions int uart_rx_validate_char(int chan_id, unsigned &uart_word) Validate received UART word according to channel configuration and provide a cleaned UART character. chan_id UART channel ID from which the char came from uart_word This function returns: UART char in the format DATA_BITS PARITY STOP BITS (parity optional according to config), modified to clean UART character on successful * return Return 0 on valid data, -1 on validation fail 7.5 Data Fetch Functions unsigned uart_rx_grab_char(unsigned chan_id)

19 Multi-UART Module Usage Manual 19/31 Get the received value from an RX slot. chan_id channel id to grab This function returns: value in slot 7.6 Multi-UART RX Server void run_multi_uart_rx(streaming chanend cuart, s_multi_uart_rx_ports &tx_ports, clock uart_clock) Multi-UART Receive Server. cuart tx_ports uart_clock channel interface for RX UART port structure clock block for UART

20 8 Multi-UART Helper API This API provides a number of functions that allow the access of architecture specific functionality within C where XC semantics are not available. unsigned get_time(timer t) Get time from timer. t timer This function returns: timestamp from timer unsigned wait_for(timer t, unsigned delta) Wait for a time period defined by delta. t timer to use delta time period to wait This function returns: timestamp on completion of pause unsigned wait_until(timer t, unsigned ts) Wait until a specific time stamp. t timer to use ts time stamp to wait until This function returns: timestamp on completion of pause void send_streaming_int(streaming_chanend c, int i) Send integer value across a streaming channel end. c chanend to use

21 Multi-UART Module Usage Manual 21/31 i integer to send unsigned get_streaming_uint(streaming_chanend c) Get unsigned integer from streaming chanend. c chanend to use This function returns: value received over the channel char get_streaming_token(streaming_chanend c) Get token from streaming chanend. c chanend to use This function returns: token received over channel

22 9 Programming Guide IN THIS CHAPTER Structure Configuration of Multi-UART component Initialisation Interfacing to the TX Server Interfacing to the RX Server Reconfiguration of RX & TX Server This section discusses the programming aspects of the Multi-UART component and typical implementation and usage of the API. 9.1 Structure This is an overview of the key header files that are required, as well as the logical core structure and information regarding the buffering provision and requirements for the component Source Code All of the files required for operation are located in the module_multi_uart directory. The files that need to be included for use of this component in an application are: File multi_uart_rxtx.h multi_uart_common.h multi_uart_rx.h multi_uart_tx.h Description Header file for simplified launch of both the TX and RX server logical cores, also provides the headers for the individual RX and TX API interfaces. Header file providing configuration ENUM definitions and other constants that may be required for operation Header file for accessing the API of the RX UART server - included by multi_uart_rxtx.h Header file for accessing the API of the TX UART server - included by multi_uart_rxtx.h 9.2 Configuration of Multi-UART component Multi-UART component configuration takes place in two domains - a static compile time configuration (discussed in this section) and a runtime dynamic configuration (as discussed in 9.3 and 9.6).

23 Multi-UART Module Usage Manual 23/31 Static configuration is done by the application providing configuration header files multi_uart_tx_conf.h and multi_uart_rx_conf.h Static configuration of UART TX Below is a summary of the configuration options that are in the multi_uart_tx_conf.h file, their suggested defaults and an explanation of their function.

24 Multi-UART Module Usage Manual 24/31 Define Default Other options Explanation UART_TX_USE_EXTERNAL_CLOCK (None) Not defined The presence of this define turns on or off the requirement to use external clocking this is discussed in 4.4. UART_TX_CLOCK_RATE_HZ Any valid clock rate UART_TX_MAX_BAUD_RATE less than or equal to UART_TX_CLOCK_DIVIDER (UART_TX_CLOCK_RATE_HZ Any appropriate / divider UART_TX_MAX_BAUD_RATE) Defines the clock rate that the baud rates are derived from Defines the max baud rate the API will allow configuration of. Validated to It is recommended to leave this at the default. It is used to set the clock divider when configuring clocking from the internal reference clock UART_TX_OVERSAMPLE 2 {1 2} Define the oversampling of the clock - this is where the UART_TX_CLOCK_DIVIDER is > 255 (otherwise set to 1) - only used when using an internal clock reference UART_TX_BUF_SIZE 16 {1,2,4,8,16,32,...} Define the buffer size in UART word entries - needs to be a power of 2 (i.e. 1,2,4,8,16,32) UART_TX_CHAN_COUNT 8 {1,2,4,8} Define the number of channels that are to be supported, must fit in the port. Also, must be a power of 2 (i.e. 1,2,4,8) - not all channels have to be utilised UART_TX_IFB 0 {0..n} Define the number of interframe bits - n should not make the to-

25 Multi-UART Module Usage Manual 25/ Static configuration of UART RX Below is a summary of the configuration options that are in the multi_uart_rx_conf.h file, their suggested defaults and an explanation of their function. Define Default Other options Explanation UART_RX_CHAN_COUNT 8 {1,2,4,8} Define the number of channels that are to be supported, must fit in the port. Also, must be a power of 2 (i.e. 1,2,4,8) - not all channels have to be utilised UART_RX_CLOCK_RATE_HZ System reference clock rate UART_RX_MAX_BAUD less than or equal to UART_RX_CLOCK_DIVIDER (UART_RX_CLOCK_RATE_HZ Any appropriate / divider UART_RX_MAX_BAUD) UART_RX_OVERSAMPLE 4 Should remain at 4 Defines the clock rate that the baud rates are derived from Defines the max baud rate the API will allow configuration of. Validated to It is recommended to leave this at the default. Is used to set the clock divider when configuring clocking using either internal or external clocks. Oversample count for the max baud rate. It is recommended that this value is left as it is unless the effects of changing it are well understood.

26 Multi-UART Module Usage Manual 26/ Initialisation The initialisation and configuration process for both the RX and TX operations is the same. For configuration, the functions uart_rx_initialise_channel() or uart_tx_initialise_channel() are utilised. The flow is visualised in Figure 1 and a working example taken from the echo test application that is used for verification. Figure 1: UART Initialisation Flow The following working example is taken from uart_manager.xc and shows a typical initial configuration. The next stage of initialisation is to release the server logical cores from their paused state. Upon start up their default state is to be paused until the following channel communication is completed. 9.4 Interfacing to the TX Server To transmit data using the TX server the application should make use of uart_tx_put_char(). An example use is shown below. This example, taken from the demo application configuration simply takes a string in the form of a character array and pushes it into the buffer one character at a time. When the API indicates that the buffer is full by returning a value of -1 then the loop moves onto the next channel. This operation must be completed on the same tile as the TX server logical core as the communication module utilises shared memory.

27 Multi-UART Module Usage Manual 27/ Interfacing to the RX Server To receive data from the RX server the application should make use of the channel that is provided. The channel provides notification to the application of which UART channel has data ready. The data itself is stored in a single storage slot with no buffering. This means that if the application layer fails to meet the timing requirements (as discussed in Client Timing 2.5) data may be lost and/or duplicated. The application implements an level buffering for receiving data. This may or may not be required in a particular implementation - dependant on whether timing requirements can be met. The receive and processing loop is shown below. Once the token is received over the channel informing the application of the UART channel which has data ready the application uses the uart_rx_grab_char() function to collect the data from the receive slot. This provides an unvalidated word. The application then utilises the uart_rx_validate_char() to ensure that the UART word fits the requirements of the configuration (parity, stop bits etc) and provides the data upon return in the uart_char variable. This data is then inserted into a buffer. 9.6 Reconfiguration of RX & TX Server The method for reconfiguring the UART software is the same for both the RX and the TX servers. When the application requires a reconfiguration then a call to uart_tx_reconf_pause() or uart_rx_reconf_pause() needs to be made. When reconfiguring the RX side the server logical core will pause immediately, however when pausing the TX side the server logical core will pause the application logical core to allow the buffers to empty in the TX logical core. Once the functions exit the server logical cores will be paused. Configuration is then done utilising the same methodology as initial configuration using a function such as the uart_tx_initialise_channel() or uart_rx_initialise_channel(). Following the reconfiguration the application must then call uart_tx_reconf_enable() and uart_rx_reconf_enable() to re-enable the TX and RX logical cores respectively. The listing below gives an example of reconfiguration that is taken from the echo test demonstration and test application.

28 10Example Applications IN THIS CHAPTER app_sk_muart_com_demo Application This section discusses the demonstration application that uses multi-uart module app_sk_muart_com_demo Application This application is available as app_sk_muart_com_demo under sc_multi_uart component directory. See the evaluation platforms section of this document for required hardware Required Software Tools The following tools should be installed on the host system in order to run this application For Win 7: Hercules Setup Utility by HW-Group For MAC users: SecureCRT Build options app_sk_muart_com_demo application uses the following modules in order to achieve its desired functionality. sc_multi_uart: utilizes TX and RX servers provided by the component sc_util: uses module_xc_ptr functions to perform pointer related arithmetic such as reading from and writing into memory This demo application is built by default for XP-SKC-L2 Slicekit Core board, SQUARE connector type. This application can also be built for other compatible connectors as follows: To build for STAR connector, make the following changes in src\main.xc file: #define SK_MULTI_UART_SLOT_STAR 1 To build for TRIANGLE connector, make the following changes in src\main.xc file: #define SK_MULTI_UART_SLOT_TRIANGLE 1

29 Multi-UART Module Usage Manual 29/31 The module requires 8-bit ports for both UART transmit and UART receive ports. Upon selection of an appropriate type of connector, the port declarations for the multi-uart component are derived automatically Hardware Settings Voltage Levels CMOS TTL RS-232 By default, this Slice Card uses the RS-232 levels. In order to use the CMOS TTL levels, short J3 pins (25-26) of the Slice Card. All 8 UART channels must use the same voltage setting Uart Header Connections When using the RS-232 levels, UART device pins must be connected to J4 of XA-SK-UART8 Slice Card. When using TTL levels, UART device pins must be connected to J3 of Multi-UART Slice Card (along with J pins shorted). UART information of XA-SK-UART8 Slice Card is as follows: XA-SK-UART8 Slice Card for Demo Applications

30 Multi-UART Module Usage Manual 30/31 UART Identifier J3/J4 Pin no.(tx) J3/J4 Pin no.(rx) Optionally, Uart #0 may be accessed via the DB9 connector on the end of the Slice Card and thus connected directly to a PC COM port Application Description The demonstration application shows a typical application structure that would employ the Multi-UART module. In addition to the two Multi-UART logical cores used by sc_multi_uart, the application utilises one more logical core to manage UART data from transmit and receive logical cores. UART data received may be user commands to perform various user actions or transaction data related to a user action (see ). The application operates a state machine to differentiate between user commands and user data, and provides some buffers to hold data received from UARTs. When the RX logical core receives a character over the UART it saves it into the local buffer. A state handler operates on the received data to identify its type and performs relevant actions. Generally, the data token received by RX buffering logical core tells which UART channel a character has been received on. The logical core then extracts this character out of the buffer slot, validates it utilising the provided validation function and inserts it into a larger, more comprehensive buffer.the RX buffering is implemented as an example only and may not be necessary for other applications. The TX logical core already provides some buffering supported at the component level. The TX handler operates by polling the buffer which is filled by the Rx handler. When an entry is seen, the Tx handler pulls it from the buffer and performs an action based on the current state of the handler. The channel for the TX logical core is primarily used for reconfiguration. This is discussed in more detail in 9.6. Specific usage of the API is also discussed in 9.4 and 9.5.

31 Multi-UART Module Usage Manual 31/ Quick Start Guide Quick starter guide and application usage is available in doc_quickstart of the application Interacting with the Application Command Interface The application provides the following commands to interact with it: e - in this mode, an entered character is echoed back on the console. In order to come out of this mode, press the Esc key r - reconfigure UART for a different baud rate b - pipe file through all uart channels. h - displays user menu At any instance Esc key can be pressed to revert back to user menu Makefiles The main Makefile for the project is in the application directory. This file specifies build options and used modules. The Makefile uses the common build infrastructure in xcommon. This system includes the source files from the relevant modules and is documented within xcommon Using Command Line Tools To build from the command line, change to app_slicekit_com_demo directory and execute the command: xmake all Open the XMOS command line tools (Desktop Tools Prompt) and execute the following command: xflash <binary >. xe

32 Multi-UART Module Usage Manual 32/31 Copyright 2012, All Rights Reserved. Xmos Ltd. is the owner or licensee of this design, code, or Information (collectively, the Information ) and is providing it to you AS IS with no warranty of any kind, express or implied and shall have no liability in relation to its use. Xmos Ltd. makes no representation that the Information, or any particular implementation thereof, is or will be free from any claims of infringement and again, shall have no liability in relation to any such claims. XMOS and the XMOS logo are registered trademarks of Xmos Ltd. in the United Kingdom and other countries, and may not be used without written permission. All other trademarks are property of their respective owners. Where those designations appear in this book, and XMOS was aware of a trademark claim, the designations have been printed with initial capital letters or in all capitals.