LIN kommunikáció UART-tal

Beküldte root - p, 11/30/2018 - 19:26

 

LIN kommunikáció regiszterei és azok működése: http://kovacsistvan.kkfh.hu/node/80

Általános ismertetők:

Magyar általános LIN leírás: https://users.iit.uni-miskolc.hu/~szkovacs/Jarmuinformatika/JarmuInfE7.pdf

http://moodle.autolab.uni-pannon.hu/Mecha_tananyag/autoipari_kommunikacios_rendszerek/ch02.html#d0e2870

 https://www.mit.bme.hu/system/files/oktatas/targyak/8604/Autos_labor_v5h.pdf  

Dokumentáció (LIN 11. old.-tól):
(Fő doksi) Asynchronous_Receiver_Transmitter_on_8bit_PIC_90003156A.pdf  
http://ww1.microchip.com/downloads/en/appnotes/00002059b.pdf 
http://ww1.microchip.com/downloads/en/AppNotes/00239a.pdf

 

   
LIN MÓDOK
A helyi összeköttetési hálózat (LIN) elsősorban az autóiparban és az ipari alkalmazásokban használt protokoll. A protokolltámogató modulhoz tartozó UART a következő LIN hardver támogatással rendelkezik:
• Automatikus ellenőrző összeg számítása
• A régi és a továbbfejlesztett ellenőrzőösszeg kiválasztása
• PID paritás bitek automatikus kiszámítása
• A soros adatfolyamban a Break, Delimiter Bit, Sync és PID automatikus beillesztése
• Rossz érzékelés az RX tűnél
• Automatikus adatátviteli sebesség érzékelés a slave csomópontokhoz
A LIN keret egy master folyamatból és egy slave folyamatból áll (lásd a 10. ábrát). A protokollt támogató UART kétféle módot kínál a LIN: LIN Master / Slave mód és a LIN Slave mód számára. A Master / Slave mód támogatja mind a master, mind a slave folyamatokat, ezért a master csomópontokban kerül végrehajtásra. A slave üzemmód viszont csak a rabszolgákat támogatja
folyamatokat, és végrehajtja a slave csomópontokban. Az 5. példa LIN Master / Slave módú minta inicializáló kódját mutatja az UART1 használatával.		 LIN MODES
Local Interconnect Network (LIN) is a protocol used primarily in automotive and industrial applications. The UART with protocol support module features the following hardware support for LIN:
•  Automatic checksum calculation
•  Selection between legacy and enhanced checksum
•  Automatic calculation of PID parity bits 
•  Automatic insertion of the Break, Delimiter Bit, Sync and PID in the serial stream
•  Break detection on the RX pin
•  Automatic baud rate detection for slave nodes
A LIN frame is composed of a master process and a slave process (see Figure 10). The UART with protocol support offers two modes for LIN: LIN  Master/Slave mode and LIN Slave mode. The Master/Slave mode supports both the master and slave processes and is therefore implemented in master nodes. The Slave mode, on the other hand, only supports slave
processes, and is implemented in slave nodes. Example 5 shows sample initialization code for LIN Master/Slave mode using UART1.
void LIN_MasterSlaveMode_Initialize (void){
    U1CON0bits.BRGS = 0;       // BRG operates in normal speed; Baud = Fosc/[16(n+1)]
    U1BRGH = 0x01;             // Initialize Baud Rate to 9600; Fosc = 64 MHz
    U1BRGL = 0x9F;
    U1CON0bits.MODE = 0b1100;  // LIN Master/Slave mode
    U1CON0bits.TXEN = 1;       // Enable transmit
    U1CON0bits.RXEN = 1;       // Enable receive
    U1CON2bits.TXPOL = 0;      // Data polarity is not inverted
    U1CON2bits.STP = 0b00;     // 1 Stop bit
    Pin_Initialize();          // Set the corresponding TX and RX pins via PPS
    U1CON2bits.C0EN = 1;       // Enhanced checksum; Clear to '0' for legacy checksum
    U1CON1bits.ON = 1;         // Enable serial port
}

