lin.c File Reference


Detailed Description

LIN service for AVR32 UC3.

This file contains basic functions for the AVR32 USART, with support for all modes, settings and clock speeds.

Author:
Atmel Corporation: http://www.atmel.com
Support and FAQ: http://support.atmel.no/

Definition in file lin.c.

#include <stdio.h>
#include <string.h>
#include "compiler.h"
#include "intc.h"
#include "pdca.h"
#include "gpio.h"
#include "lin.h"

Go to the source code of this file.

Functions

static void lin_int_handler_node0 (void)
 USART LIN interrupt handler: manage ID reception and ERROR.
static void lin_pdca_int_rx_handler_node0 (void)
 USART LIN RX PDCA interrupt handler.
static void lin_pdca_int_tx_handler_node0 (void)
 LIN TX PDCA interrupt handler.
Initialization Functions
static void lin_get_response (U8 l_node, U8 *l_data)
 This function reads (empties) the reception data buffer when a LIN response had been received. This function is additional of the ‘lin_rx_response()’ function.
U8 lin_init (Bool master, U8 l_node, U16 b_rate, long pba_hz)
 This function initializes the LIN controller and, if needed, the LIN interrupts.
static U8 lin_rx_response (U8 l_node, U8 l_handle, U8 l_len)
 This function commands the reception of a LIN response, SLAVE task of MASTER or SLAVE node.
U8 lin_send_cmd (U8 l_node, U8 l_id, U8 l_len)
 This function commands the sending of the LIN header, MASTER task of MASTER node.
static U8 lin_tx_header_and_response (U8 l_node, U8 l_handle, U8 l_len)
 This function commands the sending of a LIN header and response, MASTER task only.
static U8 lin_tx_response (U8 l_node, U8 l_handle, U8 *l_data, U8 l_len)
 This function commands the sending of a LIN response, SLAVE task of MASTER or SLAVE node.

Variables

volatile st_lin_message lin_descript_list_node0 [NUMBER_OF_LIN_FRAMES_NODE0]
 Array of structure of type:'st_lin_message'. Default: 8 elements.
volatile U16 lin_error_number_node0 = 0
 Counter of LIN error. If an error clearly linked to a message (i.e. time-out) the status of this message is written with the error (LINERR).
volatile U8 lin_handle_node0 = 0xFF
 Index in lin_descript_list[], 'lin_handle' is set after processing IDOK and verified once RXOK or TXOK rises.
volatile U16 lin_last_errors_node0 [LIN_LAST_ERR_LENGHT]
 Last error FIFO: lin_handle | status. Default: 4 elements.
volatile U8 lin_rx_buffer_node0 [256]
U8 lin_tx_buffer_node0 [256]
volatile avr32_usart_t * usart_lin_node0 = &USART_LIN_NODE0_INSTANCE
 Instance of the USART IP used.
static const gpio_map_t USART_LIN_NODE0_GPIO_MAP
 Map of the LIN pins used.


Function Documentation

static void lin_get_response ( U8  l_node,
U8 *  l_data 
) [static]

This function reads (empties) the reception data buffer when a LIN response had been received. This function is additional of the ‘lin_rx_response()’ function.

Parameters:
l_node Node Value
l_data Pointer on the data corresponding to the message pointed by the handle in the descriptor list
Returns:
Status PASS / FAIL

Definition at line 1020 of file lin.c.

References lin_rx_buffer_node0, and usart_lin_node0.

Referenced by lin_pdca_int_rx_handler_node0().

01020                                                      {
01021 
01022 U8 i, l_len;
01023 if (l_node == 0)
01024 {
01025     l_len = usart_lin_get_data_length(usart_lin_node0);
01026     for (i = 0; i < l_len; i++) {
01027         (*l_data++) = lin_rx_buffer_node0[i];
01028     }
01029 }
01030 #ifdef USART_LIN_NODE1_INSTANCE
01031 else
01032 {
01033     l_len = usart_lin_get_data_length(usart_lin_node1);
01034     for (i = 0; i < l_len; i++) {
01035         (*l_data++) = lin_rx_buffer_node1[i];
01036     }
01037 }
01038 #endif
01039 
01040 }

U8 lin_init ( Bool  master,
U8  l_node,
U16  b_rate,
long  pba_hz 
)

This function initializes the LIN controller and, if needed, the LIN interrupts.

Parameters:
master TRUE for master, FALSE for slave
l_node Node Value
b_rate Baudrate Value
pba_hz PBA Value
Returns:
Status PASS / FAIL

Enable Interrupt for Error flags and end ID Reception

Register Interrupt for LIN

Register Interrupt for PDCA Transfer TX

Register Interrupt for PDCA Transfer RX

Definition at line 470 of file lin.c.

References lin_int_handler_node0(), lin_pdca_int_rx_handler_node0(), lin_pdca_int_tx_handler_node0(), usart_lin_node0, USART_LIN_NODE0_GPIO_MAP, USART_LIN_NODE0_PDCA_RX_IRQ, USART_LIN_NODE0_PDCA_RX_IRQ_LEVEL, USART_LIN_NODE0_PDCA_TX_IRQ, USART_LIN_NODE0_PDCA_TX_IRQ_LEVEL, USART_LIN_NODE0_RX_PIN, USART_LIN_NODE0_USART_IRQ, USART_LIN_NODE0_USART_IRQ_LEVEL, USART_LIN_NODE1_PDCA_RX_IRQ, USART_LIN_NODE1_PDCA_RX_IRQ_LEVEL, USART_LIN_NODE1_PDCA_TX_IRQ, USART_LIN_NODE1_PDCA_TX_IRQ_LEVEL, USART_LIN_NODE1_RX_PIN, USART_LIN_NODE1_USART_IRQ, and USART_LIN_NODE1_USART_IRQ_LEVEL.

