icancont.c51

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

    }
    else{

        nr_of_trials = 0;
        do{
            fcan_reg.r.messages[obj_inx].MCR1.NEWDAT = CONTROL_REG_0_1_BIT_RESET;
            fcan_reg.r.messages[obj_inx].MCR1.MSGLST_or_CPUUPD = CONTROL_REG_0_1_BIT_RESET;

            nr_of_trials++; 

            c_fast_copy( &fcan_reg.r.messages[obj_inx].datas[0], arr, dat_len );

        } while ((fcan_reg.r.messages[obj_inx].MCR1.NEWDAT == CONTROL_REG_0_1_BIT_SET)
            && (nr_of_trials < NBR_OF_SEND_TRIALS));
    }
}


/*---------------------------------------------------------------------*
 *     C _ S E N D _ O B J
 *---------------------------------------------------------------------*
 *  Funktion:
 *     Uebertragung eines Objektes zum CAN-Controller zum Senden.
 *     Es werden soviele Byte gesendet, wie bei C_INIT_OBJ definiert
 *     (nur wenn nicht Remote).
 *
 *
 *---------------------------------------------------------------------*
 *  Parameter:
 *
 *    obj_adr      :  Interne Start-Adresse des Objektes
 *     remote         :  TRUE  -> sende ein Remote-Frame
 *                       FALSE -> sende ein Data-Frame
 *     arr            :  Array im XDATA-Bereich mit den Daten die gesendet
 *                       werden sollen
 *
 *     Returnwert     :  TRUE  -> Senden erfolgreich
 *                       FALSE -> Senden nicht erfolgreich
 *
 *---------------------------------------------------------------------*/

