mikrocontroller.net

Forum: Mikrocontroller und Digitale Elektronik LIN-Bus AppNotes


Autor: Mrhihi3s (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Hallo zusammen

Ich habe ein Frage zu den jenigen, die schon Mal Mit NIN-BUS beschäftig 
waren.
 habe mir ein Prototype gebaut, das Prototype beinhaltet 3 Platinen auf 
jeder Platine habe ich Mikrocontroller ein Lin -Transceiver und 
natürlich andere Elektronik . auf der erste Platine „Master„ habe ich 
Bedienelemente aufgesetzt (3Taster, 2 schalter und ein Joystick ) 
dadurch möchte ich verschiedene Anzeige Elemente( LED´s , ein Gehtrieb 
Motor und Außen Spiegel) steuern, die auf  zweite bzw. dritte Platinen 
„Slave´s“ platziert.
Ich möchte jetzt dieses Hardware Testen, ich habe die AppNotes von Atmel 
(AVR322, AVR308) geguckt, ich könnte damit nicht anfangen, kann mir 
bitte jemanden helfen, und mir erklären wie ich mit den Software 
anfangen kann?,  wie sollte das Programm Struktur ausgesehen?.
PS: als Controller habe ich  die   AT90CAN128     und    2 Atemega128
       Als Lin-Transceiver   die ATA6661  von Atmel

Autor: Dennis (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
das ist die struktur die du ungefähr in deiner UART Kommunikation 
einhalten musst.

Es ist Code von meinem LIN Projekt mit einem Fujitsu.

__interrupt void RxIRQHandler(void)
{
   /*===========================*/
   /*====== Master Code    =====*/
   /*===========================*/

   if(SW_State==SW_ST_MASTER)
   {
      if(ESCR2_LBD)                          /* LIN Break detected? 
*/
      {
         ESCR2_LBD = 0;                      /* clear Int. flag 
*/

         if(LIN_State==LIN_ST_READY)
         {
            SCR2_RXE = 1;                    /* Enable reception 
*/
            TDR2 = 0x55;                     /* Send Syncfield 
*/
            LIN_State = LIN_ST_RECEPTION;
            LIN_Checksum = 0;

            LIN_Count=0;
         }
         else
         {
            LIN_Rx_Error = LIN_BREAK_ERR;
         }
      }
      else if(SSR2_RDRF)                     /* reception Data reg full? 
*/
         {
            LIN_Rx_Data=RDR2;                /* get Reception Data 
*/

            if(SSR2_ORE || SSR2_FRE)         /* reception error ????? 
*/
            {
               LIN_Rx_Error = LIN_REC_ERR;
            }

            switch (LIN_State)
            {

            /*===========================*/
            /*====== RECEPTION      =====*/
            /*===========================*/

               case LIN_ST_RECEPTION:

                  if (LIN_Rx_Data != 0x55)
                  {
                     LIN_Rx_Error = LIN_SYNC_ERR;
                  }
                  else
                  {
                     TDR2 = LIN_Header;
                     LIN_State=LIN_ST_HEADER;
                  }
                  break;

            /*===========================*/
            /*====== HEADER         =====*/
            /*===========================*/


               case LIN_ST_HEADER:

                  if(LIN_Rx_Data != LIN_Header)    /* if sent header == 
header*/
                  {
                     LIN_Rx_Error = LIN_HEADER_ERR;
                  }
                  else
                  {
                     /* Master Send */
                     if(LIN_REQUEST)
                     {
                        TDR2=LIN_Data[LIN_Count];              /* first 
byte  */
                        LIN_Checksum = LIN_Data[LIN_Count];
                     }
                     LIN_State = LIN_ST_DATA;
                  }
                  break;

            /*===========================*/
            /*====== DATA           =====*/
            /*===========================*/


               case LIN_ST_DATA:

                  /* Master Send */

                  if(LIN_REQUEST)
                  {
                     if(LIN_Rx_Data != LIN_Data[LIN_Count])
                     {
                        LIN_Rx_Error=LIN_DATA_ERR;
                     }

                     LIN_Count++;

                     if(LIN_Count == LIN_LENGTH)
                     {
                                                               /* if all 
sent */
                       LIN_Count=0;                            /* Byte 
Count  */
                       LIN_State=LIN_ST_CHECKSUM;   /* Next Byte 
ist:Checksum */
                       TDR2=LIN_CHECKSUM;                    /* Send 
Checksum */
                     }
                     else
                     {
                        TDR2 = LIN_Data[LIN_Count];
                        LIN_Checksum += LIN_Data[LIN_Count];
                     }
                  }

                  /* Master Receive */

                  if(LIN_RESPONSE)
                  {
                     LIN_Data[LIN_Count] = LIN_Rx_Data;    /* store 
Slave Data*/
                     LIN_Checksum += LIN_Data[LIN_Count];

                     LIN_Count++;

                     if(LIN_Count == LIN_LENGTH)
                     {
                        LIN_Count = 0;
                        LIN_State = LIN_ST_CHECKSUM;
                        LIN_Checksum=LIN_CHECKSUM;
                                                                  /* 
Checksum */
                     }
                  }
                  break;

            /*===========================*/
            /*====== CHECKSUM       =====*/
            /*===========================*/


               case LIN_ST_CHECKSUM:

                  if(LIN_Rx_Data != LIN_Checksum)         /* compare 
Checksum */
                  {
                     LIN_Rx_Error=LIN_CHECK_ERR;
                  }
                  SCR2_RXE = 0;
                  LIN_State = LIN_ST_NEXT;
                  break;
            }
         }

         else
         {
            LIN_Rx_Error=LIN_UNKNOWN_ERR;
            SSR2_RIE = 0;                     /* disable reception int 
*/
         }
   }

   /*===========================*/
   /*====== Slave  Code    =====*/
   /*===========================*/

   if(SW_State==SW_ST_SLAVE)
   {
      if(ESCR2_LBD)                          /* LIN Break detected? 
*/
      {
         ESCR2_LBD = 0;                      /* clear Int. flag 
*/

         if(LIN_State==LIN_ST_READY)
         {
            SCR2_RXE = 1;                    /* Enable reception 
*/
            LIN_State = LIN_ST_RECEPTION;
            LIN_Checksum = 0;
            LIN_Count = 0;

            ICS67_ICP6 = 0;                  /* clear possible int flag 
*/
            ICS67_ICE6 = 1;                  /* enable ICU6 for sync 
measure. */
         }
         else
         {
            LIN_Rx_Error = LIN_BREAK_ERR;
         }
      }
      else if(SSR2_RDRF)                     /* reception Data reg full? 
*/
         {
            LIN_Rx_Data=RDR2;                /* get Reception Data 
*/

            if(SSR2_ORE || SSR2_FRE)         /* reception error ????? 
*/
            {
               LIN_Rx_Error = LIN_REC_ERR;
               //SCR2_CRE=1;//test
            }

            switch (LIN_State)
            {

            /*===========================*/
            /*====== Slave RECEPTION ====*/
            /*===========================*/


               case LIN_ST_RECEPTION:

                  ICS67_ICE6 =0;             /* disable ICU6 int. 
*/

                  if (LIN_Rx_Data != 0x55)   /* sync field false 
information  */
                  {
                     LIN_Rx_Error = LIN_SYNC_ERR;

                  }
                  else
                  {
                     LIN_State = LIN_ST_HEADER;
                     SCR2_CRE=1;        /* Clear All Errors (Framing)by 
timer */
                  }

                  break;

            /*===========================*/
            /*====== Slave HEADER   =====*/
            /*===========================*/


               case LIN_ST_HEADER:

                  LIN_Header = LIN_Rx_Data;

                  if(LIN_RESPONSE)                              /* Slave 
Send */
                  {

                     TDR2=LIN_Trans_Buff[LIN_Count][SW_Slave-1];
                                                         /* Slave send 
byte 1 */
                     LIN_Count++;                               /* send 
*/
                     LIN_State=LIN_ST_DATA;
                  }
                  else
                  {
                     if(!LIN_REQUEST)/* do nothing if no request and 
response */
                     {
                        LIN_State = LIN_ST_READY;
                        SCR2_RXE = 0;                    /* Disable 
reception */
                     }
                     else
                     {
                        LIN_State=LIN_ST_DATA;
                     }
                  }




                  break;

            /*===========================*/
            /*====== Slave DATA     =====*/
            /*===========================*/


               case LIN_ST_DATA:

                  /* Slave Receive */

                  if(LIN_REQUEST)
                  {
                     LIN_Checksum += LIN_Rx_Data;
                     LIN_Rec_Buff[LIN_Count][SW_Slave-1]=LIN_Rx_Data;
                                                        /* 1-8 bytes 
receive  */
                     LIN_Count++;
                     if(LIN_Count == LIN_LENGTH)
                     {
                        LIN_Count = 0;
                        LIN_State = LIN_ST_CHECKSUM;
                        LIN_Checksum=LIN_CHECKSUM;
                                                              /* Gen 
Checksum */
                     }
                  }
                  else
                  {

                     /* Slave Send */

                     if(LIN_RESPONSE)
                     {
                        LIN_Checksum += LIN_Rx_Data;
                        TDR2=LIN_Trans_Buff[LIN_Count][SW_Slave-1];
                                                       /* Send next 
Bytes 2-8 */
                        LIN_Count++;
                        if(LIN_Count == LIN_LENGTH)
                        {
                           LIN_Count = 0;
                           LIN_State = LIN_ST_CHECKSUM;
                           LIN_Checksum=LIN_CHECKSUM;
                                                             /* Send 
Checksum */
                        }
                     }
                  }
                  break;

            /*===========================*/
            /*====== Slave CHECKSUM  ====*/
            /*===========================*/


               case LIN_ST_CHECKSUM:


                  /* Slave Receive */

                  if(LIN_REQUEST)
                  {
                     if(LIN_Rx_Data != LIN_Checksum)      /* compare 
Checksum */
                     {
                        LIN_Rx_Error=LIN_CHECK_ERR;
                     }
                     LIN_State = LIN_ST_NEXT;
                  }
                  else
                  {
                     /* Slave Send */

                     if(LIN_RESPONSE)
                     {
                        TDR2 = LIN_Checksum;                 /* Send 
Checksum */
                        LIN_State = LIN_ST_NEXT;
                     }
                  }
                  SCR2_RXE = 0;                          /* Disable 
reception */
                  break;

            }

         }
         else
         {
            LIN_Rx_Error=LIN_UNKNOWN_ERR;
            SSR2_RIE = 0;                     /* disable reception int 
*/
         }
   }
}

Dennis

Autor: Dennis (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
...darin spiegelt sich das Protokoll der Version 1.3 - Master wie Slave 
seitig - des LIN wieder.

zudem würde ich mir die Protokolldefinition mal runterladen, das hilft 
u.u. ungemein, auch um diesen code zu verstehen...

dennis

Autor: Mrhihi3s (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Hi,
bin wieder nach einer Woche, und habe eine Frage
zu erst  Danke dir Dennis, dein Struktur hat mir viel geholfen, ich 
könnte jetzt die AppNote  AVR322 verstehen insbesondere die UART 
Kommunikation , ich habe mir auch den LIN Protokoll durch gelesen.
Um  mein Hardware zu testen,  habe den Quellcode angepasst, möchte auf 
mein Controller AT90CAN128  Drauf tun, ich konnte das leider nicht hin 
kriegen, es fehlt leider ein H-datei  ich habe nur einen Fehler in den 
Code und zwar :  (  ../main.c:48:19: inavr.h: No such file or directory 
)
Es scheint das header datei  #include "inavr.h" wurde nicht erkannt.
Weiß vielleicht jemand von euch was das ist? Ich glaube es hat mit 
(Interrupt,  Timer) was zu tun , weil wenn ich das Header aus blende ( 
// #include "inavr.h")  krige ich insgesammt 5 fehler :

../timer1ovf_isr.c:71: error: syntax error before "void"
../timer1ovf_isr.c: In function `TIMER1_Overflow_ISR':
../timer1ovf_isr.c:77: error: `TCNT1H' undeclared (first use in this 
function)
../timer1ovf_isr.c:77: error: (Each undeclared identifier is reported 
only once
../timer1ovf_isr.c:77: error: for each function it appears in.)
../timer1ovf_isr.c:79: error: `TCNT1L' undeclared (first use in this 
function)
make: *** [timer1ovf_isr.o] Error 1
Build failed with 5 errors and 2 warnings...

Ich hoffe hilft  das, was ich betrieben habe, um header zu erkennen.

danke

Autor: Mrhihi3s (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
hie ist Quellecode für den Module  wo die fehler getroffen sind .


#include "config.h"
#include "master_lin.h"


extern   U8 Buf_SET_SLAVE [8];
extern   U8 Buf_GET_SLAVE_0[4];
extern   U8 Buf_GET_SLAVE_1[4];
extern   U8 Buf_GET_SLAVE_2[4];


U16    CmdCtr     ;



//********************************************************************** 
****
// Timer overflow interrupt service routine
//
// Overflow Rate is Tbit -  2400 Tbit  = 416us
//                          4800 Tbit  = 208us
//                          9600 Tbit  = 104us
//                          19200 Tbit = 52us
//
//********************************************************************** 
****


#pragma vector=TIMER1_OVF_vect

__interrupt void TIMER1_Overflow_ISR (void)
{


  // Reload: Set Timer Value for a Tbit overflow

  TCNT1H = _8MHZ_TCNT1H;

  TCNT1L = _8MHZ_TCNT1L;


  if(19200 == CmdCtr)
  {

    CmdCtr = 0;

  }
  else
  {

    CmdCtr++;

  }

  l_sch_tick();                //call lin slave handler


}

Autor: Dennis (Gast)
Datum:
Angehängte Dateien:

Bewertung
0 lesenswert
nicht lesenswert
Hallo,

leider kann ich zu dem Thema mit einem atmel eher weniger sagen. hier 
aber mal die PAP's des codes auch für andere.

Dennis

Autor: Dennis (Gast)
Datum:
Angehängte Dateien:

Bewertung
0 lesenswert
nicht lesenswert
slave

Autor: Dennis (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
... deine errors seher mir so auf die schnelle nach einem include oder 
make problem aus....

kaum zeit,
dennis

Autor: stefan (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Frage:

Gute Code, leider verstehe ich nicht wie Du die Variablen z.B. 
"LIN_Rx_Error" definieren kann.

Autor: stefan (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Noch eine Frage: wie kann man den Break detektieren? Im Program ist so 
geschrieben:

if(ESCR2_LBD)                          /* LIN Break detected?
*/
Aber wie ist ESCR2_LBD definiert?

Bitte send mir ein Email, wenn jemand Antwort hat.

Vielen Dank!

Autor: Amir B-a (sticky)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
bei den ATMEGA168 gibt es ein Framing error flag.
ist dieses im slave gesetzt so liegt das break field vor. und das 
nächste im erhaltende byte wäre dein sync field

Antwort schreiben

Die Angabe einer E-Mail-Adresse ist freiwillig. Wenn Sie automatisch per E-Mail über Antworten auf Ihren Beitrag informiert werden möchten, melden Sie sich bitte an.

Wichtige Regeln - erst lesen, dann posten!

  • Groß- und Kleinschreibung verwenden
  • Längeren Sourcecode nicht im Text einfügen, sondern als Dateianhang

Formatierung (mehr Informationen...)

  • [c]C-Code[/c]
  • [avrasm]AVR-Assembler-Code[/avrasm]
  • [code]Code in anderen Sprachen, ASCII-Zeichnungen[/code]
  • [math]Formel in LaTeX-Syntax[/math]
  • [[Titel]] - Link zu Artikel
  • Verweis auf anderen Beitrag einfügen: Rechtsklick auf Beitragstitel,
    "Adresse kopieren", und in den Text einfügen




Bild automatisch verkleinern, falls nötig
Bitte das JPG-Format nur für Fotos und Scans verwenden!
Zeichnungen und Screenshots im PNG- oder
GIF-Format hochladen. Siehe Bildformate.
Hinweis: der ursprüngliche Beitrag ist mehr als 6 Monate alt.
Bitte hier nur auf die ursprüngliche Frage antworten,
für neue Fragen einen neuen Beitrag erstellen.

Mit dem Abschicken bestätigst du, die Nutzungsbedingungen anzuerkennen.