Exemplo n.º 1
0
int mvme_read(MVME_INTERFACE *vme, void *dst, mvme_addr_t vme_addr, mvme_size_t n_bytes)
{
   mvme_size_t n;
   bt_error_t status;
   BT617_TABLE *ptab;

   ptab = ((BT617_TABLE *)vme->table)+vme->handle;

   status = bt_read(ptab->btd, dst, vme_addr, n_bytes, (size_t *)&n);
   if (status != BT_SUCCESS)
      bt_perror(ptab->btd, status, "bt_read error");

   return n;
}
Exemplo n.º 2
0
ssize_t serial_read(int fd, void *data, size_t len) {
#ifndef WINDOWS
#ifdef ANDROID
	return bt_read(fd, data, len);
#else
	return read(fd, data, len);
#endif
#else
	DWORD dwBytesRead = 0;
	ReadFile(hSerial[fd], data, len, &dwBytesRead, 0);
	//SDL_Log("## serial get: %i/%i \n", dwBytesRead, len);
	return dwBytesRead;
#endif
}
Exemplo n.º 3
0
DWORD mvme_read_value(MVME_INTERFACE *vme, mvme_addr_t vme_addr)
{
   mvme_size_t n;
   DWORD data;
   bt_error_t status;
   BT617_TABLE *ptab;

   ptab = ((BT617_TABLE *)vme->table)+vme->handle;

   if (vme->dmode == MVME_DMODE_D8)
      n = 1;
   else if (vme->dmode == MVME_DMODE_D16)
      n = 2;
   else
      n = 4;

   data = 0;
   status = bt_read(ptab->btd, &data, vme_addr, n, (size_t *)&n);
   if (status != BT_SUCCESS)
      bt_perror(ptab->btd, status, "bt_read error");

   return data;
}
Exemplo n.º 4
0
int main (void)
{		
	init_pins();
	char* bt_data = bt_init();
	
	
	
	
    pacer_init (LOOP_POLL_RATE);
	pio_output_set(PIO_AUX_ENABLE, 0);
	
	short aux_power = 0;
    while (1)
    {		
		pacer_wait ();
		
		pio_output_set(PIO_LED_G, bt_connected());
		
		if (bt_read()) {
			process_command(bt_data);
		}
	}		
}
Exemplo n.º 5
0
/**
 * NOTE: The technique is not the same as that used in TinyVM.
 * The return value indicates the impact of the call on the VM
 * system. EXEC_CONTINUE normal return the system should return to the return
 * address provided by the VM. EXEC_RUN The call has modified the value of
 * VM PC and this should be used to restart execution. EXEC_RETRY The call
 * needs to be re-tried (typically for a GC failure), all global state
 * should be left intact, the PC has been set appropriately.
 *
 */
