pcancont.c51

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

/*---------------------------------------------------------------------*
 *     C _ G E T _ R E C _ I D
 *---------------------------------------------------------------------*
 *  Funktion:
 *     Abfrage des Identifiers des gerade empfangenen Objektes.
 *
 *---------------------------------------------------------------------*
 *  Parameter:
 *
 *     Returnwert     : Identifier des gerade empfangenen Objektes
 *
 *---------------------------------------------------------------------*/

unsigned long c_get_rec_id (void)
{
   unsigned long tw;

   tw =  can_reg.bcan_reg.r_ID1.ID1;
   tw = ((tw << 3) & 0x0007) + can_reg.bcan_reg.r_ID2.ID2;
   
   return tw;
}



/*---------------------------------------------------------------------*
 *     C _ R E C _ R E M O T E
 *---------------------------------------------------------------------*
 *  Funktion:
 *     Gibt zur乧k ob das eben empfangene Objekt ein Remote-Frame ist.
 *
 *---------------------------------------------------------------------*
 *  Parameter:
 *
 *     Returnwert   : TRUE  -> Remote-Frame
 *                    FALSE -> Data-Frame
 *
 *---------------------------------------------------------------------*/

byte c_rec_remote (void)
{
   if (can_reg.bcan_reg.r_ID2.RTR == 1 ) {
     return TRUE;
   }
   return FALSE;
}



/*---------------------------------------------------------------------*
 *     C _ G E T _ R E C _ L E N
 *---------------------------------------------------------------------*
 *  Funktion:
 *     Gibt die Datenl刵ge des eben empfangenen Objektes zur乧k.
 *
 *---------------------------------------------------------------------*
 *  Parameter:
 *
 *     Returnwert  :  Anzahl Datenbytes die empfangen wurden (0..8)
 *
 *---------------------------------------------------------------------*/

byte c_get_rec_len (void)
{
   return (can_reg.bcan_reg.r_ID2.DLC);
}



/*---------------------------------------------------------------------*
 *     C _ R E A D _ R E C _ D A T A
 *---------------------------------------------------------------------*
 *  Funktion:
 *     Lesen der Daten des eben empfangenen Objektes. Die Daten werden
 *     in den XDATA-Bereich, dessen Anfang mit dem Parameter BUF_PTR
 *     bezeichnet ist, kopiert.
 *     Es werden soviele Bytes kopiert wie tats刢hlich empfangen wurden
 *     (kann mit C_GET_REC_LEN gelesen werden).
 *
 *---------------------------------------------------------------------*
 *  Parameter:
 *
 *     arr       : Array im XDATA-Bereiche in den die
 *                 eben gerade empfangenen Daten kopiert werden k攏nen.
 *
 *---------------------------------------------------------------------*/

void c_read_rec_data (byte xdata *arr)
{
   c_fast_copy (&can_reg.bcan_reg.rec_buf[0], arr, c_get_rec_len());
}




/*---------------------------------------------------------------------*
 *     C _ R E L _ R E C _ R E G
 *---------------------------------------------------------------------*
 *  Funktion:
 *     Nach dem Empfang eines Objektes kann der Empfangsbuffer von
 *     der CPU gelesen werden. W刪rend dieser Zeit kann der
 *     CAN-Controller keine neue Daten in den Buffer schreiben.
 *     Nach dem Lesen der Daten muss der Buffer wieder f乺 den CAN-
 *     Controller freigegeben werden.
 *
 *---------------------------------------------------------------------*
 *  Parameter:
 *
 *     --
 *
 *---------------------------------------------------------------------*/

void c_rel_rec_reg (void)
{
   can_command_type command_reg;

   command_reg.bytes = 0;
   command_reg.bits.RRB =1;
   can_reg.bcan_reg.command = command_reg;

}



/*---------------------------------------------------------------------*
 *     C _ S E N D _ O B J
 *---------------------------------------------------------------------*
 *  Funktion:
 *     Uebertragung eines Objektes zum CAN-Controller zum Senden.
 *
 *---------------------------------------------------------------------*
 *  Parameter:
 *
 *     identifier     :  Identifier des zu sendenden Objektes
 *     remote         :  TRUE  -> sende ein Remote-Frame
 *                       FALSE -> sende ein Data-Frame
 *     length         :  Anzahl Datenbytes die gesendet werden m乻sen
 *     arr            :  Array mit den Daten die gesendet werden sollen
 *
 *---------------------------------------------------------------------*/

