icancont.c51

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

{
    union {
        unsigned long  arbitration;
        byte           mem[4];
    }tmp_arbitration;

    byte obj_inx;


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


    obj_inx = arbitr_offset - ARBITR_OFFSET - CONTR_BUF_START_ADR;
    obj_inx = (obj_inx >> 4);
    
    if (fcan_reg.r.messages[obj_inx].MCFG.XTD == 0){ /* standart */
        tmp_arbitration.arbitration = tmp_arbitration.arbitration >> 21;
    }
    else{
        tmp_arbitration.arbitration = tmp_arbitration.arbitration >> 3;
    }

    return (tmp_arbitration.arbitration);
}



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


/*---------------------------------------------------------------------*
 *     C _ H W _ I N I T
 *---------------------------------------------------------------------*
 *  Funktion:
 *     Grundinitialisierung des C515C CAN-Controllers.
 *     F乺 diese Operation wird der CAN-Controller angehalten.
 *     Er muss danach mit C_START wieder neu gestartet werden.
 *
 *---------------------------------------------------------------------*
 *  Parameter:
 *
 *     bus_t0_reg       : Bus-Timing Register 0 des C515C CAN Controller
 *     bus_t1_reg       : Bus-Timing Register 1 des C515C CAN Controller
 *     can Bus freq = XTAL / [(BRP+1)*(3+TSEG1+TSEG2)]
 *
 *
 *     Returnwert   : TRUE   -> OK
 *                    FALSE  -> Fehler beim Reset
 *---------------------------------------------------------------------*/

byte c_hw_init (byte bus_t0_reg,
                byte bus_t1_reg,
                byte dummy_1,
                byte dummy_2)
{
    int                inx;

    /* XMAP0 = 0  (damit CAN-Kontroller Zugriff m攇lich wird) */
    SYSCONA &= 0xFE; 

    /* only to evoid warning */
    inx = dummy_1;
    inx = dummy_2;

    if (can_reset_request () ){
        fcan_reg.mem[BTR0_OFFSET] = bus_t0_reg;
        fcan_reg.mem[BTR1_OFFSET] = bus_t1_reg;

        fcan_reg.r.CR.EIE = 0; /* EIE */
        fcan_reg.r.CR.SIE = 0; /* SIE */
        fcan_reg.r.CR.IE = 1; /* IE */

        fcan_reg.r.SR.LEC = 0;
        fcan_reg.r.SR.TXOK = 0;
        fcan_reg.r.SR.RXOK = 0;

        /* initialisiere alle 15 Objekte  */
        /********************************************************************/
        for (inx = 0; inx <= 14; inx++){
				fcan_reg.r.messages[inx].MCR0.TXIE = CONTROL_REG_0_1_BIT_RESET;
				fcan_reg.r.messages[inx].MCR0.RXIE = CONTROL_REG_0_1_BIT_RESET;
				fcan_reg.r.messages[inx].MCR0.INTPND = CONTROL_REG_0_1_BIT_RESET;
				fcan_reg.r.messages[inx].MCR1.RMTPND = CONTROL_REG_0_1_BIT_RESET;
				fcan_reg.r.messages[inx].MCR1.TXRQ = CONTROL_REG_0_1_BIT_RESET;
				fcan_reg.r.messages[inx].MCR1.MSGLST_or_CPUUPD = CONTROL_REG_0_1_BIT_SET;
				fcan_reg.r.messages[inx].arbitration = 0xFFFFFFFF;
				fcan_reg.r.messages[inx].MCR1.NEWDAT = CONTROL_REG_0_1_BIT_RESET;
				fcan_reg.r.messages[inx].MCFG.DIR = RECEIVE;
				fcan_reg.r.messages[inx].MCFG.DLC = 0;
				fcan_reg.r.messages[inx].MCR0.MSGVAL = CONTROL_REG_0_1_BIT_RESET;
				fcan_reg.r.messages[inx].MCFG.XTD = 0; /* standart */

				fcan_reg.r.messages[inx].datas[0]= inx;
				fcan_reg.r.messages[inx].datas[1]= inx;
				fcan_reg.r.messages[inx].datas[2]= inx;
				fcan_reg.r.messages[inx].datas[3]= inx;
				fcan_reg.r.messages[inx].datas[4]= inx;
				fcan_reg.r.messages[inx].datas[5]= inx;
				fcan_reg.r.messages[inx].datas[6]= inx;
				fcan_reg.r.messages[inx].datas[7]= inx;

        }
        /* make filtering of all individual message arbitrations activ */
        fcan_reg.r.GMS0 = 0xFFFF;
        fcan_reg.r.UGML0 = 0xFFFFFFFF;
        fcan_reg.r.UMLM0 = 0xFFFFFFFF;

        return TRUE;
    }
    else{
        return FALSE;
    }
}