Referenced by main().

00473                           {
00474 if (l_node == 0)
00475 {
00476     // Enable GPIO Alternate Functions
00477     gpio_enable_module(USART_LIN_NODE0_GPIO_MAP,
00478                      sizeof(USART_LIN_NODE0_GPIO_MAP) / sizeof(USART_LIN_NODE0_GPIO_MAP[0]));
00479 
00480     gpio_enable_pin_pull_up(USART_LIN_NODE0_RX_PIN);
00481 
00482     // USART options.
00483     if (master)
00484       usart_init_lin_master(usart_lin_node0,b_rate,pba_hz);
00485     else
00486       usart_init_lin_slave(usart_lin_node0,b_rate,pba_hz);
00487 
00488     Disable_global_interrupt();
00489 
00490     if (master==FALSE)
00491     {
00493             #if ( defined (AVR32_USART_400_H_INCLUDED) ||  \
00494                               defined (AVR32_USART_410_H_INCLUDED) ||  \
00495                               defined (AVR32_USART_420_H_INCLUDED) )   
00496                 usart_lin_node0->ier = AVR32_USART_IER_LINIR_MASK  |
00497                              AVR32_USART_IER_LINBE_MASK  |
00498                              AVR32_USART_IER_LINISFE_MASK |
00499                              AVR32_USART_IER_LINIPE_MASK |
00500                              AVR32_USART_IER_LINCE_MASK  |
00501                              AVR32_USART_IER_LINSNRE_MASK;
00503                 INTC_register_interrupt(&lin_int_handler_node0,
00504                                         USART_LIN_NODE0_USART_IRQ,
00505                                         USART_LIN_NODE0_USART_IRQ_LEVEL);
00506             #else
00507 
00508                 usart_lin_node0->ier = AVR32_USART_IER_LINID_MASK  |
00509                              AVR32_USART_IER_LINBE_MASK  |
00510                              AVR32_USART_IER_LINISFE_MASK |
00511                              AVR32_USART_IER_LINIPE_MASK |
00512                              AVR32_USART_IER_LINCE_MASK  |
00513                              AVR32_USART_IER_LINSNRE_MASK;
00515                 INTC_register_interrupt(&lin_int_handler_node0,
00516                                         USART_LIN_NODE0_USART_IRQ,
00517                                         USART_LIN_NODE0_USART_IRQ_LEVEL);
00518             #endif
00519     }
00520 
00522     INTC_register_interrupt(&lin_pdca_int_tx_handler_node0,
00523                             USART_LIN_NODE0_PDCA_TX_IRQ,
00524                             USART_LIN_NODE0_PDCA_TX_IRQ_LEVEL);
00525 
00527     INTC_register_interrupt(&lin_pdca_int_rx_handler_node0,
00528                             USART_LIN_NODE0_PDCA_RX_IRQ,
00529                             USART_LIN_NODE0_PDCA_RX_IRQ_LEVEL);
00530 
00531 }
00532 #ifdef USART_LIN_NODE1_INSTANCE
00533 else
00534 {
00535     // Enable GPIO Alternate Functions
00536     gpio_enable_module(USART_LIN_NODE1_GPIO_MAP,
00537                      sizeof(USART_LIN_NODE1_GPIO_MAP) / sizeof(USART_LIN_NODE1_GPIO_MAP[0]));
00538 
00539 
00540     gpio_enable_pin_pull_up(USART_LIN_NODE1_RX_PIN);
00541 
00542     // USART options.
00543     if (master)
00544       usart_init_lin_master(usart_lin_node1,b_rate,pba_hz);
00545     else
00546       usart_init_lin_slave(usart_lin_node1,b_rate,pba_hz);
00547 
00548     Disable_global_interrupt();
00549 
00550     if (master==FALSE)
00551     {
00553             #if ( defined (AVR32_USART_400_H_INCLUDED) ||  \
00554                               defined (AVR32_USART_410_H_INCLUDED) ||  \
00555                               defined (AVR32_USART_420_H_INCLUDED) )  
00556                 usart_lin_node1->ier = AVR32_USART_IER_LINIR_MASK  |
00557                              AVR32_USART_IER_LINBE_MASK  |
00558                              AVR32_USART_IER_LINISFE_MASK |
00559                              AVR32_USART_IER_LINIPE_MASK |
00560                              AVR32_USART_IER_LINCE_MASK  |
00561                              AVR32_USART_IER_LINSNRE_MASK;
00563                 INTC_register_interrupt(&lin_int_handler_node1,
00564                                         USART_LIN_NODE1_USART_IRQ,
00565                                         USART_LIN_NODE1_USART_IRQ_LEVEL);
00566             #else
00567                 usart_lin_node1->ier = AVR32_USART_IER_LINID_MASK  |
00568                              AVR32_USART_IER_LINBE_MASK  |
00569                              AVR32_USART_IER_LINISFE_MASK |
00570                              AVR32_USART_IER_LINIPE_MASK |
00571                              AVR32_USART_IER_LINCE_MASK  |
00572                              AVR32_USART_IER_LINSNRE_MASK;
00574                 INTC_register_interrupt(&lin_int_handler_node1,
00575                                         USART_LIN_NODE1_USART_IRQ,
00576                                         USART_LIN_NODE1_USART_IRQ_LEVEL);
00577             #endif
00578     }
00579 
00581     INTC_register_interrupt(&lin_pdca_int_tx_handler_node1,
00582                             USART_LIN_NODE1_PDCA_TX_IRQ,
00583                             USART_LIN_NODE1_PDCA_TX_IRQ_LEVEL);
00584 
00586     INTC_register_interrupt(&lin_pdca_int_rx_handler_node1,
00587                             USART_LIN_NODE1_PDCA_RX_IRQ,
00588                             USART_LIN_NODE1_PDCA_RX_IRQ_LEVEL);
00589 }
00590 #endif
00591     return PASS;
00592 }

