fcancont.c51

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

 *                   Daten kopiert werden k攏nen.
 *
 *---------------------------------------------------------------------*/

void c_read_obj (byte obj_adr,
                 byte xdata *arr)
{
   register byte len;

   /* Warten bis Zugriff frei ist (CPU-Access) */
   while (!(fcan_reg.mem[obj_adr+1] & 0x01));
   /* Daten-L刵ge testen und entsprechend handeln */
   len = fcan_reg.mem[obj_adr+2] & 0x0f;
   if (len > 1) {
      /* Aufwendigeres Verfahren wenn Datenl刵ge > 1 Byte     */
      /* Es muss nach dem Lesen getestet werden ob in der     */
      /* Zwischenzeit weitere Daten empfangen wurden          */
      do {
         /* Transfer-Status = 0 */
         fcan_reg.mem[obj_adr+2] = fcan_reg.mem[obj_adr+2] & 0xbf;
         c_fast_copy (&fcan_reg.mem[obj_adr+3], arr, len);
         /* Nun testen ob keine neuen Daten eingetroffen sind */
         /* Warten bis Zugriff frei ist (CPU-Access) */
         while (!(fcan_reg.mem[obj_adr+1] & 0x01));
      } while (fcan_reg.mem[obj_adr+2] & 0x40);
   }
   else {
      /* Datenl刵ge ist <= 1, weiterer Empfang muss nicht getestet werden */
      /* Transfer-Status = 0 */
      fcan_reg.mem[obj_adr+2] = fcan_reg.mem[obj_adr+2] & 0xbf;
      c_fast_copy (&fcan_reg.mem[obj_adr+3], arr, len);
   }
}




/*---------------------------------------------------------------------*
 *     C _ S E N D _ O B J
 *---------------------------------------------------------------------*
 *  Funktion:
 *     Uebertragung eines Objektes zum CAN-Controller zum Senden.
 *     Es werden soviele Byte gesendet, wie bei C_INIT_OBJ definiert
 *     (nur wenn nicht Remote).
 *
 *---------------------------------------------------------------------*
 *  Parameter:
 *
 *     obj_adr        :  Interne Start-Adresse des zu sendenden Objektes
 *                       (siehe C_INIT_OBJ)
 *     remote         :  TRUE  -> sende ein Remote-Frame
 *                       FALSE -> sende ein Data-Frame
 *     arr            :  Array im XDATA-Bereich mit den Daten die gesendet
 *                       werden sollen
 *
 *     Returnwert     :  TRUE  -> Senden erfolgreich
 *                       FALSE -> Senden nicht erfolgreich
 *
 *---------------------------------------------------------------------*/

byte c_send_obj (byte obj_adr,
                 byte remote,
                 byte xdata *arr)
{
   if (remote) {
      /* Nur Remote Frame senden */
      if (fcan_reg.mem[obj_adr+1] & 0x01) {
         /* Es muss nur gesendet werden, falls CPU-Access=1 ist */
         /* Andernfalls wird gearade ein Data-Frame empfangen   */
         /* Es muss daher kein Remote-Frame gesendet werden     */
         /* Transfer-Status = 0 */
         fcan_reg.mem[obj_adr+2] = fcan_reg.mem[obj_adr+2] & 0xbf;
         /* TX-Request = 1 */
         fcan_reg.mem[obj_adr+2] = fcan_reg.mem[obj_adr+2] | 0x80;
      }
      return TRUE;
   }

   /* Daten-Frame senden */
   /* Testen ob Zugriff zum Schreiben auf Objekt */
   if (can_check_write_access (obj_adr)) {
      c_fast_copy (arr, &fcan_reg.mem[obj_adr+3],
                   fcan_reg.mem[obj_adr+2] & 0x0f);
      /* Transfer-Status = 0 */
      fcan_reg.mem[obj_adr+2] = fcan_reg.mem[obj_adr+2] & 0xbf;
      /* TX-Request = 1 */
      fcan_reg.mem[obj_adr+2] = fcan_reg.mem[obj_adr+2] | 0x80;
      can_set_imp (obj_adr);
      return TRUE;
   }
   return FALSE;
}



/*---------------------------------------------------------------------*
 *     C _ W R I T E _ O B J
 *---------------------------------------------------------------------*
 *  Funktion:
 *     Speichern eines Objektes im CAN-Controller, die Daten werden
 *     nicht gesendet sondern stehen zum Beispiel f乺 eine Anfrage
 *     durch ein Remote-Frame zur Verf乬ung. Es werden soviele Byte
 *     abgespeichert, wie bei C_INIT_OBJ definiert.
 *
 *---------------------------------------------------------------------*
 *  Parameter:
 *
 *     obj_adr        :  Interne Start-Adresse des zu schreibenden Objektes
 *                       (siehe C_INIT_OBJ)
 *     arr            :  Array im XDATA-Bereich mit den Daten die
 *                       geschrieben werden sollen
 *
 *     Returnwert     :  TRUE  -> Senden erfolgreich
 *                       FALSE -> Senden nicht erfolgreich
 *
 *---------------------------------------------------------------------*/

