Configuration Pins Ports Clocks Ram Logical cores Master ~1.5K 1 Slave ~2.1K 1

Size: px

Start display at page:

Download "Configuration Pins Ports Clocks Ram Logical cores Master ~1.5K 1 Slave ~2.1K 1"

Earl Whitehead
6 years ago
Views:

1 LIN library A software defined LIN bus library. The LIN library include master and slave peripherals. Master component automatically includes slave functionality. 50MIPS is required for the baud rate of 115Kbps. Connects directly to LIN transceiver using Rxd and Txd pins. Each peripheral uses a client server architecture where the server consists of a custom UART function, extended with timeout and break detect. The client C functions are exposed as a simple API. Features LIN 2.1 master and slave protocol components 2400 to baud operation (limited by physical layer) Integrated frame processing with simple application API Timeout and mid-frame break detection Integrated frame processing with simple application API Single logical core per LIN node (either slave or master) Typical Resource Usage This following table shows typical resource usage in some different configurations. Exact resource usage will depend on the particular use of the library by the application. Configuration Pins Ports Clocks Ram Logical cores Master ~1.5K 1 Slave ~2.1K 1 Software version and dependencies This document pertains to version of this library. It is known to work on version of the xtimecomposer tools suite, it may work on other versions. The library does not have any dependencies (i.e. it does not rely on any other libraries). Copyright 2015 XMOS Ltd. 1

2 1 Usage The following header file contains prototypes of all functions required to use the LIN Bus module. The API is described in 2. File lin_master.h lin_slave.h LIN bus master API header file LIN bus slave API header file Table 1: Key Files Create a file in the app folder called lin_conf.h and modify the LIN_BAUD_RATE setting is set according to your needs. Next, if the ports you are using are wider than 1b (ie. 4b ports), set the appropriate bit fields defining which pin is connected to rxd/txd on the transceiver. This should be done within lin_conf.h and can look like this: #define TX_RECESSIVE 0xf //bits 3..0 = 1 #define TX_DOMINANT 0xb //bits 3, 1..0 = 1, bit 2 (txd) = 0 #define RX_RECESSIVE 0x1 //bits 3..1 = 0, bit 0 (rxd) = 0 #define RX_DOMINANT 0x0 //bits 3..0 = 0 Declare the ports used by the LIN bus API and lin_rx_server in the main application code. This may look something like this (1b ports shown for master and slave): out port p_master_txd = XS1_PORT_1A; in port p_master_rxd = XS1_PORT_1B; out port in port p_slave_txd = XS1_PORT_1C; p_slave_rxd = XS1_PORT_1D; Next create a main function with a par of both the lin_server task and an application task. These will require a channel to connect them for communication. For example: int main() { chan c_app_to_lin_master; par { lin_rx_server(p_master_rxd, c_app_to_lin_master); application(c_app_to_lin_master); } return 0; } Now the application task is able to use the LIN bus master receive task, as well as call tx functions. Copyright 2015 XMOS Ltd. 2

3 To setup a LIN slave within the application, follow exactly the same procedure as above, changing the port and channel names as appropriate. The main statement may look like this: int main() { chan c_app_to_lin_slave; par { lin_rx_server(p_slave_rxd, c_app_to_lin_slave); application(c_app_to_lin_slave); } return 0; } Copyright 2015 XMOS Ltd. 3

4 2 API Each LIN bus node is presented via a simple API allowing the transmission and reception of frames. Receive functions are presented via a wrapper that handles communication to a dedicated core that deals with LIN specific UART Rx task. Consequently each node requires an instance of lin_rx_server is required within an XC par statement. 2.1 Configuration Defines The file lin_conf.h must be included in the application source code, and it must define: LIN_BAUD_RATE in order to set the speed of the LIN bus communication. The file lin_conf.h can also be used to modify frame timing parameters as well port values for high and low. Defining port values is useful in the case of multi bit ports being used instead of 1b ports. LIN_BAUD_RATE: Baud rate in bits per second TX_RECESSIVE: Port value for recessive bit on Tx TX_DOMINANT: Port value for dominant bit on Tx RX_RECESSIVE: Port value for recessive bit on Rx RX_DOMINANT: Port value for dominant bit on Rx LIN_RESPONSE_SPACE: Gap between ID and response in bit periods LIN_INTERBYTE_SPACE: Gap between bytes in bit periods LIN_INTERFRAME_SPACE: Gap between LIN frames in bit periods LIN_SYNCH_BREAK_BITS_MASTER: Number of break bit periods sent LIN_SYNCH_BREAK_THRESHOLD_SLAVE: Number of bits before slave sees a break LIN_SYNCH_BREAK_DELIMIT: Gap between synch and break in bit periods LIN_MESSAGE_TIMEOUT: Maximum time in milliseconds before master gives up on slave LIN_MAXIMUM_RESPONSE_LENGTH: Maximum number of data bytes in a frame LIN_SYNCH_BYTE: Synch byte value - 0x55 as per the LIN spec 2.2 Port Configuration Ports are declared within the main application and are passed to the master/slave function calls and lin_rx_server. Each node requires a lin_rx_server core/task to handle receive, timeout and break detection. Copyright 2015 XMOS Ltd. 4