static void lin_int_handler_node0 ( void   )  [static]

USART LIN interrupt handler: manage ID reception and ERROR.

Definition at line 194 of file lin.c.

References IGNORE, st_lin_message::l_status, lin_error_number_node0, lin_handle_node0, LIN_LAST_ERR_LENGHT, lin_last_errors_node0, lin_rx_response(), lin_tx_response(), NUMBER_OF_LIN_FRAMES_NODE0, PUBLISH, SUBSCRIBE, usart_lin_node0, and usart_reset_status().

Referenced by lin_init().

00195 {
00196     U32 l_error;
00197     U8 index;
00198     U8 l_handle = 0xFF;
00199     // Check ID Value for the current message
00200     for(index = 0; index < NUMBER_OF_LIN_FRAMES_NODE0; index ++) 
00201     {
00202         if(lin_descript_list_node0[index].l_id == usart_lin_get_id_char(usart_lin_node0)) 
00203         {
00204             l_handle = index;
00205                 break;
00206         }
00207     }
00208     // Check Error Status
00209     l_error = usart_lin_get_error(usart_lin_node0);
00210     usart_reset_status(usart_lin_node0);
00211     if (l_error!=0)
00212     {
00213       if(l_handle != 0xFF) 
00214       {
00215           lin_descript_list_node0[l_handle].l_status = l_error;
00216       }
00217       lin_last_errors_node0[(((U8)lin_error_number_node0) & (LIN_LAST_ERR_LENGHT-1))] \
00218                       = ((((U16)l_handle)<<8) | ((U16)l_error))            ;
00219       lin_error_number_node0++;
00220       lin_handle_node0 = 0xFF;  // End of communication
00221     }
00222     // Here the communication go on only in case no error is detected!!!
00223     else
00224     {
00225         usart_lin_set_node_action(usart_lin_node0,lin_descript_list_node0[l_handle].l_cmd);
00226 
00227         if(l_handle != 0xFF)
00228         {
00229 #if USART_LIN_VERSION == LIN_2x
00230             // Configure Parity
00231             usart_lin_enable_parity(usart_lin_node0,TRUE);
00232             // Configure Checksum
00233             usart_lin_enable_checksum(usart_lin_node0,TRUE);
00234             // Configure Checksum Type
00235             usart_lin_set_checksum(usart_lin_node0,USART_LIN_ENHANCED_CHECKSUM);
00236             // Configure Frameslot
00237             usart_lin_enable_frameslot(usart_lin_node0,FALSE);
00238             // Configure Frame Length
00239             usart_lin_set_data_length_lin2x(usart_lin_node0,lin_descript_list_node0[l_handle].l_dlc);
00240 #elif USART_LIN_VERSION == LIN_1x
00241             // Configure Parity
00242             usart_lin_enable_parity(usart_lin_node0,TRUE);
00243             // Configure Checksum
00244             usart_lin_enable_checksum(usart_lin_node0,TRUE);
00245             // Configure Checksum Type
00246             usart_lin_set_checksum(usart_lin_node0,USART_LIN_CLASSIC_CHECKSUM);
00247             // Configure Frameslot
00248             usart_lin_enable_frameslot(usart_lin_node0,FALSE);
00249             // Configure Frame Length
00250             usart_lin_set_data_length_lin1x(usart_lin_node0);
00251 #endif
00252 
00253             // Diagnostic frames in LIN 2.0/2.1
00254             if((usart_lin_get_id_char(usart_lin_node0)>=60)) {
00255                 usart_lin_set_checksum(usart_lin_node0,USART_LIN_CLASSIC_CHECKSUM);
00256                 // Configure Frame Length
00257                 usart_lin_set_data_length_lin1x(usart_lin_node0);
00258             }
00259 
00260             switch (lin_descript_list_node0[l_handle].l_cmd) 
00261             {
00262                 //------------
00263                 case  PUBLISH:
00264                     lin_tx_response (      0,
00265                                            l_handle,
00266                                            lin_descript_list_node0[l_handle].l_pt_data,
00267                                            lin_descript_list_node0[l_handle].l_dlc) ;
00268                     break;
00269                 //------------
00270                 case SUBSCRIBE:
00271                     lin_rx_response (      0,
00272                                            l_handle,
00273                                            lin_descript_list_node0[l_handle].l_dlc) ;
00274                     break;
00275                 //------------
00276                 case IGNORE:
00277                 default:
00278                     lin_handle_node0 = 0xFF;  // End of communication
00279                     break;
00280             }
00281         }
00282     }
00283 }

