hcanobja.c51

example of using Infineon 81c91 processor.

 *     INDEX zur乧k.
 *
 *---------------------------------------------------------------------*
 *  Parameter:
 *
 *     index        :    Index des Objektes innerhalb CAN_OBJ_BUF dessen
 *                       Typ gelesen werden soll
 *
 *     Returnwert   :    Objekttyp des Objektes INDEX
 *
 *---------------------------------------------------------------------*/

byte c_get_obj_typ (byte index)
{
    return can_obj_buf[index].obj_typ;
}



/*---------------------------------------------------------------------*
 *     C _ W R I T E _ D A T A
 *---------------------------------------------------------------------*
 *  Funktion:
 *     Schreiben von Daten aus dem Array ARR in das Objekt mit INDEX
 *     im Objekt-Buffer.
 *     Es werden soviele Datenbytes geschrieben wie DATA_LENGTH
 *     des entsprechenden Objektes angibt.
 *       Die Daten werden nur in das Objekt geschrieben, sie werden
 *     nicht gesendet.
 *
 *---------------------------------------------------------------------*
 *  Parameter:
 *
 *     index      :      Index des Objektes innerhalb OBJ_BUF in das
 *                       geschrieben werden soll
 *
 *     arr        :      Zu schreibende Daten
 *
 *---------------------------------------------------------------------*/

void c_write_data (byte index,
                   byte xdata *arr)
{
    byte temp;

    if (can_obj_buf[index].data_length > 0) {
        /* Der Returnwert der Funktion wird nicht ausgewertet */
        /* Nur f乺 interne Testzwecke                           */
        temp = c_write_obj (can_obj_buf[index].contr_adr, arr);
    }
}



/*---------------------------------------------------------------------*
 *     C _ R E A D _ D A T A
 *---------------------------------------------------------------------*
 *  Funktion:
 *     Lesen der Daten des Objektes INDEX im Objekt-Buffer. Es werden
 *     soviele Daten gelesen, wie DATA_LENGTH des entsprechenden
 *     Objektes angibt.
 *
 *---------------------------------------------------------------------*
 *  Parameter:
 *
 *     index       :  Index des Objektes in OBJ_BUF aus dem gelesen
 *                    werden soll.
 *
 *     arr         :  Array in den die Daten gelesen werden sollen
 *
 *
 *---------------------------------------------------------------------*/

void c_read_data (byte index,
                  byte xdata *arr)
{
    byte length;

    length = can_obj_buf[index].data_length;
    if (length > 0) {
        c_read_obj (can_obj_buf[index].contr_adr, arr);
    }
    can_obj_buf[index].obj_read = TRUE;
}



/*---------------------------------------------------------------------*
 *     C _ R E C E I V E _ O B J
 *---------------------------------------------------------------------*
 *  Funktion:
 *     F乭rt die nach einem Receive-Interrupt n攖igen Funktionen aus.
 *
 *---------------------------------------------------------------------*
 *  Parameter:
 *
 *       Returnwert beim Siemens 81C91 :
 *       ===============================
 *                    Normale R乧kmeldung bei einwandfrei Empfangenen
 *                    Data-Frames :
 *                    1 bis 14    ->    Index innerhalb CAN_OBJ_BUF des
 *                                      empfangenen und abgespeicherten
 *                                      Objektes
 *
 *                                      R乧kmeldungen falls kein
 *                                      Data-Frame f乺 die Applikation
 *                                      empfangen :
 *
 *                    FFF0H       ->    Ein nicht bekanntes Objekt wurde
 *                                      empfangen (sollte beim korrekten
 *                                      funktionieren der Software nicht
 *                                      vorkommen, wurde jedoch aus f乺
 *                                      das Testen eingebaut)
 *                    FFF1H       ->    Das empfangene Objekt hat einen
 *                                      falschen Typ (ebenfalls nur f乺
 *                                      Testzwecke)
 *                    FFF2H       ->    Ein Objekt wurde empfangen und
 *                                      akzeptiert, die Applikation muss
 *                                      aber nicht benachrichtigt werden,
 *                                      da das Objekt nur neu beschrieben
 *                                      wurde (seit dem letzten Empfang
 *                                      noch nicht gelesen durch die
 *                                      Applikation).
 *
 *---------------------------------------------------------------------*/

