icandrv.c51

infineon C515C RTX51 example. it contains example on using this device

#pragma large
#pragma debug
#pragma registerbank(3)
#pragma pagelength(80) pagewidth(110)
/***********************************************************************
************************************************************************
*                                                                      *
*  C A N   D R I V E R                                                 *
*                                                                      *
************************************************************************
************************************************************************
*                                                                      *
*  Funktion:                                                           *
*                                                                      *
*     Diese Modul enth刲t den eigentlichen CAN-Task. Der CAN-Task      *
*     乥ernimmt die gesammte Steuerung der CAN-Treiber Software.       *
*     Er reagiert auf Befehle von der Applikation (Signal und Daten    *
*     vom Modul CANAPIF) und auf Interrupts vom CAN-Controller.        *
*     Gestartet wird der CAN-Task vom Modul CANAPIF.                   *
*                                                                      *
*                                                                      *
*  Filename           :   ICANDRV.C51                                  *
*                                                                      *
*  Modulename         :   ICANDRV                                      *
*                                                                      *
*  Zielsystem         :   Jedes C515C System                           *
*                                                                      *
*  Entwicklungssystem :   Keil C-51                                    *
*                                                                      *
************************************************************************
*  Versionen:                                                          *
*                                                                      *
*  1.0  23.5.1997   K. Birsen    : Erste Version                       *
*  1.1  11.06.1997  K. Birsen : Extended Identification                *
*                               nicht mehr auf 0xFFFF begrenzt         *
*  5.3  22.7.1997   K. Birsen : 15. Object 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 "candefs.h"

/* Befehle von der Applikation */
#define CAN_HW_INIT_ORDER        1
#define CAN_DEF_OBJ_ORDER        2
#define CAN_DEF_OBJ_ORDER_EXT    3
#define CAN_DEF_L_OBJ_ORDER      4
#define CAN_DEF_L_OBJ_ORDER_EXT  5
#define CAN_STOP_ORDER           6
#define CAN_START_ORDER          7
#define CAN_SEND_ORDER           8
#define CAN_REQUEST_ORDER        9
#define CAN_BIND_OBJ_ORDER       10
#define CAN_UNBIND_OBJ_ORDER     11
#define CAN_BIND_L_OBJ_ORDER     12
#define CAN_UNBIND_L_OBJ_ORDER   13
#define CAN_WRITE_ORDER          14
#define CAN_READ_W_IND_ORDER     15
#define CAN_READ_W_TID_ORDER     16
#define CAN_READ_ORDER           17
#define CAN_READ_L_OBJ_ORDER     18
#define CAN_GET_STATUS_ORDER     19
#define CAN_ACTIVATE_WAIT        20     /* Spezial-Funktion zum Anzeigen,      */
                                     /* das ein Task auf ein Objekt wartet  */


/* Function-Prototypes */
static void c_handle_receive_int (void);
static void c_handle_can_int (void);
static void c_get_back (byte ret_val);
static void c_handle_appli_signal (void);


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


/* Verwendeter CAN-Interrupt (definiert in XCANCONF.A51) */
extern const unsigned char code CAN_INT_NBR;

/* RTX-51 Function-Calls */
#include <rtx51.h>
#include "icanobja.h"
#include "icancont.h"


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

   /* Die Applikation erteilt dem CAN-Task 乥er den gemeinsamen        */
   /* Speicherbereich C_ORDER_BUF Befehle. Ueber diesen gemeinsamen    */
   /* Speicherbereich gibt der CAN-Driver ebenfalls Status-Meldungen   */
   /* an die Applikation zur乧k.                                       */
   /* Der C_ORDER_BUF ist im Modul CANAPIF.A51 definiert.              */
   /* Die hier definierte Struktur wird an die selbe Speicherstelle    */
   /* gelegt.                                                          */
   /* ACHTUNG !! : Diese Struktur darf nicht einfach abge刵dert werden */
   /* sie muss mit der Definition im Modul CANAPIF.A51 乥ereinstimmen  */

   /* K. Birsen um c_define_obj_ext zu realisieren                     */
   /* c_order_buf.param hier und CANAPIF.A51 vom 5 auf 6 erh攈t        */

    extern xdata struct {
                   byte order;
                   byte task_id;
                   byte param[6];
                } c_order_buf;

   /* Ist TRUE falls der CAN-Task gestoppt ist (keine Objekte senden   */
   /* oder empfangen kann) und FALSE falls der CAN-Task l剈ft.         */
   static byte can_stopped;

   /* Workaround Signal-Problem                                        */
   /* Enth刲t die identifikation aller Tasks an die ein Objekt         */
   /* gebunden ist und an die tats刢hlich mit CAN_WAIT auf das Objekt  */
   /* warten                                                           */
   static struct {
               byte task_id;
               byte task_waits;
            } signal_ok[MAX_BIND_OBJ];


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