byte c_send_obj (unsigned long identifier,
		 byte remote,
		 byte length,
		 byte xdata *arr)
{
   unsigned long tw;


   unsigned char nbr_of_trials;  /* Anzahl Sendeversuche bis Abbruch */
   can_command_type command_reg;

   nbr_of_trials = 0;
   /* Falls der Buffer noch besetzt ist, warten */
   while (!(can_reg.bcan_reg.status.bits.TBS)) {
	  nbr_of_trials++;
	  if (nbr_of_trials > 10) {
	 os_wait (K_TMO, 2, 0);
	 if (nbr_of_trials > NBR_OF_SEND_TRIALS+10) {
	    /* Bus wird nicht frei, vermutlich ist kein anderer Teilnehmer */
	    /* am Bus, abbrechen                                                                               */
	    return FALSE;
	 }
      }
   }

   /* Identifier in den Buffer schreiben */
   tw = identifier;
   
   can_reg.bcan_reg.t_ID1.ID1 = (tw >> 3) & 0x000000FF;   
   can_reg.bcan_reg.t_ID2.ID2 = tw & 0x00000007;

   can_reg.bcan_reg.t_ID2.RTR = 0;   
   if (remote) {
      /*  Sende remote immer mit data length field = 0 */
      can_reg.bcan_reg.t_ID2.DLC = 0;      
      /* rtr-bit setzen */
      can_reg.bcan_reg.t_ID2.RTR = 1;   
   }
   else {
      /* Data-Frame */
      can_reg.bcan_reg.t_ID2.DLC = length;      
      /* Daten in den Buffer schreiben */
      c_fast_copy (arr, &can_reg.bcan_reg.trans_buf[0], length);
   }
   /* Transmission Request Bit setzen */

   command_reg.bytes = 0;
   command_reg.bits.TR = 1;
   can_reg.bcan_reg.command = command_reg;

   return TRUE;
}



/*---------------------------------------------------------------------*
 *     C _ C L R _ O V E R R U N
 *---------------------------------------------------------------------*
 *  Funktion:
 *     L攕chen des Overrun-Status im SJA1000.
 *
 *
 *
 *---------------------------------------------------------------------*
 *  Parameter:
 *
 *     --
 *
 *---------------------------------------------------------------------*/

void c_clr_overrun (void)
{
   can_command_type command_reg;

   /* Overrun-Status zur乧ksetzen und Receive-Buffer releasen */

   command_reg.bytes = 0;
   command_reg.bits.COS =1;
   command_reg.bits.RRB = 1;
   can_reg.bcan_reg.command = command_reg;

   /* f乺 die erste Controller Version kurz Controller reseten */
/*   can_reset_request();*/
   can_reg.bcan_reg.control.bits.RR = 0;
   while (can_reg.bcan_reg.control.bits.RR) {
      can_reg.bcan_reg.control.bits.RR = 0;
      os_wait (K_TMO, 2, 0);
   }
}



/*---------------------------------------------------------------------*
 *     C _ G E T _ I N T _ R E G
 *---------------------------------------------------------------------*
 *  Funktion:
 *     Diese Funktion liest den Inhalt des Interrupt-Registers
 *     des SJA1000.
 *
 *---------------------------------------------------------------------*
 *  Parameter:
 *
 *     Returnwert  :  Inhalt des SJA1000 Interrupt-Registers
 *
 *---------------------------------------------------------------------*/

byte c_get_int_reg (void)
{
   return can_reg.bcan_reg.intr.bytes;
}



/*---------------------------------------------------------------------*
 *     C _ G E T _ S T A T U S
 *---------------------------------------------------------------------*
 *  Funktion:
 *     Gibt den aktuellen Bus-Zustand des SJA1000 zur乧k
 *
 *---------------------------------------------------------------------*
 *  Parameter:
 *
 *     Returnwert  :  Aktueller SJA1000 Bus-Zustand
 *
 *---------------------------------------------------------------------*/

enum can_bus_stat_t c_get_status (void)
{
   if (can_reg.bcan_reg.status.bits.BS) {
      return bus_off;
   }
   if (can_reg.bcan_reg.status.bits.ES) {
      return error_passive;
   }
   return error_active;
}