5 2.3 Master API These are the functions that are called from the application and are included in lin_master.h. lin_master_init Initialises the LIN master. Sets the txd pin to recessive and resets the serial rx server. /param p_master_txd is the master tx port on which to transmit both headers and data. /param c_a2rx is the channel for client communications with the rx sever /returns lin_slave_error type lin_master_init(out port p_master_txd, chanend c_a2rx) lin_master_send_frame Sends a header consistig of break, synch and id. Then sends the array of data, inlcuding checksum, contained in the lin_frame passed to it. Listens to see if response section is correctly seen on bus and returns an error code if not successful. Blocks until last bit transmitted /param tx_response is the stucture to send containing id, bytes & checksum /param p_master_txd is the master tx port on which to transmit both headers and data. /param c_a2rx is the channel for client communications with the rx sever /returns lin_slave_error type lin_master_send_frame(lin_frame_t tx_response, out port p_master_txd, chanend c_a2rx) lin_master_request_frame Sends a header consistig of break, synch and id. Then receives an array of data, including checksum and copies that into the lin_frame passed to it. Note that the number of bytes expected must be setup in tx_response.length before hand to allow this function to know how many bytes to receive. Checks for start/stop bit errors, incorrect checksum and timeout returns an error code as appropriate. Blocks until last bit is received, or a time out occurs /param tx_response is the stucture conytaining id, byte, /param p_master_txd is the master tx port on which to transmit both headers and data. /param c_a2rx is the channel for client communications with the rx sever /returns lin_slave_error type lin_master_request_frame(lin_frame_t &rx_response, out port p_master_txd, chanend c_a2rx) Copyright 2015 XMOS Ltd. 5

6 lin_rx_server This is the serial rx server. Runs in it s own core and continuously looks for bytes/break symbols. Communication is over channels to client functions contained within lin_rx_client. This function must be run in it s own core (within scope of a par). One rx_server is required per node, either master or slave. /param rxd is the receive port on which to listen for LIN frames /param c_a2rx is the channel over which the client communicates with the sever void lin_rx_server(in port rxd, chanend c_a2rx) Copyright 2015 XMOS Ltd. 6

7 2.4 Slave API These are the functions that are called from the application and are included in lin_slave.h. lin_slave_init Initialises the LIN slave. Sets the txd pin to recessive and resets the serial rx server. /param p_slave_txd is the slave tx port that transmits data. /param c_a2rx is the channel for client communications with the rx sever /returns lin_slave_error type lin_slave_init(out port p_slave_txd, chanend c_a2rx) lin_slave_wait_for_header Waits for valid header consisting of break, synch and id. Will keep listening until valid break/synch receieved. It will then receive the id word and will copy it into the id argument passed to it. Reports an error if there is a start/stop bit error, parity error or timeout /param c_a2rx is the channel for client communications with the rx sever /param &id is the id word (lower 6 bits) which is received by this function /returns lin_slave_error type lin_slave_wait_for_header(chanend c_a2rx, unsigned char &id) lin_slave_send_response Sends a response array consisting of data, inlcuding checksum, contained in the lin_frame passed to it. Listens to see if response section is correctly seen on bus and returns an error code if not successful. Blocks until last bit transmitted. /param p_slave_txd is the slave tx port on which to transmit data. /param c_a2rx is the channel for client communications with the rx sever /param tx_response is the stucture to send containing bytes & checksum /returns lin_slave_error type lin_slave_send_response(out port p_slave_txd, chanend c_a2rx, lin_frame_t tx_response) lin_slave_get_response Continued on next page Copyright 2015 XMOS Ltd. 7

8 Gets a response array consisting of data, inlcuding checksum, and copies it into the lin_frame passed to it. Blocks until checksum received or timeout. Reports an error if there is a start/stop bit error, parity error or timeout /param c_a2rx is the channel for client communications with the rx sever /param rx_response is the stucture to copy the received bytes & checksum /returns lin_slave_error type lin_slave_get_response(chanend c_a2rx, lin_frame_t &rx_response) lin_rx_server This is the serial rx server. Runs in it s own core and continuously looks for bytes/break symbols. Communication is over channels to client functions contained within lin_rx_client. This function must be run in it s own core (within scope of a par). One rx_server is required per node, either master or slave. /param rxd is the receive port on which to listen for LIN frames /param c_a2rx is the channel over which the client communicates with the sever void lin_rx_server(in port rxd, chanend c_a2rx) Copyright 2015 XMOS Ltd. 8

9 APPENDIX A - Known Issues Autobaud function in the slave is not implemented. xcore systems have a precise reference clock removing the need for this feature LIN Rx pin requires it s own logical port (eg. 1b port or 4b port). In the case where a >1b port is used, the other signals must be static at runtime This component assumes the bit time is greater than 2 * LIN propagation time Copyright 2015 XMOS Ltd. 9

10 APPENDIX B - LIN library change log B Repository restructured Header file includes rationalized B Fixed xsoftip explorer configuration metainfo file issue B Initial implementation B Internal version only Copyright 2015, 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. Copyright 2015 XMOS Ltd. 10

Configuration Pins Ports Clocks Ram Logical cores SDRAM server 20 4 (1-bit), 1 (16-bit) 1 ~4.0K 1 Memory address allocator ~0.

Configuration Pins Ports Clocks Ram Logical cores SDRAM server 20 4 (1-bit), 1 (16-bit) 1 ~4.0K 1 Memory address allocator ~0. SDRAM Library The XMOS SDRAM library is designed for read and write access of arbitrary length 32b long word buffers at up to 62.5MHz clock rates. It uses an optimized pinout with address and data lines