/*---------------------------------------------------------------------*
 *     C _ I N I T _ O B J
 *---------------------------------------------------------------------*
 *  Funktion:
 *     Definiert an der internen CAN-Controller Adresse BUF_ADR ein
 *     neues CAN-Objekt. Der CAN-Controller wird f乺 diese Operation
 *     angehalten, er muss danach mit C_START wieder neu gestartet
 *     werden.
 *
 *
 *---------------------------------------------------------------------*
 *
 *  Parameter:
 *        }
 *     ident       :  Identifier des zu definierenden Objektes
 *                    (0 .. 7EFH)
 *     data_len    :  Anzahl Datenbytes des Objektes (0 .. 8)
 *     obj_typ     :  Genaue Beschreibung der Objektart :
 *                    D_REC (0)         :  Receive data frame
 *                    D_SEND (1)        :  Send data frame
 *                    D_SEND_R_REC  (2) :  send data after remote recieving 
 *                    D_REC_R_SEND  (3) :  send remote frame
 *    obj_adr      :  Interne Start-Adresse des Objektes
 *    standart     :  TRUE wenn standart sonst(extendet) FALSE
 *
 *---------------------------------------------------------------------*/

void c_init_obj (unsigned long ident,
                byte         data_len,
                byte         obj_typ,
                byte         obj_adr,
                byte         standart)

{
    byte obj_inx;

    c_stop();

    obj_inx = obj_adr - CONTR_BUF_START_ADR;
    obj_inx = (obj_inx >> 4);

    if (standart == TRUE){
        fcan_reg.r.messages[obj_inx].MCFG.XTD = 0; /* standart */
    }
    else{
        fcan_reg.r.messages[obj_inx].MCFG.XTD = 1; /* extended */
    }
    fcan_reg.r.messages[obj_inx].MCFG.DLC = data_len;

    can_set_arbitrations (obj_adr + ARBITR_OFFSET, ident, standart);

    if (obj_adr == CONTR_BUF_END_ADR){
        can_set_arbitrations (UMLM_OFFSET , ident, standart);
    }

    fcan_reg.r.messages[obj_inx].MCR0.MSGVAL = CONTROL_REG_0_1_BIT_SET;
    fcan_reg.r.messages[obj_inx].MCR0.TXIE   = CONTROL_REG_0_1_BIT_RESET;
    fcan_reg.r.messages[obj_inx].MCR0.INTPND = CONTROL_REG_0_1_BIT_RESET;

    fcan_reg.r.messages[obj_inx].MCR1.RMTPND = CONTROL_REG_0_1_BIT_RESET;
    fcan_reg.r.messages[obj_inx].MCR1.TXRQ   = CONTROL_REG_0_1_BIT_RESET;
    fcan_reg.r.messages[obj_inx].MCR1.MSGLST_or_CPUUPD = CONTROL_REG_0_1_BIT_RESET;
    fcan_reg.r.messages[obj_inx].MCR1.NEWDAT = CONTROL_REG_0_1_BIT_RESET;

    /* wenn nur Data senden */
    if (obj_typ == D_SEND){
        fcan_reg.r.messages[obj_inx].MCFG.DIR  = TRANSMIT;
        fcan_reg.r.messages[obj_inx].MCR0.RXIE = CONTROL_REG_0_1_BIT_RESET;
    } 

    /* wenn remote senden und Antwort-Data empfangen */ 
    if (obj_typ == D_REC_R_SEND  ){
        fcan_reg.r.messages[obj_inx].MCFG.DIR  = RECEIVE;
        fcan_reg.r.messages[obj_inx].MCR0.RXIE = CONTROL_REG_0_1_BIT_SET;
    } 

    /* wenn nur Data empfangen */
    if (obj_typ == D_REC){
        fcan_reg.r.messages[obj_inx].MCFG.DIR  = RECEIVE;
        fcan_reg.r.messages[obj_inx].MCR0.RXIE = CONTROL_REG_0_1_BIT_SET;
    } 

    /* wenn Remote empfangen und Answer-Daten senden */
    if (obj_typ == D_SEND_R_REC){
        fcan_reg.r.messages[obj_inx].MCFG.DIR  = TRANSMIT;
        fcan_reg.r.messages[obj_inx].MCR0.RXIE = CONTROL_REG_0_1_BIT_RESET;
    } 
}


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

