canobja.c51

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

 *                                      noch nicht gelesen durch die
 *                                      Applikation).
 *
 *---------------------------------------------------------------------*/

unsigned int c_receive_obj (void)
{
   #ifdef P82C200
	  /*==================================================================*/
	  /* NUR FUER Philips 82C200										  */
	  /*==================================================================*/
      unsigned int 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;
	  }

	  /* Das Objekt hat die Akzeptanzfilterung bestanden   */
	  /* Test ob Remote-Frame							   */
	  if (c_rec_remote()) {
		 /* Test ob Antwort auf Remote-Frame gesendet werden darf */
		 if (can_obj_buf[index].obj_typ == D_SEND_R_REC) {
			/* Empfangsbuffer freigeben und Antwort senden */
			c_rel_rec_reg();
			res = c_send_obj (ident, FALSE, can_obj_buf[index].data_length,
							  can_obj_buf[index].dat);
			if (res==TRUE) {
			   return 0xfff0;
			}
			else {
			   return 0xfff2;
			}
		 }
		 else {
			/* Falscher Objekttyp */
			c_rel_rec_reg();
			return 0xfff1;
		 }
	  }
	  else {
		 /* Data-Frame empfangen */
		 if ((can_obj_buf[index].obj_typ == D_REC) ||
			(can_obj_buf[index].obj_typ == D_REC_R_SEND)) {
			/* Daten empfangen */
			c_read_rec_data (can_obj_buf[index].dat);
			c_rel_rec_reg();
			if (can_obj_buf[index].obj_read) {
			   can_obj_buf[index].obj_read = FALSE;
			   return index;
			}
			else {
			   return 0xfff6;
			}
		 }
		 else {
			/* falscher Objekttyp */
			c_rel_rec_reg();
			return 0xfff5;
		 }
	  }
   #endif

   #ifdef I82526
	  /*==================================================================*/
	  /* NUR FUER Intel 82526											  */
	  /*==================================================================*/
      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;
	  }
   #endif
}



/*---------------------------------------------------------------------*
 *     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)
{
   #ifdef P82C200
	  /*==================================================================*/
	  /* NUR FUER Philips 82C200										  */
	  /*==================================================================*/
      c_write_data (index, arr);
	  return c_send_obj (can_obj_buf[index].identifier, FALSE,
						 can_obj_buf[index].data_length,
						 arr);
   #endif

   #ifdef I82526
	  /*==================================================================*/
	  /* NUR FUER Intel 82526											  */
	  /*==================================================================*/
      return c_send_obj (can_obj_buf[index].contr_adr, FALSE, arr);
   #endif
}



/*---------------------------------------------------------------------*
 *     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)
{
   #ifdef P82C200
	  /*==================================================================*/
	  /* NUR FUER Philips 82C200										  */
	  /*==================================================================*/
      return c_send_obj (can_obj_buf[index].identifier, TRUE, 0, 0);
   #endif
   #ifdef I82526
      /*==================================================================*/
	  /* NUR FUER Intel 82526											  */
	  /*==================================================================*/
      return c_send_obj (can_obj_buf[index].contr_adr, TRUE, 0);
   #endif
}



/*---------------------------------------------------------------------*
 *     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;
   }
}



#pragma eject
/*---------------------------------------------------------------------*
 *     Akzeptanzfilterung                                              *
 *---------------------------------------------------------------------*/

#ifdef P82C200
   /*==================================================================*/
   /* NUR FUER Philips 82C200                                          */
   /*==================================================================*/
   /*---------------------------------------------------------------------*
	*	  C _ O B J _ A C C E P T
	*---------------------------------------------------------------------*
	*  Funktion:
	*	  F乭rt eine volle 11-Bit Akezptanzfilterung durch, wie beim
	*	  Philips 82C200 definiert (der 82C200 vergleicht nur die
	*	  obersten 8-Bit). Die Filterwerte werden bei C_DEFINE_OBJ
	*	  berechnet.
	*
	*---------------------------------------------------------------------*
	*  Parameter:
	*
	*	  identifier   : Identifikation die getestet werden soll
	*
	*	  Returnwert   : TRUE  ->	 Filter durchlaufen (muss aber nicht
	*								 bedeuten, dass das Objekt im Objektbuffer
	*								 definiert ist, die Filterung ist nur eine
	*								 Vorauswahl.
	*
	*					 FALSE ->	 Filterung nicht bestanden, Objekt ist
	*								 nicht im Buffer definiert.
	*
	*---------------------------------------------------------------------*/

   byte c_obj_accept (unsigned int identifier)
   {
	  if (((identifier ^ acc_code) & (acc_mask)) == 0) {
		 return TRUE;
	  }
	  else
	  {
		 return FALSE;
	  }
   }
   /*==================================================================*/
   /*  ENDE Philips 82C200                                             */
   /*==================================================================*/
#endif


/*---------------------------------------------------------------------*
 *     Ende Modul BCANOBJA                                             *
 *---------------------------------------------------------------------*/