lin_driver.h
Go to the documentation of this file.
1 /*
2  * Copyright (c) 2015, Freescale Semiconductor, Inc.
3  * Copyright 2016 - 2017 NXP
4  * All rights reserved.
5  *
6 ** * THIS SOFTWARE IS PROVIDED BY NXP "AS IS" AND ANY EXPRESSED OR
7  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
8  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
9  * IN NO EVENT SHALL NXP OR ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
10  * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
11  * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
12  * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
13  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
14  * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
15  * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
16  * THE POSSIBILITY OF SUCH DAMAGE.
17  */
18 
30 #ifndef LIN_DRIVER_H
31 #define LIN_DRIVER_H
32 
33 /*******************************************************************************
34  * Includes
35  ******************************************************************************/
36 #include <stdbool.h>
37 #include <stddef.h>
38 #include "status.h"
39 #include "interrupt_manager.h"
40 #include "osif.h"
41 
47 /*******************************************************************************
48  * Definitions
49  ******************************************************************************/
50 #define SLAVE 0U
51 #define MASTER 1U
52 #define MAKE_PARITY 0U
53 #define CHECK_PARITY 1U
54 
55 
60 typedef uint32_t (* lin_timer_get_time_interval_t) (uint32_t *nanoSeconds);
61 
66 typedef struct {
67  uint32_t baudRate;
68  bool nodeFunction;
72 
77 typedef enum {
78  LIN_NO_EVENT = 0x00U,
82  LIN_SYNC_OK = 0x04U,
83  LIN_SYNC_ERROR = 0x05U,
84  LIN_PID_OK = 0x06U,
85  LIN_PID_ERROR = 0x07U,
86  LIN_FRAME_ERROR = 0x08U,
89  LIN_TX_COMPLETED = 0x0BU,
90  LIN_RX_COMPLETED = 0x0CU,
91  LIN_RX_OVERRUN = 0x0DU
93 
98 typedef enum {
111 
116 typedef void (* lin_callback_t)(uint32_t instance, void * linState);
117 
125 typedef struct {
126  const uint8_t * txBuff;
127  uint8_t * rxBuff;
128  uint8_t cntByte;
129  volatile uint8_t txSize;
130  volatile uint8_t rxSize;
131  uint8_t checkSum;
132  volatile bool isTxBusy;
133  volatile bool isRxBusy;
134  volatile bool isBusBusy;
135  volatile bool isTxBlocking;
136  volatile bool isRxBlocking;
138  uint8_t currentId;
139  uint8_t currentPid;
142  volatile uint32_t timeoutCounter;
143  volatile bool timeoutCounterFlag;
144  volatile bool baudrateEvalEnable;
145  volatile uint8_t fallingEdgeInterruptCount;
147  semaphore_t txCompleted;
148  semaphore_t rxCompleted;
149 } lin_state_t;
150 
151 /*******************************************************************************
152  * API
153  ******************************************************************************/
154 #if defined(__cplusplus)
155 extern "C" {
156 #endif
157 
176 status_t LIN_DRV_Init(uint32_t instance,
177  lin_user_config_t * linUserConfig,
178  lin_state_t * linCurrentState);
179 
188 status_t LIN_DRV_Deinit(uint32_t instance);
189 
200 lin_callback_t LIN_DRV_InstallCallback(uint32_t instance,
201  lin_callback_t function);
202 
222 status_t LIN_DRV_SendFrameDataBlocking(uint32_t instance,
223  const uint8_t * txBuff,
224  uint8_t txSize,
225  uint32_t timeoutMSec);
226 
252 status_t LIN_DRV_SendFrameData(uint32_t instance,
253  const uint8_t * txBuff,
254  uint8_t txSize);
255 
269 status_t LIN_DRV_GetTransmitStatus(uint32_t instance,
270  uint8_t * bytesRemaining);
271 
296  uint8_t * rxBuff,
297  uint8_t rxSize,
298  uint32_t timeoutMSec);
299 
329 status_t LIN_DRV_ReceiveFrameData(uint32_t instance,
330  uint8_t * rxBuff,
331  uint8_t rxSize);
332 
341 status_t LIN_DRV_AbortTransferData(uint32_t instance);
342 
359 status_t LIN_DRV_GetReceiveStatus(uint32_t instance,
360  uint8_t * bytesRemaining);
361 
369 status_t LIN_DRV_GoToSleepMode(uint32_t instance);
370 
378 status_t LIN_DRV_GotoIdleState(uint32_t instance);
379 
388 status_t LIN_DRV_SendWakeupSignal(uint32_t instance);
389 
397 
407 void LIN_DRV_TimeoutService(uint32_t instance);
408 
416 void LIN_DRV_SetTimeoutCounter(uint32_t instance,
417  uint32_t timeoutValue);
418 
434 status_t LIN_DRV_MasterSendHeader(uint32_t instance,
435  uint8_t id);
436 
443 status_t LIN_DRV_EnableIRQ(uint32_t instance);
444 
451 status_t LIN_DRV_DisableIRQ(uint32_t instance);
452 
459 void LIN_DRV_IRQHandler(uint32_t instance);
460 
461 
475 uint8_t LIN_DRV_ProcessParity(uint8_t PID,
476  uint8_t typeAction);
477 
486 uint8_t LIN_DRV_MakeChecksumByte(const uint8_t *buffer,
487  uint8_t sizeBuffer,
488  uint8_t PID);
489 
505 status_t LIN_DRV_AutoBaudCapture(uint32_t instance);
506 
507 /* @} */
508 
509 #if defined(__cplusplus)
510 }
511 #endif
512 
515 #endif /* LIN_DRIVER_H */
516 /******************************************************************************/
517 /* EOF */
518 /******************************************************************************/
lin_node_state_t
Define type for an enumerating LIN Node state. Implements : lin_node_state_t_Class.
Definition: lin_driver.h:98
volatile bool timeoutCounterFlag
Definition: lin_driver.h:143
status_t LIN_DRV_Init(uint32_t instance, lin_user_config_t *linUserConfig, lin_state_t *linCurrentState)
Initializes an instance LIN Hardware Interface for LIN Network.
Definition: lin_driver.c:62
void LIN_DRV_IRQHandler(uint32_t instance)
Interrupt handler for LIN Hardware Interface.
Definition: lin_driver.c:466
volatile bool baudrateEvalEnable
Definition: lin_driver.h:144
uint8_t checkSum
Definition: lin_driver.h:131
volatile bool isTxBusy
Definition: lin_driver.h:132
volatile lin_event_id_t currentEventId
Definition: lin_driver.h:140
uint8_t currentPid
Definition: lin_driver.h:139
volatile uint32_t timeoutCounter
Definition: lin_driver.h:142
void(* lin_callback_t)(uint32_t instance, void *linState)
LIN Driver callback function type Implements : lin_callback_t_Class.
Definition: lin_driver.h:116
uint32_t baudRate
Definition: lin_driver.h:67
status_t LIN_DRV_ReceiveFrameData(uint32_t instance, uint8_t *rxBuff, uint8_t rxSize)
Receives frame data through the LIN Hardware Interface using non-blocking method. This function will ...
Definition: lin_driver.c:235
status_t LIN_DRV_SendWakeupSignal(uint32_t instance)
Sends a wakeup signal through the LIN Hardware Interface.
Definition: lin_driver.c:336
status_t LIN_DRV_Deinit(uint32_t instance)
Shuts down the LIN Hardware Interface by disabling interrupts and transmitter/receiver.
Definition: lin_driver.c:83
status_t LIN_DRV_DisableIRQ(uint32_t instance)
Disables LIN hardware interrupts.
Definition: lin_driver.c:446
semaphore_t rxCompleted
Definition: lin_driver.h:148
uint8_t cntByte
Definition: lin_driver.h:128
volatile lin_node_state_t currentNodeState
Definition: lin_driver.h:141
void LIN_DRV_SetTimeoutCounter(uint32_t instance, uint32_t timeoutValue)
Set Value for Timeout Counter that is used in LIN_DRV_TimeoutService.
Definition: lin_driver.c:389
lin_event_id_t
Defines types for an enumerating event related to an Identifier. Implements : lin_event_id_t_Class.
Definition: lin_driver.h:77
uint32_t(* lin_timer_get_time_interval_t)(uint32_t *nanoSeconds)
Callback function to get time interval in nanoseconds Implements : lin_timer_get_time_interval_t_Clas...
Definition: lin_driver.h:60
status_t LIN_DRV_MasterSendHeader(uint32_t instance, uint8_t id)
Sends frame header out through the LIN Hardware Interface using a non-blocking method. This function sends LIN Break field, sync field then the ID with correct parity. This function checks if the interface is Master, if not, it will return STATUS_ERROR.This function checks if id is in range from 0 to 0x3F, if not it will return STATUS_ERROR.
Definition: lin_driver.c:409
volatile bool isRxBusy
Definition: lin_driver.h:133
uint32_t linSourceClockFreq
Definition: lin_driver.h:146
volatile uint8_t fallingEdgeInterruptCount
Definition: lin_driver.h:145
lin_callback_t LIN_DRV_InstallCallback(uint32_t instance, lin_callback_t function)
Installs callback function that is used for LIN_DRV_IRQHandler.
Definition: lin_driver.c:102
volatile uint8_t rxSize
Definition: lin_driver.h:130
uint8_t currentId
Definition: lin_driver.h:138
status_t
Status return codes. Common error codes will be a unified enumeration (C enum) that will contain all ...
Definition: status.h:44
lin_timer_get_time_interval_t timerGetTimeIntervalCallback
Definition: lin_driver.h:70
uint8_t LIN_DRV_ProcessParity(uint8_t PID, uint8_t typeAction)
Makes or checks parity bits. If action is checking parity, the function returns ID value if parity bi...
Definition: lin_common.c:58
status_t LIN_DRV_AbortTransferData(uint32_t instance)
Aborts an on-going non-blocking transmission/reception. While performing a non-blocking transferring ...
Definition: lin_driver.c:257
status_t LIN_DRV_GetTransmitStatus(uint32_t instance, uint8_t *bytesRemaining)
Get status of an on-going non-blocking transmission While sending frame data using non-blocking metho...
Definition: lin_driver.c:178
status_t LIN_DRV_AutoBaudCapture(uint32_t instance)
Captures time interval to capture baudrate automatically when enable autobaud feature. This function should only be used in Slave. The timer should be in input capture mode of both rising and falling edges. The timer input capture pin should be externally connected to RXD pin.
Definition: lin_driver.c:484
volatile uint8_t txSize
Definition: lin_driver.h:129
uint8_t * rxBuff
Definition: lin_driver.h:127
void LIN_DRV_TimeoutService(uint32_t instance)
Callback function for Timer Interrupt Handler Users may use (optional, not required) LIN_DRV_TimeoutS...
Definition: lin_driver.c:374
volatile bool isRxBlocking
Definition: lin_driver.h:136
lin_node_state_t LIN_DRV_GetCurrentNodeState(uint32_t instance)
Get the current LIN node state.
Definition: lin_driver.c:354
status_t LIN_DRV_GetReceiveStatus(uint32_t instance, uint8_t *bytesRemaining)
Get status of an on-going non-blocking reception. This function returns whether the data reception is...
Definition: lin_driver.c:280
Runtime state of the LIN driver.
Definition: lin_driver.h:125
status_t LIN_DRV_SendFrameData(uint32_t instance, const uint8_t *txBuff, uint8_t txSize)
Sends frame data out through the LIN Hardware Interface using non-blocking method. This enables an a-sync method for transmitting data. Non-blocking means that the function returns immediately. The application has to get the transmit status to know when the transmit is complete. This function will calculate the checksum byte and send it with the frame data. The function will return immediately after calling this function. If txSize is equal to 0 or greater than 8 or node's current state is in SLEEP mode then the function will return STATUS_ERROR. If isBusBusy is currently true then the function will return LIN_BUS_BUSY.
Definition: lin_driver.c:153
LIN hardware configuration structure Implements : lin_user_config_t_Class.
Definition: lin_driver.h:66
volatile bool isTxBlocking
Definition: lin_driver.h:135
const uint8_t * txBuff
Definition: lin_driver.h:126
status_t LIN_DRV_ReceiveFrameDataBlocking(uint32_t instance, uint8_t *rxBuff, uint8_t rxSize, uint32_t timeoutMSec)
Receives frame data through the LIN Hardware Interface using blocking method. This function receives ...
Definition: lin_driver.c:205
status_t LIN_DRV_GoToSleepMode(uint32_t instance)
Puts current LIN node to sleep mode This function changes current node state to LIN_NODE_STATE_SLEEP_...
Definition: lin_driver.c:300
lin_callback_t Callback
Definition: lin_driver.h:137
uint8_t LIN_DRV_MakeChecksumByte(const uint8_t *buffer, uint8_t sizeBuffer, uint8_t PID)
Makes the checksum byte for a frame.
Definition: lin_common.c:102
semaphore_t txCompleted
Definition: lin_driver.h:147
status_t LIN_DRV_SendFrameDataBlocking(uint32_t instance, const uint8_t *txBuff, uint8_t txSize, uint32_t timeoutMSec)
Sends Frame data out through the LIN Hardware Interface using blocking method. This function will cal...
Definition: lin_driver.c:128
status_t LIN_DRV_GotoIdleState(uint32_t instance)
Puts current LIN node to Idle state This function changes current node state to LIN_NODE_STATE_IDLE.
Definition: lin_driver.c:318
volatile bool isBusBusy
Definition: lin_driver.h:134
status_t LIN_DRV_EnableIRQ(uint32_t instance)
Enables LIN hardware interrupts.
Definition: lin_driver.c:428