/*---------------------------------------------------------------------*
 *     C _ H A N D L E _ R E C E I V E _ I N T
 *---------------------------------------------------------------------*
 *  Funktion:
 *
 *     Steuert den Empfang eines Objektes nach einem Receive-Interrupt
 *
 *---------------------------------------------------------------------*
 *  Parameter:
 *
 *     --
 *
 *---------------------------------------------------------------------*/

static void c_handle_receive_int (void)
{
   unsigned int stat;
   byte         index, bind, i;

   stat = c_receive_obj ();
   if (stat <= 255) {
      /* Applikation muss benachrichtigt werden */
      index = stat;
      /* testen ob das empfangene Objekt an einen Task gebunden ist */
      bind = c_get_bind (index);
      if (bind != NO_BIND) {
         /* Objekt ist an einen Task gebunden */
         /* Testen ob Task bereit ist */
         for (i=0; i<=MAX_BIND_OBJ-1; i++) {
            if ((signal_ok[i].task_id == bind)
            && (signal_ok[i].task_waits == TRUE)) {
               os_send_signal (bind);
               return;
            }
         }
      }
      else {
         /* Objekt an keinen Task gebunden, an Mailbox senden          */
         /* Die Applikation liest danach mit dem Index die Objektdaten */
         if (os_send_message (7,index,0) == -1) {
            /* Objekt kann von der Applikation nicht empfangen werden */
            c_set_read (index);
         }
      }
   }
   else {
      ;
      /* Ein Objekt wurde empfangen, die Applikation muss aber nicht */
      /* benachrichtigt werden.                                      */
      /* Dieser Fall wurde nur f乺 interne Testzwecke eingef乬t      */
   }
}




/*---------------------------------------------------------------------*
 *     C _ H A N D L E _ C A N _ I N T
 *---------------------------------------------------------------------*
 *  Funktion:
 *
 *     Abhandlung der Aktionen die beim Auftreten eines CAN-Interrupts
 *     ausgef乭rt werden m乻sen.
 *
 *---------------------------------------------------------------------*
 *  Parameter:
 *
 *     --
 *
 *---------------------------------------------------------------------*/

static void c_handle_can_int (void)
{
   /* Die Informationsdarstellung ist beim Basic- und Full-CAN        */
   /* Controller nach einem Interrupt sehr unterschiedlich.           */
   /* Daher wird die Auswertung der Interrupt-Informationen f乺       */
   /* die beiden Controller getrennt implementiert                    */


     enum interrupt_t int_t;        /* 515C Interrupt Typen */

     int_t = c_get_int_typ();
     if (int_t == obj_int) {
        c_handle_receive_int();
        /* Der Interrupt wird von der Empfangsroutine zur乧kgesetzt */
     }
     else if (int_t == error_int) {
        /* Das Status-Register muss ausgewertet werden       */
        /* Es k攏nen mehrere Fehler gleichzeitig auftreten */
        if (c_get_status() == bus_off) {
           /* Applikation mit Index 0 benachrichtigen */
           os_send_message (7,0,0);
        }
        /* Error-Interrupt zur乧ksetzen */
        c_receipt_error_int();
     }
     else if (int_t == no_int) {
        /* Der Controller zeigt keinen Interrupt an       */
        /* Sollte eigentlich nicht vorkommen              */
        /* Wird jedoch aus Sicherheitsgr乶den abgefangen  */
        c_receipt_error_int(); /* Interrupt zur乧ksetzen */
     }
}

#pragma eject
/*---------------------------------------------------------------------*
 *     C _ G E T _ B A C K
 *---------------------------------------------------------------------*
 *  Funktion:
 *
 *     R乧kgabe des Statuswert RET_VAL an die Applikation, starten
 *     der Applikation mit einem Signal
 *
 *---------------------------------------------------------------------*
 *  Parameter:
 *
 *     ret_val  :  Wert der an die Applikation zur乧kgegeben werden soll
 *
 *---------------------------------------------------------------------*/

