pcanobja.c51

Philips sja1000 can controller. it contains example on how to control this device

*---------------------------------------------------------------------*
*  Funktion:
*         Gibt die beim Definieren der Objekte (mit C_DEFINE_OBJ)
*         berechnete Acceptance-Maske f乺 den SJA1000 zur乧k.
*
*---------------------------------------------------------------------*
*  Parameter:
*
*         Returnwert   : Acceptance-Maske f乺 den SJA1000
*
*---------------------------------------------------------------------*/

byte c_get_acc_mask (void)
{
   /* Nur die 8 MSB der acc_mask zur乧kgeben */
   return ~(acc_mask >> 3);
}




#pragma eject
/*---------------------------------------------------------------------*
 *     Zugriffsfunktionen                                              *
 *---------------------------------------------------------------------*/

 /* Die Applikation benutzt die Objekt-Identifikation f乺 den Zugriff  */
 /* auf ein bestimmtes Objekt. Intern wird jedoch nur der Index eines  */
 /* bestimmten Objektes innerhalb des Objektbuffers zum Zugriff        */
 /* benutzt. Mit den Prozeduren C_GET_INDEX und C_GET_IDENT    */
 /* kann der Index resp. die Identifikation eines bestimmten Objektes  */
 /* ermittelt werden.                                                  */
 /*                                                                    */
 /* Die jeweiligen Zugriffsprozeduren testen aus Zeitgr乶den jeweils   */
 /* nicht mehr ob ein bestimmter Index tats刢hlich einem definierten   */
 /* Objekt entspricht !                                                */


/*---------------------------------------------------------------------*
 *         C _ G E T _ I N D E X _ F R O M _ I D E N T
 *---------------------------------------------------------------------*
 *  Funktion:
 *     Testet ob das Objekt IDENTIFIER im Objekt-Buffer definiert ist
 *     und gibt den entsprechenden Index innerhalb CAN_OBJ_BUF zur乧k.
 *
 *---------------------------------------------------------------------*
 *  Parameter:
 *
 *     identifier   :    Identifikation des gesuchten Objektes
 *
 *     Returnwert   :    0        -->   Das Objekt IDENTIFIER existiert
 *                                      nicht
 *                       1 .. 255 -->   Index des Objektes IDENTIFIER
 *
 *---------------------------------------------------------------------*/

byte c_get_index_from_ident (unsigned long identifier)
{
   byte i, temp;

   temp = nbr_of_obj;
   for (i=1; i<=temp; i++) {
      if (can_obj_buf[i].identifier == identifier) return i;
   }
   return 0;
}



/*---------------------------------------------------------------------*
 *     C _ G E T _ I D E N T
 *---------------------------------------------------------------------*
 *  Funktion:
 *     Gibt den Identifier des Objektes mit dem INDEX innerhalb
 *     CAN_OBJ_BUF zur乧k.
 *
 *---------------------------------------------------------------------*
 *  Parameter:
 *
 *     index        :    Index des gesuchten Objektes
 *
 *     Returnwert   :    0 .. 7EFH  ->  Identifikation des gew乶schten
 *                       Objektes
 *                       FFFFH      ->  Objekt existiert nicht
 *
 *---------------------------------------------------------------------*/

unsigned long c_get_ident (byte index)
{
   if ((index == 0) || (index > nbr_of_obj)) return 0xffff;
   return can_obj_buf[index].identifier;
}



/*---------------------------------------------------------------------*
 *     C _ G E T _ R E C _ B I N D
 *---------------------------------------------------------------------*
 *  Funktion:
 *     Gibt den Index eines neu empfangenen und noch nicht von der
 *     Applikation gelesenen Objektes, das fest an den Task TASK_ID
 *     gebunden ist, zur乧k.
 *
 *---------------------------------------------------------------------*
 *  Parameter:
 *
 *     task_id   :    Task-Identifikation des Tasks an den das Objekt
 *                    gebunden ist
 *
 *     Returnwert   :    0        -->   Es existiert kein gew乶schtes Objekt
 *                       1 .. 255 -->   Index des Objektes
 *
 *---------------------------------------------------------------------*/

byte c_get_rec_bind (byte task_id)
{
   byte i, ind;

   for (i=0; i<=MAX_BIND_OBJ-1; i++) {
      ind = bind_index_list[i];
      if (ind != 0) {
	 if (can_obj_buf[ind].task_bind == task_id) {
	    if (!(can_obj_buf[ind].obj_read)) {
	       return ind;
	    }
	 }
      }
   }
   return 0;
}



/*---------------------------------------------------------------------*
 *     C _ G E T _ O B J _ T Y P
 *---------------------------------------------------------------------*
 *  Funktion:
 *     Gibt den Objekttyp wie in C_DEFINE_OBJ definiert des Objektes
 *     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)
{
   if (can_obj_buf[index].data_length > 0) {
      c_fast_copy (arr, &can_obj_buf[index].dat[0],
		   can_obj_buf[index].data_length);

   }
}



/*---------------------------------------------------------------------*
 *     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_fast_copy (&can_obj_buf[index].dat[0], arr, length);
   }
   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 Philips SJA1000 :
 *         ==============================
 *                                        Normale R乧kmeldung bei einwandfrei Empfangenen
 *                    Data-Frames :
 *                    1 bis 255   ->    Index innerhalb OBJ_BUF des
 *                                      empfangenen und abgespeicherten
 *                                                                              Objektes
 *
 *                                                                              R乧kmeldungen falls kein
 *                                                                              Data-Frame f乺 die Applikation
 *                                      empfangen :
 *
 *                                        FFF0H           ->    Ein Remote-Frame wurde empfangen und
 *                                      beantwortet
 *                    FFF1H       ->    Ein Remote-Frame wurde empfangen,
 *                                      das entsprechende Objekt hat aber
 *                                      einen falschen Typ
 *                    FFF2H       ->    Ein Remote-Frame wurde empfangen,
 *                                      die Antwort konnte aber wegen
 *                                      Bus-Problemen nicht gesendet werden
 *                    FFF3H       ->    Das Objekt hat die 2. Stufe der
 *                                      Akzeptanzfilterung nicht passiert
 *                    FFF4H       ->    Das Objekt hat die 3. Stufe der
 *                                      Akzeptanzfilterung nicht passiert
 *                    FFF5H       ->    Ein Objekt wurde empfangen und
 *                                      akzeptiert, das entsprechende
 *                                      Objekt hat aber einen falschen Typ
 *                    FFF6H       ->    Ein Objekt wurde empfangen,
 *                                      akzeptiert und abgespeichert,
 *                                      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)
{
unsigned long ident;
byte index;
byte res;

   ident = c_get_rec_id();
   /* 2. Stufe der Akzeptanzfilterung */
   if (!(c_obj_accept(ident))) {
      c_rel_rec_reg();
      return 0xfff3;
   }
   /* 3. Stufe der Akzeptanzfilterung */
   index = c_get_index_from_ident(ident);
   if (index == 0) {
      c_rel_rec_reg();
      return 0xfff4;
   }