ccont592.c51

RTX51 example for Intel 82526. it contains example use of CAN.

#pragma large
#pragma debug
#pragma registerbank(3)
#pragma pagelength(80) pagewidth(110)
/***********************************************************************
************************************************************************
*                                                                      *
*  80592 - C A N   C O N T R O L L E R                                 *
*                                                                      *
************************************************************************
************************************************************************
*                                                                      *
*  Funktion:                                                           *
*                                                                      *
*     Direkte HW-Steuerung der CAN-Schnittstelle des Philips 80592.    *
*     Ausf乭rung aller Low-Level Funktionen. Dieses Modul ist das      *
*     einzige, dass direkt in die HW-Register des CAN-Controllers      *
*     schreiben darf.                                                  *
*                                                                      *
*                                                                      *
*  Filename           :  CCONT592.C51                                  *
*                                                                      *
*  Modulename         :  CCONT592                                      *
*                                                                      *
*  Zielsystem         :  Philips 80592 Prozessor                       *
*                                                                      *
*  Entwicklungssystem :  Keil C-51                                     *
*                                                                      *
************************************************************************
*  Versionen:                                                          *
*                                                                      *
*  1.0  17.10.1991  Th. Fischler : Erste Version                       *
*                                                                      *
************************************************************************
*    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 "ccont592.h"

/* Maximale Anzahl der Sende-Versuche bei Bus-Problemen */
/* von CCONF592.A51                                     */
extern const unsigned char code NBR_OF_SEND_TRIALS;


/* Definition der einzelnen Bits im STATUS-REGISTER    */
/* des CAN-Controllers                                 */
union can_status_typ {
   struct {
      byte rec_buffer_stat  : 1;
      byte data_overrun     : 1;
      byte trans_buf_access : 1;
      byte trans_complete   : 1;
      byte rec_status       : 1;
      byte trans_status     : 1;
      byte err_status       : 1;
      byte bus_status       : 1;
   } status_bits;
   byte status_byte;
};


/* Definition der internen Adressen der CAN-Register (82C200 Register) */
#define CONTROL   0
#define COMMAND   1
#define STATUS    2
#define INTERRUPT 3
#define ACC_CODE  4
#define ACC_MASK  5
#define BUS_T_0   6
#define BUS_T_1   7
#define OUT_CONTR 8
#define TRANSMIT  10
#define RECEIVE   20


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


/* RTX-51 Function-Calls */
#include <rtx51.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 der speziellen 80592 CAN-Steuer-Register */

sfr CANADR = 0xdb;
sfr CANDAT = 0xda;
sfr CANCON = 0xd9;
sfr CANSTA = 0xd8;


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

/*---------------------------------------------------------------------*
 *     S E T _ I N T E R N A L _ R E G
 *---------------------------------------------------------------------*
 *  Funktion:
 *     Setzt das interne CAN-Register 'reg' auf den Wert 'value'
 *
 *---------------------------------------------------------------------*
 *  Parameter:
 *     reg      : Interne Adresse des zu beschreibenden Registers
 *     value    : Wert der geschrieben werden soll
 *
 *---------------------------------------------------------------------*/

static void set_internal_reg (byte reg, byte value)
{
   CANADR = reg;
   CANDAT = value;
}


/*---------------------------------------------------------------------*
 *     G E T _ I N T E R N A L _ R E G
 *---------------------------------------------------------------------*
 *  Funktion:
 *     Liest das interne CAN-Register 'reg'.
 *
 *---------------------------------------------------------------------*
 *  Parameter:
 *     reg           : Interne Adresse des zu lesenden Registers
 *
 *     R乧kgabewert  : Aktueller Wert des Register 'reg'
 *
 *---------------------------------------------------------------------*/

static byte get_internal_reg (byte reg)
{
   CANADR = reg;
   return CANDAT;
}

                 
/*---------------------------------------------------------------------*
 *     C A N _ R E S E T _ R E Q U E S T
 *---------------------------------------------------------------------*
 *  Funktion:
 *     Setzt den CAN-Controller in den Reset-Zustand
 *
 *---------------------------------------------------------------------*
 *  Parameter:
 *     --
 *
 *---------------------------------------------------------------------*/

static void can_reset_request (void)
{
   byte cont;

   cont = get_internal_reg (CONTROL);
   cont = cont | 0x01;
   set_internal_reg (CONTROL, cont);
}



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