byte c_send_obj (byte obj_adr,
                 byte remote,
                 byte xdata *arr)
{

    byte obj_inx;
    byte dat_len;
    byte ret_val;

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

    fcan_reg.r.SR.TXOK = 0;

    if (!remote){
        /* setze MSGLST_or_CPUUPD w刪rend Dataspeichern */
        fcan_reg.r.messages[obj_inx].MCR1.MSGLST_or_CPUUPD = CONTROL_REG_0_1_BIT_SET;

        dat_len = fcan_reg.r.messages[obj_inx].MCFG.DLC;
        c_fast_copy(arr, &fcan_reg.r.messages[obj_inx].datas[0], dat_len );

        /* Ende Dataspeichern : reset MSGLST_or_CPUUPD */
        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_SET;
    }
    else{
        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_SET;

    if (can_wait_until_sended () ){
        ret_val = TRUE;
    }
    else{
        ret_val = FALSE;
    }

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

    return ret_val;
}


/*---------------------------------------------------------------------*
 *     C _ W R I T E _ O B J
 *---------------------------------------------------------------------*
 *  Funktion:
 *     Speichern eines Objektes im CAN-Controller, die Daten werden
 *     nicht gesendet sondern stehen zum Beispiel f乺 eine Anfrage
 *     durch ein Remote-Frame zur Verf乬ung. Es werden soviele Byte
 *     abgespeichert, wie bei C_INIT_OBJ definiert.
 *
 *---------------------------------------------------------------------*
 *  Parameter:
 *
 *    obj_adr      :  Interne Start-Adresse des Objektes
 *     arr            :  Array im XDATA-Bereich mit den Daten die
 *                       geschrieben werden sollen
 *
 *     Returnwert     :  immer TRUE
 *
 *---------------------------------------------------------------------*/

byte c_write_obj (byte obj_adr,
                  byte xdata *arr)
{
    byte dat_len;
    byte obj_inx;

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

    /* setze MSGLST_or_CPUUPD w刪rend Dataspeichern */
    fcan_reg.r.messages[obj_inx].MCR1.MSGLST_or_CPUUPD = CONTROL_REG_0_1_BIT_SET;

    dat_len = fcan_reg.r.messages[obj_inx]. MCFG.DLC;
    c_fast_copy(arr, &fcan_reg.r.messages[obj_inx].datas[0], dat_len );

    /* Ende Dataspeichern : zur乧ksetze MSGLST_or_CPUUPD */
    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_SET;

    return TRUE;
}


/*---------------------------------------------------------------------*
 *     C _ G E T _ I N T _ T Y P
 *---------------------------------------------------------------------*
 *  Funktion:
 *     Diese Funktion gibt den Typ des Aufgetretenen Interrupts zur乧k.
 *
 *---------------------------------------------------------------------*
 *  Parameter:
 *
 *     Returnwert  :
 *                no_int               :
 *                error_int            :     Status register Inhalt ge刵dert
 *                                           wenn (SIE = 1)
 *                obj_int              :     object number+2 is in
 *                                           interrupt_register
 *                obj_15_int           :     15. object interrupt_register
 *
 *---------------------------------------------------------------------*/

enum interrupt_t c_get_int_typ (void)
{

    if (fcan_reg.r.IR == 0x00){
        return no_int;
    }

    /* Status Register Inhalt ge刵dert (wenn SIE = 1) */
    else if (fcan_reg.r.IR == 0x01){
        return error_int;
    }

    /* Message Object 1 bis 14 */
    else if ((fcan_reg.r.IR >= 0x03)
        &&   (fcan_reg.r.IR <= 0x10) ) {
        return obj_int;
    }

    /* wennf Objekt 15 Interrupt pending */
    if (fcan_reg.r.IR == 2){ 
        return obj_int;
    }

}


/*---------------------------------------------------------------------*
 *     C _ G E T _ O B J _ I N T _ A D R
 *---------------------------------------------------------------------*
 *  Funktion:
 *     Gibt die Startadresse des Objektes(1..15) bei dem ein Objekt-Interrupt
 *     aufgetreten ist zur乧k oder 0 wenn kein intr. pending.
 *
 *---------------------------------------------------------------------*
 *  Parameter:
 *
 *     Returnwert  :
 *                return interrupt_register wenn interrupt_register = 0 oder 1
 *                return F0 wenn interrupt_register = 2 (15 Message )
 *                Startaddress des Objektes bei dem ein Interrupt aufgetreten ist
 *
 *---------------------------------------------------------------------*/

byte c_get_obj_int_adr (void)
{
    byte adr;

    /* wenn Objekt 1..14 Interrupt pending */
    if(   (fcan_reg.r.IR >= 0x03) && (fcan_reg.r.IR <= 0x10)
        ){
        adr = fcan_reg.r.IR - 3;
        adr = adr << 4;
        return (adr + CONTR_BUF_START_ADR);
    }

    /* wennf Objekt 15 Interrupt pending */
    if (fcan_reg.r.IR == 2){ 
        return CONTR_BUF_END_ADR;
    }

    /* Keine Interrupt pending oder staus register is erneuert */
    if (   (fcan_reg.r.IR == 0) /* keine intr. pending */
        || (fcan_reg.r.IR == 1) /* status reg ist erneuert */
        ){
        return fcan_reg.r.IR;
    }
}

/*---------------------------------------------------------------------*
 *     C _ R E C E I P T _ O B J _ I N T
 *---------------------------------------------------------------------*
 *  Funktion:
 *     Diese Funktion setzt einen Objekt-Interrupt des Objektes mit der
 *     internen Startadresse obj_inx zur乧k.
 *
 *---------------------------------------------------------------------*
 *  Parameter:
 *
 *     obj_adr        :  Interne Adresse des Objektes dessen Interrupt
 *                       werden soll.
 *---------------------------------------------------------------------*/

void c_receipt_obj_int (byte obj_adr)
{
    byte obj_inx;

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

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

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

    if (obj_adr == CONTR_BUF_END_ADR){
        tmp_arbitration.arbitration = can_get_arbitrations (obj_adr + ARBITR_OFFSET);

        tmp_last_data[0] = tmp_arbitration.mem[0];
        tmp_last_data[1] = tmp_arbitration.mem[1];
        tmp_last_data[2] = tmp_arbitration.mem[2];
        tmp_last_data[3] = tmp_arbitration.mem[3];

        c_fast_copy( &fcan_reg.r.messages[obj_inx].datas[0], &tmp_last_data[4], 8 );
    }

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


/*---------------------------------------------------------------------*
 *     C _ R E C E I P T _ E R R O R _ I N T
 *---------------------------------------------------------------------*
 *  Funktion:
 *     Diese Funktion quittiert einen Error-Interrupt
 *
 *---------------------------------------------------------------------*
 *  Parameter:
 *    --
 *---------------------------------------------------------------------*/

void c_receipt_error_int (void)
{
   SR_type dummy_SR;

    /* dummy Lesen vom Status-Register um  */
    dummy_SR = fcan_reg.r.SR;

    fcan_reg.r.SR.LEC = 0;
}


/*---------------------------------------------------------------------*
 *     C _ G E T _ S T A T U S
 *---------------------------------------------------------------------*
 *  Funktion:
 *     Gibt den aktuellen Bus-Zustand des C515C CAN Controller.
 *
 *---------------------------------------------------------------------*
 *  Parameter:
 *
 *     Returnwert  :  Bus-Zustand des C515C CAN Controller
 *
 *---------------------------------------------------------------------*/

enum can_bus_stat_t c_get_status (void)
{
    if (fcan_reg.r.SR.BOFF == 1){
        return bus_off;
    }
    if (fcan_reg.r.SR.LEC == 0){
        return error_active;
    }
    return error_passive;

}