pcanobja.c51

Philips sja1000 can controller. it contains example on how to control this device

#pragma large
#pragma debug
#pragma registerbank(3)
#pragma pagelength(80) pagewidth(110)
/***********************************************************************
************************************************************************
*                                                                      *
*  C A N   O B J E C T  A D M I N I S T R A T I O N                    *
*                                                                      *
************************************************************************
************************************************************************
*                                                                      *
*  Funktion:                                                           *
*                                                                      *
*     Dieses Modul 乥ernimmt die Verwaltung von allen vom Benutzer     *
*     definierten Kommunikationsobjekten. Es regelt den Empfang und    *
*     das Senden der Kommunikationsobjekte.                            *
*                                                                      *
*     Beim kompilieren muss ein Makro mit dem Namen                    *
*     SJA1000 angegeben werden                                         *
*                                                                      *
*                                                                      *
*  Filename           :   PCANOBJA.C51                                 *
*                                                                      *
*  Modulename         :   PCANOBJA                                     *
*                                                                      *
*  Zielsystem         :   Jedes 8051 System mit einem Philips          *
*                         SJA1000 CAN-Controller                       *
*                                                                      *
*  Entwicklungssystem :   Keil C-51                                    *
*                                                                      *
************************************************************************
*  Versionen:                                                          *
*                                                                      *
*  0.1  26.10.1990  Th. Fischler : Erste Version                       *
*  1.0  21.01.1991  Th. Fischler : Send-Error Handling eingebaut       *
*  1.1  13.02.1991  Th. Fischler : Mit Variante f乺 den Intel-         *
*                                  Controller erweitert                *
*  1.2  09.04.1992  Th. Fischler : Fehler in Akkzeptanzfilterung       *
*                                  und Unbind von Objekten behoben     *
*                                                                      *
************************************************************************
*    Copyright 1991 .. 2001 METTLER  &  FUCHS  AG,  CH-8953 Dietikon   *
************************************************************************/

/*---------------------------------------------------------------------*
 *     D E F I N I T I O N E N                                         *
 *---------------------------------------------------------------------*/


/* Test ob der CAN-Controller angew刪lt wurde */
#ifndef SJA1000
   #error "SJA1000 muss definiert werden"
#endif



#include "abbrev.h"
#include "pcanobja.h"
#include "candefs.h"

#define MAX_OBJECTS 255


/* Maximale L刵ge der Daten in einem Objekt */
#define MAX_OBJECT_DATA_SIZE 8

/* Gr攕ster Basic CAN Objektidentifier, der benutzt werden darf */
#define MAX_OBJECT_IDENT 2031


/*---------------------------------------------------------------------*
*     I M P O R T S                                                   *
*---------------------------------------------------------------------*/

#include "pcancont.h"
#include "pcanutil.h"


/*---------------------------------------------------------------------*
*     M O D U L G L O B A L E  V A R I A B L E N                      *
*---------------------------------------------------------------------*/

/*==================================================================*/
/* NUR FUER Philips SJA1000                                          */
/*==================================================================*/
/* Die Gr攕se des Objektbuffers kann vom Kunden in einem eigenen    */
/* Konfigurationsfile festgelegt werden (BCANCONF.A51).             */
/* Jedes zu definierende Objekt ben攖igt 14 Byte XDATA-RAM          */
/* (unabh刵gig von der tats刢hlich verwendeten Datenl刵ge).         */
/* Der Linker alloziert diese Variable automatisch an den die       */
/* Speicherstelle, die das Symbol CAN_OBJ_BUF im Assembler Modul    */
/* BCANCONF einnimmt.                                               */
/* Hier wird die maximal m攇liche Anzahl von Objekten definiert     */
/* (Korrekte Code-Generierung des Compilers !)                      */
/* Das Objekt mit dem Index 0 wird nicht verwendet !                */
/* (Dummy-Element, zum Anzeigen der Nichtexistenz eines Objektes)   */