/*---------------------------------------------------------------------*
 *     C _ F I R S T _ I N I T
 *---------------------------------------------------------------------*
 *  Funktion:
 *     Diese Routine sollte vor der ersten
 *     initialisierung des Controllers aufgerufen werden.
 *     (Sie ist vorallem aus zur Sicherstellung der Kompatibilit則 zur
 *     Basic-CAN Software vorhanden).
 *
 *---------------------------------------------------------------------*
 *  Parameter:
 *     --
 *---------------------------------------------------------------------*/
void c_first_init (void)
{
   can_reset_request();
}


/*---------------------------------------------------------------------*
 *     C _ H W _ I N I T
 *---------------------------------------------------------------------*
 *  Funktion:
 *     Grundinitialisierung des 80592 CAN-Controllers.
 *     Der CAN-Controller wird f乺 diese Operation angehalten.
 *     Er muss danach mit C_START wieder neu gestartet werden.
 *
 *---------------------------------------------------------------------*
 *  Parameter:
 *
 *     bus_t0_reg   : Bus-Timing Register 0 des 80592
 *     bus_t1_reg   : Bus-Timing Register 1 des 80592
 *     out_c_reg    : Output-Control Register des 80592
 *
 *     Returnwert   : TRUE   -> OK
 *                    FALSE  -> Fehler beim Init
 *---------------------------------------------------------------------*/

byte c_hw_init (byte bus_t0_reg,
                byte bus_t1_reg,
                byte out_c_reg)
{
   byte cont;

   can_reset_request();
   /* test-mode ausschalten */
   cont = get_internal_reg (CONTROL);
   cont = cont & 0x7f;;
   set_internal_reg (CONTROL, cont);
   set_internal_reg (BUS_T_0, bus_t0_reg);
   set_internal_reg (BUS_T_1, bus_t1_reg);
   set_internal_reg (OUT_CONTR, out_c_reg);
   return TRUE;
}



/*---------------------------------------------------------------------*
 *     C _ I N I T _ C O N T _ R E G
 *---------------------------------------------------------------------*
 *  Funktion:
 *     Initialisierung des CONTROL-REGISTERS des 80592
 *     (Festlegung der Interrupts und des Synch-Modes).
 *     Der CAN-Controller wird f乺 diese Operation angehalten, er muss
 *     danach mit C_START wieder neu gestartet werden.
 *
 *---------------------------------------------------------------------*
 *  Parameter:
 *
 *     cont_reg    :  Inhalt des 80592 Control-Registers
 *
 *---------------------------------------------------------------------*/

void c_init_cont_reg (byte cont_reg)
{
   /* Reset-Request Bit einschalten und sicherstellen dass Test-Mode */
   /* ausgeschaltet bleibt                                           */
   set_internal_reg (CONTROL, (cont_reg | 0x01) & 0x7f);
}



/*---------------------------------------------------------------------*
 *     C _ I N I T _ A C C E P T _ R E G
 *---------------------------------------------------------------------*
 *  Funktion:
 *     Acceptance-Code und Acceptance-Mask Register initialisieren.
 *     Der CAN-Controller wird f乺 diese Operation angehalten, er muss
 *     danach mit C_START wieder neu gestartet werden.
 *
 *---------------------------------------------------------------------*
 *  Parameter:
 *
 *     acc_code    :  Inhalt des Acceptanc-Code Registers
 *     acc_mask    :  Inhalt des Acceptance-Mask Registers
 *
 *---------------------------------------------------------------------*/

void c_init_accept_reg (byte acc_code,
                        byte acc_mask)
{
   can_reset_request();
   set_internal_reg (ACC_CODE, acc_code);
   set_internal_reg (ACC_MASK, acc_mask);
}



/*---------------------------------------------------------------------*
 *     C _ S T A R T
 *---------------------------------------------------------------------*
 *  Funktion:
 *     Starten des CAN-Controllers nach Init oder nach C_STOP.
 *     Nach C_START k攏nen Objekte empfangen und gesendet werden.
 *
 *---------------------------------------------------------------------*
 *  Parameter:
 *
 *     --
 *
 *---------------------------------------------------------------------*/

void c_start (void)
{
   /* Das Reset request Bit kann durch einen externen Hardware Reset */
   /* ausgeschaltet bleiben, darum solange ausschalten bis der Reset */
   /* Zustand wirklich freigegeben ist                               */
   can_reset_request();
   set_internal_reg (CONTROL, get_internal_reg(CONTROL) & 0x0fe );
   while (get_internal_reg(CONTROL) & 0x01) {
      set_internal_reg (CONTROL, get_internal_reg(CONTROL) & 0x0fe );
      os_wait (K_TMO, 2, 0);