hcandrv.c51

example of using Infineon 81c91 processor.

                            c_init_clock_cont_reg (c_order_buf.param[4]);

         if (done == FALSE) {
            c_get_back (C_CAN_FAILURE);
            return;
         }

         c_init_obj_buf ();
         for (i=0; i<=MAX_BIND_OBJ-1; i++) {
            signal_ok[i].task_id = NO_BIND;
            signal_ok[i].task_waits = FALSE;
         }
      break;

      case CAN_DEF_OBJ_ORDER:
         if (can_stopped == FALSE) {
            c_get_back (C_NOT_STOPPED);
            return;
         }
         qq.tb[0] = c_order_buf.param[0];               /* ident */
         qq.tb[1] = c_order_buf.param[1];

         temp = c_define_obj (qq.tw,                    /* ident */
                             c_order_buf.param[2],      /* length */
                             c_order_buf.param[3]);     /* type */
         if (temp != C_OK) {
            c_get_back (temp);
            return;
         }
      break;

      case CAN_STOP_ORDER:
         c_stop ();
         can_stopped = TRUE;
      break;

      case CAN_START_ORDER:

         /* Alle Objekte im Objekt-Buffer als gelesen markieren   */
         /* zum Erreichen eines definierten Anfangszustandes      */
         c_set_all_read ();
         c_start ();
         can_stopped = FALSE;
         if (c_get_status() == bus_off) {
            /* wenn der CAN-Controller bereits nach dem Starten im */
            /* Bus-Off Zustand ist, ist etwas schief gelaufen       */
            c_get_back (C_CAN_FAILURE);
            return;
         }
      break;

      case CAN_SEND_ORDER:
         if (c_get_status() == bus_off) {
            c_get_back (C_BUS_OFF);
            return;
         }
         /* Pointer auf das Datenfeld initialisieren */
         po.short_ptr.offs[0] = c_order_buf.param[0];
         po.short_ptr.offs[1] = c_order_buf.param[1];
         temp = c_get_index_from_ident (*po.i_ptr);
         if (temp == 0) {
            c_get_back (C_OBJ_ERROR);
            return;
         }
         temp2 = c_get_obj_typ (temp);
         if ((temp2 != D_SEND) && (temp2 != D_SEND_R_REC)) {
            c_get_back (C_OBJ_ERROR);
            return;
         }
         done = c_transmit_obj (temp, po.c_ptr+2);
         if (done==FALSE) {
            c_get_back (C_SEND_ERROR);
            return;
         }
      break;

      case CAN_REQUEST_ORDER:
         if (c_get_status() == bus_off) {
            c_get_back (C_BUS_OFF);
            return;
         }
         qq.tb[0] = c_order_buf.param[0];
         qq.tb[1] = c_order_buf.param[1];
         temp = c_get_index_from_ident (qq.tw);
         if (temp == 0) {
            c_get_back (C_OBJ_ERROR);
            return;
         }
         temp2 = c_get_obj_typ (temp);
         if (temp2 != D_REC_R_SEND) {
            c_get_back (C_OBJ_ERROR);
            return;
         }
         done = c_send_remote (temp);
         if (done==FALSE) {
            c_get_back (C_SEND_ERROR);
            return;
         }
      break;

      case CAN_BIND_OBJ_ORDER:
         qq.tb[0] = c_order_buf.param[0];
         qq.tb[1] = c_order_buf.param[1];
         temp = c_get_index_from_ident (qq.tw);
         if (temp == 0) {
            c_get_back (C_OBJ_ERROR);
            return;
         }
         temp2 = c_get_bind (temp);
         done = c_set_bind (temp, c_order_buf.param[2]);
         for (i=0; i<=MAX_BIND_OBJ-1; i++) {
            if ((signal_ok[i].task_id == NO_BIND)
            || (signal_ok[i].task_id == c_order_buf.param[2])) {
               signal_ok[i].task_id = c_order_buf.param[2];
               signal_ok[i].task_waits = FALSE;
               break;
            }
         }

         if (done == FALSE) {
            c_get_back (C_MEM_FULL);
            return;
         }
         if (temp2 != NO_BIND) {
            /* Objekt war schon an Task gebunden */
            c_get_back (C_OBJ_REBIND);
            return;
         }
      break;

      case CAN_UNBIND_OBJ_ORDER:
         qq.tb[0] = c_order_buf.param[0];
         qq.tb[1] = c_order_buf.param[1];
         temp = c_get_index_from_ident (qq.tw);
         if (temp == 0) {
            c_get_back (C_OBJ_ERROR);
            return;
         }
         temp2 = c_get_bind(temp);
         c_clear_bind (temp);
         for (i=0; i<=MAX_BIND_OBJ-1; i++) {
            if (signal_ok[i].task_id == temp2) {
               signal_ok[i].task_id = NO_BIND;
               signal_ok[i].task_waits = FALSE;
               break;
            }
         }

      break;

      case CAN_WRITE_ORDER:
         /* Pointer auf das Datenfeld initialisieren */
         po.short_ptr.offs[0] = c_order_buf.param[0];
         po.short_ptr.offs[1] = c_order_buf.param[1];
         temp = c_get_index_from_ident (*po.i_ptr);
         if (temp == 0) {
            c_get_back (C_OBJ_ERROR);
            return;
         }
         temp2 = c_get_obj_typ (temp);
         if ((temp2 != D_SEND) && (temp2 != D_SEND_R_REC)) {
            c_get_back (C_OBJ_ERROR);
            return;
         }
         c_write_data (temp, po.c_ptr+2);
      break;

      case CAN_READ_W_IND_ORDER:
         /* Pointer auf das Datenfeld initialisieren */
         po.short_ptr.offs[0] = c_order_buf.param[0];
         po.short_ptr.offs[1] = c_order_buf.param[1];
         w_temp = c_get_ident (c_order_buf.param[2]);
         if (w_temp == 0xffff) {
            if (c_get_status() == bus_off) {
               c_get_back (C_BUS_OFF);
            }
            else {
               c_get_back (C_CAN_FAILURE);
            }
            return;
         }
         *po.i_ptr = w_temp;
         c_read_data (c_order_buf.param[2], po.c_ptr+2);
      break;

      case CAN_READ_W_TID_ORDER:
         /* Pointer auf das Datenfeld initialisieren */
         po.short_ptr.offs[0] = c_order_buf.param[0];
         po.short_ptr.offs[1] = c_order_buf.param[1];
         temp = c_get_rec_bind (c_order_buf.param[2]);
         if (temp == 0) {
            c_get_back (C_CAN_FAILURE);
            return;
         }
         *po.i_ptr = c_get_ident (temp);
         c_read_data (temp, po.c_ptr+2);
         for (i=0; i<=MAX_BIND_OBJ-1; i++) {
            if (signal_ok[i].task_id == c_order_buf.param[2]) {
               signal_ok[i].task_waits = FALSE;
               break;
            }
         }
      break;

      case CAN_READ_ORDER:
         qq.tb[0] = c_order_buf.param[2];
         qq.tb[1] = c_order_buf.param[3];
         temp = c_get_index_from_ident (qq.tw);
         if (temp == 0) {
            c_get_back (C_OBJ_ERROR);
            return;
         }
         /* Pointer auf das Datenfeld initialisieren */
         po.short_ptr.offs[0] = c_order_buf.param[0];
         po.short_ptr.offs[1] = c_order_buf.param[1];
         *po.i_ptr = c_get_ident (temp);
         c_read_data (temp, po.c_ptr+2);
      break;

      case CAN_GET_STATUS_ORDER:
         if (c_get_status() == error_active) {
            c_get_back (C_ERR_ACTIVE);
         }
         else if (c_get_status() == error_passive) {
            c_get_back (C_ERR_PASSIVE);
         }
         else if (c_get_status() == bus_off) {
            c_get_back (C_BUS_OFF);
         }
         else {
            c_get_back (C_CAN_FAILURE);
         }
         return;
      break;

      case CAN_ACTIVATE_WAIT:
         for (i=0; i<=MAX_BIND_OBJ-1; i++) {
            if (signal_ok[i].task_id == (c_order_buf.task_id)) {
               signal_ok[i].task_waits = TRUE;
               break;
            }
         }
         if (c_get_rec_bind (c_order_buf.task_id) != 0) {
            os_send_signal (c_order_buf.task_id);
         }
         return;
      break;

      default:
         c_get_back (C_CAN_FAILURE);
         return;
      break;
   }
   c_get_back (C_OK);
}




