pcandrv.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   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           :   PCANDRV.C51                                  *
*                                                                      *
*  Modulename         :   PCANDRV                                      *
*                                                                      *
*  Zielsystem         :   Jedes 8051 System mit einem Philips          *
*                         SJA1000                                      *
*                                                                      *
*  Entwicklungssystem :   Keil C-51                                    *
*                                                                      *
************************************************************************
*  Versionen:                                                          *
*                                                                      *
*  0.1  26.10.1990  Th. Fischler : Erste Version                       *
*  1.0   7.12.1990  Th. Fischler : Bus-off Handling eingebaut          *
*        21.1.1991  Th. Fischler : Send-Error Verhalten eingebaut      *
*        14.1.1991  Th. Fischler : Full-CAN eingebaut                  *
*        20.8.1991  Th. Fischler : Beim Basic-CAN wird der Error-INT   *
*                                  nicht mehr benutzt                  *
*  2.0  10.10.1991  Th. Fischler : Version f乺 RTX-51 V4.0             *
*  2.1  24.8.1992   Th. Fischler : Workaround f乺 Signal Mehrfach-     *
*                                  verwendungsproblem                  *
*                                                                      *
*                                                                      *
************************************************************************
*    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 "candefs.h"


/* Befehle von der Applikation */
#define CAN_HW_INIT_ORDER       1
#define CAN_DEF_OBJ_ORDER       2
#define CAN_STOP_ORDER          3
#define CAN_START_ORDER         4
#define CAN_SEND_ORDER          5
#define CAN_REQUEST_ORDER       6
#define CAN_BIND_OBJ_ORDER      7
#define CAN_UNBIND_OBJ_ORDER    8
#define CAN_WRITE_ORDER         9
#define CAN_READ_W_IND_ORDER    10
#define CAN_READ_W_TID_ORDER    11
#define CAN_READ_ORDER          12
#define CAN_GET_STATUS_ORDER    13
#define CAN_ACTIVATE_WAIT       14   /* 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 "pcanobja.h"
#include "pcancont.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  */

   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;

   /* Z刪lt die Anzahl aufgetretener Overrun-Interrupts vom            */
   /* Philips SJA1000 CAN-Controller (f乺 interne Testzwecke)           */
   static unsigned int c_overrun_counter;

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


   can_interrupt_type int_r; /* Interrupt-Bits im CAN-Controller */

   /* Interrupt Register lesen, um den Grund des Interrupts zu          */
   /* eruieren und zum R乧ksetzen des Interrupts                                                */
   int_r.bytes = c_get_int_reg ();

   /* Alle m攇lichen Interrupts testen, es k攏nen mehrere                       */
   /* gleichzeitig auftreten                                                                                    */
   if (int_r.bits.RI) {
      /* Receive-Interrupt */
      c_handle_receive_int();
   }

   if (int_r.bits.DOI) {
      /* Overrun-Interrupt */
      c_overrun_counter++;
      c_clr_overrun ();
   }
}



#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, temp2;
   byte done, i;
   unsigned int w_temp;
   /* Hilfsvariable zum separaten ansprechen von High- und Low-Byte  */
   /* in einem Word                                                  */
   union {
      unsigned int tw;
      byte tb[2];
   } qq;

   /* Union um den den Pointer als einzelne Bytes ansprechen zu k攏nen   */
   union {
      struct
      {  byte offs[2];
      } short_ptr;
      unsigned int xdata *i_ptr;
      byte xdata *c_ptr;
   } po;

   can_control_type cont_r;

   switch (c_order_buf.order) {
      case CAN_HW_INIT_ORDER:
	 c_stop ();
	 can_stopped = TRUE;
	 done = c_hw_init (c_order_buf.param[0], /* bus_timing_0 */
			   c_order_buf.param[1], /* bus_timing_1 */
			   c_order_buf.param[2], /* out control */
			   c_order_buf.param[3]); /* clock devider */
	 if (done == FALSE) {
	    c_get_back (C_CAN_FAILURE);
	    return;
	 }

	 /************ NUR Receive- und Overrun Interrupt enablen ********/
	 /* und SYNC-Mode auf 0 einstellen                               */