hcancont.c51

example of using Infineon 81c91 processor.

    mod_status_type loc_mod_status;                    
    unsigned int     wait_t;

    for (wait_t = 0; wait_t <= 2000; wait_t++);

    can_disable_interrupts();

    fcan_reg.r.receive_ready = 0x0000;
    fcan_reg.r.transmit_request_set = 0x0000;
    fcan_reg.r.remote_request_pending = 0x0000;

    loc_mod_status.auto_decrement_enable = 0; 
    /* setze IM und RES bit(cpu hat Schreibrecht auf BL1,Bl2,OC,BRP Reg.) */
    loc_mod_status.init_mode  = 1;
    /* soft reset : RR1,RR2, TRS1,TRS2, RRP1,RRP2 sind zur乧kgesetzt*/
    loc_mod_status.reset_request = 1;
    fcan_reg.r.mod_status=loc_mod_status;

}


/*---------------------------------------------------------------------*
 *     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.
 *
 *     maskiere alle Interrupts
 *     Daten auf arr kopieren
 *     Interrupt mask wiederherstellen
 *
 *---------------------------------------------------------------------*
 *  Parameter:
 *
 *     obj_adr     : Interne Start-Adresse des zu lesenden Objektes
 *                   (siehe C_INIT_OBJ)
 *
 *     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;
    byte obj_inx;
    byte dummy;

    obj_inx = can_get_obj_inx (obj_adr); 
    dat_len = fcan_reg.r.descriptor[obj_inx].dlc;

    /* lese 7. Byte um Shadow-Register zum laden */
    dummy = fcan_reg.r.message[obj_inx].datas[7];

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


/*---------------------------------------------------------------------*
 *     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).
 *
 *     wenn nicht remote
 *       return FALSE wenn Datal刵ge = 0
 *       Daten vom arr auf CAN Buffer kopieren(zuerst most significant byte)
 *     sonst rtr = 1
 *     transmit.request = 1
 *     warte bis letzter Objekt gesendet ist oder timeout
 *     rtr = 0 und return FALSE wenn timeout
 *     rtr = 0 und return TRUE
 *
 *---------------------------------------------------------------------*
 *  Parameter:
 *
 *     obj_adr        :  Interne Start-Adresse des zu sendenden Objektes
 *                       (siehe C_INIT_OBJ)
 *     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         dat_len;
    byte         obj_inx;
    unsigned int mask;

    obj_inx = can_get_obj_inx (obj_adr); 

    if (!remote){
        dat_len = fcan_reg.r.descriptor[obj_inx].dlc;
        if (dat_len != 0){
            /* Daten vom arr auf CAN Buffer kopieren(zuerst most significant byte) */
            do{
                dat_len--;
                fcan_reg.r.message[obj_inx].datas[dat_len] = *(arr + dat_len);
            } while (dat_len != 0);
        }
        else{
            return FALSE;
        }
    }
    else{
        /* vorbereite zum request senden */
        fcan_reg.r.descriptor[obj_inx].rtr = 1;
    }

    mask = can_get_obj_mask (obj_adr);
    /* sende remote oder request */
    fcan_reg.r.transmit_request_set |= mask;

    if (can_wait_until_sended (obj_adr) ){
        /* vorbereite Antwort zum request empfangen */
        fcan_reg.r.descriptor[obj_inx].rtr = 0;
        return TRUE;
    }
    else{
        fcan_reg.r.descriptor[obj_inx].rtr = 0;
        /* vorbereite Antwort zum request empfangen */
        return FALSE;
    }
}


/*---------------------------------------------------------------------*
 *     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.
 *
 *     warte bis letzter Objekt gesendet ist oder timeout
 *     return FALSE wenn timeout
 *     return FALSE wenn Datal刵ge = 0
 *     Daten vom arr auf CAN Buffer kopieren(zuerst most significant byte)
 *     return TRUE
 *
 *---------------------------------------------------------------------*
 *  Parameter:
 *
 *     obj_adr        :  Interne Start-Adresse des zu schreibenden Objektes
 *                       (siehe C_INIT_OBJ)
 *     arr            :  Array im XDATA-Bereich mit den Daten die
 *                       geschrieben werden sollen
 *
 *     Returnwert     :  TRUE wenn Daten erfolgreich gespeichert
 *                       FALSE wenn Daten nicht gespeichert
 *
 *---------------------------------------------------------------------*/