int dispatch_native(TWOBYTES signature, STACKWORD * paramBase)
{
  STACKWORD p0 = paramBase[0];
  switch (signature) {
  case wait_4_5V:
    return monitor_wait((Object *) word2ptr(p0), 0);
  case wait_4J_5V:
    return monitor_wait((Object *) word2ptr(p0), ((int)paramBase[1] > 0 ? 0x7fffffff : paramBase[2]));
  case notify_4_5V:
    return monitor_notify((Object *) word2ptr(p0), false);
  case notifyAll_4_5V:
    return monitor_notify((Object *) word2ptr(p0), true);
  case start_4_5V:
    // Create thread, allow for instruction restart
    return init_thread((Thread *) word2ptr(p0));
  case yield_4_5V:
    schedule_request(REQUEST_SWITCH_THREAD);
    break;
  case sleep_4J_5V:
    sleep_thread(((int)p0 > 0 ? 0x7fffffff : paramBase[1]));
    schedule_request(REQUEST_SWITCH_THREAD);
    break;
  case getPriority_4_5I:
    push_word(get_thread_priority((Thread *) word2ptr(p0)));
    break;
  case setPriority_4I_5V:
    {
      STACKWORD p = (STACKWORD) paramBase[1];

      if (p > MAX_PRIORITY || p < MIN_PRIORITY)
	return throw_new_exception(JAVA_LANG_ILLEGALARGUMENTEXCEPTION);
      else
	set_thread_priority((Thread *) word2ptr(p0), p);
    }
    break;
  case currentThread_4_5Ljava_3lang_3Thread_2:
    push_ref(ptr2ref(currentThread));
    break;
  case interrupt_4_5V:
    interrupt_thread((Thread *) word2ptr(p0));
    break;
  case interrupted_4_5Z:
    {
      JBYTE i = currentThread->interruptState != INTERRUPT_CLEARED;

      currentThread->interruptState = INTERRUPT_CLEARED;
      push_word(i);
    }
    break;
  case isInterrupted_4_5Z:
    push_word(((Thread *) word2ptr(p0))->interruptState
	      != INTERRUPT_CLEARED);
    break;
  case join_4_5V:
    join_thread((Thread *) word2ptr(p0), 0);
    break;
  case join_4J_5V:
    join_thread((Thread *) word2obj(p0), paramBase[2]);
    break;
  case halt_4I_5V:
    schedule_request(REQUEST_EXIT);
    break;
  case shutdown_4_5V:
    shutdown_program(false);
    break;
  case currentTimeMillis_4_5J:
    push_word(0);
    push_word(systick_get_ms());
    break;
  case readSensorValue_4I_5I:
    push_word(sp_read(p0, SP_ANA));
    break;
  case setPowerTypeById_4II_5V:
    sp_set_power(p0, paramBase[1]);
    break;
  case freeMemory_4_5J:
    push_word(0);
    push_word(getHeapFree());
    break;
  case totalMemory_4_5J:
    push_word(0);
    push_word(getHeapSize());
    break;
  case floatToRawIntBits_4F_5I:	// Fall through
  case intBitsToFloat_4I_5F:
    push_word(p0);
    break;
  case doubleToRawLongBits_4D_5J:	// Fall through
  case longBitsToDouble_4J_5D:
    push_word(p0);
    push_word(paramBase[1]);
    break;
  case drawString_4Ljava_3lang_3String_2II_5V:
    {
      String *p = (String *)word2obj(p0);
      Object *charArray;
      if (!p) return throw_new_exception(JAVA_LANG_NULLPOINTEREXCEPTION);
      charArray = (Object *) word2ptr(get_word_4_ns(fields_start(p)));
      if (!charArray) return throw_new_exception(JAVA_LANG_NULLPOINTEREXCEPTION);
      display_goto_xy(paramBase[1], paramBase[2]);
      display_jstring(p);
    }
    break;
  case drawInt_4III_5V:
    display_goto_xy(paramBase[1], paramBase[2]);
    display_int(p0, 0);
    break;
  case drawInt_4IIII_5V:
     display_goto_xy(paramBase[2], paramBase[3]);
     display_int(p0, paramBase[1]);
    break;   
  case asyncRefresh_4_5V:
    display_update();
    break;
  case clear_4_5V:
    display_clear(0);
    break;
  case getDisplay_4_5_1B:
    push_word(display_get_array());
    break;
  case setAutoRefreshPeriod_4I_5I:
    push_word(display_set_auto_update_period(p0));
    break;
  case getRefreshCompleteTime_4_5I:
    push_word(display_get_update_complete_time());
    break;
  case bitBlt_4_1BIIII_1BIIIIIII_5V:
    {
      Object *src = word2ptr(p0);
      Object *dst = word2ptr(paramBase[5]);
      display_bitblt((byte *)(src != NULL ?jbyte_array(src):NULL), paramBase[1], paramBase[2], paramBase[3], paramBase[4], (byte *)(dst!=NULL?jbyte_array(dst):NULL), paramBase[6], paramBase[7], paramBase[8], paramBase[9], paramBase[10], paramBase[11], paramBase[12]);
      break;
    }
  case getSystemFont_4_5_1B:
    push_word(display_get_font());
    break;
  case setContrast_4I_5V:
    nxt_lcd_set_pot(p0);
    break;
  case getBatteryStatus_4_5I:
    push_word(battery_voltage());
    break;
  case getButtons_4_5I:
    push_word(buttons_get());
    break;
  case getTachoCountById_4I_5I:
    push_word(nxt_motor_get_count(p0));
    break;
  case controlMotorById_4III_5V:
    nxt_motor_set_speed(p0, paramBase[1], paramBase[2]); 
    break;
  case resetTachoCountById_4I_5V:
    nxt_motor_set_count(p0, 0);
    break;
  case i2cEnableById_4II_5V:
    if (i2c_enable(p0, paramBase[1]) == 0)
      return EXEC_RETRY;
    else
      break;
  case i2cDisableById_4I_5V:
    i2c_disable(p0);
    break;
  case i2cStatusById_4I_5I:
    push_word(i2c_status(p0));
    break;
  case i2cStartById_4II_1BIII_5I:
    {
    	Object *p = word2obj(paramBase[2]);
    	JBYTE *byteArray = p ? jbyte_array(p) + paramBase[3] : NULL;
    	push_word(i2c_start(p0,
    	                    paramBase[1],
    	                    (U8 *)byteArray,
    	                    paramBase[4],
    	                    paramBase[5]));
    }
    break; 
  case i2cCompleteById_4I_1BII_5I:
    {
    	Object *p = word2ptr(paramBase[1]);
    	JBYTE *byteArray = p ? jbyte_array(p) + paramBase[2] : NULL;
    	push_word(i2c_complete(p0,
    	                       (U8 *)byteArray,
    	                       paramBase[3]));
    }
    break; 
  case playFreq_4III_5V:
    sound_freq(p0,paramBase[1], paramBase[2]);
    break;
  case btGetBC4CmdMode_4_5I:
    push_word(bt_get_mode());
    break;
  case btSetArmCmdMode_4I_5V:
    if (p0 == 0) bt_set_arm7_cmd();
    else bt_clear_arm7_cmd(); 
    break;
  case btSetResetLow_4_5V:
    bt_set_reset_low();
    break;
  case btSetResetHigh_4_5V:
    bt_set_reset_high();
    break;
  case btWrite_4_1BII_5I:
    {
      Object *p = word2ptr(p0);
      byte *byteArray = (byte *) jbyte_array(p);
      push_word(bt_write(byteArray, paramBase[1], paramBase[2]));                      
    }
    break;
  case btRead_4_1BII_5I:
    {
      Object *p = word2ptr(p0);
      byte *byteArray = (byte *) jbyte_array(p);
      push_word(bt_read(byteArray, paramBase[1], paramBase[2]));                      
    }
    break;
  case btPending_4_5I:
    {
      push_word(bt_event_check(0xffffffff));
    }
    break;
  case btEnable_4_5V:
    if (bt_enable() == 0)
      return EXEC_RETRY;
    else
      break;
  case btDisable_4_5V:
    bt_disable();
    break;
  case usbRead_4_1BII_5I:
     {
      Object *p = word2ptr(p0);
      byte *byteArray = (byte *) jbyte_array(p);
      push_word(udp_read(byteArray,paramBase[1], paramBase[2]));
    } 
    break;
  case usbWrite_4_1BII_5I:
     {
      Object *p = word2ptr(p0);
      byte *byteArray = (byte *) jbyte_array(p);
      push_word(udp_write(byteArray,paramBase[1], paramBase[2]));                      
    }
    break; 
  case usbStatus_4_5I:
    {
      push_word(udp_event_check(0xffffffff));
    }
    break;
  case usbEnable_4I_5V:
    {
      udp_enable(p0);
    }
    break;
  case usbDisable_4_5V:
    {
      udp_disable();
    }
    break;
  case usbReset_4_5V:
    udp_reset();
    break; 
  case usbSetSerialNo_4Ljava_3lang_3String_2_5V: 
    {
      byte *p = word2ptr(p0);
      int len;
      Object *charArray = (Object *) word2ptr(get_word_4_ns(fields_start(p)));

      len = get_array_length(charArray);
      udp_set_serialno((U8 *)jchar_array(charArray), len);
    }
    break;
  case usbSetName_4Ljava_3lang_3String_2_5V:
    {
      byte *p = word2ptr(p0);
      int len;
      Object *charArray = (Object *) word2ptr(get_word_4_ns(fields_start(p)));

      len = get_array_length(charArray);
      udp_set_name((U8 *)jchar_array(charArray), len);
    }
    break;
  case flashWritePage_4_1BI_5I:
    {
      Object *p = word2ptr(p0);
      unsigned long *intArray = (unsigned long *) jint_array(p);
      push_word(flash_write_page(intArray,paramBase[1]));                      
    }
    break;
  case flashReadPage_4_1BI_5I:
    {
      Object *p = word2ptr(p0);
      unsigned long *intArray = (unsigned long *) jint_array(p);
      push_word(flash_read_page(intArray,paramBase[1]));                      
    }
    break;
  case flashExec_4II_5I:
    push_word(run_program((byte *)(&FLASH_BASE[(p0*FLASH_PAGE_SIZE)]), paramBase[1]));
    break;
  case playSample_4IIIII_5V:
    sound_play_sample(((unsigned char *) &FLASH_BASE[(p0*FLASH_PAGE_SIZE)]) + paramBase[1],paramBase[2],paramBase[3],paramBase[4]);
    break;
  case playQueuedSample_4_1BIIII_5I:
    push_word(sound_add_sample((U8 *)jbyte_array(word2obj(p0)) + paramBase[1],paramBase[2],paramBase[3],paramBase[4]));
    break;
  case getTime_4_5I:
    push_word(sound_get_time());
    break;
  case getDataAddress_4Ljava_3lang_3Object_2_5I:
    if (is_array(word2obj(p0)))
      push_word (ptr2word ((byte *) array_start(word2ptr(p0))));
    else
      push_word (ptr2word ((byte *) fields_start(word2ptr(p0))));
    break;
  case getObjectAddress_4Ljava_3lang_3Object_2_5I:
    push_word(p0);
    break;
  case gc_4_5V:
    // Restartable garbage collection
    return garbage_collect();
  case shutDown_4_5V:
    shutdown(); // does not return
  case boot_4_5V:
    display_clear(1);
    while (1) nxt_avr_firmware_update_mode(); // does not return 
  case arraycopy_4Ljava_3lang_3Object_2ILjava_3lang_3Object_2II_5V:
    return arraycopy(word2ptr(p0), paramBase[1], word2ptr(paramBase[2]), paramBase[3], paramBase[4]);
  case executeProgram_4I_5V:
    // Exceute program, allow for instruction re-start
    return execute_program(p0);
  case setDebug_4_5V:
    set_debug(word2ptr(p0));
    break;
  case eventOptions_4II_5I:
    {
      byte old = debugEventOptions[p0];
      debugEventOptions[p0] = (byte)paramBase[1];
      push_word(old);
    }
    break;
  case suspendThread_4Ljava_3lang_3Object_2_5V:
    suspend_thread(ref2ptr(p0));
    break;
  case resumeThread_4Ljava_3lang_3Object_2_5V:
    resume_thread(ref2ptr(p0));
    break;
  case getProgramExecutionsCount_4_5I:
    push_word(gProgramExecutions);
    break;
  case getFirmwareRevision_4_5I:
    push_word((STACKWORD) getRevision());
    break;
  case getFirmwareRawVersion_4_5I:
    push_word((STACKWORD) VERSION_NUMBER); 
    break;
  case hsEnable_4II_5V:
    {
      if (hs_enable((int)p0, (int)paramBase[1]) == 0)
        return EXEC_RETRY;
    }
    break;
  case hsDisable_4_5V:
    {
      hs_disable();
    }
    break;
  case hsWrite_4_1BII_5I:
    {
      Object *p = word2ptr(p0);
      byte *byteArray = (byte *) jbyte_array(p);
      push_word(hs_write(byteArray, paramBase[1], paramBase[2]));                      
    }
    break;
  case hsRead_4_1BII_5I:
    {
      Object *p = word2ptr(p0);
      byte *byteArray = (byte *) jbyte_array(p);
      push_word(hs_read(byteArray, paramBase[1], paramBase[2]));                      
    }
    break;
  case hsPending_4_5I:
    {
      push_word(hs_pending());
    }
    break;
  case hsSend_4BB_1BII_1C_5I:
    {
      Object *p = word2ptr(paramBase[2]);
      U8 *data = (U8 *)jbyte_array(p);
      p = word2ptr(paramBase[5]);
      U16 *crc = (U16 *)jchar_array(p);
      push_word(hs_send((U8) p0, (U8)paramBase[1], data, paramBase[3], paramBase[4], crc));
    }
    break;
  case hsRecv_4_1BI_1CI_5I:
    {
      Object *p = word2ptr(p0);
      U8 *data = (U8 *)jbyte_array(p);
      p = word2ptr(paramBase[2]);
      U16 *crc = (U16 *)jchar_array(p);
      push_word(hs_recv(data, paramBase[1], crc, paramBase[3]));
    }
    break;
    
  case getUserPages_4_5I:
    push_word(FLASH_MAX_PAGES - flash_start_page);
    break;
  case setVMOptions_4I_5V:
    gVMOptions = p0;
    break;
  case getVMOptions_4_5I:
    push_word(gVMOptions);
    break;
  case isAssignable_4II_5Z:
    push_word(is_assignable(p0, paramBase[1]));
    break;
  case cloneObject_4Ljava_3lang_3Object_2_5Ljava_3lang_3Object_2:
    {
      Object *newObj = clone((Object *)ref2obj(p0));
      if (newObj == NULL) return EXEC_RETRY;
      push_word(obj2ref(newObj));
    }
    break;
  case memPeek_4III_5I:
    push_word(mem_peek(p0, paramBase[1], paramBase[2]));
    break;
  case memCopy_4Ljava_3lang_3Object_2IIII_5V:
    mem_copy(word2ptr(p0), paramBase[1], paramBase[2], paramBase[3], paramBase[4]);
    break;
  case memGetReference_4II_5Ljava_3lang_3Object_2:
    push_word(mem_get_reference(p0, paramBase[1]));
    break;
  case setSensorPin_4III_5V:
    sp_set(p0, paramBase[1], paramBase[2]);
    break;
  case getSensorPin_4II_5I:
    push_word(sp_get(p0, paramBase[1]));
    break;
  case setSensorPinMode_4III_5V:
    sp_set_mode(p0, paramBase[1], paramBase[2]);
    break;
  case readSensorPin_4II_5I:
    push_word(sp_read(p0, paramBase[1]));
    break;
  case nanoTime_4_5J:
    {
      U64 ns = systick_get_ns();
      push_word(ns >> 32);
      push_word(ns);
    }
    break;
  case createStackTrace_4Ljava_3lang_3Thread_2Ljava_3lang_3Object_2_5_1I:
    {
      Object *trace = create_stack_trace((Thread *)ref2obj(p0), ref2obj(paramBase[1]));
      if (trace == NULL) return EXEC_RETRY;
      push_word(obj2ref(trace));
    }
    break;
  case registerEvent_4_5I:
    push_word(register_event((NXTEvent *) ref2obj(p0)));
    break;
  case unregisterEvent_4_5I:
    push_word(unregister_event((NXTEvent *) ref2obj(p0)));
    break;
  case changeEvent_4II_5I:
    push_word(change_event((NXTEvent *) ref2obj(p0), paramBase[1], paramBase[2]));
    break;
  case isInitialized_4I_5Z:
    push_word(is_initialized_idx(p0));
    break;
  case allocate_4II_5Ljava_3lang_3Object_2:
    {
      Object *allocated;
      if(paramBase[1]>0){
        allocated=new_single_array(p0,paramBase[1]);
      }else{
        allocated=new_object_for_class(p0);
      }
      if(allocated == NULL) return EXEC_RETRY;
      push_word(obj2ref(allocated));
    }
    break;
  case memPut_4IIII_5V:
    store_word_ns((byte *)(memory_base[p0] + paramBase[1]), paramBase[2],paramBase[3]);
    break;
  case notifyEvent_4ILjava_3lang_3Thread_2_5Z:
    push_word(debug_event(paramBase[1], NULL, (Thread*) ref2obj(paramBase[2]), 0, 0, 0, 0));
    break;
  case setThreadRequest_4Ljava_3lang_3Thread_2Llejos_3nxt_3debug_3SteppingRequest_2_5V:
    {
      Thread *th = (Thread*) ref2obj(p0);
      th->debugData = (REFERENCE) paramBase[1];
      // currently we only get stepping requests
      if(paramBase[1])
        th->flags |= THREAD_STEPPING;
      else
        th->flags &= ~THREAD_STEPPING;
    }
    break;
  case isStepping_4Ljava_3lang_3Thread_2_5Z:
    {
      Thread *th = (Thread*) ref2obj(p0);
      push_word(is_stepping(th));
    }
    break;
  case setBreakpointList_4_1Llejos_3nxt_3debug_3Breakpoint_2I_5V:
    breakpoint_set_list((Breakpoint**) array_start(p0), paramBase[1]);
    break;
  case enableBreakpoint_4Llejos_3nxt_3debug_3Breakpoint_2Z_5V:
    breakpoint_enable((Breakpoint*) word2ptr(p0), (boolean) paramBase[1]);
    break;
  case firmwareExceptionHandler_4Ljava_3lang_3Throwable_2II_5V:
    firmware_exception_handler((Throwable *)p0, paramBase[1], paramBase[2]);
    break;
  case exitThread_4_5V:
    currentThread->state = DEAD;
    schedule_request(REQUEST_SWITCH_THREAD);
    break;
  case updateThreadFlags_4Ljava_3lang_3Thread_2II_5I:
    ((Thread *)p0)->flags |= paramBase[1];
    ((Thread *)p0)->flags &= ~paramBase[2];
//printf("m %x %d\n", p0, ((Thread *)p0)->flags);
    push_word(((Thread *)p0)->flags);
    break;
    
  default:
    return throw_new_exception(JAVA_LANG_NOSUCHMETHODERROR);
  }
  return EXEC_CONTINUE;
}
Exemplo n.º 6
0
int main(void) 
{
 	key_t		skey=SEMAPHORE_KEY;
	int			nsems=NSEM;
	int			semid;
	int			semno;

   	union		semun {
      	int 			val;
      	struct 			semid_ds *buf;
      	unsigned short 	*array;
   	} arg;
	int       shmid1, shmid2;
	int       shmemsize=BUFFER_LENGTH;
	int       *shm1ptr, *shm2ptr;
	key_t     bkey=SHAREDMEM_KEY;
	key_t     mkey=MESSAGE_KEY;
	int       i;
	FILE      *strm;
	int       fd;
	int       exades;                /* File descriptor for Exabyte            */
	int       opendes;               /* File descripter of opened file         */
	int       new_des_min = 10;      /* Offset for new file descriptor ?       */
	int       write_data = 0;        /* Write raw data to tape or not          */
	ssize_t   bytes_written;

   	int       	*bufp;                 	/* Pointer to databuffer in shared memory	*/
   	int       	*messp;                	/* Pointer to message_box in shared memory	*/
   	int       	*buf1p, *buf2p, *buf3p, *buf4p;

   	long      	message_length = 40;   	/* VME Message_Box is 10 Words long			*/
   	long      	*mess_p;               	/* Pointer to Message_Box					*/

   	long      	movebytes;            	/* Length (bytes) of movebuffer from RIO3	*/
   	long      	Message_Box[10];      	/* Vector to hold Message_Box				*/
   	unsigned long moveaddress;     		/* Data buffer address in VME				*/
   	long      	*sem1ptr;             	/* Pointer to VME semaphore 1				*/
   	long      	*sem2ptr;             	/* Pointer to VME semaphore 2				*/
   	long      	*sem3ptr;             	/* Pointer to VME semaphore 3				*/
   	long      	*sem4ptr;             	/* Pointer to VME semaphore 4				*/
   	long      	sem1val, sem2val, sem3val, sem4val;
  	long      	*engstatptr;
   	long      	engstatval;
   	long      	semph1, semph2, semph3, semph4, tiger, stbox;

   	int       	*sortp;               	/* Pointer to message_box(0) - sort flag	*/
   	int       	*engp;                	/* Pointer to message_box(1) - engine flag	*/
   	int       	*stgp;                	/* Pointer to message_box(2) - storage		*/
   	int       	*vmesp;               	/* Pointer to message_box(3) - VME status	*/
   	int       	*recp;                	/* Pointer to message_box(5) - record count	*/
   	int       	sort_off      = 0;    	/* Offset for pointer to message_box[0]		*/
   	int       	engine_off    = 1;    	/* Offset for pointer to message_box[1]		*/
   	int       	stgflag_off   = 2;    	/* Offset for pointer to message_box[2]		*/
   	int       	vmes_off      = 3;    	/* Offset for pointer to message_box[3]		*/
   	int       	reccount_off  = 5;    	/* Offset for pointer to message_box[5]		*/
   	int       	part_offset   = 8192; 	/* Pointer off in databuffer part			*/

    size_t		amt_read;				/* Amount of data read from device			*/
 
   	arg.buf 	= (void *) malloc (100); 
   	mess_p  	= &Message_Box[0];
   	sem1ptr 	= &sem1val;
   	sem2ptr 	= &sem2val;
   	sem3ptr 	= &sem3val;
   	sem4ptr 	= &sem4val;
    engstatptr 	= &engstatval;
	
   	/* Check if the engine lock-file is present, create if not. This is */
   	/* a security precaution, multiple engine processes cause system crash*/
   	if((fd = open("/Applications/sirius/system/engine.lock",O_CREAT|O_EXCL,PERMS)) == -1 )
   	{
      	printf("Engine ERROR: Could not start engine due to lock file /Applications/sirius/system/engine.lock\n");
      	exit(errno);
   	}

   	/* Get semaphore identifier */
   	semid = semget(skey, nsems, PERMS );
   	if (semid == -1) {
      	printf("Engine ERROR: Get semaphore identifier failed \n");
      	exit(errno);
   	}  

   	/* Initialize VME front-end system link */
   	if (vme_open() != 0) {
      	printf("Engine ERROR: Could not initialize and open SBS VME-PCI interface\n");
      	exit(errno);
   	}
	
	/* Attach shared message_box segment to process */
   	shmemsize = 80;
   	shmid2 = shmget(mkey, shmemsize, PERMS);
   	if (shmid2 == -1) {
      	printf("Engine ERROR: Shared message_box memory allocation failed\n");
      	exit(errno);
  		}

   	shm2ptr = shmat(shmid2, NULL, 0);
   	if (*shm2ptr == -1) {
      	printf("Engine ERROR: Attach shared message_box to process failed\n");
      	exit(errno);
   	} 
	
   	/* Attach shared data buffer segment to process */
   	shmemsize = BUFFER_LENGTH;
   	shmid1 = shmget(bkey, shmemsize, IPC_CREAT | PERMS);
   	if (shmid1 == -1) {
      	printf("Engine ERROR: Shared data buffer memory allocation failed %d\n", errno);
      	exit(errno);
   	}

   	shm1ptr = shmat(shmid1, NULL, 0);
   	if (*shm1ptr == -1) {
      	printf("Engine ERROR: Attach shared data buffer to process failed\n");
      	exit(errno);
   	} 

   	/* Take a copy of the pointers to shared memory segments           */
   	bufp  = shm1ptr;          /* Points to databuffer in shared memory */
   	messp = shm2ptr;          /* Points to message_box n shared memory */

   	/* Pointers used in write to Exabyte, buffer is divided into 4     */
   	buf1p = shm1ptr;                 /* Points to part 1 of databuffer */
   	buf2p = shm1ptr + part_offset;   /* Points to part 2 of databuffer */
   	buf3p = shm1ptr + part_offset*2; /* Points to part 3 of databuffer */
   	buf4p = shm1ptr + part_offset*3; /* Points to part 4 of databuffer */

   	/* Initialize pointers to message_box variables */
   	sortp = messp + sort_off;
   	recp  = messp + reccount_off;
   	stgp  = messp + stgflag_off;
   	engp  = messp + engine_off;
   	vmesp = messp + vmes_off;

   	/* Clear data buffer segment */
   	for (i = 0; i < 32768; i++)  {  
      	*(bufp+i) = 0;
   	} 
   	bufp = shm1ptr;									/* Restore pointer	*/

   	/* Signal to VME front-end system that the acquisition is running	*/
   	/* This is done by setting the VME Message_Box[1] to '1'            */
   	engstatval = 1;
   	status = bt_write(btd, engstatptr, ENGSTATUS, 4, &amt_read);
	if ( BT_SUCCESS != status) { /* At first VME write failure, we print out a lot of errors*/
        if (amt_read != 4) {
            fprintf(stderr, "Engine ERROR: Only %d bytes written to SBS VME-PCI.\n", (int) amt_read);
        }
        else {
            fprintf(stderr, "Engine ERROR: Could not write to %s.\n", &devname[0]);
        }
        bt_perror(btd, status, "Engine ERROR: Could not write engine status to SBS VME-PCI");
        vme_close();
        return EXIT_FAILURE;
    }
   

   	/* Read the whole VME Message_box to get info from bobcat (installed in the VME crate) */
   	status = bt_read(btd, mess_p, MESSAGE_ADDRESS, message_length, &amt_read);
	if ( BT_SUCCESS != status) { /* At first VME read error, we print out a lot of messages*/
        if (amt_read != message_length) {
            fprintf(stderr, "Engine ERROR: Only %d bytes read from device.\n", (int) amt_read);
        }
        else {
            fprintf(stderr, "Engine ERROR: Could not read from %s.\n", &devname[0]);
        }
        bt_perror(btd, status, "Engine ERROR: Could not read VME Message_box from VME A24 memory");
        vme_close();
        return EXIT_FAILURE;
    }

   	if ( Message_Box[6] == 1) {
      	*vmesp = 1;                     /* VME system is in running state */
   	}else {
      	*vmesp = 0;
   	}
   	movebytes = BUFFER_LENGTH/4;      	/* Bufferlength is in bytes */
   	moveaddress = Message_Box[0];		/* Address of VME A24 event buffer */

   	/* Write status to file /help/vmestatus.tmp */
   	strm = fopen("/Applications/sirius/help/vmestatus.tmp","w");
   	if ( Message_Box[6] == 1 ) {
      	fprintf(strm," VME system status\t\t: RUNNING\n");
   	}
   	else if ( Message_Box[6] == 0 ) {
      	fprintf(strm," VME system status\t\t: STOPPED\n");
   	}else {
      	fprintf(strm," VME system status\t\t: UNKNOWN ?\n");
   	}
   	fprintf(strm, " Buffer address\t\t: %lx (hex) \n", moveaddress);
   	fprintf(strm, " Buffer length\t\t: %lx (hex) \n", Message_Box[1]);
	fprintf(strm," ---------------------------------------------\n");
   	fclose( strm );

   	/* Take a copy of the file descriptor for storage unit if used */
   	if (*stgp > 0) {
      	opendes = *stgp;
      	exades = fcntl( opendes, F_DUPFD, new_des_min );
      	write_data = 1;
      	if ( exades == -1) {
         	perror("\n Engine ERROR: Could not copy file descriptor \n");
         	write_data = 0;
      	}
   	}

   	semph1 = Message_Box[2]&0x00000001;               /*Test on the last 4 bits*/
   	semph2 = Message_Box[3]&0x00000001;
   	semph3 = Message_Box[4]&0x00000001;               /*Test on the last 4 bits*/
   	semph4 = Message_Box[5]&0x00000001;
   	tiger  = Message_Box[7]&0x00000001;
   	stbox  = MESSAGE_ADDRESS;
	
	printf("\n --------------------------------------------------------- \n");
   	printf(  "|                    E N G I N E 1.0                      |\n");
	printf(  "|                     Apr. 10. 2008                       |\n");
	printf(  "|---------------------------------------------------------|\n");
   	printf(  "| VME message box starts at                  : 0x%8lx |\n",stbox);
   	printf(  "| Buffer starts at                           : 0x%8lx |\n",moveaddress);
   	printf(  "| Start of buffer address     (messagebox 0) : 0x%8lx |\n",Message_Box[0]);
   	printf(  "| Buffer length (words)       (messagebox 1) :   %8ld |\n",Message_Box[1]);
   	printf(  "| Semaphore # 1               (messagebox 2) :   %8ld |\n",semph1);
   	printf(  "| Semaphore # 2               (messagebox 3) :   %8ld |\n",semph2);
   	printf(  "| Semaphore # 3               (messagebox 4) :   %8ld |\n",semph3);
   	printf(  "| Semaphore # 4               (messagebox 5) :   %8ld |\n",semph4);
   	printf(  "| VME ready(1) or not(0)      (messagebox 6) :   %8ld |\n",Message_Box[6]);
   	printf(  "| Linux ready(1) or not(0)    (messagebox 7) :   %8ld |\n",tiger);
   	printf(  "| Not used                    (messagebox 8) :   %8ld |\n",Message_Box[8]);
   	printf(  "| Not used                    (messagebox 9) :   %8ld |\n",Message_Box[9]);
	printf(  " --------------------------------------------------------- \n");

   	for(;;) {                               /*MAIN DATA ACQUISITION LOOP*/
		if ( *engp == 9 ) goto exitengine;   /*STOP COMMAND FROM MASTER */

/**********************************************************************	*/
/*                            B U F F E R                              	*/
/*:::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::	*/
/* 	Since A32 slave DRAM gives crash 									*/
/*  after typically 2 - 5 hours, we use A24 SRAM. However, this space  	*/
/*  is only 128 kbytes. Thus, we cannot use the 2 buffer technique   	*/
/*  from the original version designed by Tore Ramsoey. We				*/
/*  have to segment 1 eventbuffer (32 kwords) into 4 movebuffers,      	*/
/*  each 32 kbytes. Tests show that this is almost as fast as before,  	*/
/*  and no more crashes of the eventbuilder running on bobcat RIO2!!!  	*/
/*  First buffer is called for every 100 us, the next three other		*/
/*  buffers is called for every 1 us.									*/
/*:::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::	*/

/************************************************************************/ 
/*1.0 Check if movebuffer is ready                                     	*/
/*		Loop on VME semaphore #	1 until it becomes 1 (FULL)				*/
/*		The call to usleep suspends the process 100 us                  */
		for (;;) {
			status = bt_read(btd, sem1ptr, SEM_1, 4, &amt_read);
			if ( BT_SUCCESS != status) {
				bt_perror(btd, status, "Engine ERROR: Could not read VME semaphore # 1");
				vme_close();
				return EXIT_FAILURE;
			}
			if (sem1val == 1 ) break;				/* Buffer in VME is FULL, go and fetch it		*/    
			if (*engp	== 9) goto exitengine;		/* User has requested to stop acquisition		*/
			usleep(100);							/* Buffer is EMPTY, continue asking (polling)	*/
		}

/*1.1 Signal the sorting task to disrupt sorting						*/
/*		This is done by setting message_box[0] to '3'                   */
		*sortp = 3;

/*1.2 Fetch movebuffer #1 from the VMEbus system						*/
		status = bt_read(btd, bufp + 0x0000, moveaddress, movebytes, &amt_read);
		if ( BT_SUCCESS != status) {
			bt_perror(btd, status, "Engine ERROR: Could not read VME event buffer 1");
			vme_close();
			return EXIT_FAILURE;
		}

/*1.3 Reset VMEbus semaphore # 1 to empty								*/
		sem1val = 0;
		status = bt_write(btd, sem1ptr, SEM_1, 4, &amt_read);
		if ( BT_SUCCESS != status) {
			bt_perror(btd, status, "Engine ERROR: Could not reset VME semaphore # 1 to empty");
			vme_close();
			return EXIT_FAILURE;
		}

/************************************************************************/ 
/*2.0 Check if movebuffer is ready                                     	*/
/*		Loop on VME semaphore # 2 until it becomes 1 (FULL)				*/
/*		The call to usleep suspends the process 1 us                    */
		for (;;) {
			status = bt_read(btd, sem2ptr, SEM_2, 4, &amt_read);
			if ( BT_SUCCESS != status) {
				bt_perror(btd, status, "Engine ERROR: Could not read VME semaphore # 2");
				vme_close();
				return EXIT_FAILURE;
			}
			if (sem2val == 1 ) break;				/* Buffer in VME is FULL, go and fetch it		*/    
			if (*engp	== 9) goto exitengine;		/* User has requested to stop acquisition		*/
			usleep(1);								/* Buffer is EMPTY, continue asking (polling)	*/
		}

/*2.1 Signal the sorting task to disrupt sorting						*/
/*		This is done by setting message_box[0] to	3                   */
		*sortp = 3;

/*2.2 Fetch movebuffer #2 from the VMEbus system						*/
		status = bt_read(btd, bufp + 0x2000, moveaddress, movebytes, &amt_read);
		if ( BT_SUCCESS != status) {
			bt_perror(btd, status, "Engine ERROR: Could not read VME event buffer 2");
			vme_close();
			return EXIT_FAILURE;
		}

/*2.3 Reset VMEbus semaphore # 2 to empty								*/
		sem2val = 0;
		status = bt_write(btd, sem2ptr, SEM_2, 4, &amt_read);
		if ( BT_SUCCESS != status) {
			bt_perror(btd, status, "Engine ERROR: Could not reset VME semaphore # 2 to empty");
			vme_close();
			return EXIT_FAILURE;
		}
       
/************************************************************************/ 
/*3.0 Check if movebuffer is ready                                     	*/
/*		Loop on VME semaphore # 3 until it becomes 1 (FULL)				*/
/*		The call to usleep suspends the process 1 us                    */
		for (;;) {
			status = bt_read(btd, sem3ptr, SEM_3, 4, &amt_read);
			if ( BT_SUCCESS != status) {
				bt_perror(btd, status, "Engine ERROR: Could not read VME semaphore # 3");
				vme_close();
				return EXIT_FAILURE;
			}
			if (sem3val == 1 ) break;				/* Buffer in VME is FULL, go and fetch it		*/    
			if (*engp	== 9) goto exitengine;		/* User has requested to stop acquisition		*/
			usleep(1);								/* Buffer is EMPTY, continue asking (polling)	*/
		}

/*3.1 Signal the sorting task to disrupt sorting						*/
/*		This is done by setting message_box[0] to 3						*/
		*sortp = 3;

/*3.2 Fetch movebuffer #3 from the VMEbus system						*/
		status = bt_read(btd, bufp + 0x4000, moveaddress, movebytes, &amt_read);
		if ( BT_SUCCESS != status) {
			bt_perror(btd, status, "Engine ERROR: Could not read VME event buffer 3");
			vme_close();
			return EXIT_FAILURE;
		}

/*3.3 Reset VMEbus semaphore # 3 to empty								*/
		sem3val = 0;
		status = bt_write(btd, sem3ptr, SEM_3, 4, &amt_read);
		if ( BT_SUCCESS != status) {
			bt_perror(btd, status, "Engine ERROR: Could not reset VME semaphore #3 to empty");
			vme_close();
			return EXIT_FAILURE;
		}
		
/************************************************************************/ 
/*4.0 Check if movebuffer is ready                                     	*/
/*		Loop on VME semaphore # 4 until it becomes 1 (FULL)				*/
/*		The call to usleep suspends the process 1 us                    */
		for (;;) {
			status = bt_read(btd, sem4ptr, SEM_4, 4, &amt_read);
			if ( BT_SUCCESS != status) {
				bt_perror(btd, status, "Engine ERROR: Could not read VME semaphore # 4");
				vme_close();
				return EXIT_FAILURE;
			}
			if (sem4val == 1 ) break;				/* Buffer in VME is FULL, go and fetch it		*/    
			if (*engp	== 9) goto exitengine;		/* User has requested to stop acquisition		*/
			usleep(1);								/* Buffer is EMPTY, continue asking (polling)	*/
		}

/*4.1 Signal the sorting task to disrupt sorting						*/
/*		This is done by setting message_box[0] to 3						*/
		*sortp = 3;

/*4.2 Fetch movebuffer # 4 from the VMEbus system						*/
		status = bt_read(btd, bufp + 0x6000, moveaddress, movebytes, &amt_read);
		if ( BT_SUCCESS != status) {
			bt_perror(btd, status, "Engine ERROR: Could not read VME event buffer 4");
			vme_close();
			return EXIT_FAILURE;
		}

/*4.3 Reset VMEbus semaphore # 4 to empty								*/
		sem4val = 0;
		status = bt_write(btd, sem4ptr, SEM_4, 4, &amt_read);
		if ( BT_SUCCESS != status) {
			bt_perror(btd, status, "Engine ERROR: Could not reset VME semaphore # 4 to empty");
			vme_close();
			return EXIT_FAILURE;
		}


/* testing, magne
   for (i = 0; i < 32768; i++)  {  
   if(*(bufp+i) < 40000 ){
   printf(" no %d buffer read = %d \n",i, *(bufp+i) );}
   } 
   exit(0);
*/

/***********************************************************************/ 
/*5.0 Activate sorting task                                            */
/*		This is done by setting the sort semaphore to 0                */
		*sortp  = 0;                              /*Remove disrupt flag*/
		semno   = 0;
		arg.val = 0;
		if ( semctl(semid, semno, SETVAL, arg) == -1) {
			printf("Engine ERROR: Set Sort Semaphore to Zero Failed\n");
			exit(errno);
		}

/*6.0 Start dump of total eventbuffer to exabyte tape or disk			*/
/*		Buffer is segmented into 4 records, each 32 kbytes long			*/
		if ( write_data == 1 ) {
			bytes_written = write(exades, buf1p, RECORD_LENGTH);
			bytes_written = write(exades, buf2p, RECORD_LENGTH);
			bytes_written = write(exades, buf3p, RECORD_LENGTH);
			bytes_written = write(exades, buf4p, RECORD_LENGTH);
			if (bytes_written != RECORD_LENGTH) {
				printf("Engine ERROR: Could not write event buffer to disk (or tape)\n");
			}
		} 

/*7.0 Update record count message_box[9] variable						*/
		*recp = *recp + 1;
	}                               /*END OF MAIN DATA ACQUISITION LOOP	*/

	exitengine:

/*	Signal to VME front-end system that the acquisition is stopped		*/
/*	This is done by setting the VME Message_Box[1] to 0					*/
  	engstatval = 0;
   	status = bt_write(btd, engstatptr, ENGSTATUS, 4, &amt_read);
	if ( BT_SUCCESS != status) { 
		if (amt_read != 4) {
            fprintf(stderr, "Engine ERROR: Only %d bytes written to SBS VME-PCI\n", (int) amt_read);
        }
        else {
            fprintf(stderr, "Engine ERROR: Could not write to %s\n", &devname[0]);
        }
        bt_perror(btd, status, "Engine ERROR: Could not write engine status to SBS VME-PCI");
	}

/*	Detach shared memory */
	if ( shmdt( shm1ptr ) == -1) {
		printf("Engine ERROR: Could not detach databuffer shared memory\n");
	}
	if ( shmdt( shm2ptr ) == -1) {
		printf("Engine ERROR: Could not detach message_box shared memory\n");
	} 

/*	Remove the lock file */
	if ( remove("/Applications/sirius/system/engine.lock") == -1) {
		printf("Engine ERROR: Could not remove engine.lock file\n");      
	}

/* Closing VME front-end system */
	if (vme_close() != 0) {
		printf("Engine ERROR: Problems to close SBS VME_PCI\n");
		exit(errno);
	}
	exit(0);
}