AN704-00007-2v0-E
16-BIT MICROCONTROLLER
F2MC-16FX Family
MB96600 series
How to control LIN communication
AN704-00007-2v0-E
All Rights Reserved.
The contents of this document are subject to change without notice. Customers are advised to consult with
FUJITSU sales representatives before ordering.
The information, such as descriptions of function and application circuit examples, in this document are
presented solely for the purpose of reference to show examples of operations and uses of Fujitsu
semiconductor device; Fujitsu does not warrant proper operation of the device with respect to use based on
such information. When you develop equipment incorporating the device based on such information, you
must assume any responsibility arising out of such use of the information. Fujitsu assumes no liability for
any damages whatsoever arising out of the use of the information.
Any information in this document, including descriptions of function and schematic diagrams, shall not be
construed as license of the use or exercise of any intellectual property right, such as patent right or
copyright, or any other right of Fujitsu or any third party or does Fujitsu warrant non-infringement of any
third-party’s intellectual property right or other right by using such information. Fujitsu assumes no liability
for any infringement of the intellectual property rights or other rights of third parties which would result from
the use of information contained herein.
The products described in this document are designed, developed and manufactured as contemplated for
general use, including without limitation, ordinary industrial use, general office use, personal use, and
household use, but are not designed, developed and manufactured as contemplated (1) for use
accompanying fatal risks or dangers that, unless extremely high safety is secured, could have a serious
effect to the public, and could lead directly to death, personal injury, severe physical damage or other loss
(i.e., nuclear reaction control in nuclear facility, aircraft flight control, air traffic control, mass transport
control, medical life support system, missile launch control in weapon system), or (2) for use requiring
extremely high reliability (i.e., submersible repeater and artificial satellite).
Please note that Fujitsu will not be liable against you and/or any third party for any claims or damages
arising in connection with above-mentioned uses of the products.
Any semiconductor devices have an inherent chance of failure. You must protect against injury, damage or
loss from such failures by incorporating safety design measures into your facility and equipment such as
redundancy, fire protection, and prevention of over-current levels and other abnormal operating conditions.
If any products described in this document represent goods or technologies subject to certain restrictions on
export under the Foreign Exchange and Foreign Trade Law of Japan, the prior authorization by Japanese
government will be required for export of those products from Japan.
The company names and brand names herein are the trademarks or registered trademarks of their
respective owners.
Copyright© 2011-2012 FUJITSU SEMICONDUCTOR LIMITED all rights reserved
1
AN704-00007-2v0-E
Revision History
Rev
Date
Remark
1.0
2011.10.28
First Edition
2.0
2012.4.10
Target Products are added.
2
AN704-00007-2v0-E
Subject
Revision History...................................................................................................................... 2
Subject .................................................................................................................................... 3
Target Products ...................................................................................................................... 4
1
Introduction...................................................................................................................... 5
2
Outline of LIN .................................................................................................................. 6
2.1
What is LIN?............................................................................................................. 6
2.2
LIN specifications ..................................................................................................... 8
2.2.1
3
2.3
LIN communication flow..........................................................................................11
2.4
Communication between master and slave if an error occurs .............................. 13
Hardware Description.................................................................................................... 14
3.1
Detail of hardware environment ............................................................................. 14
3.1.1
4
Lin frame configuration ..................................................................................... 8
LIN/IF .............................................................................................................. 15
Software Description ..................................................................................................... 18
4.1
LIN Driver software overview ................................................................................. 18
4.1.1
LIN communication configuration ................................................................... 19
4.2
LIN Driver program setting ..................................................................................... 21
4.3
LIN Master Sample Program ................................................................................. 22
4.4
LIN Slave Sample program.................................................................................... 35
3
AN704-00007-2v0-E
Target Products
This application note is described about below products;
Series
MB96610
MB96620
MB96630
MB96640
MB96650
MB96670
MB96680
MB96690
MB966A0
MB966B0
MB966C0
Product Number (not included Package suffix）
MB96F612R, MB96F612A
MB96F613R, MB96F613A
MB96F615R, MB96F615A
MB96F622R, MB96F622A
MB96F623R, MB96F623A
MB96F625R, MB96F625A
MB96F633R, MB96F633A
MB96F635R, MB96F635A
MB96F636R
MB96F637R
MB96F643R, MB96F643A
MB96F645R, MB96F645A
MB96F646R
MB96F647R
MB96F653R, MB96F653A
MB96F655R, MB96F655A
MB96F656R
MB96F657R
MB96F673R, MB96F673A
MB96F675R, MB96F675A
MB96F683R, MB96F683A
MB96F685R, MB96F685A
MB96F693R, MB96F693A
MB96F695R, MB96F695A
MB96F696R
MB96F6A5R, MB96F6A5A
MB96F6A6R
MB96F6B5R, MB96F6B5A
MB96F6B6R
MB96F6C5R, MB96F6C5A
MB96F6C6R
4
AN704-00007-2v0-E
1
Introduction
This application note explains the method of control LIN Master and LIN Slave with
F2MC-16FX(MB96F615). You can apply to various applications to perform LIN control.
5
AN704-00007-2v0-E
2
Outline of LIN
2.1
What is LIN?
LIN is an acronym for Local Interconnect Network, and is a type of communications
protocol for vehicle-mounted LAN. The LIN consortium was proposed in 1999 with the
objective of enabling a less expensive configuration than CAN, which is the most
widespread control system vehicle-mounted LAN. Thereafter, after several version
upgrades, LIN2.0, which has added diagnostic and other functions, was launched in 2003.
Further, in 2006, the version was upgraded to LIN2.1.
This section explains LIN applications. Concomitant with multi-function vehicles, the
existence of a network in vehicles also became indispensable. Currently, vehicle-mounted
LANs are broadly divided into two classifications: control systems, which are concerned
with motoring and the vehicle body, and information systems, which connect devices such
as the satellite navigation system and audio, and so different LANs are used depending
on the application. In particular, vehicle body devices such as electric mirrors and power
windows, which are classified as body systems, do not require such fast or detailed
control. Consequently, they are also inexpensive. This is where LIN is used.
Accessories

Wipers

Back mirror

Switch control
Seats

Power seat and motor control

Passenger detection

Heater

Switch control
AC

Motor control

Rear panel
Rear

Rear window heater

Rear wiper

Rear blinkers
Doors

Switch control

Power windows

Mirror control
Figure 1 Example of vehicle LIN applications
6
AN704-00007-2v0-E
The characteristics of LIN used in the way described above, are collated and introduced in
the following five points.
1.
Single master communication
LIN has two types of communication nodes. One is the “master” (sender).This controls
the start of all communications. The other is the slave (recipient).The slave responds to
commands sent by the master. LIN communication must start from the master, and
cannot be started by a slave. Further, the LIN communication mode designated as the
master is pre-determined. This format is called a “single master format”.
2.
A maximum of 15 slave nodes can be connected using bus wiring.
The LIN network configuration (topology) is a bus. With single master LINs, the slaves
communicate only when they receive commands from the master, so there is no conflict
of signals in the bus. A maximum of 15 slave nodes can be connected to one master.
Master
(Door)
Communications cannot be
started from the slave!!
Communications can be
started from the master
Slave1
(Mirror)
Slave2
(Door Lock)
Slave3
(Windows)
Slave15
Up to 15 slaves max. can be connected
Transceiver IC (Electronic component for sending and
receiving data)
Figure 2 Main LIN network configuration
3.
Wiring is completed using a single wire
The on-board ECUs are connected to the LIN network via transceiver ICs (electronic
7
AN704-00007-2v0-E
components that send and receive data), and each ECU is connected on the bus from
the master to a slave. An ordinary single metal wire is used as the bus cable. CAN
combines two opposing metal wires to make one twisted pair cable. FlexRay uses two
twisted pair cables. Consequently, LIN has the advantage of using a single cable for
numerous network wires, unlike CAN and FlexRay, which use twisted pair cables.
The communications distance is 40m max. LIN can be used in combination with CAN,
and in such cases, CAN is most frequently used as the core network, and LIN is used
as the branch network.
4.
The baud rate is 20kbps max.
L The baud rate according to LIN specifications is within the range 1 to 20kbps.
Practically, the baud rate of LINs used as LANs depends on the individual vehicle
manufacturer’s system specifications, but generally one of the following is used:
2,400bps, 9,600bps, or 19,200bps.
5.
Communications errors are detected only, and subsequent processing depends on the
application
With LIN, communications errors are detected based on information as to whether
transmitting and receiving has been performed successfully. Processing after an error
has been detected, however, is not specified. Here, LIN error processing can be
customized according to the application. CAN and FlexRay management of the
communications status depends on the counter value, which is called the error counter,
is featured by the specifications, but in LIN, if an error occurs, simple error processing is
possible, in which LIN merely waits for the next command.
2.2 LIN specifications
This section explains briefly the LIN specifications.
For detailed specifications, access the LIN consortium website
(http://www.lin-subbus.org/), and register your name and e-mail address to get a
specifications.
2.2.1
Lin frame configuration
This section explains frames, which is the basic unit of LIN communication.
LIN frames are configured using “headers” and “responses”. As shown in Figure 3
8
LIN
AN704-00007-2v0-E
communication flow, the basic communications flow is a procedure in which the master
sends headers to the slaves, and the slaves implement processing according to the
contents of the headers received, and then send a response to the master.
Slave
Master
Header
Identifier
Sync byte
Break
Response
Data
Figure 3
Check sum
LIN communication flow
Further, header is configured using three fields: Sync break (Break), Sync field (Sync
byte), and ID field (Identifier), and responses are configured using two fields: Data field and
Checksum field.
Response
Header
DATA1
ID
Break
Sync Byte
ID Field
DATAN
Data Field
：Start bit(“L”)
：Stop bit(“H”)
：Interval
：Response space
：Break delimiter
：Inter-frame space
Figure 4 LIN frame configuration
9
Check Sum
Checksum Field
AN704-00007-2v0-E
1.
Break
Break, which are in the header fields, are variable-length fields that indicate the
start of a new frame. They comprise 13 to 16 “0” bits (fixed value zero) min.
2.
Sync field
Sync filed, which follow on from breaks, are 10-bit fixed-length fields that
synchronize the master and the slaves. Sync byte configurations comprise 1 starter
bit (“0”), 8 data bits, and 1 stop bit (“1”).The 8-bit data bit has the fixed value “0x55”
(which is expressed as “0x01010101” in binary).If the slave receives the 0x55 in
the sync filed send by the master normally, the master and slave are synchronized.
3.
ID field
The “ID field”, which is the final header field and comes after the synchronous byte,
is a 10-bit fixed-length field that specifies the frame type and objective. ID fields
have values from “0” to “63” (6 bits).This ID field is also used by the master to
specify individual slaves. Slaves judge what type of frame has been sent and if it
was intended for them according to the ID field sent by the master, and send
responses to the master accordingly. Further, the ID field has a 2-bit parity bit
following the “0” to “63” (6 bits).This is bracketed by a 1-bit starter bit and 1-bit stop
bit in the same way as the synchronous byte, so overall the field is 10 bits in length.
4.
Data field
The “data”, which is in the response header, is a variable-length field that literally
transfers data. The data in the number of bytes that has been predetermined (1 to
8 bytes) is sent. As there is a 1-bit start bit and 1-bit stop bit bracketing the 1-byte
data in the same way as the header synchronous byte, 1 byte of data is configured
from 10 bits. Consequently, the total data field length is “number of bytes x 10
bites”.
5.
Checksum field
The “checksum”, which follows the data, is a 10-bit fixed-length field for checking
data. The data recipient checks whether there is an error in the data by comparing
the data received with the checksum. The checksum field length is also 10 bits: a
start bit and a stop bit added to the 8-bit checksum in the same way as the
synchronous byte.
10
AN704-00007-2v0-E
2.3 LIN communication flow
In general LIN communication, one master communicates with numerous slaves. LINs,
which adopt a bus topology, connect the master and all the slaves using a single wire, so
header electrical signals sent by the master are transmitted by the wire to all the slaves.
The slaves check the frame ID, and if the header is addressed to them, sent a response to
the master according to the content received. If the header received is addressed to
another slave, it is ignored. In this way, 1-to-1 communication between the master and
each slave is achieved.
This section explains the actual trading of communications. Currently, functions are
allocated to each of the slaves from 1 to 15.The master first communicates with slave 1
and turns the motor ((1) in Figure 5 Main LIN network configuration and Figure 6 Example
of
communication
sequence
between
the master and
slaves
during normal
communication), and next acquires sensor information by communicating with slave 3.
((2) in Figure 5 Main LIN network configuration and Figure 6 Example of communication
sequence between the master and slaves during normal communication.) Thereafter, the
motor is turned by communications with slave 2 ((3) in Figure 5 Main LIN network
configuration and Figure 6 Communications sequence between master and slave during
normal communications).The master acquires sensor information from slave 3 again ((4)
in Figure 5 Main LIN network configuration and Figure 6 Communications sequence
between master and slave during normal communications), and finally turns ON the lamp
by communicating with slave 15 ((5) in Figure 5 Main LIN network configuration and
Figure 6 Communications sequence between master and slave during normal
communications).In this chain of communications, communications between the master
and slaves 2 and 3 are contiguous, and the master processes the motor turning by
communicating with slave 2 using sensor information acquired by communicating with
slave 3 first. In this way, during actual communications the master and multiple slaves
repeatedly communicate on a 1-to-1 basis.
11
AN704-00007-2v0-E
Master
Slave 1
Slave 2
Motor
Slave 3
Slave 15
Motor
Sensor
: Transceiver IC (electronic component
for sending and receiving data)
Figure 5 Main LIN network configuration
Master
Slave 1
Slave 2
Slave 3
Slave 15
Motor
operation
All communications
start from the master
Acquiring
sensor
information
Motor
operation
Acquiring
sensor
information
Lamp
ON
Figure 6 Example of communication sequence between the master and slaves during
normal communication
12
AN704-00007-2v0-E
2.4 Communication between master and slave if an error occurs
LIN error processing is not determined by the protocols, and so depends on the
application. Consequently, during design, it is necessary to consider the error detection
methods and the process after the error has been processed. As this is not determined by
the protocols in the LIN specifications either, however, examples of system design if an
error occurs are introduced in the chapter “Status Management”. In the examples
introduced, errors are managed by slaves reporting their own status to the master. This
mechanism is described below.
The basic master operation is merely to send the header to the next slave when
communications with the current slave have ended. On the other hand, the slave
operation is to perform error checking when a header is received and when a response is
sent. Checksums and other checks are implemented during reception. When sending,
checks are performed by comparing the sent data and the bus data that performs the
monitoring. In this way, the slave identifies its own status, and inserts the results into the
response that is sent to the master. The master identifies the slave status from the
response, and if there is a nonconformance, initializes the slave. In this way, the error
status is completely cleared.
13
AN704-00007-2v0-E
3
Hardware Description
The hardware function overview for LIN communication is shown Figure 7 Hardware
function overview for LIN communication. Master Unit and Slave Unit have LED for output
and Push SW and Volume SW for input each together. LIN sample software is capable of
transmitting input information of these SW to a facing unit via LIN bus and performs LED
control.
Figure 7 Hardware function overview for LIN communication
3.1
Detail of hardware environment
Evaluation environment for LIN communication control are as follows. These are provided
from Fujitsu semiconductor.
-Fujitsu Semiconductor MCU: MB96F615
-Fujitsu Semiconductor MCU Evaluation board: MB2198-760-E
-MB96610 Evaluation board: MB2198-761-01-E
Figure 8 Hardware environment for LIN communication
14
AN704-00007-2v0-E
3.1.1
LIN/IF
The circuit configuration of LIN is shown below. The LIN interface is mounted on Fujitsu
Semiconductor MCU Evaluation board by two channels. LIN power supply setting of LIN
transceiver (MAX13020) can be selected by LIN_PWR and can be chosen from internal
power (default) or external power. It is necessary to short JP46 to use for LIN Master.
Figure 9 LIN I/F circuit configuration
Figure 10 LIN I/F pin assigns (D-SUB9)
15
AN704-00007-2v0-E
Figure 11 LIN I/F connector
LIN communication environment image is shown below. LIN USART channel 7 is used for
LIN communication in LIN sample software. In the evaluation environment of the MB96610
series, LIN-USART channel 7 is connected the LIN ch.0 of MB2198-760-E.
Figure 12 Top View of LIN communication environment
16
AN704-00007-2v0-E
Figure 13 Connection of LIN
17
AN704-00007-2v0-E
4
Software Description
The project software can be separated into two main parts. The first part comprises the
LIN driver control, the second part is application program.
Figure 14 Project Folder
4.1
LIN Driver software overview
The functions of LIN driver software provided are as follows.
- Enable to change LIN Master and LIN Slave function
- Selecting Baud rate (2400/9600/19200bps)
- Enable to add new LIN message ID and DATA easily
- Synchronization control in sync field (LIN slave only)
- Wake up output (LIN slave only)
- Application software including SW and Analog input and LED control
The peripherals used in LIN sample software is shown below.
Figure 15 The peripherals used in LIN sample software
18
AN704-00007-2v0-E
4.1.1
LIN communication configuration
The LIN communication parameters used by the sample program are summarized in Table 1
LIN communication conditions of the sample program.
Table 1 LIN communication conditions of the sample program
Condition
Value
Baud rate
2400/9600/19200bps
Input frequency
4MHz
Peripheral
16MHz(PLL on)
Clock2(CLKP2)
for LIN Clock
13 bit (Reception is fixed to
Sync Break length
detect 11 bits)
Data length
8bit
Data bit format
LSB first
Data byte count
8Byte
The LIN message ID used in LIN communication are described in “Table 2
LIN message
ID and data in the sample program”. Even number of LIN ID is used for data transmit from
master to slave, and odd number of LIN ID is used for data transmit from slave to master.
19
AN704-00007-2v0-E
Table 2
LIN message ID and data in the sample program
※H: Header R: Response
Contents of Data for each LIN ID are below.
○LIN ID:0x00
byte 0:Get command of Slave AD value (If byte0 is 0x55, command is active)
byte 1:Analog value of LIN Master volume SW
○LIN ID:0x01
byte 2:Analog value of LIN Slave volume SW
○LIN ID:0x02
byte 0：Control command of LED01(If byte0 is 0x55, command is active)
byte 1：LIN Master SW4 count value
○LIN ID:0x03
byte 2：LIN Slave SW4 count value
○LIN ID:0x04
byte 0：Control command of LED23(If byte0 is 0x55, command is active)
byte 3：LIN Master SW7 count value
○LIN ID:0x05
byte 4：LIN Slave SW7 count value
20
AN704-00007-2v0-E
4.2
LIN Driver program setting
This sample program can operate as both LIN Master and LIN slave. Please select the
function definition in lindmsg.h.
○In case of using LIN Master: #define
LIN_MASTER 1
○In case of using LIN Slave: #define LIN_MASTER 0
/*===============================================================*/
/*Function definition
*/
/*
BASE_TIME:
5[ms]
*/
/*
LIN_MASTER:
0:SLABE NODE, 1:MASTER NODE
*/
/*
LINUART_CH:
7
*/
/*
EXTERNAL_INT:
10
*/
/*
FREE_RUN_TIMER_CH
1
*/
/*
OUTPUT_COMPARE_CH
6
*/
/*===============================================================*/
#define
BASE_TIME
5
#define
LIN_MASTER
1
#define
LINUART_CH
7
#define
EXTERNAL_INT
10
#define
FREERUN_TIMER_CH
1
#define
OUTPUT_COMPARE_CH
6
Figure 16 Selection of LIN Node(lindbmsg.h)
As for baud rate setting, you can select three type of baud rate setting by changing baud
rate definition in lindmsg.h.
○In case of 2400 bps: #define
BAUD_RATE
2400
○In case of 9600 bps: #define
BAUD_RATE
9600
○In case of 19200 bps: #define BAUD_RATE 19200
/*========================================================*/
/*
BAUDRATE Definition (2400/9600/19200)
/*========================================================*/
#define
BAUD_RATE
9600
#define
BAUD_RATE_ADJUST
1
Figure 17 Changing of baud rate
21
*/
AN704-00007-2v0-E
4.3
LIN Master Sample Program
The flowcharts for the LIN communication in the sample program are shown in Figure 18
LIN communication flowchart (main routine) and Figure 19 LIN communication flowchart
(LIN USART receive interrupt routine). First, the microcontroller is initialized, the LIN-USART
is initialized, and the timer is initialized. Next, the bus connection processing is performed as
the LIN master, and the schedule is set. After this, the program enters a loop. Within the loop,
headers are sent and responses are sent and received at fixed intervals. Sending of the
sync break, sync field, and ID field headers and sending and receiving of responses is
processed by the LIN-USART receive interrupt. Processing is performed in response to the
master ID (identifier).
START
Microcontroller
initialization
LIN-USART
initialization
Timer
initialization
LIN bus connection
processing
Set schedule
Infinite loop
Figure 18 LIN communication flowchart (main routine)
22
AN704-00007-2v0-E
USART receive
interrupt occurred
Start USART receive
interrupt processing
Send ID field
Receive ID?
No
Yes
Data receive
processing
Data send
processing
Checksum receive
processing
Checksum send
processing
Send sync break
and sync field
End USART receive
interrupt processing
Figure 19 LIN communication flowchart (LIN USART receive interrupt routine)
23
AN704-00007-2v0-E
ID field receive
START Application program
for LIN ID
ID=0x00 ?
Yes
AD conversion
Transmit 0x55 and
AD value
No
ID=0x01 ?
Yes
No
ID=0x02 ?
Get Slave AD
value and change
LED4-7 Output
Yes
No
Get Master SW4
count
Transmit 0x55 and
Master SW4 count
Yes
ID=0x03 ?
No
ID=0x04 ?
Get Slave SW4 count
and change LED01
output
Yes
No
Get Master SW7
count
Transmit 0x55 and
Master SW7 count
Yes
ID=0x05 ?
Get Slave SW7 count
and change LED23
output
No
Yes
ID=0x06 ?
No
Transmit 0x66
(Sample Data)
Yes
ID=0x07 ?
No
Transmit 0x77
(Sample Data)
End Application program
for LIN ID
Figure 20 LIN communication flowchart (data processing by ID)
24
AN704-00007-2v0-E
The points where this sample program operates in the LIN protocol during LIN
communication are shown below. Because the sample program is the LIN master, the LIN
bus connection processing and schedule registration are performed first.
void
main(void)
{
(omitted)
l_ifc_connect(hLIN_NORMAL_WAKEUP);
← LIN bus connection
l_sch_set(hSchedule1, Schedule1_DATA00);
←Set schedule
Figure 21 LIN bus initial settings
Parts of the section that sets the LIN ID and sets the schedule is shown below.
In the sample program, one schedule table and eight IDs are used. The IDs that actually use
a response are ID 0x00 to ID 0x05.
typedef
enum {
←Register 8 IDs
Schedule1_DATA00 = 0,
Schedule1_DATA01,
Schedule1_DATA02,
Schedule1_DATA03,
Schedule1_DATA04,
Schedule1_DATA05,
Schedule1_DATA06,
Schedule1_DATA07,
(omitted)
#define
Schedule1Count
←Register 8 IDs
8
(omitted)
__far const
←Register 8 IDs
l_u8
Schedule1_IdList[Schedule1Count] =
{
ID_00, ID_01, ID_02, ID_03, ID_04, ID_05, ID_06, ID_07
Figure 22 LIN ID registration – Lindbmaster.h
25
};
AN704-00007-2v0-E
← Register send response
l_u8*
__far const
/*
0
/* 0*/
ucDATA00, 0, ucDATA02, 0, ucDATA04, 0, ucDATA06, 0, 0, 0,
/*10*/
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1
2
LinTxDataPtr[64] = {
3
4
5
6
7 8
9
*/
(omitted)
← Register receive response
l_u8*
__far const
/*
0
/* 0*/
0, ucDATA01, 0, ucDATA03, 0, ucDATA05, 0, ucDATA07, 0, 0,
1
2
Figure 23
LinRxDataPtr[64] = {
3
4
5
6
7 8
9
*/
Transmit and receive response registration – Lindbmsg.h
This sample program operates by processing multiple interrupts, as shown in Figure 24
Points where the processing of each interrupt is performed. We will now look at the
processing performed by the sample program for each field of the LIN protocol.
HEADER
Sync Break
RESPONSE
Sync Field
ID Field
Data Field
ID
Sync break detect
interrupt
Figure 24
LIN receive
interrupt
(receive sync field)
DT
LIN receive
LIN receive
interrupt Freerun Timer
interrupt
(receive ID)
(receive Data)
interrupt
DT
LIN receive
interrupt
(receive Data)
Check Sum
LIN receive interrupt
(receive Checksum)
Points where the processing of each interrupt is performed
1. Sync break
On sync break, a sync break signal (a low signal for 13 to 16 bits) is sent. In the
sample program, 13 bit are sent. Receive processing is also performed at the same
time, and if the bus is “0” for 11 bit times or more, a sync break interrupt (LBD) occurs.
After a sync break interrupt is detected, the sync break interrupt is set to disabled.
26
AN704-00007-2v0-E
Serial clock cycle
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16
Transmit DATA
Sync break
LBR LIN LIN
Synch
break生成ビット
synch
break
generate bit
0
1
影響なし
No
effect
LIN SynchLIN
break
生成break
Generate
synch
Figure 25
__interrupt void
LBL0
LBL1
LIN
Synch
break長選択ビット
LIN
synch
break
length selection bits
0
0
13ビット分
13
bits long
1
0
14ビット分
14
bits long
0
1
15ビット分
15
bits long
1
1
16ビット分
16
bits long
Sync break data setting
_LinUartRx(void)
{
← Error check
if ((ssr & 0xE0) != 0) {
(omitted)
} else if (IO_UART7_ESCR7_bit_LBD == SET) {
#if
← Sync break detection
(LIN_MASTER==1)
IO_UART7_ESCR7_bit_LBD = CLEAR;
← Clear sync break detection flag
(omitted)
}else{
← Receive processing
l_ifc_rx(data);
Figure 26
Sync break interrupt control
2. Sync field
After a sync break is detected, processing is performed to send and receive the
synch field. 0x55 is sent in the synch field. If this data is successfully received by the
slave, the slave becomes synchronized.
27
AN704-00007-2v0-E
Sync field
START 0 1 2 3 4 5 6 7 STOP
BIT
BIT
DATA = 0x55
8Tbit
2Tbit
2Tbit
2Tbit
2Tbit
First
Time
Fifth
Time
Figure 27
Sync field interrupt control
Sync field reception is performed in l_ifc_rx(l_ifc_handle rx_data). The processing for sync
break reception, sync field reception, ID reception, DATA transmission and reception, and
WAKEUP transmission are split up according to the status,
void
l_ifc_rx(l_ifc_handle rx_data)
{
switch(ucLinStatus){
case
← Transmit DATA FIELD
LIN_TRANSMIT:
(omitted)
case
← Receive DATA FIELD
LIN_DATA_RECEPTION:
(omitted)
case
← Wait to receive ID FIELD
LIN_ID_RECEPTION:
(omitted)
case
← Wait to receive Synch field
LIN_WAIT_SYNCH_FIELD:
(omitted)
case
←Sync break 受信待ち
LIN_MS_WAIT_SYNCH_BREAK:
IO_UART7_ESCR7_byte = 0x00;
← Clear ESCR register
(omitted)
ucLinStatus = LIN_WAIT_SYNCH_FIELD;
case
← Switch to wait to receive
(omitted)
Sync field state
LIN_WAKEUP_TRANSMIT:
← Transmit WAKEUP state
(omitted)
｝
Figure 28
Processing to determine whether synch break was received
28
AN704-00007-2v0-E
In Figure 29 sync field receive processing, once it has been confirmed that the data
is 0x55, the program enters a state of waiting to receive the ID field and performs ID
send processing.
void
l_ifc_rx(l_ifc_handle rx_data)
{
(omitted)
case
LIN_WAIT_SYNCH_FIELD:
← Wait to receive sync field
if (rx_data == SYNCH_FIELD_CHAR) {
← Check if Sync field is 0x55
ucLinStatus = LIN_ID_RECEPTION;
← Switch to wait to receive ID
l_ifc_tx(ucLinMsScheduleCurrentId);
← Transmit ID processing
(omitted)
(omitted)
Figure 29 sync field receive processing
The transmit data is stored in a register within the send start processing function
l_ifc_tx(l_ifc_handle tx_data) as shown in Figure 30 USART transmit start processing.
void
l_ifc_tx(l_ifc_handle tx_data)
{
#if
(LINUART_CH == 3)
← Set transmit data in register
IO_UART3_RDR3 = tx_data;
(omitted)
Figure 30 USART transmit start processing
3. ID field
In order to transition to the state of waiting to receive the ID field, the ID receive
determination processing is performed in the normal sequence in the ID receive
processing, as shown in Figure 31
ID receive determination processing. In the ID
receive determination processing, a judgment is made as to whether the acquired ID
is for sending or for receiving and a parity check is performed. If the ID is for sending,
the status is changed to the send preparation state and the send data is copied to a
29
AN704-00007-2v0-E
buffer. If the ID is for receiving, the status is changed to the DATA receive wait state
in preparation for receiving a response (data) from the slave.
void
l_ifc_rx(l_ifc_handle rx_data){
(omitted)
case
← Wait to receive ID FIELD state
LIN_ID_RECEPTION:
ucCurrentId.byte
← Store received ID
= rx_data;
if( ucCurrentId.fields.parity != ucRightParity[ucCurrentId.fields.id] ) {
← Parity check
← Error processing
l_flg_tst(hBIT_ERR);
l_flg_clr(hBIT_ERR);
(omitted)
} else if( LinRxDataPtr[ucCurrentId.fields.id] != 0 ) { ← If receive ID
ucLinStatus = LIN_DATA_RECEPTION;
← DATA receive wait state
(omitted)
vSetLinFreerunTimersCompare(ucRxCount);
← Set Freerun timer
} else if ( LinTxDataPtr[ucCurrentId.fields.id] != 0 ) { ← If transmit ID
(omitted)
↓ Copy send data to buffer
vLinWordCopy(ucUartTxBuffer, LinTxDataPtr[ucCurrentId.fields.id], ucTxCount);
vSetLinFreerunTimersCompare(hTINFRAME_SPACE_IND);← Set Freerun timer
}
(omitted)
}
}
Figure 31
ID receive determination processing
30
AN704-00007-2v0-E
4. DATA field
This section explains data transmission and reception in the DATA field.
As for Data transmission, if the receive ID is for transmit, vTimeoutCheckTask
function for timeout process is called by detecting freerun timer interrupt at first. This
function is called when the timeout value configured in the free-running timer is
detected, and in this case, the function is called when the timeout value from
receiving the header to sending the response (response space) is detected.
The vTimeoutCheckTask function is divided into send pre-processing, initialization
processing, etc. depending on the status information. When the status is the send
pre-processing state, the first byte of the data is sent.
void
vTimeoutCheckTask(void){
(omitted)
if ( uiIntDemandCounter == 0 ) {
switch ( ucLinStatus ) {
case
← Pre-transmit state
LIN_PRETRANSMIT:
ucLinStatus = LIN_TRANSMIT;
← State transition: Transmit DATA FIELD state
ucSaveData = ucUartTxBuffer[0];
← Transmit data: Acquire 1 byte
l_ifc_tx(ucUartTxBuffer[0]);
← Data transmit processing
(omitted)
case
LIN_UART_INITIAL:
(omitted)
case
LIN_ID_RECEPTION:
(omitted)
case
LIN_DATA_RECEPTION:
(omitted)
case
LIN_TRANSMIT:
(omitted)
case
LIN_WAIT_SYNCH_FIELD_START:
(omitted)
}
}
Figure 32
Timeout detection processing
31
AN704-00007-2v0-E
When the first byte of data is sent, a receive interrupt occurs due to receiving the data
that the program itself sent. Therefore, in the same way as the operation for the ID
field, the receive determination processing function _ifc_rx(l_ifc_handle rx_data) is
called, and processing to send the second and subsequent data is performed based
on the send state of the DATA FIELD as shown in Figure 33 DATA transmit
processing, with this same process repeated over and over. Because the data byte
count is set to 8 in the current LIN communication, after the 8th bytes of DATA has
been sent the Checksum is finally sent and the send processing finishes.
void
l_ifc_rx(l_ifc_handle rx_data){
switch(ucLinStatus){
case
LIN_TRANSMIT:
← Transmit DATA FIELD
if ( ucTxCurrentIndex < ucTxCount ){
← If transmit DATA remains
(omitted)
l_ifc_tx(ucUartTxBuffer[ucTxCurrentIndex]);
← Transmit processing
(omitted)
} else if ( ucTxCurrentIndex == ucTxCount ){
← If all transmit data has been sent
(omitted)
l_ifc_tx(((unsigned char)~uiTxCheckSum));
← Transmit checksum
(omitted)
}
case
LIN_DATA_RECEPTION:
(omitted)
case
LIN_ID_RECEPTION:
(omitted)
case
LIN_WAKEUP_TRANSMIT:
(omitted)
}
}
Figure 33 DATA transmit processing
32
AN704-00007-2v0-E
If the ID acquired in the ID receive processing is for receiving, the status is changed
to the DATA receive state and the program waits to receive data from the bits pot
yellow. If an interrupt occurs due to receiving data from the bits pot yellow, the receive
processing is performed within the receive processing function l_ifc_rx(data) as
shown in Figure 34
DATA receive processing. For the case of receiving data, the
receive processing is performed by l_ifc_rx(l_ifc_handle rx_data) for each single byte
of data received, and once all 8 bytes of data have been received, the receive
success flag is set if there are no checksum errors and the receive processing
finishes.
void
l_ifc_rx(l_ifc_handle rx_data){
switch(ucLinStatus){
case
LIN_TRANSMIT:
(omitted)
case
← Receive DATA FIELD
LIN_DATA_RECEPTION:
if ( ucRxCurrentIndex >= ucRxCount ) {
← If all data has been received
if ( (uiRxCheckSum + rx_data) == 0xFF ) {
← If checksum calculation is correct
(omitted)
flagsLinTxRx.bit.SucceedReception = SET;
← Set receive success flag
memcpy( &ucUartRxFixedBuffer[0], &ucUartRxBuffer[0], ucRxCount );
↑ Copy received data
(omitted)
← If there is a checksum error
} else {
l_flg_tst(hCHECKSUM_ERR);
← Error processing
← If there is receive data remaining
} else {
ucUartRxBuffer[ucRxCurrentIndex] = rx_data;
(omitted)
case
LIN_ID_RECEPTION:
(omitted)
case
LIN_WAKEUP_TRANSMIT:
(omitted)
}
}
Figure 34
DATA receive processing
33
← Store receive data in buffer
AN704-00007-2v0-E
Finally, the vBaseTimeTask function in main.c checks whether sending and receiving has
finished primarily. If this function is called when all of the data reception has finished
(flagsLinTxRx.bit.SucceedReception is set), the sub_control function in submain.c is called
and perform application program shown in Figure 20 LIN communication flowchart (data
processing by ID).
34
AN704-00007-2v0-E
4.4
LIN Slave Sample program
The LIN communication flowcharts for the sample programs are shown in Figure 35 LIN
communication flowchart (main routine) and Figure 36 LIN communication flowchart (LIN
USART receive interrupt routine). First, initialize the microcontroller, LIN-USART, and timer.
Next, implement LIN bus connection processing as a LIN slave. Thereafter, the program
enters a loop. Within the loop, monitor whether the data being sent and received can be
completed in a fixed cycle, and when the data has finished being received, implement
processing according to the ID. Synch break detection, ID reception, and data sending and
receiving to operate as a LIN slave is processed using LIN-UART reception interrupts.
Further, the baud rate is adjusted within the input capture interrupts as described in Figure
37 LIN communication flowchart (Input Capture interrupt).
START
Microcontroller
initialization
LIN-USART
initialization
Timer
initialization
LIN bus connection
processing
Set schedule
Infinite loop
Figure 35 LIN communication flowchart (main routine)
35
AN704-00007-2v0-E
USART receive
interrupt occurred
Start USART receive
interrupt processing
Send ID field
Receive ID?
No
Yes
Data receive
processing
Data send
processing
Checksum receive
processing
Checksum send
processing
Send sync break
and sync field
End USART receive
interrupt processing
Figure 36 LIN communication flowchart (LIN USART receive interrupt routine)
36
AN704-00007-2v0-E
Occur input capture
interruption
Start input capture
interrupt process
Get value of ICU Timer1
Get value of ICU Timer2
Baud rate adjust
End input capture
interrupt process
Figure 37 LIN communication flowchart (Input Capture interrupt)
37
AN704-00007-2v0-E
ID field reception
Start Application program for
LIN ID
Yes
ID=0x00 ?
ucDATA00[0]
== 0x55 ?
No
No
ID=0x01 ?
Get Master AD
value and change
LED4-7 Output
Yes
No
ID=0x02 ?
Yes
Transmit Slave
AD value
Yes
No
ucDATA02[0]
== 0x55 ?
Yes
No
Get Master SW4 count
And change LED01
output
Yes
ID=0x03 ?
No
Get Slave SW4
count
Transmit Slave
SW4 count
No
ID=0x04 ?
Yes
No
ucDATA04[0]
== 0x55 ?
Get Master SW7
count And change
LED23 output
No
ID=0x05 ?
Yes
No
Get Slave SW7
count
Transmit Slave
SW7 count
Yes
ID=0x06 ?
No
Transmit 0x66
(Sample Data)
Yes
ID=0x07 ?
No
Transmit 0x77
(Sample Data)
End Application program
for LIN ID
Figure 38 LIN communication flowchart (data processing by ID)
38
AN704-00007-2v0-E
This sample program operates by processing multiple interrupts, as shown in Figure 39
Points where the processing of each interrupt is performed Points where the processing of
each interrupt is performed. We will now look at the processing performed by the sample
program for each field of the LIN protocol.
RESPONSE
HEADER
Sync Break
Sync Field
ID Field
Data Field
ID
Sync break detect Input capture Input capture
interrupt
interrupt
interrupt
DT
DT
LIN receive
LIN receive
interrupt
interrupt Freerun Timer
(receive Data)
(receive ID)
interrupt
LIN receive
interrupt
(receive Data)
Check Sum
LIN receive interrupt
(receive Checksum)
Figure 39 Points where the processing of each interrupt is performed
1.
Sync break
In sync break field, LIN slave receive sync break signal (13 to16-bit Low signals) from
Master and when the bus is “0” in the 11-bit time or greater, a sync break interrupt is
created. When a sync break interrupt is detected, the sync break interrupt prohibition
settings and input capture interrupts are authorized, and the system migrates to waiting
for the synch field to start.
__interrupt void
_LinUartRx(void)
{
←Error check
if ((ssr & 0xE0) != 0) {
(Omitted)
} else if (IO_UART7.ESCR7.bit.LBD==SET {
←Sync break detection
IO_UART7.ESCR7.bit.LBD = CLEAR;
←Clear sync break detection flag
(Omitted)
vSetLinFreerunTimersCompare(hTHEADER_MAX_IND);
ucLinStatus = LIN_WAIT_SYNCH_FIELD_START;
(Omitted)
←State transition:
Wait sync field start
}
Figure 40 Sync break interrupt control
39
←FreeRun Timer setting
AN704-00007-2v0-E
2.
Sync field
After sync break has detected, LIN slave measure the baud rate using input capture
in the sync field and perform compensation. In the sample software, input capture is
set to detect both edges and input capture source is set to LIN USART channel 7.
When the input capture interrupts are set to enable and both edge detection, when
an edge is detected, an input capture interrupt is created. The timer value at both
edges and the number of overflows are measured, and the baud rate calculated and
adjusted using interrupts at 8.
Sync field
START 0 1 2 3 4 5 6 7 STOP
BIT
BIT
DATA = 0x55
8Tbit
2Tbit
2Tbit
2Tbit
2Tbit
First
Time
Fifth
Time
Internal
Signal
FFH
uiICUTime2
・・・・
uiICUTime1
Figure 41 Input capture operation in the synch field
40
AN704-00007-2v0-E
__interrupt void
_LinICU (void)
{
if (ucLinStatus == LIN_WAIT_SYNCH_FIELD_START){
←Synch field start wait
←Acquire timer value
uiICUTime1 = IO_IPCP9;
(Omitted)
ucLinStatus =
LIN_WAIT_SYNCH_FIELD_END;
else if(ucLinStatus == LIN_WAIT_SYNCH_FIELD_END){
←State transition:
sync field end wait
(Omitted)
←Acquire timer value
uiICUTime2= IO_IPCP9;
/* adjust Boud Rate
*/
(Omitted)
←Baud rate adjustment
vEnableLinUartReception();
←LIN-UART interrupt authorized
←State transition: ID
ucLinStatus = LIN_ID_RECEPTION;
}
}
Figure 42 Input capture interrupt controls
3.
ID field
ID reception processing is performed in the LIN-USART interrupt function
_LinUART(void).When an interrupt is created, if no error is created and the cause of the
interrupt isn’t a sync break interrupt, reception processing is performed.
__interrupt void
_LinUART (void)
{
(Omitted)
if ((ssr & 0xE0) != 0) {
←Error check
(Omitted)
} else if (ESCR_LBD == SET) {
←Sync break detection
(Omitted)
}else{
l_ifc_rx(data);
←Receive processing
}
}
Figure 43 LIN-USART receive interrupt control
41
AN704-00007-2v0-E
Processing is divided into ID reception, data sending, data reception, and wakeup
sending
according
the
status
in
the
reception
judgment
processing
function
l_ifc_rx(l_ifc_handle rx_data) as shown in Figure 44 ID receive determination processing. In
normal sequences, to migrate the status during the second input capture interrupt process
to ID FIELD reception waiting, ID reception processing is performed. In ID reception
processing, the ID that has been acquired is judged to be either a send ID or reception ID
and parity check performed, and if it is a send ID, the status is migrated to send preparation
status, and the data to be sent is copied to the buffer. If the ID is a reception ID, the status is
migrated to data reception wait status, and a response (data) is received from the master.
42
AN704-00007-2v0-E
void
l_ifc_rx(l_ifc_handle rx_data){
switch(ucLinStatus){
case
←DATA FIELD transmit status
LIN_TRANSMIT:
(Omitted)
case
LIN_DATA_RECEPTION:
← DATA FIELD reception status
(Omitted)
case
← ID FIELD reception wait status
LIN_ID_RECEPTION:
ucCurrentId.byte
←Store received ID
= rx_data;
←Parity check
if( ucCurrentId.fields.parity != ucRightParity[ucCurrentId.fields.id] ) {
←Error processing
(Omitted)
else if( LinRxDataPtr[ucCurrentId.fields.id] != 0 ) {
ucLinStatus = LIN_DATA_RECEPTION;
←If ID is for reception
←State transition: DATA reception
wait status
(Omitted)
vSetLinFreerunTimersCompare(ucRxCount);
←Freerun Timer set
} else if ( LinTxDataPtr[ucCurrentId.fields.id] != 0 ) {
ucLinStatus = LIN_PRETRANSMIT;
(Omitted)
↓Copy send data to buffer
vLinWordCopy(ucUartTxBuffer, LinTxDataPtr[ucCurrentId.fields.id], ucTxCount);
vSetLinFreerunTimersCompare(hTINFRAME_SPACE_IND);
set
}
(Omitted)
case
←Freerun Timer
LIN_WAKEUP_TRANSMIT:
←WAKEUP send status
(Omitted)
}
}
Figure 44
ID receive determination processing
43
AN704-00007-2v0-E
4.
DATA field
This section explains data transmission and reception in the DATA field.
As for Data transmission, if the receive ID is for transmit, vTimeoutCheckTask
function for timeout process is called by detecting freerun timer interrupt at first. This
function is called when the timeout value configured in the freerun timer is detected.
In this case, the function is called when the timeout value from receiving the header
to sending the response (response space) is detected.
The vTimeoutCheckTask function is divided into send pre-processing, initialization
processing, etc. depending on the status information. When the status is the send
pre-processing state, the first byte of the data is sent.
void
vTimeoutCheckTask(void){
(Omitted)
if ( uiIntDemandCounter == 0 ) {
switch ( ucLinStatus ) {
case
← Pre-transmit state
LIN_PRETRANSMIT:
ucLinStatus = LIN_TRANSMIT;
←State transition: Transmit DATA FIELD
ucSaveData = ucUartTxBuffer[0];
←Transmit data: Acquire 1 byte
l_ifc_tx(ucUartTxBuffer[0]);
←Data transmit processing
(Omitted)
case
LIN_UART_INITIAL:
(Omitted)
case
LIN_ID_RECEPTION:
(Omitted)
case
LIN_DATA_RECEPTION:
(Omitted)
case
LIN_TRANSMIT:
(Omitted)
case
LIN_WAIT_SYNCH_FIELD_START:
(Omitted)
}
}
Figure 45 Timeout detection processing
44
AN704-00007-2v0-E
When sending the first data byte, a reception interrupt is created by receiving the
self-sent data. Whereupon, the reception judgment processing function
_ifc_rx(l_ifc_handle rx_data) is called in the same way as for ID field operations, and
the data is sent from the second byte onwards according to the data field send status
as shown in Figure 46 DATA transmit processing, and the same process is repeated.
In this LIN communication, the number of data bytes is set to 8, so when the eighth
data byte has finished being sent, finally a checksum is sent, and the send
processing ends.
void
l_ifc_rx(l_ifc_handle rx_data){
switch(ucLinStatus){
case
LIN_TRANSMIT:
←DATA FIELD transmit status
if ( ucTxCurrentIndex < ucTxCount ){
←If any transmit data is remaining
(Omitted)
l_ifc_tx(ucUartTxBuffer[ucTxCurrentIndex]);
←Data transmit processing
(Omitted)
} else if ( ucTxCurrentIndex == ucTxCount ){
←If transmit data has all been sent
(Omitted)
l_ifc_tx(((unsigned char)~uiTxCheckSum));
←Checksum transmit processing
(Omitted)
}
case
LIN_DATA_RECEPTION:
(Omitted)
case
LIN_ID_RECEPTION:
(Omitted)
case
LIN_WAKEUP_TRANSMIT:
(Omitted)
}
}
Figure 46 DATA transmit processing
45
AN704-00007-2v0-E
If the ID acquired in the ID receive processing is for receiving, the status is changed
to the DATA receive state and the program waits to receive data from the bits pot
yellow. If an interrupt occurs due to receiving data from the bits pot yellow, the receive
processing is performed within the receive processing function l_ifc_rx(data) as
shown in Figure 47 DATA receive processing. For the case of receiving data, the
receive processing is performed by l_ifc_rx(l_ifc_handle rx_data) for each single byte
of data received, and once all 8 bytes of data have been received, the receive
success flag is set if there are no checksum errors and the receive processing
finishes.
void
l_ifc_rx(l_ifc_handle rx_data){
switch(ucLinStatus){
case
LIN_TRANSMIT:
(Omitted)
case
← Receive DATA FIELD
LIN_DATA_RECEPTION:
if ( ucRxCurrentIndex >= ucRxCount ) {
← If all data has been received
if ( (uiRxCheckSum + rx_data) == 0xFF ) {
← If checksum calculation is correct
(Omitted)
flagsLinTxRx.bit.SucceedReception = SET;
← Set receive success flag
memcpy( &ucUartRxFixedBuffer[0], &ucUartRxBuffer[0], ucRxCount );
↑Copy received data
(Omitted)
← If there is a checksum error
} else {
l_flg_tst(hCHECKSUM_ERR);
← Error processing
← If there is receive data remaining
} else {
ucUartRxBuffer[ucRxCurrentIndex] = rx_data;
(Omitted)
case
LIN_ID_RECEPTION:
(Omitted)
case
LIN_WAKEUP_TRANSMIT:
(Omitted)
}
}
Figure 47 DATA receive processing
46
← Store receive data in buffer
AN704-00007-2v0-E
Finally, the vBaseTimeTask function in main.c checks whether sending and receiving has
finished primarily. If this function is called when all of the data reception has finished
(flagsLinTxRx.bit.SucceedReception is set), the sub_control function in submain.c is called
and perform application program shown in Figure 38 LIN communication flowchart (data
processing by ID).
47