static void lin_pdca_int_rx_handler_node0 ( void   )  [static]

USART LIN RX PDCA interrupt handler.

Definition at line 163 of file lin.c.

References st_lin_message::l_pt_function, lin_get_response(), lin_handle_node0, NUMBER_OF_LIN_FRAMES_NODE0, usart_lin_node0, and USART_LIN_NODE0_RX_PDCA_CHANNEL.

Referenced by lin_init().

00164 {
00165   U8 index = 0;
00166   U8 l_handle = 0xFF;
00167   // Check ID Value for the current message
00168   for(index = 0; index < NUMBER_OF_LIN_FRAMES_NODE0; index ++) {
00169       if(lin_descript_list_node0[index].l_id == usart_lin_get_id_char(usart_lin_node0)) {
00170           l_handle = index;
00171               break;
00172       }
00173   }
00174   // Check if the ID received is registered into the lin description list
00175   if (l_handle!=0xFF)
00176   {
00177     if (pdca_get_transfer_status(USART_LIN_NODE0_RX_PDCA_CHANNEL)&PDCA_TRANSFER_COMPLETE)
00178     {
00179         pdca_disable_interrupt_transfer_complete(USART_LIN_NODE0_RX_PDCA_CHANNEL);
00180         lin_get_response (0,lin_descript_list_node0[l_handle].l_pt_data);
00181         // Start of the associated task
00182         lin_descript_list_node0[l_handle].l_pt_function(lin_descript_list_node0[l_handle].l_pt_data);
00183         lin_handle_node0 = 0xFF;  // End of communication
00184     }
00185   }
00186 }

static void lin_pdca_int_tx_handler_node0 ( void   )  [static]

LIN TX PDCA interrupt handler.

Definition at line 130 of file lin.c.

References st_lin_message::l_pt_function, lin_handle_node0, NUMBER_OF_LIN_FRAMES_NODE0, usart_lin_node0, and USART_LIN_NODE0_TX_PDCA_CHANNEL.

Referenced by lin_init().

00131 {
00132   U8 index = 0;
00133   U8 l_handle = 0xFF;
00134 
00135   // Check ID Value for the current message
00136   for(index = 0; index < NUMBER_OF_LIN_FRAMES_NODE0; index ++) {
00137       if(lin_descript_list_node0[index].l_id == usart_lin_get_id_char(usart_lin_node0)) {
00138           l_handle = index;
00139               break;
00140       }
00141   }
00142   // Check if the ID received is registered into the lin description list
00143   if (l_handle!=0xFF)
00144   {
00145     if (pdca_get_transfer_status(USART_LIN_NODE0_TX_PDCA_CHANNEL)&PDCA_TRANSFER_COMPLETE)
00146     {
00147         pdca_disable_interrupt_transfer_complete(USART_LIN_NODE0_TX_PDCA_CHANNEL);
00148         // Start of the associated task
00149         lin_descript_list_node0[l_handle].l_pt_function(lin_descript_list_node0[l_handle].l_pt_data);
00150         lin_handle_node0 = 0xFF;  // End of communication
00151     }
00152   }
00153 }

static U8 lin_rx_response ( U8  l_node,
U8  l_handle,
U8  l_len 
) [static]

This function commands the reception of a LIN response, SLAVE task of MASTER or SLAVE node.

Parameters:
l_node Node Value
l_handle Handle on the descriptor list
l_len Message length corresponding to the message pointed by the handle in the descriptor list
Returns:
Status PASS / FAIL

Definition at line 960 of file lin.c.

References lin_rx_buffer_node0, USART_LIN_NODE0_PDCA_PID_RX, USART_LIN_NODE0_RX_PDCA_CHANNEL, USART_LIN_NODE1_PDCA_PID_RX, and USART_LIN_NODE1_RX_PDCA_CHANNEL.

Referenced by lin_int_handler_node0(), and lin_send_cmd().