void c_start (void)
{

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

    fcan_reg.r.CR.EIE = 1; /* EIE */
    fcan_reg.r.CR.SIE = 0; /* SIE */
    fcan_reg.r.CR.IE = 1; /* IE */

    fcan_reg.r.SR.LEC = 0;
    fcan_reg.r.SR.TXOK = 0;
    fcan_reg.r.SR.RXOK = 0;
}


/*---------------------------------------------------------------------*
 *     C _ S T O P
 *---------------------------------------------------------------------*
 *  Funktion:
 *     Tempor剅es Anhalten des CAN-Controllers. Es kann mit C_START
 *     weitergefahren werden. Solange C_STOP aktiv ist, k攏nen keine
 *     Objekte empfangen oder gesendet werden.
 *
 *
 *---------------------------------------------------------------------*
 *  Parameter:
 *
 *     --
 *
 *---------------------------------------------------------------------*/

void c_stop (void)
{
    /* setze CCE=1 (cpu hat Schreibrecht auf timing-Register  */
    fcan_reg.r.CR.CCE = 1;
    fcan_reg.r.CR.INIT = 1;

    fcan_reg.r.CR.EIE = 0; /* EIE */
    fcan_reg.r.CR.SIE = 0; /* SIE */
    fcan_reg.r.CR.IE  = 0; /* IE */

}


/*---------------------------------------------------------------------*
 *     C _ R E A D _ O B J
 *---------------------------------------------------------------------*
 *  Funktion:
 *     Lesen der Daten eines Objektes. Die Daten werden
 *     in den XDATA-Bereich, dessen Anfang mit dem Parameter BUF_PTR
 *     bezeichnet ist, kopiert. Es werden soviele Bytes kopiert wie bei
 *     C_INIT_OBJ definiert.
 *
 *
 *---------------------------------------------------------------------*
 *  Parameter:
 *
 *    obj_adr      : Interne Start-Adresse des Objektes
 *
 *     arr         : Array im XDATA-Bereiche in den die
 *                   Daten kopiert werden k攏nen.
 *
 *---------------------------------------------------------------------*/

void c_read_obj (byte obj_adr,
                 byte xdata *arr)
{

    byte dat_len;
    unsigned int nr_of_trials;
    byte obj_inx;


    obj_inx = obj_adr - CONTR_BUF_START_ADR;
    obj_inx = (obj_inx >> 4);

    dat_len = fcan_reg.r.messages[obj_inx].MCFG.DLC;

    if (obj_adr == CONTR_BUF_END_ADR){
        c_fast_copy( tmp_last_data, arr - 4, dat_len + 4 );