pcanobja.c51

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

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



/*---------------------------------------------------------------------*
 *     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)
{
   c_write_data (index, arr);
   return c_send_obj (can_obj_buf[index].identifier, FALSE,
			 can_obj_buf[index].data_length,
			 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].identifier, TRUE, 0, 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;
   }
}



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

/*---------------------------------------------------------------------*
*         C _ O B J _ A C C E P T
*---------------------------------------------------------------------*
*  Funktion:
*         F乭rt eine volle 11-Bit Akezptanzfilterung durch, wie beim
*         Philips SJA1000 definiert (der SJA1000 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 long identifier)
{
   if (((identifier ^ acc_code) & (acc_mask)) == 0) {
      return TRUE;
   }
   else
   {
      return FALSE;
   }
}


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