00963                             {
00964 
00965 if (l_node == 0)
00966 {
00967     // PDCA channel options
00968     pdca_channel_options_t USART_LIN_PDCA_OPTIONS =
00969     {
00970       .addr = (void *)lin_rx_buffer_node0,   // memory address
00971       .pid = USART_LIN_NODE0_PDCA_PID_RX,  // select peripheral - data are transmit on USART TX line.
00972       .size = (l_len),                 // transfer counter
00973       .r_addr = NULL,                 // next memory address
00974       .r_size = 0,                    // next transfer counter
00975       .transfer_size = PDCA_TRANSFER_SIZE_BYTE  // select size of the transfer
00976     };
00977 
00978     pdca_init_channel(USART_LIN_NODE0_RX_PDCA_CHANNEL, &USART_LIN_PDCA_OPTIONS);
00979 
00980      pdca_enable_interrupt_transfer_complete(USART_LIN_NODE0_RX_PDCA_CHANNEL);
00981     // Start PDCA transfer Data
00982     pdca_enable(USART_LIN_NODE0_RX_PDCA_CHANNEL);
00983     return 1;
00984 }
00985 #ifdef USART_LIN_NODE1_INSTANCE
00986 else
00987 {
00988     // PDCA channel options
00989     pdca_channel_options_t USART_LIN_PDCA_OPTIONS =
00990     {
00991       .addr = (void *)lin_rx_buffer_node1,   // memory address
00992       .pid = USART_LIN_NODE1_PDCA_PID_RX,  // select peripheral - data are transmit on USART TX line.
00993       .size = (l_len),                 // transfer counter
00994       .r_addr = NULL,                 // next memory address
00995       .r_size = 0,                    // next transfer counter
00996       .transfer_size = PDCA_TRANSFER_SIZE_BYTE  // select size of the transfer
00997     };
00998 
00999     pdca_init_channel(USART_LIN_NODE1_RX_PDCA_CHANNEL, &USART_LIN_PDCA_OPTIONS);
01000 
01001      pdca_enable_interrupt_transfer_complete(USART_LIN_NODE1_RX_PDCA_CHANNEL);
01002     // Start PDCA transfer Data
01003     pdca_enable(USART_LIN_NODE1_RX_PDCA_CHANNEL);
01004     return 1;
01005 }
01006 #endif
01007 }

U8 lin_send_cmd ( U8  l_node,
U8  l_id,
U8  l_len 
)

This function commands the sending of the LIN header, MASTER task of MASTER node.

Parameters:
l_node Node Value
l_id LIN identifier value. In case of ‘LIN_1X’, the coded length is transported into the LIN identifier.
l_len True length (not coded), number of data bytes transported in the response. This information is not used in ‘LIN_1X’ because it is coded in ‘l_id’.
Returns:
Status PASS / FAIL

Definition at line 604 of file lin.c.

References lin_rx_response(), lin_tx_header_and_response(), NUMBER_OF_LIN_FRAMES_NODE0, PUBLISH, SUBSCRIBE, usart_lin_node0, and usart_reset_status().

Referenced by lin_master_task_ID12(), and lin_master_task_ID15().

00607                        {
00608       U8 index = 0;
00609       U8 l_handle = 0;
00610 if (l_node == 0)
00611 {
00612     // Clear error in case of previous communication
00613     usart_reset_status(usart_lin_node0);
00614 
00615     for(index = 0; index < NUMBER_OF_LIN_FRAMES_NODE0; index ++) 
00616     {
00617         if(lin_descript_list_node0[index].l_id == l_id) 
00618         {
00619             l_handle = index;
00620               break;
00621         }
00622     }
00623 
00624     if(l_handle != 0xFF) 
00625     {
00626         usart_lin_set_node_action(usart_lin_node0,lin_descript_list_node0[l_handle].l_cmd);
00627 #if USART_LIN_VERSION == LIN_2x
00628         // Configure Parity
00629         usart_lin_enable_parity(usart_lin_node0,TRUE);
00630         // Configure Checksum
00631         usart_lin_enable_checksum(usart_lin_node0,TRUE);
00632         // Configure Checksum Type
00633         usart_lin_set_checksum(usart_lin_node0,USART_LIN_ENHANCED_CHECKSUM);
00634         // Configure Frameslot
00635         usart_lin_enable_frameslot(usart_lin_node0,FALSE);
00636         // Configure Frame Length
00637         usart_lin_set_data_length_lin2x(usart_lin_node0,l_len);
00638 #elif USART_LIN_VERSION == LIN_1x
00639         // Configure Parity
00640         usart_lin_enable_parity(usart_lin_node0,TRUE);
00641         // Configure Checksum
00642         usart_lin_enable_checksum(usart_lin_node0,TRUE);
00643         // Configure Checksum Type
00644         usart_lin_set_checksum(usart_lin_node0,USART_LIN_CLASSIC_CHECKSUM);
00645         // Configure Frameslot
00646         usart_lin_enable_frameslot(usart_lin_node0,FALSE);
00647         // Configure Frame Length
00648         usart_lin_set_data_length_lin1x(usart_lin_node0);
00649 #endif
00650         // Switch to Classic Checksum if diagnostic ID request
00651         if (lin_descript_list_node0[l_handle].l_id>=60)
00652         {
00653                 usart_lin_set_checksum(usart_lin_node0,USART_LIN_CLASSIC_CHECKSUM);
00654                 // Configure Frame Length
00655                 usart_lin_set_data_length_lin1x(usart_lin_node0);
00656         }
00657 
00658         switch (lin_descript_list_node0[l_handle].l_cmd)
00659         {
00660             // In Publish, the USART Send the Header and the response
00661             case PUBLISH:
00662                   lin_tx_header_and_response(0,l_handle,l_len);
00663               break;
00664             // In Subscribe, the USART Receive the response
00665             case SUBSCRIBE:
00666                   usart_lin_set_id_char(usart_lin_node0,l_id);
00667                   lin_rx_response(0,l_handle,l_len);
00668               break;
00669             default:
00670               break;
00671         }
00672         return PASS;
00673     }
00674     else
00675     {
00676         return FAIL;
00677     }
00678 }
00679 #ifdef USART_LIN_NODE1_INSTANCE
00680 else
00681 {
00682     // Clear error in case of previous communication
00683     usart_reset_status(usart_lin_node1);
00684 
00685     for(index = 0; index < NUMBER_OF_LIN_FRAMES_NODE1; index ++) {
00686         if(lin_descript_list_node1[index].l_id == l_id) {
00687             l_handle = index;
00688               break;
00689         }
00690     }
00691 
00692     if(l_handle != 0xFF) {
00693 
00694         usart_lin_set_node_action(usart_lin_node1,lin_descript_list_node1[l_handle].l_cmd);
00695 
00696 #if USART_LIN_VERSION == LIN_2x
00697         // Configure Parity
00698         usart_lin_enable_parity(usart_lin_node1,TRUE);
00699         // Configure Checksum
00700         usart_lin_enable_checksum(usart_lin_node1,TRUE);
00701         // Configure Checksum Type
00702         usart_lin_set_checksum(usart_lin_node1,USART_LIN_ENHANCED_CHECKSUM);
00703         // Configure Frameslot
00704         usart_lin_enable_frameslot(usart_lin_node1,FALSE);
00705         // Configure Frame Length
00706         usart_lin_set_data_length_lin2x(usart_lin_node1,l_len);
00707 #elif USART_LIN_VERSION == LIN_1x
00708         // Configure Parity
00709         usart_lin_enable_parity(usart_lin_node1,TRUE);
00710         // Configure Checksum
00711         usart_lin_enable_checksum(usart_lin_node1,TRUE);
00712         // Configure Checksum Type
00713         usart_lin_set_checksum(usart_lin_node1,USART_LIN_CLASSIC_CHECKSUM);
00714         // Configure Frameslot
00715         usart_lin_enable_frameslot(usart_lin_node1,FALSE);
00716         // Configure Frame Length
00717         usart_lin_set_data_length_lin1x(usart_lin_node1);
00718 #endif
00719         // Switch to Classic Checksum if diagnostic ID request
00720         if (lin_descript_list_node1[l_handle].l_id>=60)
00721         {
00722                 usart_lin_set_checksum(usart_lin_node1,USART_LIN_CLASSIC_CHECKSUM);
00723                 // Configure Frame Length
00724                 usart_lin_set_data_length_lin1x(usart_lin_node1);
00725         }
00726 
00727         switch (lin_descript_list_node0[l_handle].l_cmd)
00728         {
00729             // In Publish, the USART Send the Header and the response
00730             case PUBLISH:
00731                   lin_tx_header_and_response(1,l_handle,l_len);
00732               break;
00733             // In Subscribe, the USART Receive the response
00734             case SUBSCRIBE:
00735                   usart_lin_set_id_char(usart_lin_node1,l_id);
00736                   lin_rx_response(1,l_handle,l_len);
00737               break;
00738             default:
00739               break;
00740         }
00741         return PASS;
00742     }
00743     else
00744     {
00745         return FAIL;
00746     }
00747 }
00748 #endif
00749 }

