hcanobja.c51

example of using Infineon 81c91 processor.

#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.                            *
*                                                                      *
*                                                                      *
*  Filename           :   HCANOBJA.C51                                 *
*                                                                      *
*  Modulename         :   HCANOBJA                                     *
*                                                                      *
*  Zielsystem         :   Jedes 8051 System mit einem                  *
*                         Siemens 81C91 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     *
*  1.3  21.03.1996    K. Birsen  : 81C91 implementiert                 *
*                                                                      *
************************************************************************
*    Copyright 1991 .. 2001 METTLER  &  FUCHS  AG,  CH-8953 Dietikon   *
************************************************************************/

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

#include "abbrev.h"
#include "hcanobja.h"
#include "candefs.h"

/* Maximale Anzahl Objekte im Objektbuffer */
#define MAX_OBJECTS 16

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

/* Gr攕ster Objektidentifier, der benutzt werden darf */
#define MAX_OBJECT_IDENT 2047


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

#include "hcancont.h"
#include "canutil.h"


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

    /* Definition des Objektbuffers                    */
    /* Das Objekt mit dem Index 0 wird nicht verwendet !                */
    /* (Dummy-Element, zum Anzeigen der Nichtexistenz eines Objektes)   */
    static xdata struct {
                   unsigned int identifier;    /* CAN Objekt-ID      */
                   byte obj_typ;               /* Typ des Objekts    */
                   byte data_length;           /* Anzahl Datenbytes  */
                   byte task_bind;             /* Task-ID oder FFH   */
                   byte obj_read;              /* Objekt gelesen ?   */
                   byte contr_adr;             /* interne Start-     */
            } can_obj_buf[MAX_OBJECTS+1];      /* Adresse des Objekts  */

    /* Anzahl freie Bytes im 81C91 internen Objekt-Speicher           */
    static byte xdata free_contr_buf;

   /* 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                           *
 *---------------------------------------------------------------------*/

/*---------------------------------------------------------------------*
*      C _ G E T _ I N D E X _ F R O M _ A D R
*---------------------------------------------------------------------*
*  Funktion:
*      Testet ob das Objekt mit der Controller internen Adresse C_ADR
*      im Objekt-Buffer definiert ist und gibt den entsprechenden Index
*      innerhalb von CAN_OBJ_BUF zur乧k.
*
*---------------------------------------------------------------------*
*  Parameter:
*
*      c_adr   :    Controller interne Start-Adresse des Objektes
*
*      Returnwert   :  0                  -->   Das Objekt existiert nicht
*                      1 .. MAX_OBJECTS   -->   Index des Objektes
*
*---------------------------------------------------------------------*/

static byte c_get_index_from_adr (byte c_adr)
{
  byte i, temp;

  temp = nbr_of_obj;
  for (i=1; i<=temp; i++) {
     if (can_obj_buf[i].contr_adr == c_adr) return i;
  }
  return 0;
}


#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;

    free_contr_buf =  CONTR_BUF_START_ADR ;

    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 82C200 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 int 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 (free_contr_buf >= CONTR_BUF_END_ADR) 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++;
       free_contr_buf = free_contr_buf + MESSAGE_SIZE;
       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;
       if (nbr_of_obj == 1) {
          can_obj_buf[nbr_of_obj].contr_adr = CONTR_BUF_START_ADR;
       }
       else {
          can_obj_buf[nbr_of_obj].contr_adr =
            can_obj_buf[nbr_of_obj-1].contr_adr + MESSAGE_SIZE ;
       }
       c_init_obj (identifier,
                  data_length,
                  obj_typ,
                  can_obj_buf[nbr_of_obj].contr_adr
                  );
       return C_OK;
    }
    else {
       /* Objekt existiert schon */
       return C_OBJ_ERROR;
    }
}


