candrv.c51

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

      unsigned int xdata *i_ptr;
      byte xdata *c_ptr;
   } po;

   /* Definition der einzelnen Control-Bits im CAN-Controller       */
   union can_control_typ cont_r;

   switch (c_order_buf.order) {
      case CAN_HW_INIT_ORDER:
         c_stop ();
         can_stopped = TRUE;
         done = c_hw_init (c_order_buf.param[0], c_order_buf.param[1],
                           c_order_buf.param[2]);
         if (done == FALSE) {
            c_get_back (C_CAN_FAILURE);
            return;
         }

		 #ifdef P82C200
			/*=============================================================*/
			/* NUR FUER Philips 82C200									   */
			/*=============================================================*/
            /* Receive- und Overrun Interrupt enablen und            */
			/* SYNC-Mode einstellen 								 */
			cont_r.cont_byte = 0;
			cont_r.cont_bits.rec_int_ena = 1;
			cont_r.cont_bits.overrun_int_ena = 1;
			cont_r.cont_bits.speed_mode = c_order_buf.param[3];
			c_init_cont_reg (cont_r.cont_byte);
			/*=============================================================*/
         #endif

		 #ifdef I82526
			/*=============================================================*/
			/* NUR FUER Intel 82526 									   */
			/*=============================================================*/
			/* Transmit- und Error Interrupt enablen, SYNC-Mode */
			/* und Sleep-Mode einstellen						*/
			cont_r.cont_byte = 0;
			cont_r.cont_bits.trans_int_ena = 1;
			cont_r.cont_bits.error_int_ena = 1;
			cont_r.cont_bits.syncon = c_order_buf.param[3];
			cont_r.cont_bits.sleep_mode = c_order_buf.param[4];
			c_init_cont_reg (cont_r.cont_byte);
			/*=============================================================*/
         #endif

         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;
         }
         c_overrun_counter = 0;
      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];
         qq.tb[1] = c_order_buf.param[1];
         temp = c_define_obj (qq.tw, c_order_buf.param[2],
                              c_order_buf.param[3]);
         if (temp != C_OK) {
            c_get_back (temp);
            return;
         }
      break;

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

      case CAN_START_ORDER:
		 #ifdef P82C200
			/*=============================================================*/
			/* NUR FUER Philips 82C200									   */
			/*=============================================================*/
			/* Akkzeptanz-Maske des Controllers setzen */
			temp = c_get_acc_code ();
			temp2 = c_get_acc_mask ();
			c_init_accept_reg (temp, temp2);
			/*=============================================================*/
         #endif

         /* 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_first_init ();
   c_init_obj_buf ();
   c_overrun_counter = 0;
   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 ();
      }
   }
}


/*---------------------------------------------------------------------*
 *	   Ende Modul CANDRV											   *
 *---------------------------------------------------------------------*/