static U8 lin_tx_header_and_response ( U8  l_node,
U8  l_handle,
U8  l_len 
) [static]

This function commands the sending of a LIN header and response, MASTER task only.

Parameters:
l_node Node Value
l_handle Handle on the descriptor list
l_len Message length corresponding to the message pointed by the handle in the descriptor list
Returns:
Status PASS / FAIL

Enable Interrupt for Error flags and end ID Reception

Definition at line 760 of file lin.c.

References st_lin_message::l_id, lin_tx_buffer_node0, usart_lin_node0, USART_LIN_NODE0_PDCA_PID_TX, USART_LIN_NODE0_TX_PDCA_CHANNEL, USART_LIN_NODE1_PDCA_PID_TX, and USART_LIN_NODE1_TX_PDCA_CHANNEL.

Referenced by lin_send_cmd().

00764 {
00765 if (l_node == 0)
00766 {
00768         #if ( defined (AVR32_USART_400_H_INCLUDED) ||  \
00769               defined (AVR32_USART_410_H_INCLUDED) ||  \
00770               defined (AVR32_USART_420_H_INCLUDED) )  
00771           // PDCA channel options
00772           pdca_channel_options_t USART_LIN_PDCA_OPTIONS =
00773           {
00774             .addr           = (void *)lin_tx_buffer_node0,   // memory address
00775             .pid            = USART_LIN_NODE0_PDCA_PID_TX,       // select peripheral - data are transmit on USART TX line.
00776             .size           = (l_len+1),           // transfer counter
00777             .r_addr         = NULL, // next memory address
00778             .r_size         = 0,       // next transfer counter
00779             .transfer_size  = PDCA_TRANSFER_SIZE_BYTE // select size of the transfer
00780           };
00781       
00782           pdca_init_channel(USART_LIN_NODE0_TX_PDCA_CHANNEL, &USART_LIN_PDCA_OPTIONS);
00783       
00784           // Copy data of the data contained in the descriptor list into the tx buffer of the PDCA
00785           memcpy(&lin_tx_buffer_node0[1],lin_descript_list_node0[l_handle].l_pt_data,l_len);
00786       
00787           pdca_enable_interrupt_transfer_complete(USART_LIN_NODE0_TX_PDCA_CHANNEL);
00788       
00789           // Set the ID First
00790           lin_tx_buffer_node0[0] = lin_descript_list_node0[l_handle].l_id;
00791       
00792           // Start PDCA transfer ID + Data
00793           pdca_enable(USART_LIN_NODE0_TX_PDCA_CHANNEL);
00794           
00795           usart_lin_set_id_char(usart_lin_node0,lin_descript_list_node0[l_handle].l_id);                   
00796       #else
00797           // PDCA channel options
00798           pdca_channel_options_t USART_LIN_PDCA_OPTIONS =
00799           {
00800             .addr           = (void *)lin_tx_buffer_node0,   // memory address
00801             .pid            = USART_LIN_NODE0_PDCA_PID_TX,       // select peripheral - data are transmit on USART TX line.
00802             .size           = (l_len+1),           // transfer counter
00803             .r_addr         = NULL, // next memory address
00804             .r_size         = 0,       // next transfer counter
00805             .transfer_size  = PDCA_TRANSFER_SIZE_BYTE // select size of the transfer
00806           };
00807       
00808           pdca_init_channel(USART_LIN_NODE0_TX_PDCA_CHANNEL, &USART_LIN_PDCA_OPTIONS);
00809       
00810           // Copy data of the data contained in the descriptor list into the tx buffer of the PDCA
00811           memcpy(&lin_tx_buffer_node0[1],lin_descript_list_node0[l_handle].l_pt_data,l_len);
00812       
00813           pdca_enable_interrupt_transfer_complete(USART_LIN_NODE0_TX_PDCA_CHANNEL);
00814       
00815           // Set the ID First
00816           lin_tx_buffer_node0[0] = lin_descript_list_node0[l_handle].l_id;
00817       
00818           // Start PDCA transfer ID + Data
00819           pdca_enable(USART_LIN_NODE0_TX_PDCA_CHANNEL);    
00820       #endif          
00821     return PASS;
00822 }
00823 #ifdef USART_LIN_NODE1_INSTANCE
00824 else
00825 {
00827       #if ( defined (AVR32_USART_400_H_INCLUDED) ||  \
00828             defined (AVR32_USART_410_H_INCLUDED) ||  \
00829             defined (AVR32_USART_420_H_INCLUDED) )  
00830         // PDCA channel options
00831         pdca_channel_options_t USART_LIN_PDCA_OPTIONS =
00832         {
00833           .addr           = (void *)lin_tx_buffer_node1,   // memory address
00834           .pid            = USART_LIN_NODE1_PDCA_PID_TX,       // select peripheral - data are transmit on USART TX line.
00835           .size           = (l_len+1),           // transfer counter
00836           .r_addr         = NULL, // next memory address
00837           .r_size         = 0,     // next transfer counter
00838           .transfer_size  = PDCA_TRANSFER_SIZE_BYTE // select size of the transfer
00839         };
00840     
00841         pdca_init_channel(USART_LIN_NODE1_TX_PDCA_CHANNEL, &USART_LIN_PDCA_OPTIONS);
00842     
00843         // Copy data of the data contained in the descriptor list into the tx buffer of the PDCA
00844         memcpy(&lin_tx_buffer_node1[1],lin_descript_list_node1[l_handle].l_pt_data,l_len);
00845     
00846         pdca_enable_interrupt_transfer_complete(USART_LIN_NODE1_TX_PDCA_CHANNEL);
00847     
00848         // Set the ID First
00849         lin_tx_buffer_node1[0] = lin_descript_list_node1[l_handle].l_id;
00850     
00851         // Start PDCA transfer ID + Data
00852         pdca_enable(USART_LIN_NODE1_TX_PDCA_CHANNEL);    
00853         
00854         usart_lin_set_id_char(usart_lin_node1,lin_descript_list_node1[l_handle].l_id);            
00855       #else
00856         // PDCA channel options
00857         pdca_channel_options_t USART_LIN_PDCA_OPTIONS =
00858         {
00859           .addr           = (void *)lin_tx_buffer_node1,   // memory address
00860           .pid            = USART_LIN_NODE1_PDCA_PID_TX,       // select peripheral - data are transmit on USART TX line.
00861           .size           = (l_len+1),           // transfer counter
00862           .r_addr         = NULL, // next memory address
00863           .r_size         = 0,     // next transfer counter
00864           .transfer_size  = PDCA_TRANSFER_SIZE_BYTE // select size of the transfer
00865         };
00866     
00867         pdca_init_channel(USART_LIN_NODE1_TX_PDCA_CHANNEL, &USART_LIN_PDCA_OPTIONS);
00868     
00869         // Copy data of the data contained in the descriptor list into the tx buffer of the PDCA
00870         memcpy(&lin_tx_buffer_node1[1],lin_descript_list_node1[l_handle].l_pt_data,l_len);
00871     
00872         pdca_enable_interrupt_transfer_complete(USART_LIN_NODE1_TX_PDCA_CHANNEL);
00873     
00874         // Set the ID First
00875         lin_tx_buffer_node1[0] = lin_descript_list_node1[l_handle].l_id;
00876     
00877         // Start PDCA transfer ID + Data
00878         pdca_enable(USART_LIN_NODE1_TX_PDCA_CHANNEL);
00879       #endif
00880     return PASS;
00881 }
00882 #endif
00883 }

