icancont.c51

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

#pragma large
#pragma debug
#pragma registerbank(3)
#pragma pagelength(80) pagewidth(110)
/***********************************************************************
************************************************************************
*                                                                      *
*  F U L L - C A N   C O N T R O L L E R                               *
*                                                                      *
************************************************************************
************************************************************************
*                                                                      *
*  Funktion:                                                           *
*                                                                      *
*     Direkte HW-Steuerung des Siemens C515C interne Full-CAN          *
*     Controllers.                                                     *
*     Ausf乭rung aller Low-Level Funktionen. Dieses Modul ist das      *
*     einzige, dass direkt in die HW-Register des CAN-Controllers      *
*     schreiben darf.                                                  *
*                                                                      *
*                                                                      *
*  Filename           :  IANCONT.C51                                   *
*                                                                      *
*  Modulename         :  IANCONT                                       *
*                                                                      *
*  Zielsystem         :  jedes System mit einem Siemens C515           *
*                        interne CAN-Controller                        *
*                                                                      *
*  Entwicklungssystem :  Keil C-51                                     *
*                                                                      *
************************************************************************
*  Versionen:                                                          *
*                                                                      *
*  1.0  23.05.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                                         *
 *---------------------------------------------------------------------*/

sfr   SYSCONA = 0xB1;

#include "abbrev.h"
#include "icancont.h"
#include "candefs.h"

/* Maximale Anzahl der verschiedenen Versuche */
/* von ICACNCONF.A51                          */
extern const unsigned int code NBR_OF_SEND_TRIALS;

#define CONTROL_REG_0_1_BIT_SET          2    /* 10 */
#define CONTROL_REG_0_1_BIT_RESET        1    /* 01 */
#define TRANSMIT                         1
#define RECEIVE                          0

/* verschiedene Ofsets des Message-Registers */
#define MCR0_OFFSET                0
#define MCR1_OFFSET                1
#define UAR0_OFFSET                2
#define MCFG_OFFSET                6
#define MSG_DATA_OFFSET            7

#define BTR0_OFFSET                0x04
#define BTR1_OFFSET                0x05
#define ARBITR_OFFSET              0x02
#define UMLM_OFFSET                0x0C


/* Definition der einzelnen Bits im CONTROL-REGISTER    */
/* des CAN-Controllers                                  */
    typedef struct {
        byte INIT              : 1;        /* rw 1 */
        byte IE                : 1;        /* rw 0 */
        byte SIE               : 1;        /* rw 0 */
        byte EIE               : 1;        /* rw 0 */
        byte reserve_1         : 1;        /* r  0 */
        byte reserve_2         : 1;        /* r  0 */
        byte CCE               : 1;        /* rw 0 */
        byte TEST              : 1;        /* rw 0 */
    } CR_typ;

/* Definition der einzelnen Bits im STATUS-REGISTER    */
/* des CAN-Controllers                                 */
    typedef struct {
        byte LEC               : 3;        /* rw x */
        byte TXOK              : 1;        /* rw x */
        byte RXOK              : 1;        /* rw x */
        byte reserve           : 1;        /* r  x */
        byte EWRN              : 1;        /* r  x */
        byte BOFF              : 1;        /* r  x */
    } SR_type;

    /* Registers der Messages  */
    typedef struct {
        byte INTPND            : 2;        /* rw x */
        byte RXIE              : 2;        /* rw x */
        byte TXIE              : 2;        /* rw x */
        byte MSGVAL            : 2;        /* rw x */
    } MCR0_type;
    typedef struct {
        byte NEWDAT            : 2;        /* rw x */
        byte MSGLST_or_CPUUPD  : 2;        /* rw x */
        byte TXRQ              : 2;        /* rw x */
        byte RMTPND            : 2;        /* rw x */
    } MCR1_type;
    typedef struct {
        byte reserve           : 2;        /* r  0 */
        byte XTD               : 1;        /* rw x */
        byte DIR               : 1;        /* rw x */
        byte DLC               : 4;        /* rw x */
    } MCFG_type;

    typedef struct {
        byte BRP               : 6;        /* rw x */
        byte SLW               : 2;        /* rw x */
    } BTR0_type;
    typedef struct {
        byte TSEG1             : 4;        /* rw x */
        byte TSEG2             : 3;        /* rw x */
        byte reseve            : 1;        /* r  x */
    } BTR1_type;

    /* Message type */
    typedef struct {
/* 00H */        MCR0_type     MCR0;
/* 01H */        MCR1_type     MCR1;
/* 02H */        unsigned long arbitration;        /*arbitration_0,arbitration_1,arbitration_2,arbitration_3 */
/* 06H */        MCFG_type     MCFG;
/* 07H */        byte          datas[8];
/* 0FH */        byte			 reseve;
    } message_type;


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