#pragma eject
/*---------------------------------------------------------------------*
 *     Zugriffsfunktionen                                              *
 *---------------------------------------------------------------------*/

 /* Die Applikation benutzt die Objekt-Identifikation f乺 den Zugriff  */
 /* auf ein bestimmtes Objekt. Intern wird jedoch nur der Index eines  */
 /* bestimmten Objektes innerhalb des Objektbuffers zum Zugriff        */
 /* benutzt. Mit den Prozeduren C_GET_INDEX und C_GET_IDENT            */
 /* kann der Index resp. die Identifikation eines bestimmten Objektes  */
 /* ermittelt werden.                                                  */
 /*                                                                    */
 /* Die jeweiligen Zugriffsprozeduren testen aus Zeitgr乶den jeweils   */
 /* nicht mehr ob ein bestimmter Index tats刢hlich einem definierten   */
 /* Objekt entspricht !                                                */


/*---------------------------------------------------------------------*
 *       C _ G E T _ I N D E X _ F R O M _ I D E N T
 *---------------------------------------------------------------------*
 *  Funktion:
 *     Testet ob das Objekt IDENTIFIER im Objekt-Buffer definiert ist
 *     und gibt den entsprechenden Index innerhalb CAN_OBJ_BUF zur乧k.
 *
 *---------------------------------------------------------------------*
 *  Parameter:
 *
 *     identifier   :  Identifikation des gesuchten Objektes
 *
 *     Returnwert   :  0                -->   Das Objekt IDENTIFIER existiert
 *                                              nicht
 *                     1 .. MAX_OBJECTS -->   Index des Objektes IDENTIFIER
 *
 *---------------------------------------------------------------------*/
    byte c_get_index_from_ident (unsigned int identifier)

{
    byte i, temp;

    temp = nbr_of_obj;
    for (i=1; i<=temp; i++) {
        if (can_obj_buf[i].identifier == identifier) return i;
    }
    return 0;
}



/*---------------------------------------------------------------------*
 *     C _ G E T _ I D E N T
 *---------------------------------------------------------------------*
 *  Funktion:
 *     Gibt den Identifier des Objektes mit dem INDEX innerhalb
 *     CAN_OBJ_BUF zur乧k.
 *
 *---------------------------------------------------------------------*
 *  Parameter:
 *
 *     index        :    Index des gesuchten Objektes
 *
 *     Returnwert   :    0 .. 7EFH  ->  Identifikation des gew乶schten
 *                       Objektes
 *                       FFFFH      ->  Objekt existiert nicht
 *
 *---------------------------------------------------------------------*/
   unsigned int c_get_ident (byte index)

{
    if ((index == 0) || (index > nbr_of_obj)) return 0xffff;
    return can_obj_buf[index].identifier;
}


/*---------------------------------------------------------------------*
 *     C _ G E T _ R E C _ B I N D
 *---------------------------------------------------------------------*
 *  Funktion:
 *     Gibt den Index eines neu empfangenen und noch nicht von der
 *     Applikation gelesenen Objektes, das fest an den Task TASK_ID
 *     gebunden ist, zur乧k.
 *
 *---------------------------------------------------------------------*
 *  Parameter:
 *
 *     task_id   :    Task-Identifikation des Tasks an den das Objekt
 *                    gebunden ist
 *
 *     Returnwert   :  0                 -->   Es existiert kein gew乶schtes Objekt
 *                     1 .. MAX_OBJECTS  -->   Index des Objektes
 *
 *---------------------------------------------------------------------*/

byte c_get_rec_bind (byte task_id)
{
    byte i, ind;

    for (i=0; i<=MAX_BIND_OBJ-1; i++) {
        ind = bind_index_list[i];
        if (ind != 0) {
            if (can_obj_buf[ind].task_bind == task_id) {
                if (!(can_obj_buf[ind].obj_read)) {
                    return ind;
                }
            }
        }
    }
    return 0;
}



/*---------------------------------------------------------------------*
 *     C _ G E T _ O B J _ T Y P
 *---------------------------------------------------------------------*
 *  Funktion:
 *     Gibt den Objekttyp wie in C_DEFINE_OBJ definiert des Objektes