LIN-BUS experten??

Gast #452691
Lesenswert?

sorry code habe ich vergessen




#include "lin_drv_usart.h"


////G L O B A L S
//
volatile BYTE    id;           //Ohne parity bits
volatile BYTE    id_w_parity;  //lin v1.3 identifier mit gerechnete 
parity bits
volatile BYTE    tab_data[8];  //8 bytes daten puffer
volatile BYTE    Index;        //Index for data buffer
volatile BYTE    status;
volatile BYTE    err;          //lin error status
volatile BYTE    state;        //lin state machine status
volatile BYTE    cmd;          //lin current command
volatile BYTE    cpt;          //Zähler
volatile UINT    crc;          //lin checksumme




/**
* @fn SIGNAL(USART0_RX_vect)
* @brief This interrupt function manages the State machine of the LIN.
**/

SIGNAL(USART0_RX_vect)
{
  switch (state)
  {

//////STATE_CK_BREAK://///
//
  case ST_CK_BREAK:
    if (Uart_get_byte() == 0x00)
  {
      Set_BRR(UART_BRR_NORM);

      switch(cmd)
    {                   // Slave Task
      case LIN_S_TX:
      case LIN_S_RX:
        state = ST_CK_SYNC;
        break;
                         // Master Task
      case LIN_M_TX:
      case LIN_M_RX:
        Uart_send_byte(0x55);      // sende Synchronisationsfeld
        crc = LIN_CalcChecksum();  // rechne Checksumme
        state = ST_CK_SYNC;        // nächste Zustand
        break;

      default:
        state = ST_CK_SYNC;
        break;
      }
    }
  else
  {
      state = ST_CK_BREAK;
    }
    break;


/////STATE_CK_SYNC:////
//
  case ST_CK_SYNC:

    if (( Uart_get_byte()==0x55 ) )
  {
      switch(cmd)
    {                     // Master Task
      case LIN_M_TX:
      case LIN_M_RX:

    id_w_parity = LIN_InitIdField(id ); //add P0/P1 parity bits
        Uart_send_byte(id_w_parity);        //sende id mit parity
        state = ST_ID_TX;                   //nächste Zustand
        break;
      default: // in slave mode
        state = ST_ID_RX;
        break;
      }
    }
  else
  {
      state = ST_CK_BREAK;
      status = MSK_ST_ERR;

      switch(cmd)
    {
      case LIN_M_TX:
      case LIN_M_RX:
        err  = MSK_ST_ERRBIT;           // Bit fehler
        break;
      default: // in slave mode
        err = MSK_ST_ERRSYNCHRO;        // Synchronisationsfehler
        break;
      }
    }
    break;
//
/////STATE_ID_TX://////
//
  case ST_ID_TX:
    if (Uart_get_error())             // fehler aufgetreten??
  {
      err = MSK_ST_ERRBIT;            // Bitfehler
      status = MSK_ST_ERR;            // fehler aufgetreten
      state = ST_CK_BREAK;            // zu ST_CK_BREAK springen
      Set_BRR(UART_BRR_SYNC);         // baud rate ändern

    }
  else if((Uart_get_byte() == id_w_parity))   // Parity empfangen ??
  {
      switch (cmd)
    {
//TRANSMITION//
      case LIN_M_TX:                            // sende daten
        Index = Lin_dlctonbyte(id);             // gibt Datenfeldlänge

        if (Index)
    {
          Uart_send_byte(tab_data[0x00]);
          state = ST_DATA_TX;                   // zu ST_DATA_TX Zustand
          Index--;
          cpt = 0x01;
        }
    else
    {
          /* nix */
        }
        break;
//RECEPTION//
      case LIN_M_RX:                           // Empfang daten
        state = ST_DATA_RX;                    // zu ST_DATA_RX Zustand
        cpt  = 0x00;
        Index = Lin_dlctonbyte(id);            //gibt datenfeldlänge
        break;
      default:
        break;
      }
    }
  else
  {
      state = ST_CK_BREAK;                   // zu ST_CK_BREAK springen
      err = MSK_ST_ERRBIT;
      status = MSK_ST_ERR;                   // fehler augetreten
      Set_BRR(UART_BRR_SYNC);                // baud rate ändern
    }
    break;

//
/////STATE_DATA_RX:////// RECEPTION
//
  case ST_DATA_RX:
    if (Uart_get_error())                      // fehler aufgetreten??
  {
      err = MSK_ST_ERRBIT;
      status = MSK_ST_ERR;
      state = ST_CK_BREAK;                    //  zu ST_CK_BREAK 
springen
      Set_BRR(UART_BRR_SYNC);                 //
    }
  else
  {
      tab_data[cpt]=Uart_get_byte();      // daten empfangen
      cpt++;
      if(cpt == Index)                        // datenfeldlänge stimmt 
??
    {
        crc  =  LIN_CalcChecksum();           // rechnet Checksumme
        state = ST_CRC_RX;                    // nächste zustand
      }
    }
    break;
//
/////STATE_DATA_TX://////TRANSMITION
//

  case ST_DATA_TX:
    if (Uart_get_error())           // fehler aufgetreten??
  {                               //stop bitfehler
      err = MSK_ST_ERRBIT;
      status = MSK_ST_ERR;
      state = ST_CK_BREAK;         // zu ST_CK_BREAK springen
      Set_BRR(UART_BRR_SYNC);      // baud rate ändern
    }
  else if ((Uart_get_byte() == tab_data[ cpt-1 ]))
  {
      if (Index)
    {
        Uart_send_byte(tab_data[cpt]);    // daten gesendet
        Index--;
        cpt++;
      }
    else
    {
        Uart_send_byte(crc);             // sende Checksumme
        state = ST_CRC_TX;               // zu nächste Zustand
      }
    }
  else
  {
      err = MSK_ST_ERRBIT;          //stop bitfehler
      status = MSK_ST_ERR;
      state = ST_CK_BREAK;          // zu ST_CK_BREAK springen
      Set_BRR(UART_BRR_SYNC);       // baud rate ändern
    }
    break;
//
/////STATE_CRC_RX://////RECEPTION
//
  case ST_CRC_RX:
    if (Uart_get_error())         // fehler ??
  {
      err = MSK_ST_ERRBIT;
      status = MSK_ST_ERR;
    }
  else if ( Uart_get_byte() != ((crc) & (0x00FF)) )   // Checksumme 
geprüft
  {
      err = MSK_ST_ERRCSUM;                             //  Checksumme 
fehler
      status = MSK_ST_ERR;
    }
  else
  {
      status = MSK_ST_RXOK;                         // Reception erfolgt
    }

    state = ST_CK_BREAK;        // das ganze widerholen: zum ersten 
Zustand
    Set_BRR(UART_BRR_SYNC);     // baud rate änderen
    break;
//
/////STATE_CRC_TX://////TRANSMITION
//

  case ST_CRC_TX:
    if (Uart_get_error())               //feler augetreten ??
  {
      err = MSK_ST_ERRBIT;
      status = MSK_ST_ERR;
    }
  else  if (Uart_get_byte() != ((crc) & 0xFF))  // check summe geprüft
  {
      err = MSK_ST_ERRCSUM;                       // Checksumme fehler
      status = MSK_ST_ERR;
    }
  else
  {
      status = MSK_ST_TXOK;              // Transmision erfolgt
    }
    state = ST_CK_BREAK;                 // das ganze widerholen: zum 
ersten Zustand
    Set_BRR(UART_BRR_SYNC);
    break;
  default:
    state = ST_CK_BREAK;
    Set_BRR(UART_BRR_SYNC);
    break;

  }//end case
}//end usart rxc isr