#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 Siemens C515C HW-Register, diese werden an die     */
  /* Speicherstelle des Symbols FCAN_REG im Assembler-Modul            */
  /* ICANCONF.A51 alloziert. (absolute Variable)                       */

   extern xdata volatile union
    {
        struct{
/* 00H */   CR_typ           CR;            /* 0x01 */
/* 01H */   SR_type          SR;            /* undefined */
/* 02H */   byte             IR;            /* undefined */
/* 03H */   byte             reserve;
/* 04H */   BTR0_type        BTR0;          /* unchanged */
/* 05H */   BTR1_type        BTR1;          /* unchanged */
/* 06H */   unsigned int     GMS0;          /* unchanged */
/* 08H */   unsigned long    UGML0;         /* unchanged */
/* 0CH */   unsigned long    UMLM0;         /* unchanged */

/* 10H */   message_type     messages[15];  /* unchanged */
        } r;
        byte                 mem[256];
    } fcan_reg;



/* Um diese Registers zum 刵dern control.CCE muss 1 sein */
/*             BTR0      */
/*             BTR1      */



byte tmp_last_data[12];



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


/*---------------------------------------------------------------------*
 *     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 byte can_reset_request (void)
{
    unsigned int nr_of_trials;

    /* setze CCE(cpu hat Schreibrecht auf bit timing-Reg.) */
    fcan_reg.r.CR.INIT = 1;
    fcan_reg.r.CR.CCE = 1;

    /*  Warte bis RESET PIN = low (return FALSE nach timeout) */
    nr_of_trials=0;
    while (fcan_reg.r.CR.INIT != 1){
        nr_of_trials++; 
        if (nr_of_trials > NBR_OF_SEND_TRIALS){
            return FALSE;
        }
    }
    return TRUE;
}



/*---------------------------------------------------------------------*
 *     C A N _ W A I T _ U N T I L _ S E N D E D
 *---------------------------------------------------------------------*
 *  Funktion:
 *     Warte bis ein Object mit Erfolgt gesendt
 *
 *---------------------------------------------------------------------*
 *  Parameter:
 *
 *     Returnwert     :  TRUE  --> Data mit Erfolg gesendet
 *                       FALSE --> Data nicht gesendet (time out )
 *
 *---------------------------------------------------------------------*/

static byte can_wait_until_sended (void)
{
    unsigned int nr_of_trials=0;

    /*   warte bis TXOK = 1 oder timeout */
    do{
        nr_of_trials++; 
        if (nr_of_trials > NBR_OF_SEND_TRIALS){
            return FALSE;
        }
    } while (fcan_reg.r.SR.TXOK == 0 );

    return TRUE;
}

/*---------------------------------------------------------------------*
 *     C A N _ S E T _A R B I T R A T I O N
 *---------------------------------------------------------------------*
 *  Funktion:
 *        Lade standart oder extended arbitration eines Objectes.
 *
 *---------------------------------------------------------------------*
 *  Parameter:
 *
 *    arbitr_offset:  Interne Start-Adresse der Objektarbitration
 *    ident        :  Object Arbitration
 *    standart     :  TRUE wenn standart sonst(extendet) FALSE
 *
 *---------------------------------------------------------------------*/

static can_set_arbitrations (byte arbitr_offset,
                             unsigned long ident,
                             byte standart
                             )
{
    union {
        unsigned long  arbitration;
        byte           mem[4];
    }tmp_arbitration;

    tmp_arbitration.arbitration = ident;

    if (standart){
        tmp_arbitration.arbitration = tmp_arbitration.arbitration << 21;
    }
    else{
        tmp_arbitration.arbitration = tmp_arbitration.arbitration << 3;
    }

    fcan_reg.mem[arbitr_offset + 0] = tmp_arbitration.mem[0];
    fcan_reg.mem[arbitr_offset + 1] = tmp_arbitration.mem[1];
    fcan_reg.mem[arbitr_offset + 2] = tmp_arbitration.mem[2];
    fcan_reg.mem[arbitr_offset + 3] = tmp_arbitration.mem[3];
}

/*---------------------------------------------------------------------*
 *     C A N _ G E T _A R B I T R A T I O N
 *---------------------------------------------------------------------*
 *  Funktion:
 *          Momentan nicht ben乼zt
 *---------------------------------------------------------------------*
 *  Parameter:
 *
 *    arbitr_offset:  Interne Start-Adresse der Objektarbitration
 *
 *    Returnwert   :  Object Arbitration
 *
 *---------------------------------------------------------------------*/


static unsigned long can_get_arbitrations (byte arbitr_offset)