static void c_get_back (byte ret_val)
{
   c_order_buf.param[0] = ret_val;
   os_send_signal (c_order_buf.task_id);
}




/*---------------------------------------------------------------------*
 *     C _ H A N D L E _ A P P L I _ S I G N A L
 *---------------------------------------------------------------------*
 *  Funktion:
 *     Ausf乭rung aller Applikationsbefehle
 *
 *---------------------------------------------------------------------*
 *  Parameter:
 *
 *     --
 *
 *---------------------------------------------------------------------*/

static void c_handle_appli_signal (void)
{

   byte temp_0, temp_1;
   byte done, i;
   /* Hilfsvariable zum separaten ansprechen von Bytes               */
   /* in einem int oder long int                                     */
   union {
      unsigned int tw;
      unsigned long tl;
      byte tb[4];
   } qq;
   /* Union um den den Pointer als einzelne Bytes ansprechen zu k攏nen   */
   union {
      struct
      {  byte offs[4];
      } short_ptr;
      unsigned long xdata *l_ptr;
      byte xdata *c_ptr;
   } po;


   switch (c_order_buf.order) {

      case CAN_HW_INIT_ORDER:
         c_stop ();
         can_stopped = TRUE;
         done = c_hw_init (
                          c_order_buf.param[0],   /* t0 reg */
                          c_order_buf.param[1],   /* t1_reg */
                          c_order_buf.param[2],   /* dummy */
                          c_order_buf.param[3]);  /* dummy */

         if (done == FALSE) {
            c_get_back (C_CAN_FAILURE);
            return;
         }

         c_init_obj_buf ();
         for (i=0; i<=MAX_BIND_OBJ-1; i++) {
            signal_ok[i].task_id = NO_BIND;
            signal_ok[i].task_waits = FALSE;
         }
      break;

      case CAN_DEF_OBJ_ORDER:
         if (can_stopped == FALSE) {
            c_get_back (C_NOT_STOPPED);
            return;
         }
         qq.tb[0] = c_order_buf.param[0];               /* ident */
         qq.tb[1] = c_order_buf.param[1];

         temp_0 = c_define_obj (qq.tw,                  /* ident */
                              c_order_buf.param[2],     /* length */
                              c_order_buf.param[3]);    /* type */
         if (temp_0 != C_OK) {
            c_get_back (temp_0);
            return;
         }
      break;

      case CAN_DEF_OBJ_ORDER_EXT:
         if (can_stopped == FALSE) {
            c_get_back (C_NOT_STOPPED);
            return;
         }
         qq.tb[0] = c_order_buf.param[0];               /* ident */
         qq.tb[1] = c_order_buf.param[1];
         qq.tb[2] = c_order_buf.param[2];
         qq.tb[3] = c_order_buf.param[3];

         temp_0 = c_define_obj_ext (qq.tl,              /* ident */
                                c_order_buf.param[4],   /* len */
                                c_order_buf.param[5]);  /* type */
         if (temp_0 != C_OK) {
            c_get_back (temp_0);
            return;
         }
      break;

      case CAN_DEF_L_OBJ_ORDER:
         if (can_stopped == FALSE) {
            c_get_back (C_NOT_STOPPED);
            return;
         }
         qq.tb[0] = c_order_buf.param[0];               /* ident */
         qq.tb[1] = c_order_buf.param[1];
         qq.tb[2] = c_order_buf.param[2];
         qq.tb[3] = c_order_buf.param[3];

         temp_0 = c_define_l_obj (qq.tl,                  /* ident */
                             c_order_buf.param[4]       /* length */
                             );
         if (temp_0 != C_OK) {
            c_get_back (temp_0);
            return;
         }
      break;

      case CAN_DEF_L_OBJ_ORDER_EXT:
         if (can_stopped == FALSE) {
            c_get_back (C_NOT_STOPPED);
            return;
         }
         qq.tb[0] = c_order_buf.param[0];                /* ident */
         qq.tb[1] = c_order_buf.param[1];
         qq.tb[2] = c_order_buf.param[2];
         qq.tb[3] = c_order_buf.param[3];

         temp_0 = c_define_l_obj_ext (qq.tl,              /* ident */
                                c_order_buf.param[4]    /* len */
                                );
         if (temp_0 != C_OK) {
            c_get_back (temp_0);
            return;
         }
      break;