byte c_write_obj (byte obj_adr,
                  byte xdata *arr)
{
   if (can_check_write_access (obj_adr)) {
      c_fast_copy (arr, &fcan_reg.mem[obj_adr+3],
                   fcan_reg.mem[obj_adr+2] & 0x0f);
      /* Transfer-Status = 0 */
      fcan_reg.mem[obj_adr+2] = fcan_reg.mem[obj_adr+2] & 0xbf;
      can_set_imp (obj_adr);
      return TRUE;
   }
   return FALSE;
}



/*---------------------------------------------------------------------*
 *     C _ W R I T E _ E N D _ M A R K
 *---------------------------------------------------------------------*
 *  Funktion:
 *     Schreibt die Endmarke (FFH) an das Ende des Objektes OBJ_ADR.
 *     Diese Funktion dient zum Abschliessen der Objektliste.
 *
 *---------------------------------------------------------------------*
 *  Parameter:
 *
 *     OBJ_ADR        :  Interne Adresse des Objektes an dessen Ende die
 *                       Endmarke gesetzt werden soll(siehe C_INIT_OBJ)
 *
 *---------------------------------------------------------------------*/

void c_write_end_mark (byte obj_adr)
{
   byte len;

   can_halt_request();
   /* L刵ge des Objektes berechnen */
   len = fcan_reg.mem[obj_adr+2] & 0x0f;
   fcan_reg.mem[obj_adr+3+len] = 0xff;
}



/*---------------------------------------------------------------------*
 *     C _ G E T _ I N T _ T Y P
 *---------------------------------------------------------------------*
 *  Funktion:
 *     Diese Funktion gibt den Typ des Aufgetretenen Interrupts zur乧k.
 *
 *---------------------------------------------------------------------*
 *  Parameter:
 *
 *     Returnwert  :  no_int, error_int, obj_int (enum interrupt_t)
 *
 *---------------------------------------------------------------------*/

enum interrupt_t c_get_int_typ (void)
{
   if (fcan_reg.r.intr == 0xff) {
      return no_int;
   }
   else if (fcan_reg.r.intr == 0x01) {
      return error_int;
   }
   else {
      return obj_int;
   }
}



/*---------------------------------------------------------------------*
 *     C _ G E T _ O B J _ I N T _ A D R
 *---------------------------------------------------------------------*
 *  Funktion:
 *     Gibt die Startadresse des Objektes bei dem ein Objekt-Interrupt
 *     aufgetreten ist zur乧k.
 *
 *---------------------------------------------------------------------*
 *  Parameter:
 *
 *     Returnwert  :  Startadresse des Objektes bei dem ein Interrupt
 *                    aufgetreten ist
 *
 *---------------------------------------------------------------------*/

byte c_get_obj_int_adr (void)
{
   return fcan_reg.r.intr;
}



/*---------------------------------------------------------------------*
 *     C _ R E C E I P T _ O B J _ I N T
 *---------------------------------------------------------------------*
 *  Funktion:
 *     Diese Funktion setzt einen Objekt-Interrupt des Objektes mit der
 *     internen Startadresse OBJ_ADR zur乧k.
 *
 *---------------------------------------------------------------------*
 *  Parameter:
 *
 *     OBJ_ADR        :  Interne Adresse des Objektes dessen Interrupt
 *                       zur乧kgesetzt werden soll (siehe C_INIT_OBJ)
 *
 *---------------------------------------------------------------------*/

void c_receipt_obj_int (byte obj_adr)
{
   /* Transfer-Status des Objektes = 0 */
   fcan_reg.mem[obj_adr+2] = fcan_reg.mem[obj_adr+2] & 0xbf;
   /* Empty-Pointer in das Interrupt Register schreiben */
   fcan_reg.r.intr = 0xff;
}


/*---------------------------------------------------------------------*
 *     C _ R E C E I P T _ E R R O R _ I N T
 *---------------------------------------------------------------------*
 *  Funktion:
 *     Diese Funktion quittiert einen Error-Interrupt
 *
 *---------------------------------------------------------------------*
 *  Parameter:
 *    --
 *---------------------------------------------------------------------*/

void c_receipt_error_int (void)
{
   /* Empty-Pointer in das Interrupt Register schreiben */
   fcan_reg.r.intr = 0xff;
}



/*---------------------------------------------------------------------*
 *     C _ G E T _ S T A T U S
 *---------------------------------------------------------------------*
 *  Funktion:
 *     Gibt den aktuellen Bus-Zustand des 82526.
 *
 *---------------------------------------------------------------------*
 *  Parameter:
 *
 *     Returnwert  :  Bus-Zustand des 82526
 *
 *---------------------------------------------------------------------*/

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

   stat_r.status_byte = fcan_reg.r.status;
   if ((stat_r.status_bits.bus_status) ||
       (stat_r.status_bits.dpram_status)) {
      /* Der CAN-Controller ist auch bei einem DPRAM.Error */
      /* im Bus-Off Zustand                                */
      return bus_off;
   }
   if (stat_r.status_bits.error_status) {
      return error_passive;
   }
   return error_active;
}