extern xdata struct {
	     unsigned long identifier;    /* CAN Objekt-ID      */
	     byte frame;                 /* 1 f乺 ext, 0 f乺 standart */
	     byte obj_typ;               /* Typ des Objekts    */
	     byte data_length;           /* Anzahl Datenbytes  */
	     byte task_bind;             /* Task-ID oder FFH   */
	     byte obj_read;              /* Objekt gelesen ?   */
	     byte dat[MAX_OBJECT_DATA_SIZE]; /* Objekt-Daten  */
	  } can_obj_buf[MAX_OBJECTS+1];

/* Hilfsvariablen, liegen an derselben Adresse wie die Symbole    */
/* CAN_OBJ_BUF_END und CAN_OBJ_BUF_START im Assembler Modul       */
/* PCANCONF.A51                                                   */
extern xdata byte can_obj_buf_start;
extern xdata byte can_obj_buf_end;

/* Vom Benutzer definierte L刵ge des Objektbuffers in Anzahl        */
/* Objekten                                                         */
static xdata unsigned int obj_buf_len;

static xdata unsigned long acc_code, acc_mask;
/* Bilden zusammen die 11-Bit Akzeptanzfilterung, die Variable      */
/* ACC_MASK gibt an, welche Bits der Variable ACC_CODE f乺 die      */
/* Filterung relevant sind (1->relevant, 0->nicht relevant).        */
/* Falls der Identifier eines empfangenen Objektes zumindest an den */
/* durch die Variable ACC_MASK bestimmten Stellen mit der Variablen */
/* ACC_CODE 乥ereinstimmt, hat das Objekt die zweite Stufe der      */
/* Akzeptanzfilterung passiert (1. Stufe macht der SJA1000).         */
/*                                                                  */
/* Eine Identifiaktion (ID) passiert die Akzeptanzfilterung in der  */
/* zweiten Stufe wenn :                                             */
/*   (ID XOR ACC_CODE) AND (ACC_MASK) = 00000000000B                */

static xdata byte new_init;
/* Ist TRUE falls der Objektbuffer eben mit C_INIT_OBJ_BUFF neu     */
/* initialisiert wurde                                              */




/* Anzahl definierte Objekte                                        */
static xdata byte nbr_of_obj;

/* Enth刲t die Indexe aller Objekte die an einen bestimmten Task    */
/* gebunden sind (deren Feld OBJ_BUF.TASK_BIND ungleich FFH ist).   */
/* Der Wert 0 zeigt ein unbenutztes Feld an (enth刲t keinen Index). */
/* Mit Hilfe dieses Arrays kann schnell ein zu einem bestimmten     */
/* Task geh攔endes Objekt gefunden werden.                          */
static xdata byte bind_index_list[MAX_BIND_OBJ];


#pragma eject
/*---------------------------------------------------------------------*
*          L O K A L E   P R O Z E D U R E N                                                       *
*---------------------------------------------------------------------*/


#pragma eject
/*---------------------------------------------------------------------*
*     E X P O R T I E R T E  P R O Z E D U R E N                      *
*---------------------------------------------------------------------*/


/*---------------------------------------------------------------------*
*     Initialisieren und Definieren von Objekten                      *
*---------------------------------------------------------------------*/

/*---------------------------------------------------------------------*
 *     C _ I N I T _ O B J _  B U F
 *---------------------------------------------------------------------*
 *  Funktion:
 *     Neu Initialisieren des Objektbuffers, L攕chen aller vorhandenen
 *     Objekte
 *
 *---------------------------------------------------------------------*
 *  Parameter:
 *
 *     --
 *
 *---------------------------------------------------------------------*/

void c_init_obj_buf (void)
{
   byte i;

   obj_buf_len = ((&can_obj_buf_end+1) - &can_obj_buf_start) /
					sizeof(can_obj_buf[1]);
   acc_code = acc_mask = 0xffffffff;
   new_init = TRUE;

   nbr_of_obj = 0;
   for (i=0; i<=MAX_BIND_OBJ-1; i++) bind_index_list[i] = 0;
}