unsigned int c_receive_obj (void)
{
    byte index, adr;

    adr = c_get_obj_int_adr();
    index = c_get_index_from_adr (adr);
    if (index == 0) {
        /* Objekt ist nicht bekannt */
        c_receipt_obj_int (adr);
        return 0xfff0;
    }

    /* G乴tiges Data-Frame empfangen, Typ testen */
    if ((can_obj_buf[index].obj_typ == D_REC) ||
        (can_obj_buf[index].obj_typ == D_REC_R_SEND)) {
        /* Interrupt freigeben */
        c_receipt_obj_int (adr);
        if (can_obj_buf[index].obj_read) {
            can_obj_buf[index].obj_read = FALSE;
            return index;
        }
        else {
            return 0xfff2;
        }
    }
    else {
        /* falscher Objekttyp */
        c_receipt_obj_int (adr);
        return 0xfff1;
    }
}


/*---------------------------------------------------------------------*
 *     C _ T R A N S M I T _ O B J
 *---------------------------------------------------------------------*
 *  Funktion:
 *       Senden eines Data-Frames 乥er den CAN-Bus mit Abspeichern der
 *       Daten im Objektbuffer.
 *
 *---------------------------------------------------------------------*
 *  Parameter:
 *
 *       Index       :  Index des zu sendenden Objektes
 *
 *     arr         :  Array mit den Daten die gesendet werden sollen
 *
 *     Returnwert  :  TRUE  --> Objekt erfolgreich gesendet
 *                    FALSE --> Objekt konnte nicht gesendet werden
 *                              (Bus-Fehler)
 *
 *---------------------------------------------------------------------*/

byte c_transmit_obj (byte index,
                     byte xdata *arr)
{
    return c_send_obj (can_obj_buf[index].contr_adr, FALSE, arr);
}



/*---------------------------------------------------------------------*
 *     C _ S E N D _ R E M O T E
 *---------------------------------------------------------------------*
 *  Funktion:
 *     Senden eines eines Remote-Frames 乥er den CAN-Bus
 *
 *---------------------------------------------------------------------*
 *  Parameter:
 *
 *     Index       :  Index des Objektes von dem ein Remote-Frame
 *                    gesendet werden soll
 *
 *       Returnwert  :  TRUE    --> Objekt erfolgreich gesendet
 *                      FALSE   --> Objekt konnte nicht gesendet werden
 *                                  (Bus-Fehler)
 *
 *---------------------------------------------------------------------*/

byte c_send_remote (byte index)
{
    return c_send_obj (can_obj_buf[index].contr_adr, TRUE, 0);
}



/*---------------------------------------------------------------------*
 *     C _ S E T _ B I N D
 *---------------------------------------------------------------------*
 *  Funktion:
 *     Setzt das Feld TASK_BIND innerhalb des Objektes INDEX im
 *     Objekt-Buffer auf eine bestimmte TASK_ID (wird zum festen
 *     Anbinden eines Objektes an einen Task ben攖igt, der CAN-Driver
 *     kann damit ermitteln, zu welchem Task er ein Signal senden muss,
 *     wenn dieses Objekt empfangen wird). Gleichzeitig wird der Index
 *     des Objektes im Array BIND_INDEX_LIST abgespeichert.
 *
 *---------------------------------------------------------------------*
 *  Parameter:
 *
 *     index      :  Index des Objekts bei dem der Task-Bind Wert
 *                   gesetzt werden soll
 *
 *     task_id    :  Wert auf den der Task-Bind Wert gesetzt werden soll
 *
 *     Returnwert  :  TRUE  -->   OK
 *                    FALSE -->   Die BIND_INDEX_LIST ist voll
 *                                (bereits 8 Objekte angebunden)
 *
 *---------------------------------------------------------------------*/

