pcandrv.c51

Philips sja1000 can controller. it contains example on how to control this device

	 cont_r.bytes = 0;
	 cont_r.bits.RIE = 1;
	 cont_r.bits.OIE = 1;
	 cont_r.bits.S = 0x00; /* set sync immer auf 0 */

	 c_init_cont_reg(cont_r.bytes);


	 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];  /* HIGH Ident */
	 qq.tb[1] = c_order_buf.param[1];  /* LOW Ident */
	 temp = c_define_obj (
                  qq.tw,                   /* Ident */
                  c_order_buf.param[2],    /* data length */
		  c_order_buf.param[3]     /* obj 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:
	 /* Akkzeptanz-Maske des Controllers setzen */
	 temp = c_get_acc_code ();
	 temp2 = c_get_acc_mask ();
	 c_init_accept_reg (temp, temp2);

	 /* 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 PCANDRV                                                                                       *
 *---------------------------------------------------------------------*/