byte c_write_obj (byte obj_adr,
                  byte xdata *arr)
{

    int  dat_len;
    byte obj_inx;

    if (can_wait_until_sended (obj_adr) ){
        obj_inx = can_get_obj_inx (obj_adr); 
        dat_len = fcan_reg.r.descriptor[obj_inx].dlc;

        if (dat_len != 0){
            /* Daten vom arr auf CAN Buffer kopieren(zuerst most significant byte) */
            do{
                dat_len--;
                fcan_reg.r.message[obj_inx].datas[dat_len] = *(arr + dat_len);
            } while (dat_len != 0);
            return TRUE;
        }
        else{
            return FALSE;
        }
    }
    else{
        return FALSE;
    }
}


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

enum interrupt_t c_get_int_typ (void)
{

    if ( fcan_reg.r.interrupt_reg.buss_off_interrupt == 1 ){
        return error_int;
    }

    /* Message Object 0 bis 15 */
    if ( fcan_reg.r.interrupt_reg.receive_interrupt == 1 ){
        return obj_int;
    }

    return no_int;
}


/*---------------------------------------------------------------------*
 *     C _ G E T _ O B J _ I N T _ A D R
 *---------------------------------------------------------------------*
 *  Funktion:
 *     Gibt die Startadresse des Objektes(1..16) bei dem ein Objekt-Interrupt
 *     aufgetreten ist zur乧k oder 0 wenn kein intr. pending.
 *
 *---------------------------------------------------------------------*
 *  Parameter:
 *
 *     Returnwert  :
 *                return Startadresse des Objektes bei dem ein Interrupt aufgetreten ist
 *                CONT_BUF_START_ADR(80H) ist der erste Object
 *                oder andere (88H, ... F8H)
 *                wenn mehrere Objekt-Interrupt aufgetreten sind, 
 *                kleinste Adresse wird zur乧kgegeben.
 *                0 wird zur乧kgegeben wenn keine Interrupt aufgetreten ist.
 *---------------------------------------------------------------------*/

byte c_get_obj_int_adr (void)
{
    unsigned int    obj_adr;
    unsigned int    mask;

    for (obj_adr = CONTR_BUF_START_ADR; obj_adr <= CONTR_BUF_END_ADR; obj_adr = obj_adr + MESSAGE_SIZE){

        mask = can_get_obj_mask (obj_adr);

        if ( (fcan_reg.r.receive_ready & mask) != 0x000){
            return obj_adr;
        }
    }

    return 0;
}


/*---------------------------------------------------------------------*
 *     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_ADR zur乧k.
 *
 *---------------------------------------------------------------------*
 *  Parameter:
 *
 *     OBJ_ADR        :  Interne Adresse des Objektes dessen Interrupt
 *                       (receive_ready) zur乧kgesetzt
 *                       werden soll.
 *---------------------------------------------------------------------*/

void c_receipt_obj_int (byte obj_adr)
{
    unsigned int  mask;

    mask = can_get_obj_mask (obj_adr);

    fcan_reg.r.receive_ready &= ~mask;
}


/*---------------------------------------------------------------------*
 *     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)
{
    fcan_reg.r.tr_check_error_counter.tcec = 0;
    fcan_reg.r.time_stamp_counter          = 0x0000;

    fcan_reg.r.interrupt_reg.buss_off_interrupt      = 0;
    fcan_reg.r.interrupt_reg.error_passive_interrupt = 0;
}


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

enum can_bus_stat_t c_get_status (void)

{
    if (   (fcan_reg.r.mod_status.bus_state == 1)
        || (fcan_reg.r.interrupt_reg.buss_off_interrupt == 1)
    ){
        return bus_off;
    }
    if ( fcan_reg.r.interrupt_reg.error_passive_interrupt == 1 ){
        return error_passive;
    }
    return error_active;

}