ccont592.c51

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

   }
}



/*---------------------------------------------------------------------*
 *     C _ S T O P
 *---------------------------------------------------------------------*
 *  Funktion:
 *     Tempor剅es Anhalten des CAN-Controllers. Es kann mit C_START
 *     weitergefahren werden. Solange C_STOP aktiv ist, k攏nen keine
 *     Objekte empfangen oder gesendet werden.
 *
 *---------------------------------------------------------------------*
 *  Parameter:
 *
 *     --
 *
 *---------------------------------------------------------------------*/

void c_stop (void)
{
   can_reset_request();
}



/*---------------------------------------------------------------------*
 *     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 int c_get_rec_id (void)
{
   /* Hilfsvariable zum separaten ansprechen von High- und Low-Byte  */
   /* in einem Word                                                  */
   register union {
               unsigned int tw;
               byte tb[2];
            } temp;

   temp.tb[0] = get_internal_reg(RECEIVE) >> 5;
   temp.tb[1] = (get_internal_reg(RECEIVE+1) >> 5) + (get_internal_reg(RECEIVE) << 3);
   return temp.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 (get_internal_reg(RECEIVE+1) & 0x10) {
      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 (get_internal_reg(RECEIVE+1) & 0x0f);
}



/*---------------------------------------------------------------------*
 *     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)
{
   byte len;
   byte i;

   len = c_get_rec_len();
   /* Startadresse mit Auto-Inkrement laden */
   CANADR = (RECEIVE+2) | 0x20;
   for (i=0; i<len; i++) {
      *arr = CANDAT;
      arr++;
   }
}



/*---------------------------------------------------------------------*
 *     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)
{
   CANCON = (get_internal_reg(COMMAND) & 0xe0) | 0x04;
}



/*---------------------------------------------------------------------*
 *     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 int identifier,
                 byte remote,
                 byte length,
                 byte xdata *arr)
{
   register union {
               unsigned int tw;
               byte tb[2];
            } temp;

   byte nbr_of_trials;  /* Anzahl Sendeversuche bis Abbruch */
   byte i;
   byte len;
   byte xdata *ptr;

   nbr_of_trials = 0;
   /* Falls der Buffer noch besetzt ist, warten */
   while (!(CANSTA & 0x04)) {
	  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 */
   temp.tw = identifier;
   set_internal_reg (TRANSMIT, (temp.tb[0] << 5) + (temp.tb[1] >> 3));
   if (remote) {
      /* rtr-bit setzen */
      set_internal_reg (TRANSMIT+1, (temp.tb[1] << 5) | 0x10);
   }
   else {
      set_internal_reg (TRANSMIT+1, (temp.tb[1] << 5)+length);
      /* Data-Frame */
      /* Daten in den Buffer schreiben */
      len = length;
      ptr = arr;
      CANADR = (TRANSMIT+2) | 0x20;
      for (i=0; i<len; i++) {
         CANDAT = *ptr;
         ptr++;
      }
   }
   /* Transmission Request Bit setzen */
   CANCON = (get_internal_reg(COMMAND) & 0xe0) | 0x01;
   return TRUE;
}



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

void c_clr_overrun (void)
{
   /* Overrun-Status zur乧ksetzen und Receive-Buffer releasen */
   CANCON = (get_internal_reg(COMMAND) & 0xe0) | 0x0c;
   /* f乺 die erste Controller Version kurz Controller reseten */
   can_reset_request();
   set_internal_reg (CONTROL, get_internal_reg(CONTROL) & 0x0fe );
   while (get_internal_reg(CONTROL) & 0x01) {
      set_internal_reg (CONTROL, get_internal_reg(CONTROL) & 0x0fe );
      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 82C200.
 *
 *---------------------------------------------------------------------*
 *  Parameter:
 *
 *     Returnwert  :  Inhalt des 82C200 Interrupt-Registers
 *
 *---------------------------------------------------------------------*/

byte c_get_int_reg (void)
{
   return CANCON;
}



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

enum can_bus_stat_t c_get_status (void)
{
   union can_status_typ stat_r;   /* Status-Bits im CAN-Controller    */

   stat_r.status_byte = CANSTA;
   if (stat_r.status_bits.bus_status) {
      return bus_off;
   }
   if (stat_r.status_bits.err_status) {
      return error_passive;
   }
   return error_active;
}