This file contains basic functions for the AVR32 USART, with support for all modes, settings and clock speeds.
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. |
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.
l_node | Node Value | |
l_data | Pointer on the data corresponding to the message pointed by the handle in the descriptor list |
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.
master | TRUE for master, FALSE for slave | |
l_node | Node Value | |
b_rate | Baudrate Value | |
pba_hz | PBA Value |
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.
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 |
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.
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’. |
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.
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 |
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.
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 |
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 }
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] |
U8 lin_tx_buffer_node0[256] |
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 |
Instance of the USART IP used.
Definition at line 110 of file lin.c.
Referenced by lin_get_response(), lin_init(), lin_int_handler_node0(), lin_pdca_int_rx_handler_node0(), lin_pdca_int_tx_handler_node0(), lin_send_cmd(), and lin_tx_header_and_response().
const gpio_map_t USART_LIN_NODE0_GPIO_MAP [static] |
Initial value:
{ {USART_LIN_NODE0_RX_PIN, USART_LIN_NODE0_RX_FUNCTION}, {USART_LIN_NODE0_TX_PIN, USART_LIN_NODE0_TX_FUNCTION} }
Definition at line 95 of file lin.c.
Referenced by lin_init().