static U8 lin_tx_response ( U8  l_node,
U8  l_handle,
U8 *  l_data,
U8  l_len 
) [static]

This function commands the sending of a LIN response, SLAVE task of MASTER or SLAVE node.

Parameters:
l_node Node Value
l_handle Handle on the descriptor list
l_data Pointer on the data corresponding to the message pointed by the handle in the descriptor list
l_len Message length corresponding to the message pointed by the handle in the descriptor list
Returns:
Status PASS / FAIL

Definition at line 895 of file lin.c.

References lin_tx_buffer_node0, USART_LIN_NODE0_PDCA_PID_TX, USART_LIN_NODE0_TX_PDCA_CHANNEL, USART_LIN_NODE1_PDCA_PID_TX, and USART_LIN_NODE1_TX_PDCA_CHANNEL.

Referenced by lin_int_handler_node0().

00899                                       {
00900 
00901 if (l_node == 0)
00902 {
00903       // PDCA channel options
00904       pdca_channel_options_t USART_LIN_PDCA_OPTIONS =
00905       {
00906         .addr = (void *)lin_tx_buffer_node0,   // memory address
00907         .pid = USART_LIN_NODE0_PDCA_PID_TX,  // select peripheral - data are transmit on USART TX line.
00908         .size = (l_len),                 // transfer counter
00909         .r_addr = NULL,                 // next memory address
00910         .r_size = 0,                      // next transfer counter
00911         .transfer_size = PDCA_TRANSFER_SIZE_BYTE  // select size of the transfer
00912       };
00913   
00914       pdca_init_channel(USART_LIN_NODE0_TX_PDCA_CHANNEL, &USART_LIN_PDCA_OPTIONS);
00915   
00916       // Copy data of the data contained in the descriptor list into the tx buffer of the PDCA
00917       memcpy(&lin_tx_buffer_node0[0],lin_descript_list_node0[l_handle].l_pt_data,l_len+1);
00918   
00919        pdca_enable_interrupt_transfer_complete(USART_LIN_NODE0_TX_PDCA_CHANNEL);
00920       // Start PDCA transfer Data
00921       pdca_enable(USART_LIN_NODE0_TX_PDCA_CHANNEL);
00922     return 1;
00923 }
00924 #ifdef USART_LIN_NODE1_INSTANCE
00925 else
00926 {
00927     // PDCA channel options
00928     pdca_channel_options_t USART_LIN_PDCA_OPTIONS =
00929     {
00930       .addr = (void *)lin_tx_buffer_node1,   // memory address
00931       .pid = USART_LIN_NODE1_PDCA_PID_TX,  // select peripheral - data are transmit on USART TX line.
00932       .size = (l_len),                 // transfer counter
00933       .r_addr = NULL,                 // next memory address
00934       .r_size = 0,                    // next transfer counter
00935       .transfer_size = PDCA_TRANSFER_SIZE_BYTE  // select size of the transfer
00936     };
00937 
00938     pdca_init_channel(USART_LIN_NODE1_TX_PDCA_CHANNEL, &USART_LIN_PDCA_OPTIONS);
00939 
00940     // Copy data of the data contained in the descriptor list into the tx buffer of the PDCA
00941     memcpy(&lin_tx_buffer_node1[0],lin_descript_list_node1[l_handle].l_pt_data,l_len+1);
00942 
00943      pdca_enable_interrupt_transfer_complete(USART_LIN_NODE1_TX_PDCA_CHANNEL);
00944     // Start PDCA transfer Data
00945     pdca_enable(USART_LIN_NODE1_TX_PDCA_CHANNEL);
00946     return 1;
00947 }
00948 #endif
00949 }