/*---------------------------------------------------------------------*
 *     C _ D E F I N E _ O B J
 *---------------------------------------------------------------------*
 *  Funktion:
 *     Definiert ein neues Objekt im Objekt-Buffer und berechnet die
 *         resultierende Akzeptanz-Maske (beim Philips SJA1000 Controller).
 *
 *---------------------------------------------------------------------*
 *  Parameter:
 *
 *     identifier   : Identifikation des zu definierenden Objektes
 *     data_length  : Anzahl Datenbytes des zu definierenden
 *                    Objektes (0..8)
 *     obj_typ      : Genauere Beschreibung der Verwendungsart des
 *                    Objektes :
 *
 *                    D_REC        :   Objekt kann nur empfangen werden
 *                    D_SEND       :   Objekt kann nur gesendet werden
 *                    D_REC_R_SEND :   Objekt kann empfangen werden
 *                                     und es kann ein entsprechende
 *                                     Remote-Frame ausgesendet werden
 *                    D_SEND_R_REC :   Objekt kann gesendet werden und es
 *                                     kann ein entsprechendes Remote-Frame
 *                                     empfangen und beantwortet werden
 *
 *
 *     Returnwert   : OK, OBJ_ERROR, TOO_LONG, INVALID_TYPE, MEM_FULL
 *
 *---------------------------------------------------------------------*/

byte c_define_obj (unsigned long identifier,
		   byte data_length,
		   byte obj_typ)
{
   /* Test der Input-Werte */
   if (data_length > MAX_OBJECT_DATA_SIZE) return C_TOO_LONG;
   if ((obj_typ != D_REC) && (obj_typ != D_SEND) &&
	 (obj_typ != D_REC_R_SEND) && (obj_typ != D_SEND_R_REC))
		 return C_INVALID_TYPE;
   if (nbr_of_obj >= obj_buf_len) return C_MEM_FULL;
   if (nbr_of_obj >= MAX_OBJECTS) return C_MEM_FULL;
   if (identifier > MAX_OBJECT_IDENT) return C_OBJ_ERROR;
   if (c_get_index_from_ident(identifier) == 0) {
      nbr_of_obj++;
      can_obj_buf[nbr_of_obj].identifier = identifier;
      can_obj_buf[nbr_of_obj].obj_typ = obj_typ;
      can_obj_buf[nbr_of_obj].data_length = data_length;
      can_obj_buf[nbr_of_obj].task_bind = NO_BIND;
      can_obj_buf[nbr_of_obj].obj_read = TRUE;
      /* Werte f乺 die Akkzeptanzfilterung berechnen */
      if (obj_typ != D_SEND) {
	 if (new_init) {
	    /* erstes Objekt */
	    acc_code = identifier;
	    new_init = FALSE;
	 }
	 else {
	    acc_mask = ~(acc_code ^ identifier) & acc_mask;
	    acc_code = acc_code & identifier;
	 }
      }
      return C_OK;
   }
   else {
      /* Objekt existiert schon */
      return C_OBJ_ERROR;
   }

}


#pragma eject

/*---------------------------------------------------------------------*
*         C _ G E T _ A C C _ C O D E
*---------------------------------------------------------------------*
*  Funktion:
*         Gibt den beim Definieren der Objekte (mit C_DEFINE_OBJ)
*         berechneten Acceptance-Code f乺 den SJA1000 zur乧k.
*
*---------------------------------------------------------------------*
*  Parameter:
*
*         Returnwert   : Acceptance-Code f乺 den SJA1000
*
*---------------------------------------------------------------------*/

byte c_get_acc_code (void)
{
   /* Nur die 8 MSB des acc_code zur乧kgeben */
   return (acc_code >> 3);
}



/*---------------------------------------------------------------------*
*         C _ G E T _ A C C _ M A S K