Asm Pic18FxxK42:

 
A LIN slave üzemmód ugyanazt az inicializálási mintát követi, kivéve a MODE <3: 0> bites konfigurációt, amelyet 0b1011-re kell beállítani.
Jegyzet:
A különböző LIN módokat csak az UART támogatja, csak a protokolltámogatással, de az EUSART-nak is van néhány támogatási funkciója a LIN protokollhoz (lásd az "EUSART LIN Support" funkció alfejezetet).		 The LIN Slave mode follow the same initialization pattern except for the MODE<3:0> bits configuration which must be set to 0b1011.
Note:
The different LIN modes are supported by the UART with protocol support only but the EUSART also has a few support features for the LIN protocol (refer to Section “EUSART LIN Support” Features subsection).
Master folyamat
Az UART létrehozza a Break mezőt olyan térként, amely 13 bites periódusok széles és a Break határolójel egy hosszúságú jelként. A Sync, a PID és az adatmezők nyolc adatbit-aszinkron formátumát valósítja meg. A stopbitek száma választható 1, 1,5 és 2 bit periódus között. A Sync byte egy "U" (55h) karakter, míg a PID byte hat bit keretazonosítóból és két paritásbitből áll, amelyeket a hardver automatikusan kiszámít. A Break, Delimiter bit és a Sync automatikusan továbbításra kerül, miután a 6 bites azonosítót egy dedikált regiszterbe írta. A 6. példa a Master folyamat mintakódját mutatja.		 Master Process
The UART generates the Break field as a space that is 13-bit periods wide and the Break delimiter as a mark that is one bit time long. It implements the eight data-bit asynchronous format for the Sync, PID and data fields. The number of Stop bits is selectable between 1, 1.5 and 2 bit periods. The Sync byte is a ‘U’ (55h) character while the PID byte is composed of six bits of frame identifier and two parity bits that are automatically calculated by the hardware. The Break, Delimiter bit, and Sync are automatically transmitted after writing the 6-bit ID to a dedicated register. Example 6 shows a sample code for the Master process.
6. példa:
void LIN_MasterTransmitHeader (uint8_t slave_ID){
    U1P1L = slave_ID; 
}
Slave folyamat:
A PID meghatározza, mely slave folyamatok várhatóan reagálnak a masterre. A szolgafolyamat felelős a keretre adott válasz átviteléért, ha egy kiadó, és a keretre adott válasz fogadása, ha előfizető. Ez az adat- és ellenőrzőösszeg-mezőkből áll. Az adatmezők a ténylegesek a slave folyamat alatt továbbított vagy fogadott információ, miközben a checksum mezőt használják hibaérzékelésre.
A 7. példa példakénti kódot mutat be a PID-nek a slave-eljárás során történő megszerzésére vonatkozóan, miközben a 8. és a 9. példa bemutatja, hogyan kell továbbítani és fogadni az adatmezőt tömbök segítségével.		 Slave Process:
The PID determines which slave processes are expected to respond to the master. The slave process is responsible for transmitting the frame response when it  is a publisher and for receiving the frame response when it is a subscriber. It is composed of the data and checksum fields. Data fields are the actual information transmitted or received during the slave process while the checksum field is used for error detection. 
Example 7 shows a sample code on how to get the PID during slave process while Example 8 and Example 9 show how to transmit and receive the data field using arrays.
7. példa:
uint8_t LIN_Get_PID (void) {
uint8_t PID;
while (!U1ERRIRbits.RXBKIF);  // Wait for break reception
U1ERRIRbits.RXBKIF = 0;
PID = UART_Read();
return PID;
}
Megj.: A szolga a vett PID-et kiértékeli és ha minden rendben és őt érinti, akkor reagál.
8. példa: 
void LIN_SlaveDataTransmit (uint8_t txLength, uint8_t *txDataArray){
    U1P2H = 0x00;
    U1P2L = txLength;                    // Size of the data array; Max value = 8
    for(uint8_t i = 0; i < txLength; i++){
        UART_Write(txDataArray[i]);
    }
}
Megj.: A szolga veszi az adatokat, mivel minden rendben és a PID is neki szól, ami szintén rendben van. A PID tartaémazza azt is, hogy adatot küldjön-e vagy adatot fogadjon. Jelen esetben adatokat küld a szolga a mesternek.
8. példa: 
void LIN_SlaveDataReceive (uint8_t rxLength){      // rxLength = Number of data bytes 
// to receive
uint8_t rxDataArray[8];
U1P3H = 0x00;
U1P3L = rxLength;
for (uint8_t i = 0; i < rxLength; i++) {
rxDataArray[i] = UART_Read();             // Save data
}
/** Some code for checksum verification and processing of received data **/
Megj.: A szolga veszi az adatokat, mivel minden rendben és a PID is neki szól, ami szintén rendben van. A PID tartaémazza azt is, hogy adatot küldjön-e vagy adatot fogadjon. Jelen esetben adatokat fogad a szolga a mestertől.
Az ellenőrző összeg számításának két módja áll rendelkezésre: örökölt és továbbfejlesztett. A régi ellenőrzőösszeg csak az adatbájtokat tartalmazza, míg a javított ellenőrzőösszeg PID-t és az adatbájtokat tartalmazza.
Amikor egy slave folyamat adatot küld, az UART automatikusan kiszámítja az elküldött bájtok ellenőrző összegét, és elküldi őket, és hozzáadja az invertált ellenőrző bájtot a slave válaszhoz. Amikor egy rabszolga adatokat fogad, az ellenőrző összeg minden egyes bájtra felhalmozódik, mivel ugyanazt az algoritmust fogadja, mint a küldés. Az utolsó bájtot, amely a küldő folyamat által kiszámított inverz ellenőrző összeg, hozzáadódik az UART helyileg kiszámított ellenőrzőösszeghez. A csekk átmegy, ha az eredmény mindegyik az 1-es, egyébként az ellenőrzés meghiúsul, és a Checksum Error Flag bit beállítva. A 10. példa bemutatja, hogy ellenőrizni lehessen egy ellenőrzőösszeget, vagy nem sikerült. Az ellenőrzőösszeg-módszert, az adatbájtok számát és a slave-folyamat adatainak küldését vagy fogadását a PID szerinti szoftver határozza meg. Az inter-byte periódus, az időtúllépés és a frame periódus időzítése szoftverrel történik, az UART-tól eltérő eszközökkel. A chipen lévő hardveres időzítők, mint például az imer0 / 1/2, erre a célra használhatók.		 Two methods for computing the checksum are available: legacy and enhanced. The legacy checksum includes only the data bytes while the enhanced checksum includes PID and the data bytes.
When a slave process sends data, the UART automatically calculates the checksum for the transmitted bytes as they are sent and appends the inverted checksum byte to the slave response. When a slave receives data, the checksum is accumulated on each byte as it is received using the same algorithm as the sending process. The last byte, which is the inverted checksum value calculated by the sending process, is added to the locally calculated checksum by the UART. The check passes when the result is all ‘1’s, otherwise the check fails and the Checksum Error Flag bit is set. Example 10 shows how to verify if a checksum has passed or failed. The checksum  method, number of data  bytes, and whether to send or receive data in slave process, is defined by software according to the PID. The inter-byte period, timeout and frame period are timed by software using a means other than the UART. On-chip hardware timers such as  imer0/1/2 can be used for this purpose.
   

 

   
LIN módok (csak UART1)
A LIN elsősorban az autóipari alkalmazásokban használt protokoll. A LIN hálózat kétféle szoftverfolyamatból áll: Master folyamatból és Slave folyamatból. Minden hálózatnak csak egy mesteri folyamata és egy vagy több szláv folyamata van. Fizikai rétegbeli szempontból az egyik processzoron lévő UART-t mester- és slave-eljárás vezérelheti, amennyiben csak egy mesterfolyam létezik a hálózaton.
A LIN tranzakció Master folyamatból áll, amelyet Slave folyamat követ. A slave-folyamat több olyan szlávot is magában foglalhat, ahol az egyik az átvitelt és a
más (k) fognak. A tranzakció a következő Mesterfeldolgozási sorrendben kezdődik:
1. Break
2. Határoló bit
3. Szinkron mező
4. PID byte
A PID meghatározza, mely Slave folyamatok várhatóan reagálnak a Mesterre. Amikor a PID byte befejeződött, a TX kimenet készenléti állapotban marad. A Slave folyamatok közül egy vagy több válaszolhat a Master folyamatra. Ha senki sem válaszol az inter-bájt periódus alatt, a mester szabadon indíthat egy másik átvitelt. Az inter-byte periódus időzített szoftverrel, az UART kivételével.
A slave folyamat a mesterfolyamatot követi. Amikor a Slave szoftver elismeri a PID-t, akkor a Slave-folyamat válaszként továbbítja a kívánt választ vagy a továbbított adatokat. Csak a Slave feldolgozza az adatokat. Ezért az Slave adatfeldolgozó folyamatai egy másik Slave-eljáráshoz jutnak.
Amikor egy slave adatokat küld, a Slave UART automatikusan kiszámolja az elküldött bájtok ellenőrző összegét, és elküldi őket, és hozzáadja az invertált ellenőrző bájtot a slave válaszhoz.
Amikor egy slave adatokat fogad, az ellenőrző összeg minden egyes bájtra felhalmozódik, ugyanazt az algoritmust fogadja, mint a küldés. Az utolsó bájtot, amely a küldő folyamat által kiszámított inverz ellenőrző összeg, hozzáadódik az UART helyileg kiszámított ellenőrzőösszeghez. A csekk átmegy, ha az eredmény mindegyik 1-es, ellenkező esetben az ellenőrzés meghiúsul és a CERIF bit be van állítva.
Az ellenőrző összeg számításának két módja áll rendelkezésre: örökölt és továbbfejlesztett. A régi ellenőrzőösszeg csak az adatbájtokat tartalmazza. A továbbfejlesztett ellenőrző összeg tartalmazza a PID-t és az adatokat. Az UxCON2 regiszter C0EN vezérlőbitje meghatározza az ellenőrzőösszeg-módszert. A C0EN beállítása "1" -re állítja be a továbbfejlesztett módszert. A szoftvernek ki kell választania a megfelelő módszert, mielőtt megkapja az ellenőrzőösszeg-bájt kezdő bitjét.		 31.5
LIN Modes (UART1 only)
LIN is a protocol used primarily in automotive applications. The LIN network consists of two kinds of software  processes: a Master process and a Slave process. Each network has only one Master process and one or more Slave processes. From a physical layer point of view, the UART on one processor may be driven by both a Master and a Slave process, as long as only one Master process exists on the network. 
A LIN transaction consists of a Master process followed by a Slave  process. The Slave process may involve more than one Slave where one is transmitting and the
other(s) are receiving. The transaction begins by the following Master process transmission sequence:
1. Break
2. Delimiter bit
3. Sync Field
4. PID byte
The PID determines which Slave processes are expected to respond to the Master. When the PID byte is complete, the TX output remains in the Idle state. One or more of the Slave processes may respond to the Master process. If no one responds within the inter-byte period, the Master is free to start another transmission. The inter-byte period is timed by software using a means other than the UART. 
The Slave process follows the Master process. When the Slave software recognizes the PID then that Slave process responds by either transmitting the required response or by receiving the transmitted data. Only Slave processes send data. Therefore, Slave processes receiving data are receiving that of another Slave process.
When a Slave sends data, the Slave UART automatically calculates the checksum for the transmitted bytes as they are sent and appends the inverted checksum byte to the slave response.
When a Slave receives data, the checksum is accumulated on each byte as it is received using the same algorithm as the sending process. The last byte, which is the inverted checksum value calculated by the sending process, is added to the locally calculated checksum by the UART. The check passes when the result is all ‘1’s, otherwise the check fails and the CERIF bit is set.
Two methods for computing the checksum are available: legacy and enhanced. The legacy checksum includes only the data bytes. The enhanced checksum includes the PID and the data. The C0EN control bit in the UxCON2 register determines the checksum method. Setting C0EN to ‘1’ selects the enhanced method. Software must select the appropriate method before the Start bit of the checksum byte is received.
31.5.1
LIN MASTER / SLAVE MODE
A LIN Master módban lehetőség van Slave folyamatok létrehozására. A master folyamat leáll a PID továbbításnál. Minden olyan adatot, amelyet a Master /
A slave üzemmód Slave eljárásként történik. A LIN Master / Slave mód a következő beállításokkal van konfigurálva:
• MODE <3: 0> = 1100
• TXEN = 1
• RXEN = 1
• UxBRGH: L = érték a kívánt adatátviteli sebesség eléréséhez
• TXPOL = 0
(nagy üresjárati állapot esetén)
• STP = kívánt Stop bit kiválasztása
• C0EN = a kívánt ellenőrző ellenőrző mód
• RxyPPS = TX tüskeválasztó kód
• TRIS vezérlés = 0
• BE = 1
Jegyzet:
A TXEN bitet be kell állítani, mielőtt a Master folyamat fogadása megtörténne és LIN módban marad, amíg a slave folyamat egy adó. A mesterfolyamat elindul, ha a PID-t UxP1L regiszterbe írja, amikor az UxP2 "0" és a Az UART készenléti állapotban van. Ebben az esetben az UxTXIF nem állítható be. Csak az UxP1L hat legfontosabb bitjét használják a PID továbbításban. A továbbított PID két legfontosabb bitje PID paritás bit. PID <6> az exkluzív vagy a PID bit 0,1, 2, és 4. A PID <7> az exkluzív vagy a 1,3, 4 és 5 PID bitek inverze. Az UART kiszámítja és beilleszti ezek a bitek a soros streamben. Az UxP1L írása automatikusan törli az UxTXCHK és az UxRXCHK regisztereket, és generálja a tranzakció Break, delimiter bitjét, szinkron karakterét (55h) és PID átviteli részét. A tranzakció adatrésze
ebből következik, ha van ilyen, egy slave folyamat. A folyamat részleteiről lásd a 31.5.2 "LIN Slave Mode" részt. A mester megkapja saját PID-kódját, amikor az RXEN be van állítva. A szoftver végrehajtja a Slave folyamatot, amely megfelel a küldött és fogadott PID-nek. Ha megpróbál írni az UxP1L-t, mielőtt az aktív mesterprocesszor befejeződött, nem sikerül. Ehelyett a TXWRE bit lesz beállítva.		 31.5.1
LIN MASTER/SLAVE MODE
The LIN Master mode includes capabilities to generate Slave processes. The Master process stops at the PID transmission. Any data that is transmitted in Master/
Slave mode is done as a Slave process. LIN Master/Slave mode is configured by the following settings:
•  MODE<3:0> = 1100
•  TXEN = 1
•  RXEN = 1
•  UxBRGH:L = Value to achieve desired baud rate
•  TXPOL = 0
 (for high Idle state)
•  STP = desired Stop bits selection
•  C0EN = desired checksum mode
•  RxyPPS = TX pin selection code
•  TX pin TRIS control = 0
•  ON = 1
Note:
The TXEN bit must be set before the Master process is received and remain set while in LIN mode whether or not the slave process is a transmitter.The Master process is started by writing the PID to the UxP1L register when UxP2 is ‘0’ and the UART is idle. The UxTXIF will not be set in this case. Only the six Least Significant bits of UxP1L are used in the PID transmission. The two Most Significant bits of the transmitted PID are PID parity bits. PID<6> is the exclusive-or of PID bits 0,1,2,and 4. PID<7> is the inverse of the exclusive-or of PID bits 1,3,4,and 5. The UART calculates and inserts these bits in the serial stream. Writing UxP1L automatically clears the UxTXCHK and UxRXCHK registers and generat es the Break, delimiter bit, Sync character (55h), and PID transmission portion of the transaction. The data portion of the transaction
that follows, if there is one, is a Slave process. See Section 31.5.2 “LIN Slave Mode” for more details of that process. The Master receives it’s own PID when RXEN is set. Software performs the Slave process corresponding to the PID that was sent and received. Attempting to write UxP1L before an active  master process is complete will not succeed. Instead, the TXWRE bit will be set.
31.5.2
LIN SLAVE MODE
A LIN Slave üzemmódot az alábbi beállítások konfigurálják:
• MODE <3: 0> = 1011
• TXEN = 1
• RXEN = 1
• UxP2 = Adott adatbájtok száma
• UxP3 = A fogadni kívánt bájtok száma
• UxBRGH: L = Az alapértelmezett átviteli sebesség elérésének értéke
• TXPOL = 0
(nagy üresjárati állapot esetén)
• STP = kívánt Stop bit kiválasztása
• C0EN = a kívánt ellenőrző ellenőrző mód
• RxyPPS = TX tüskeválasztó kód
• TRIS vezérlés = 0
• BE = 1
A Slave-folyamat az RX-pólus megszakadásának észlelésekor indul. A Break törli az UxTXCHK, UxRXCHK, UxP2 és UxP3 regisztereket. A szünet végén az automatikus baud áramkör aktiválódik, és a sebesség átvitele automatikusan megtörténik a szünet után. A Sync karaktert követő karakter PID kódként fogadódik, és a FIFO fogadása elmentésre kerül. Az UART kiszámítja a két PID paritásbitet a PID hat legfontosabb bitje közül. Ha valamelyik paritás bit nem egyezik a kapott PID kód megfelelő bitjével, a PERIF zászló a PID kóddal azonos FIFO helyre van állítva és mentve. Az UxRXIF bit beállítva jelzi, hogy a PID rendelkezésre áll. A szoftver visszakeréli a PID-t az UxRXB regiszter olvasásával, és meghatározza a végrehajtandó Slave folyamatot. Az ellenőrzőösszeg-módszert, az adatbájtok számát és az adatok küldését vagy fogadását a PID-kód szerinti szoftver határozza meg.		 31.5.2
LIN SLAVE MODE
LIN Slave mode is configured by the following settings:
•  MODE<3:0> = 1011
•  TXEN = 1
•  RXEN = 1
•  UxP2 = Number of data bytes to transmit
•  UxP3 = Number of data bytes to receive
•  UxBRGH:L = Value to achieve default baud rate
•  TXPOL = 0
 (for high Idle state)
•  STP = desired Stop bits selection
•  C0EN = desired checksum mode
•  RxyPPS = TX pin selection code
•  TX pin TRIS control = 0
•  ON = 1
The Slave process starts upon detecting a Break on the RX pin. The Break clears the UxTXCHK, UxRXCHK, UxP2, and UxP3 registers. At the end of the Break, the auto-baud circuity is activated and the baud rate is automatically set using the Sync character following the Break. The character following the Sync character is received as the PID code and is saved in the receive FIFO. The UART computes the two PID parity bits from the six Least Significant bits of the PID. If either parity bit does not match the corresponding bit of the received PID code, the PERIF flag is set and saved at the same FIFO location as the PID code. The UxRXIF bit is set indicating that the PID is available. Software retrieves the PID by reading the UxRXB register and determines the Slave process to execute from that. The checksum method, number of data bytes, and whether to send or receive data, is defined by software according to the PID code. 
31.5.2.1
LIN Slave Receiver
Amikor a Slave folyamat vevőkészülék, a szoftver a következő feladatokat végzi el:
• Az UxP3 regiszter értéke megegyezik a fogadni kívánt bájtok számával.
• A C0EN bit beállítása vagy törlése a megfelelő ellenőrző összeg kiválasztásához. Ezt be kell fejezni, mielőtt megkapja az ellenőrző bájt kezdő bitjét.
• A folyamat válaszának minden byte-ja az UxRXB-ből olvasható, amikor a PIR6 regiszter UxRXIF bitje 1 lesz, majd kiolvasva 0-ra vált.
Az UART frissíti az egyes fogadott bájtok ellenőrző összegét. Amikor az utolsó adatbájt érkezik, a kiszámított
a teljes ellenőrző összeg az UxRXCHK regiszterben van tárolva. A következő fogadott bájt a vételi FIFO-ba kerül, és hozzáadódik az UxRXCHK értékhez. Az adagolás eredménye nem hozzáférhető. Ha azonban az eredmény nem mindegyik, akkor az UxERRIR-ben lévő CERIF bit be van állítva. A CERIF zászló továbbra is fennmarad, amíg szoftver el nem hagyja. A szoftvernek el kell olvasnia az UxRXB-t, hogy eltávolítsa a checksum byte-ot a FIFO-ból, de a bájt eldobható, ha más célra nem szükséges.
Miután megkapta az ellenőrzőösszeget, az UART figyelmen kívül hagy minden tevékenységet az RX tüskén, amíg egy Break megkezdi a következő tranzakciót.		 31.5.2.1
LIN Slave Receiver 
When the Slave process is a receiver, the software performs the following tasks:
•  UxP3 register is written with a value equal to the number of data bytes to receive. 
•  C0EN bit is set or cleared to select the appropriate checksum. This must be completed before the Start bit of the checksum byte is received. 
•  Each byte of the process response is read from UxRXB when UxRXIF is set.
The UART updates the checksum on each received byte. When the last data byte is received, the computed
checksum total is stored in the UxRXCHK register. The next received byte is saved in the receive FIFO and added with the value in UxRXCHK. The result of this addition is not accessible. However, if the result is not all ‘1’s, the CERIF bit in the UxERRIR is set. The CERIF flag persists until cleared by software. Software needs to read UxRXB to remove the checksum byte from the FIFO, but the byte can be discarded if not needed for any other purpose.
After the checksum is received, the UART ignores all activity on the RX pin until a Break starts the next transaction. 
31.5.2.2
LIN Slave Transmitter
Ha a slave folyamat adó, akkor a szoftver az alábbi sorrendben végzi a feladatokat:
• Az UxP2 regisztert olyan értékkel kell írni, amely megegyezik az elküldendő bájtok számával. Ez lehetővé teszi a TXIF zászlót, amely le van tiltva, ha az UxP2 "0".
• A C0EN bit beállítása vagy törlése a megfelelő ellenőrző összeg kiválasztásához
• Végrehajtja az inter-byte késleltetést
• A folyamatválasz minden bájtja fel van írva
UxTXB, amikor az UxTXIF be van állítva Az UART összegyűjti az ellenőrző összeget, mivel minden byte UxTXB-re van írva. Az utolsó bájt írása után az UART tárolja a kiszámított ellenőrzőösszeget az UxTXCHK regiszterben, és az invertált eredményt a válaszban az utolsó bájtumból továbbítja.
A TXIF zászló le van tiltva, ha UxP2 byte-okat írtak. Minden olyan UxTXB-re írt, amely meghaladja az UxP2-számot, figyelmen kívül hagyja és beállítja a TXWRE jelzőt az UxFIFO regiszterben.		 31.5.2.2
LIN Slave Transmitter
When the Slave process is a transmitter, software performs the following tasks in the order shown:
•  UxP2 register is written with a value equal to the number of bytes to transmit. This will enable TXIF flag which is disabled when UxP2 is ‘0’.
•  C0EN bit is set or cleared to select the appropriate checksum
•  Inter-byte delay is performed
•  Each byte of the process response is written to 
UxTXB when UxTXIF is set The UART accumulates the checksum as each byte is written to UxTXB. After the last byte is written, the UART stores the calculated checksum in the UxTXCHK register and transmits the inverted result as the last byte in the response.
The TXIF flag is disabled when UxP2 bytes have been written. Any writes to UxTXB that exceed the UxP2 count will be ignored and set the TXWRE flag in the UxFIFO register.

 

 

D:507-tól

   
UxP1L: UART PARAMETER 1 LOW REGISTER
LIN mode: PID to transmit (Only Least Significant 6 bits used)

UxP1H: UART PARAMETER 1 HIGH REGISTER		 UxP1L: UART PARAMETER 1 LOW REGISTER
LIN mode: PID to transmit (Only Least Significant 6 bits used)

UxP1H: UART PARAMETER 1 HIGH REGISTER
UxP2L: UART PARAMETER 2 LOW REGISTER
LIN Slave mode: Number of data bytes to transmit

UxP2H: UART PARAMETER 2 HIGH REGISTER		 UxP2L: UART PARAMETER 2 LOW REGISTER
LIN Slave mode: Number of data bytes to transmit

UxP2H: UART PARAMETER 2 HIGH REGISTER
UxP3L: UART PARAMETER 3 LOW REGISTER 
LIN Slave mode: Number of data bytes to receive
UxP3H: UART PARAMETER 3 HIGH REGISTER		 UxP3L: UART PARAMETER 3 LOW REGISTER 
LIN Slave mode: Number of data bytes to receive
UxP3H: UART PARAMETER 3 HIGH REGISTER
UxTXCHK: UART TRANSMIT CHECKSUM RESULT REGISTER
TXCHK<7:0>(R/W-0/0): 
Checksum calculated from TX bytes
LIN mode and C0EN = 1: 
Sum of all transmitted bytes including PID
LIN mode and C0EN = 0: 
Sum of all transmitted bytes except PID
All other modes and C0EN = 1: 
Sum of all transmitted bytes since last clear
All other modes and C0EN = 0:
Not used		 UxTXCHK: UART TRANSMIT CHECKSUM RESULT REGISTER
TXCHK<7:0>(R/W-0/0): 
Checksum calculated from TX bytes
LIN mode and C0EN = 1: 
Sum of all transmitted bytes including PID
LIN mode and C0EN = 0: 
Sum of all transmitted bytes except PID
All other modes and C0EN = 1: 
Sum of all transmitted bytes since last clear
All other modes and C0EN = 0:
Not used
UxRXCHK: UART RECEIVE CHECKSUM RESULT REGISTER
RXCHK<7:0>(R/W-0/0): 
Checksum calculated from RX bytes
LIN mode and C0EN* = 1: 
Sum of all received bytes including PID
LIN mode and C0EN* = 0: 
Sum of all received bytes except PID
All other modes and C0EN* = 1: 
Sum of all received bytes since last clear
All other modes and C0EN* = 0:
Not used		 UxRXCHK: UART RECEIVE CHECKSUM RESULT REGISTER
RXCHK<7:0>(R/W-0/0): 
Checksum calculated from RX bytes
LIN mode and C0EN* = 1: 
Sum of all received bytes including PID
LIN mode and C0EN* = 0: 
Sum of all received bytes except PID
All other modes and C0EN* = 1: 
Sum of all received bytes since last clear
All other modes and C0EN* = 0:
Not used
* UxCON2<C0EN>
C0EN: Checksum Mode Select bit(2)
LIN mode:
1 =  Checksum Mode 1, enhanced LIN checksum includes PID in sum
0 =  Checksum Mode 0, legacy LIN checksum does not include PID in sum

Megj.: UART1 only.		 * UxCON2<C0EN>
C0EN: Checksum Mode Select bit(2)
LIN mode:
1 =  Checksum Mode 1, enhanced LIN checksum includes PID in sum
0 =  Checksum Mode 0, legacy LIN checksum does not include PID in sum

Megj.: UART1 only.
UxERRIR<RXBKIF><2>  D:501 
Break Reception Interrupt Flag bit
1 =  Break detected
0 =  No Break detected		 UxERRIR<RXBKIF><2>  D:501 
Break Reception Interrupt Flag bit
1 =  Break detected
0 =  No Break detected
   

 

 

Ha a mester a szolgáknak 80H kódú azonosítót küld, akkor azok alacsony fogyasztású üzemmódba kerülnek. A SLEEP üzenethez tartozó két adatbájt tartalmát a protokoll nem definiálja. A buszt bármelyik kapcsolódó szolga egy 80H bájt küldésével felébresztheti. 

---------------------------------------

 

 6. fejezet: Kommunikációs perifériák      
 
     189      
   
 
 
6.5. LIN (LOCAL INTERCONNECT NETWORK)  BUSZ A LIN (Local Interconnect Network)  busz az európai autóipar által kifejlesztett olcsó, rövid távolságokra (max. 40m) használható alacsony sebességű (maximum  20 kbit/sec) hálózat. Az OSI modell alsó két rétegét – a fizikai és az adatkapcsolati réteg – valósítja meg.  
 
A  kétirányú kommunikáció a buszon egy vezetéken történik. A buszon lévő jelek időzítéséhez elegendő az olcsó RC oszcillátor által biztosított pontosság. Mivel az időzítés változhat, ezért a protokoll minden üzenetfogadáskor automatikus sebességmeghatározást végez. A busz energiaellátását bármelyik kapcsolódó eszköz biztosíthatja. A buszon lévő eszköz kis fogyasztású SLEEP üzemmódban is képes működni, csökkentve a fogyasztást (telepes üzem!). Maga a busz átmenetet képez az I2C és az RS232 soros buszok között. A buszvonal egy ellenállással van magas szintre húzva, amit bármelyik csomópont alacsony szintre állíthat, mint az I2C busznál. Azonban külön órajel vonal helyett minden bájt START és STOP bitekkel kiegészítve kerül átvitelre, hasonlóan az RS232-höz. A busz tápfeszültsége 9–18V között lehet, de a buszhoz közvetlenül kapcsolódó áramköröknek max. 40 V-ot is el kell viselniük. A leírásokban a busz magas szintű állapotát recesszív, míg alacsony állapotát domináns állapotnak nevezik. A kommunikáció master-slave jellegű, azaz van egy kitüntetett egység – a master, amely vezérli az adatátvitelt. Ebből az is következik, hogy két szolga közötti adatátvitel is csak a mesteren keresztül történhet. Minden csomópontnál a busz a VBAT tápfeszültséghez van kötve. A mester 1K, a szolgák 30 kΏ-os ellenálláson keresztül.