Gast #454357
Lesenswert?

Hallo,
verstehe auch nicht warum den Jenigen, die nicht helfen wollen oder 
können . die anderen ärgern. Es reicht wenn die nicht antworten oder tut 
mir leid ich weiß nicht sagen .

jetzt mein nächste frage aber ,bitte euch ich habe genug stress. Leute 
die nicht helfen wollen nicht antworten.

Ich habe bis jetzt geschafft ein Signal aus den LIN-Transceiver  raus zu 
sehen und zwar den lin   Synchronisations- Break und Synchronisationss 
Feld  ja es sieht nicht aus  wie das Signal, das man in Literatur Bucher 
sieht aber trotzdem ist schon was. In mein Zustandsmaschine wurde den 
Synchronisations feld nicht detektiert deshalb macht nicht weiter und 
springt zum Synchronisations-Break wieder könnte jemand vielleicht warum 
? das war mwin erste Frage .
Zweite  Frage: ich benutze 16.0000 M Quarz  und ich weiß nicht, ob ich 
Überhaupt den Takt fraquenz in den knoten haben darf oder ist das zu 
viel?

 Danke euch alle
Gast #454451
Lesenswert?

> ...wie kann man nur so viel spass daran haben jemandem nicht zu helfen!?

Wie kann man nur so unverschämt sein, 5 Meter Code einzustellen und zu 
fragen: "Was mache ich falsch", ohne sich zuvor auf den eigenen Hintern 
gesetzt zu haben ?
Gast #454474
Lesenswert?

ich habe leute gefragt, die schon mal mit LIN-bus was gemacht haben, und 
den LIN-Protokol kennen. LIN-BUS experten?? <steht oben sehr gross 
gesrieben>

fals du nicht zu "LIN-experten" gehört, hättest du liber nix 
antworten.!!

Gast #3516838
Lesenswert?

Hallo, der code list ungewohnlich.
Nach welchem Lin protokoll dem alten oder Eminem neueren
Auch scheint mir gewisses ausserhalb der specs.
Auf erstem blick, nachdem 0x55 gesendet wird geht die state machine in 
ST_CK_SYNC wobei deren case Anweisung auskommentiert list.
Dieser Beitrag ist gesperrt und kann nicht beantwortet werden.