#pragma eject
/*---------------------------------------------------------------------*
 *     C A N - T A S K                                                 *
 *---------------------------------------------------------------------*/

/*---------------------------------------------------------------------*
 *     C A N _ C A N _ T A S K _ M A I N
 *---------------------------------------------------------------------*
 *  Funktion:
 *
 *     Hauptschleife des CAN-Task.
 *
 *---------------------------------------------------------------------*
 *  Parameter:
 *
 *     --
 *
 *---------------------------------------------------------------------*/

void can_can_task_main (void) _task_ CAN_TASK_ID _priority_ 3
{
   byte i;

   /* Grundinitialisierung beim Starten des CAN-Task          */
   /* CAN-Controller auf anhalten, bis zur Initialisierung    */
   /* durch die Applikation d乺fen keine Interrupts auftreten */
   can_stopped = TRUE;
   c_init_obj_buf ();
   for (i=0; i<=MAX_BIND_OBJ-1; i++) {
      signal_ok[i].task_id = NO_BIND;
      signal_ok[i].task_waits = FALSE;
   }

   /* CAN-Interrupt zuordnen */
   os_attach_interrupt (CAN_INT_NBR);

   /* Hauptschleife des Task */
   for (;;) {
      /* Auf Signal von der Applikation oder Interrupt vom  */
      /* CAN-Controller warten                              */
      if (os_wait (K_INT+K_SIG, 0xff, 0) == INT_EVENT) {
         /* CAN-Controller Interrupt abhandeln */
         c_handle_can_int ();
      }
      else {
         /* Signal von der Applikation abhandeln */
         c_handle_appli_signal ();
      }
   }
}