byte c_set_bind (byte index,
                 byte task_id)
{
    byte i;
    for (i=0; i<=MAX_BIND_OBJ-1; i++) {
        if ((bind_index_list[i] == 0) || (bind_index_list[i] == index)) {
            bind_index_list[i] = index;
            can_obj_buf[index].task_bind = task_id;
            return TRUE;
        }
    }
    return FALSE;
}



/*---------------------------------------------------------------------*
 *     C _ C L E A R _B I N D
 *---------------------------------------------------------------------*
 *  Funktion:
 *     Markiert das Objekt als zu keinem bestimmten Task zugeh攔ig.
 *     Setzt das Feld TASK_BIND innerhalb des Objektes INDEX im
 *     Objekt-Buffer auf FFH (in RTX-51 keine g乴tige TASK-ID).
 *
 *---------------------------------------------------------------------*
 *  Parameter:
 *
 *     index  : Index des Objekts bei dem der Task-Bind Wert gel攕cht
 *              werden soll
 *
 *---------------------------------------------------------------------*/

void c_clear_bind (byte index)
{
   byte i;

    for (i=0; i<=7; i++) {
        if (bind_index_list[i] == index) bind_index_list[i] = 0;
    }
    can_obj_buf[index].task_bind = NO_BIND;
}



/*---------------------------------------------------------------------*
 *     C _ G E T _ B I N D
 *---------------------------------------------------------------------*
 *  Funktion:
 *     Gibt den aktuellen Wert des Feldes TASK_BIND im Objekt
 *     INDEX zur乧k. NO_BIND bedeutet dabei, dass das Objekt an keinen
 *     Task gebunden ist.
 *
 *---------------------------------------------------------------------*
 *  Parameter:
 *
 *     index       :  Index des Objekts dessen Task-Bind Wert gelesen
 *                    werden soll
 *
 *     Returnwert  :  Alle Werte ausser FFH sind eine g乴tige Task-ID.
 *                    FFH bedeutet, dass das Objekt an keinen Task
 *                    gebunden ist.
 *
 *---------------------------------------------------------------------*/

byte c_get_bind (byte index)
{
    return can_obj_buf[index].task_bind;
}



/*---------------------------------------------------------------------*
 *     C _ S E T _ R E A D
 *---------------------------------------------------------------------*
 *  Funktion:
 *     Setzt OBJ_READ innerhalb des Objektes INDEX auf TRUE. Diese
 *     Funktion dient dazu ein neu empfangenes Objekt als von der
 *     Applikation gelesen zu markieren, falls die Applikation nicht
 *     getstartet werden kann (Mailbox voll usw.).
 *
 *---------------------------------------------------------------------*
 *  Parameter:
 *
 *     index       :  Index des Objekts bei dem OBJ_READ gesetzt
 *                    werden soll
 *
 *---------------------------------------------------------------------*/

void c_set_read (byte index)
{
    can_obj_buf[index].obj_read = TRUE;
}



/*---------------------------------------------------------------------*
 *     C _ S E T _ A L L _ R E A D
 *---------------------------------------------------------------------*
 *  Funktion:
 *     Setzt OBJ_READ innerhalb aller Objekte auf TRUE. Diese
 *     Funktion dient dazu alle empfangenen Objekte als von der
 *     Applikation gelesen zu markieren.
 *
 *---------------------------------------------------------------------*/

void c_set_all_read (void)
{
    byte i;

    for (i=1; i<=nbr_of_obj; i++) {
        can_obj_buf[i].obj_read = TRUE;
    }
}



/*---------------------------------------------------------------------*
 *     Ende Modul HCANOBJA                                             *
 *---------------------------------------------------------------------*/