canobja.c51

RTX51 example for Intel 82526. it contains example use of CAN.

		 free_contr_buf = free_contr_buf - OBJ_DESC_SIZE - data_length;
		 can_obj_buf[nbr_of_obj].identifier = identifier;
		 can_obj_buf[nbr_of_obj].obj_typ = obj_typ;
		 can_obj_buf[nbr_of_obj].data_length = data_length;
		 can_obj_buf[nbr_of_obj].task_bind = NO_BIND;
		 can_obj_buf[nbr_of_obj].obj_read = TRUE;
		 if (nbr_of_obj == 1) {
			can_obj_buf[nbr_of_obj].contr_adr = CONTR_BUF_START_ADR;
		 }
		 else {
			can_obj_buf[nbr_of_obj].contr_adr =
				  can_obj_buf[nbr_of_obj-1].contr_adr + OBJ_DESC_SIZE +
				  data_length;
		 }
		 c_init_obj (identifier, data_length, obj_typ,
					 can_obj_buf[nbr_of_obj].contr_adr);
		 c_write_end_mark (can_obj_buf[nbr_of_obj].contr_adr);
		 return C_OK;
	  }
	  else {
		 /* Objekt existiert schon */
		 return C_OBJ_ERROR;
	  }
   #endif
}


#pragma eject
#ifdef P82C200
   /*==================================================================*/
   /* NUR FUER Philips 82C200										   */
   /*==================================================================*/

   /*---------------------------------------------------------------------*
	*	  C _ G E T _ A C C _ C O D E
	*---------------------------------------------------------------------*
	*  Funktion:
	*	  Gibt den beim Definieren der Objekte (mit C_DEFINE_OBJ)
	*	  berechneten Acceptance-Code f乺 den 82C200 zur乧k.
	*
	*---------------------------------------------------------------------*
	*  Parameter:
	*
	*	  Returnwert   : Acceptance-Code f乺 den 82C200
	*
	*---------------------------------------------------------------------*/

   byte c_get_acc_code (void)
   {
	  /* Nur die 8 MSB des acc_code zur乧kgeben */
	  return (acc_code >> 3);
   }



   /*---------------------------------------------------------------------*
	*	  C _ G E T _ A C C _ M A S K
	*---------------------------------------------------------------------*
	*  Funktion:
	*	  Gibt die beim Definieren der Objekte (mit C_DEFINE_OBJ)
	*	  berechnete Acceptance-Maske f乺 den 82C200 zur乧k.
	*
	*---------------------------------------------------------------------*
	*  Parameter:
	*
	*	  Returnwert   : Acceptance-Maske f乺 den 82C200
	*
	*---------------------------------------------------------------------*/

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

   /*==================================================================*/
   /*  ENDE Philips 82C200                                             */
   /*==================================================================*/
#endif



#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 int 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 int 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)
{
	  #ifdef I82526
   byte temp;
	  #endif

   if (can_obj_buf[index].data_length > 0) {
	  #ifdef P82C200
		 /*===============================================================*/
		 /* NUR FUER Philips 82C200 									  */
		 /*===============================================================*/
         c_fast_copy (arr, &can_obj_buf[index].dat[0],
                      can_obj_buf[index].data_length);
	  #endif
	  #ifdef I82526
		 /*===============================================================*/
		 /* NUR FUER Intel 82526										  */
		 /*===============================================================*/
         /* Der Returnwert der Funktion wird nicht ausgewertet */
		 /* Nur f乺 interne Testzwecke						   */
         temp = c_write_obj (can_obj_buf[index].contr_adr, arr);
	  #endif
   }
}



/*---------------------------------------------------------------------*
 *     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) {
	  #ifdef P82C200
		 /*===============================================================*/
		 /* NUR FUER Philips 82C200 									  */
		 /*===============================================================*/
         c_fast_copy (&can_obj_buf[index].dat[0], arr, length);
	  #endif
	  #ifdef I82526
		 /*===============================================================*/
		 /* NUR FUER Intel 82526										  */
		 /*===============================================================*/
         c_read_obj (can_obj_buf[index].contr_adr, arr);
	  #endif
   }
   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 82C200 :
 *	   ==============================
 *					  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).
 *
 *
 *
 *	   Returnwert beim Intel 82526 :
 *	   ===========================
 *					  Normale R乧kmeldung bei einwandfrei Empfangenen
 *                    Data-Frames :
 *                    1 bis 255   ->    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