Variable Documentation

volatile st_lin_message lin_descript_list_node0[NUMBER_OF_LIN_FRAMES_NODE0]

Array of structure of type:'st_lin_message'. Default: 8 elements.

Definition at line 59 of file lin.c.

Referenced by lin_master_task_ID12(), lin_master_task_ID15(), and main().

volatile U16 lin_error_number_node0 = 0

Counter of LIN error. If an error clearly linked to a message (i.e. time-out) the status of this message is written with the error (LINERR).

Definition at line 71 of file lin.c.

Referenced by lin_int_handler_node0().

volatile U8 lin_handle_node0 = 0xFF

Index in lin_descript_list[], 'lin_handle' is set after processing IDOK and verified once RXOK or TXOK rises.

Definition at line 65 of file lin.c.

Referenced by lin_int_handler_node0(), lin_pdca_int_rx_handler_node0(), and lin_pdca_int_tx_handler_node0().

volatile U16 lin_last_errors_node0[LIN_LAST_ERR_LENGHT]

Last error FIFO: lin_handle | status. Default: 4 elements.

Definition at line 77 of file lin.c.

Referenced by lin_int_handler_node0().

volatile U8 lin_rx_buffer_node0[256]

Definition at line 89 of file lin.c.

Referenced by lin_get_response(), and lin_rx_response().

Definition at line 83 of file lin.c.

Referenced by lin_tx_header_and_response(), and lin_tx_response().

volatile avr32_usart_t* usart_lin_node0 = &USART_LIN_NODE0_INSTANCE

const gpio_map_t USART_LIN_NODE0_GPIO_MAP [static]

Initial value:

Map of the LIN pins used.

Definition at line 95 of file lin.c.

Referenced by lin_init().


Generated on Fri Feb 19 02:30:31 2010 for AVR32 - Service for LIN Management - Example by  doxygen 1.5.5