bcancont.c51

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

 *     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] = bcan_reg.rec_buf[0] >> 5;
   temp.tb[1] = (bcan_reg.rec_buf[1] >> 5) + (bcan_reg.rec_buf[0] << 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 (bcan_reg.rec_buf[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 (bcan_reg.rec_buf[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)
{
   c_fast_copy (&bcan_reg.rec_buf[2], 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)
{
   bcan_reg.command = 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;

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

   nbr_of_trials = 0;
   /* Falls der Buffer noch besetzt ist, warten */
   while (!(bcan_reg.status & 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;
   bcan_reg.trans_buf[0] = (temp.tb[0] << 5) + (temp.tb[1] >> 3);
   bcan_reg.trans_buf[1] = temp.tb[1] << 5;
   if (remote) {
      /* rtr-bit setzen */
      bcan_reg.trans_buf[1] = bcan_reg.trans_buf[1] | 0x10;
   }
   else {
      /* Data-Frame */
      bcan_reg.trans_buf[1] = bcan_reg.trans_buf[1] + length;
      /* Daten in den Buffer schreiben */
      c_fast_copy (arr, &bcan_reg.trans_buf[2], length);
   }
   /* Transmission Request Bit setzen */
   bcan_reg.command = 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 */
   bcan_reg.command = 0xc;
   /* f乺 die erste Controller Version kurz Controller reseten */
/*   can_reset_request();*/
   bcan_reg.control = bcan_reg.control & 0x0fe;
   while (bcan_reg.control & 0x01) {
      bcan_reg.control = bcan_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 bcan_reg.intr;
}



/*---------------------------------------------------------------------*
 *     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 = bcan_reg.status;
   if (stat_r.status_bits.bus_status) {
      return bus_off;
   }
   if (stat_r.status_bits.err_status) {
      return error_passive;
   }
   return error_active;
}