unsigned char
i2c_inbyte(void)
{
	unsigned char aBitByte = 0;
	int i;

	/* Switch off I2C to get bit */
	i2c_disable();
	i2c_dir_in();
	i2c_delay(CLOCK_HIGH_TIME/2);

	/* Get bit */
	aBitByte |= i2c_getbit();

	/* Enable I2C */
	i2c_enable();
	i2c_delay(CLOCK_LOW_TIME/2);

	for (i = 1; i < 8; i++) {
		aBitByte <<= 1;
		/* Clock pulse */
		i2c_clk(I2C_CLOCK_HIGH);
		i2c_delay(CLOCK_HIGH_TIME);
		i2c_clk(I2C_CLOCK_LOW);
		i2c_delay(CLOCK_LOW_TIME);

		/* Switch off I2C to get bit */
		i2c_disable();
		i2c_dir_in();
		i2c_delay(CLOCK_HIGH_TIME/2);

		/* Get bit */
		aBitByte |= i2c_getbit();

		/* Enable I2C */
		i2c_enable();
		i2c_delay(CLOCK_LOW_TIME/2);
	}
	i2c_clk(I2C_CLOCK_HIGH);
	i2c_delay(CLOCK_HIGH_TIME);

        /*
	 * we leave the clock low, getbyte is usually followed
	 * by sendack/nack, they assume the clock to be low
	 */
        i2c_clk(I2C_CLOCK_LOW);
	return aBitByte;
}
Beispiel #2
0
void i2c_init(i2c_t *obj, PinName sda, PinName scl)
{
    /* Assign mbed pins */
    i2c_preinit(obj, sda, scl);

    /* Enable clock for the peripheral */
    CMU_ClockEnable(i2c_get_clock(obj), true);

    /* Initializing the I2C */
    /* Using default settings */
    I2C_Init_TypeDef i2cInit = I2C_INIT_DEFAULT;
    I2C_Init(obj->i2c.i2c, &i2cInit);

    /* Enable pins at correct location */
    obj->i2c.i2c->ROUTE = I2C_ROUTE_SDAPEN | I2C_ROUTE_SCLPEN | (obj->i2c.loc << _I2C_ROUTE_LOCATION_SHIFT);
    i2c_enable_pins(obj, true);

    /* Enable General Call Address Mode. That is; we respond to the general address (0x0) */
    obj->i2c.i2c->CTRL |= _I2C_CTRL_GCAMEN_MASK;

    /* We are assuming that there is only one master. So disable automatic arbitration */
    obj->i2c.i2c->CTRL |= _I2C_CTRL_ARBDIS_MASK;

    /* Enable i2c */
    i2c_enable(obj, true);
}
Beispiel #3
0
void initialize_i2c(void)
{
	i2c_str i2c_h;
	i2c_msg_str msg;
	uint8_t tab[2];

	i2c_init_str i2c;
	i2c.i2c_clock_val = 15;
	i2c.op_mode = I2C_MASTER;
	i2c.own_address = 0;
	i2c.rx_buffer_size = 6;
	i2c.tx_buffer_size = 2;

	i2c_h = i2c_init(&i2c);


	msg.destination_address = 0b1101000;
	msg.generate_stop_after_transmission = 1;
	msg.i2c_buffer = (uint8_t*)&tab;
	msg.i2c_buffer_length = 2;
	msg.i2c_op_mode = I2C_MASTER;

	tab[0] = 0x68;
	tab[1] = 0x10;

	i2c_enable(i2c_h);

	i2c_send(i2c_h, &msg);

}
Beispiel #4
0
void
accm_init(void) {
  if(!(_ADXL345_STATUS & INITED)){
    PRINTFDEBUG("ADXL345 init\n");
    _ADXL345_STATUS |= INITED;
    accm_int1_cb = NULL;
    accm_int2_cb = NULL;
    int1_event = process_alloc_event();
    int2_event = process_alloc_event();

    /* Set up ports and pins for interrups. */
    ADXL345_DIR  &=~ (ADXL345_INT1_PIN | ADXL345_INT2_PIN);
    ADXL345_SEL  &=~ (ADXL345_INT1_PIN | ADXL345_INT2_PIN);
    ADXL345_SEL2 &=~ (ADXL345_INT1_PIN | ADXL345_INT2_PIN);

    /* Set up ports and pins for I2C communication */
    i2c_enable();

    /* set default register values. */
    accm_write_stream(15, &adxl345_default_settings[0]);
    accm_write_stream(5, &adxl345_default_settings[15]);
    accm_write_reg(ADXL345_DATA_FORMAT, adxl345_default_settings[20]);
    accm_write_reg(ADXL345_FIFO_CTL, adxl345_default_settings[21]);

    process_start(&accmeter_process, NULL);

    /* Enable msp430 interrupts on the two interrupt pins. */
    dint();
    ADXL345_IES &=~ (ADXL345_INT1_PIN | ADXL345_INT2_PIN);   // low to high transition interrupts
    ADXL345_IE |= (ADXL345_INT1_PIN | ADXL345_INT2_PIN);     // enable interrupts
    eint();
  }
}
Beispiel #5
0
int sht21_humidity(void)
{
  int val;

  i2c_enable();
  /* For for about 15ms before the SHT11 can be used */
  sht21_timer = RTIMER_NOW();
  while(RTIMER_CLOCK_LT(RTIMER_NOW(), sht21_timer + (RTIMER_SECOND/1000)*15));

  buf[0] = 0xe5;
  i2c_transmitinit(0x40, 1, buf);
  while(!i2c_transferred()) ;

  /* Wait for measurement about 85ms */
  sht21_timer = RTIMER_NOW();
  while(RTIMER_CLOCK_LT(RTIMER_NOW(), sht21_timer + (RTIMER_SECOND/1000)*85));

  i2c_receiveinit(0x40, 3, buf);
  while(!i2c_transferred()) ;

  val = (int)(buf[0]<<24 | buf[1]<<16 | buf[2]<<8 | buf[3]);

//  i2c_disable();
  /* return relative humidity * 100 (0.04 % accuracy) */
  return (-6.0 + (125.0*((val>>16)&0x0000fffc))/0x10000)*100;
}
 void read_coefficients() {
   int16_t a0coeff;
   int16_t b1coeff;
   int16_t b2coeff;
   int16_t c12coeff;
   BAR_POWER_UP();
   i2c_enable();

   i2c_start();
   i2c_write((DEVICE_ADDRESS | WRITE));
   i2c_write((READ_COEFFICIENTS_COMMAND));

   i2c_start();
   i2c_write((DEVICE_ADDRESS | READ));

   a0coeff = (( (uint16_t) i2c_read(1) << 8) | i2c_read(1));
   b1coeff = (( (uint16_t) i2c_read(1) << 8) | i2c_read(1));
   b2coeff = (( (uint16_t) i2c_read(1) << 8) | i2c_read(1));
   c12coeff = (( (uint16_t) (i2c_read(1) << 8) | i2c_read(0))) >> 2;


   _mpl115a2_a0 = (float)a0coeff / 8;
   _mpl115a2_b1 = (float)b1coeff / 8192;
   _mpl115a2_b2 = (float)b2coeff / 16384;
   _mpl115a2_c12 = (float)c12coeff;
   _mpl115a2_c12 /= 4194304.0;

   i2c_stop();
   i2c_disable();
   BAR_POWER_DOWN();
 }
Beispiel #7
0
void mma7660_init(void)
{
  int32_t val;

  i2c_enable();

  buf[0] = INTSU;
  buf[1] = 0x00;
  i2c_transmitinit(ADDR, 2, buf);
  while(!i2c_transferred()) ;

  buf[0] = MODE;
  buf[1] = 0x01;
  i2c_transmitinit(ADDR, 2, buf);
  while(!i2c_transferred()) ;

  buf[0] = SR;
  buf[1] = 0x1F;
  i2c_transmitinit(ADDR, 2, buf);
  while(!i2c_transferred()) ;

  buf[0] = PDET;
  buf[1] = 0xFF;
  i2c_transmitinit(ADDR, 2, buf);
  while(!i2c_transferred()) ;

  buf[0] = PD;
  buf[1] = 0xFF;
  i2c_transmitinit(ADDR, 2, buf);
  while(!i2c_transferred()) ;

  i2c_disable();
}
//! [initialize_i2c]
static void configure_i2c_slave(void)
{
	/* Initialize config structure and software module. */
	//! [init_conf]
	struct i2c_slave_config config_i2c_slave;
	i2c_slave_get_config_defaults(&config_i2c_slave);
	//! [init_conf]
	/* Change address and address_mode. */
	//! [conf_changes]
	config_i2c_slave.address = SLAVE_ADDRESS;
	config_i2c_slave.pin_number_pad0 = PIN_LP_GPIO_14;
	config_i2c_slave.pin_number_pad1 = PIN_LP_GPIO_15;
	config_i2c_slave.pinmux_sel_pad0 = MUX_LP_GPIO_14_MUX4_I2C1_SDA;
	config_i2c_slave.pinmux_sel_pad1 = MUX_LP_GPIO_15_MUX4_I2C1_SCL;
	//! [conf_changes]
	/* Initialize and enable device with config, and enable i2c. */
	//! [init_module]
	while(i2c_slave_init(&i2c_slave_instance, I2C1, &config_i2c_slave)     \
			!= STATUS_OK);
	//! [init_module]
	//! [enable_module]
	i2c_enable(i2c_slave_instance.hw);
	//! [enable_module]
	//! [enable_interurpt]
	i2c_slave_rx_interrupt(i2c_slave_instance.hw, true);
	i2c_slave_tx_interrupt(i2c_slave_instance.hw, true);
	//! [enable_interurpt]
}
Beispiel #9
0
static void i2c_drivers_setup(){

	/** I2C_2 configuration for RGB LED Driver **/
	gpio_set_i2c_scl(GPIO_B, GPIO_PIN_10);
	gpio_set_i2c_sda(GPIO_B, GPIO_PIN_11);
	i2c_enable(I2C_2, I2C_CLOCK_MODE_FAST);
	boot_success("I2C_2 enabled\n");
}
Beispiel #10
0
/*
 * Initialize the specified port to be used for I2C communication
 * NOTE: user defined I2C sensor initialize function should be implemented
 *       in user defined an OSEK initialization Task (not in LEJOS OSEK device init hook).
 *       because device init hook is invoked in a loop while the button instruction screen is appeared.
 */
void init_nxtcam(U8 port_id)
{
	nxt_avr_set_input_power(port_id, 2);
	i2c_enable(port_id);

	int i;
	for (i = 0; i < 41; i++)
		nxtcamdata[i] = 0;
}
Beispiel #11
0
unsigned char
i2c_inbyte(void)
{
	unsigned char aBitByte = 0;
	int i;

	
	i2c_disable();
	i2c_dir_in();
	i2c_delay(CLOCK_HIGH_TIME/2);

	
	aBitByte |= i2c_getbit();

	
	i2c_enable();
	i2c_delay(CLOCK_LOW_TIME/2);

	for (i = 1; i < 8; i++) {
		aBitByte <<= 1;
		
		i2c_clk(I2C_CLOCK_HIGH);
		i2c_delay(CLOCK_HIGH_TIME);
		i2c_clk(I2C_CLOCK_LOW);
		i2c_delay(CLOCK_LOW_TIME);

		
		i2c_disable();
		i2c_dir_in();
		i2c_delay(CLOCK_HIGH_TIME/2);

		
		aBitByte |= i2c_getbit();

		
		i2c_enable();
		i2c_delay(CLOCK_LOW_TIME/2);
	}
	i2c_clk(I2C_CLOCK_HIGH);
	i2c_delay(CLOCK_HIGH_TIME);

	i2c_clk(I2C_CLOCK_LOW);
	return aBitByte;
}
Beispiel #12
0
unsigned char
i2c_inbyte(void)
{
	unsigned char aBitByte = 0;
	int i;

	/* Switch off I2C to get bit */
	i2c_disable();
	i2c_dir_in();
	i2c_delay(CLOCK_HIGH_TIME/2);

	/* Get bit */
	aBitByte |= i2c_getbit();

	/* Enable I2C */
	i2c_enable();
	i2c_delay(CLOCK_LOW_TIME/2);

	for (i = 1; i < 8; i++) {
		aBitByte <<= 1;
		/* Clock pulse */
		i2c_clk(I2C_CLOCK_HIGH);
		i2c_delay(CLOCK_HIGH_TIME);
		i2c_clk(I2C_CLOCK_LOW);
		i2c_delay(CLOCK_LOW_TIME);

		/* Switch off I2C to get bit */
		i2c_disable();
		i2c_dir_in();
		i2c_delay(CLOCK_HIGH_TIME/2);

		/* Get bit */
		aBitByte |= i2c_getbit();

		/* Enable I2C */
		i2c_enable();
		i2c_delay(CLOCK_LOW_TIME/2);
	}
	i2c_clk(I2C_CLOCK_HIGH);
	i2c_delay(CLOCK_HIGH_TIME);
	return aBitByte;
}
Beispiel #13
0
/*
 * Resets the MPU and enables I2C communication with it
 */
int mpu_enable(void)
{
    int ret=0;

    i2c_enable();
    if(!mpu_reset())
        printf("Could not reset the MPU");
    else
        ret=1;

    return ret;
}
Beispiel #14
0
/*---------------------------------------------------------------------------*/
static int
configure(int type, int value)
{
  if(type != SENSORS_ACTIVE) {
    return SHT25_ERROR;
  }
  if(value) {
    i2c_enable();
  } else {
    i2c_disable();
  }
  enabled = value;
  return 0;
}
Beispiel #15
0
void i2c_init() {   

LPC_SC->PCONP |= (1 << 7);  //Power control pheriperals For I2C0
LPC_SC->PCLKSEL = 4; 
i2c_enable();
// Clock frequency = (CLK/PCLKSEL)/(I2CSCLH+I2CSCLL) = 30M/300 = 100khz standard frequency clock.
LPC_I2C0->SCLH = 0x96; // CSCLH = 150
LPC_I2C0->SCLL = 0x96; // CSCLH = 150

// Configure GPIO’s     
LPC_IOCON -> P1_30 = 0xA4;  //I2C0 SDA  
LPC_IOCON -> P1_31 = 0xA4;  //I2C0_SCK
	
}
Beispiel #16
0
/** Configure I2C address.
 *  @param obj     The I2C object
 *  @param idx     Currently not used
 *  @param address The address to be set
 *  @param mask    Currently not used
 */
void i2c_slave_address(i2c_t *obj, int idx, uint32_t address, uint32_t mask)
{
    struct i2c_s *obj_s = I2C_S(obj);

    /* disable I2C peripheral */
    i2c_disable(obj_s->i2c);
    /* I2C clock configure */
    i2c_clock_config(obj_s->i2c, 100000, I2C_DTCY_2);
    /* I2C address configure */
    i2c_mode_addr_config(obj_s->i2c, I2C_I2CMODE_ENABLE, I2C_ADDFORMAT_7BITS, address);
    /* enable I2C0 */
    i2c_enable(obj_s->i2c);
    /* enable acknowledge */
    i2c_ack_config(obj_s->i2c, I2C_ACK_ENABLE);
}
Beispiel #17
0
//------------------------------------------------------------------------------
// void i2c_receiveinit(uint8_t slave_address, 
//                              uint8_t prescale)
//
// This function initializes the USCI module for master-receive operation. 
//
// IN:   uint8_t slave_address   =>  Slave Address
//       uint8_t prescale        =>  SCL clock adjustment 
//-----------------------------------------------------------------------------
//static volatile uint8_t rx_byte_tot = 0;
void i2c_receiveinit(uint8_t slave_address, uint8_t byte_ctr, uint8_t *rx_buf) {
	// wait for bus to be free before setting MSTA (assuming we're in a multi-master environment or still sending something else)
//	while(i2c_busy()) /* wait */;

// Jagun@UCL - now using a timeout version
	uint16_t timeout = I2C_TIMEOUT;
    while(i2c_busy() && --timeout) ; // Wait 
	if(!timeout) {
		//printf("\nDEBUG: I2C Timeout Detected in recvinit!!\n");
		i2c_force_reset();
		clock_delay_msec(6);
		//i2c_disable();
		i2c_enable(); 
		clock_delay_msec(6);
		*I2CSR &= ~I2C_MAL; // should be cleared in software
		// Arbitration lost; reset..
		rx_byte_ctr = tx_byte_ctr = 0;
		*I2CCR &= ~I2C_MSTA; // generate stop condition
		// clear MIF
		*I2CSR &= ~I2C_MIF;
		*rx_buf = 0;
		return;			// TODO; return some meaningful value in rx_buf!
    }

	// assert: rx_byte_ctr <= 0
	// assert: tx_byte_ctr <= 0
	tx_buf_ptr = 0;
	tx_byte_ctr = 0; // indicate that nothing is to be received
	rx_byte_ctr = byte_ctr;
	rx_buf_ptr  = rx_buf;

	// clockdiv
	//*I2CFDR = 0x20; // 150 khz for redbee econotag
	
	// assume being master, thus no addres has to be set
	*I2CCR = I2C_MEN |
#ifdef I2C_NON_BLOCKING
		I2C_MIEN | 
#endif
		I2C_MSTA | I2C_MTX | I2C_RXAK; // start condition is triggered
	
	// write out address of slave
	*I2CDR = (slave_address & 0x7f) <<1 | 0x01;

#ifndef I2C_NON_BLOCKING
	i2c_receive();
#endif	
}
Beispiel #18
0
/*!
    \brief      handle I2C1 event interrupt request
    \param[in]  none
    \param[out] none
    \retval     none
*/
void I2C1_EventIRQ_Handler(void)
{
    if(i2c_flag_get(I2C1, I2C_ADDSEND)){
        /* clear the ADDSEND bit */
        event2 =i2c_flag_get(I2C1,I2C_ADDSEND );
    }else if(i2c_flag_get(I2C1, I2C_RBNE)){
        /* if reception data register is not empty ,I2C1 will read a data from I2C_DATA */
        *i2c_rxbuffer++ = i2c_receive_data(I2C1);
    }else if(i2c_flag_get(I2C1, I2C_STPDET)){
        Status=SUCCESS;
        /* clear the STPDET bit */
        i2c_enable(I2C1);
        /* disable I2C1 interrupt */
        i2c_interrupt_disable(I2C1, I2C_CTL1_ERRIE | I2C_CTL1_BUFIE | I2C_CTL1_EVIE);
    }
}
Beispiel #19
0
/** Configure I2C as slave or master.
 *  @param obj The I2C object
 *  @param data    The buffer for receiving
 *  @param length  Number of bytes to read
 *  @return non-zero if a value is available
 */
int i2c_slave_read(i2c_t *obj, char *data, int length)
{
    struct i2c_s *obj_s = I2C_S(obj);
    int count = 0;
    int timeout = 0;

    i2c_ack_config(obj_s->i2c, I2C_ACK_ENABLE);

    /* wait until ADDSEND bit is set */
    while (!i2c_flag_get(obj_s->i2c, I2C_FLAG_ADDSEND)) {
        timeout++;
        if (timeout > 100000) {
            return -1;
        }
    }
    /* clear ADDSEND bit */
    i2c_flag_clear(obj_s->i2c, I2C_FLAG_ADDSEND);

    while (0 < length) {
        /* wait until the RBNE bit is set */
        timeout = 0;
        while (!i2c_flag_get(obj_s->i2c, I2C_FLAG_RBNE)) {
            timeout++;
            if (timeout > 100000) {
                return -1;
            }
        }
        *data = i2c_data_receive(obj_s->i2c);
        data++;
        length--;
        count++;
    }
    /* wait until the STPDET bit is set */
    timeout = 0;
    while (!i2c_flag_get(obj_s->i2c, I2C_FLAG_STPDET)) {
        timeout++;
        if (timeout > 100) {
            return count;
        }
    }
    /* clear the STPDET bit */
    i2c_enable(obj_s->i2c);

    i2c_ack_config(obj_s->i2c, I2C_ACK_DISABLE);

    return count;
}
Beispiel #20
0
//initialize the display
void lcd_init()
{
  printf("initialize lcd...");

  i2c_enable();
  const char init_commands[] = {0x38, 0x39, 0x14, 0x74, 0x54, 0x6f, 0x0c, 0x01};
  i2c_transmitinit(LCD_ADDR,8,init_commands);
  wait_for_transfer();
  cursor = 0x0f;
  line = 0x00;
  
  // turn backlight on
  lcd_backlight(1);

  lcd_print("hello boss :)");
  lcd_set_cursor(1,0);
  lcd_print("contiki booted!");

  printf("[OK]\n\r");
}
Beispiel #21
0
void platform_drivers_setup()
{
    // Set base address and AHB bit for all GPIO ports
    gpio_enable(GPIO_A);
    gpio_enable(GPIO_B);
    gpio_enable(GPIO_C);
    gpio_enable(GPIO_D);

    // Enable the AFIO
    rcc_apb_enable(RCC_APB_BUS_AFIO, RCC_APB_BIT_AFIO);

    // Start the TIM3 at ~32kHz
    timer_enable(TIM_3);
    timer_select_internal_clock(TIM_3, (rcc_sysclk_get_clock_frequency(
                                           RCC_SYSCLK_CLOCK_PCLK1_TIM) / 32768) - 1);
    timer_start(TIM_3, 0xFFFF, NULL, NULL);

    // Enable the print uart
    gpio_set_uart_tx(GPIO_A, GPIO_PIN_9);
    gpio_set_uart_rx(GPIO_A, GPIO_PIN_10);
    uart_enable(UART_1, PLATFORM_UART_PRINT_BAUDRATE);

    // Configure the DMA for the SPIs
    dma_enable(DMA_1_CH4);
    dma_enable(DMA_1_CH5);

    // Configure the SPI 2
    gpio_set_spi_clk(GPIO_B, GPIO_PIN_13);
    gpio_set_spi_miso(GPIO_B, GPIO_PIN_14);
    gpio_set_spi_mosi(GPIO_B, GPIO_PIN_15);
    spi_set_dma(SPI_2, DMA_1_CH4, DMA_1_CH5);
    spi_enable(SPI_2, 4000000, SPI_CLOCK_MODE_IDLE_LOW_RISING);

    // Configure the I2C 1
    gpio_set_i2c_scl(GPIO_B, GPIO_PIN_6);
    gpio_set_i2c_sda(GPIO_B, GPIO_PIN_7);
    i2c_enable(I2C_1, I2C_CLOCK_MODE_FAST);

    // Force inclusion of EXTI
    exti_set_handler(EXTI_LINE_Px0, NULL, NULL);
}
Beispiel #22
0
void mma7660_acc(int *x, int *y, int *z)
{
  int tmp;
  i2c_enable();

  /* Read data */
  buf[0] = XOUT;
  i2c_transmitinit(ADDR, 1, buf);
  while(!i2c_transferred()) ;
  i2c_receiveinit(ADDR, 3, buf);
  while(!i2c_transferred()) ;

  i2c_disable();

  tmp = (signed char)((buf[0] & 0x20) ? (buf[0] | 0xC0) : (buf[0] & 0x3F));
  *x = (tmp*150)/32;
  tmp = (signed char)((buf[1] & 0x20) ? (buf[1] | 0xC0) : (buf[1] & 0x3F));
  *y = (tmp*150)/32;
  tmp = (signed char)((buf[2] & 0x20) ? (buf[2] | 0xC0) : (buf[2] & 0x3F));
  *z = (tmp*150)/32;
}
Beispiel #23
0
int
i2c_getack(void)
{
	int ack = 1;
	i2c_dir_out();
	i2c_data(I2C_DATA_HIGH);
	i2c_dir_in();
	i2c_delay(CLOCK_HIGH_TIME/4);
	i2c_clk(I2C_CLOCK_HIGH);
#if 0
	i2c_clk(1);
	i2c_data(1);
	i2c_data(1);
	i2c_disable();
	i2c_dir_in();
#endif

	i2c_delay(CLOCK_HIGH_TIME/2);
	if (i2c_getbit())
		ack = 0;
	i2c_delay(CLOCK_HIGH_TIME/2);
	if (!ack) {
		if (!i2c_getbit()) 
			ack = 1;
		i2c_delay(CLOCK_HIGH_TIME/2);
	}

#if 0
   i2c_data(I2C_DATA_LOW);

	i2c_enable();
	i2c_dir_out();
#endif
	i2c_clk(I2C_CLOCK_LOW);
	i2c_delay(CLOCK_HIGH_TIME/4);
	i2c_dir_out();
	i2c_data(I2C_DATA_HIGH);
	i2c_delay(CLOCK_LOW_TIME/2);
	return ack;
}
Beispiel #24
0
void luke_init() {
    LATC = 0x0;
    ANSELC = 0x00;  // All pins are set as digital I/O
    PORTC = 0x00;
    TRISC = 0x07;  // RC0, RC1, RC2: input, other pins: output

    WPUA = 0x38;   // Enable weak pull-up of RA3, RA4, RA5
    OPTION_REGbits.nWPUEN = 0;

    // Load parameters from HEF memory
    lowCurrentSlope   = NVM_LOW_CURRENT_SLOPE;
    lowCurrentOffset  = NVM_LOW_CURRENT_OFFSET;
    highCurrentSlope  = NVM_HIGH_CURRENT_SLOPE;
    highCurrentOffset = NVM_HIGH_CURRENT_OFFSET;
    lowVoltageSlope   = NVM_LOW_VOLTAGE_SLOPE;
    lowVoltageOffset  = NVM_LOW_VOLTAGE_OFFSET;
    highVoltageSlope  = NVM_HIGH_VOLTAGE_SLOPE;
    highVoltageOffset = NVM_HIGH_VOLTAGE_OFFSET;
    
    i2c_enable();
    set_autorange_threshould();
}
Beispiel #25
0
void
tlc59116_init(void)
{
  /* Set up ports and pins for I2C communication */
  i2c_enable();

  /* set default register values. */
  tlc59116_write_reg(TLC59116_MODE1, TLC59116_MODE1_DEFAULT);
  tlc59116_write_reg(TLC59116_MODE2, TLC59116_MODE2_DEFAULT);

  /*Set all PWM values to 0x00 (off) */
  /*This would maybe be better with a SWRST */
  uint8_t tx_buf[] =
    { TLC59116_PWM0_AUTOINCR, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
  tlc59116_write_stream(17, &tx_buf);

  /* set all leds to PWM control */
  tlc59116_write_reg(TLC59116_LEDOUT0, TLC59116_LEDOUT_PWM);
  tlc59116_write_reg(TLC59116_LEDOUT1, TLC59116_LEDOUT_PWM);
  tlc59116_write_reg(TLC59116_LEDOUT2, TLC59116_LEDOUT_PWM);
  tlc59116_write_reg(TLC59116_LEDOUT3, TLC59116_LEDOUT_PWM);
}
 uint16_t read_temperature_barometer_MPL115A2(){
 	 uint16_t ret = 0;
 	 uint8_t res = 0;
 	 float t;
 	 BAR_POWER_UP();
 	 i2c_enable();

 	 i2c_start();
 	 i2c_write((DEVICE_ADDRESS | WRITE));
 	 i2c_write((START_CONVERSION_COMMAND));
 	 i2c_write((0x01)); // trovato su un forum di uno spagnolo
 	 i2c_stop();
 	 //delay 1.6 ms
 	 __delay_cycles(1662500);

 	 i2c_start();
 	 i2c_write((DEVICE_ADDRESS | WRITE));
 	 i2c_write((READ_TEMPERATURE_MSB_COMMAND));

 	 i2c_start();
 	 i2c_write((DEVICE_ADDRESS | READ));

 	 res = i2c_read(1);
 	 //printf("temp MSB %x\n", res);
 	 ret = (res << 8);
 	 res = i2c_read(0);
 	 ret += res;
 	 ret = ret >> 6;

 	 i2c_stop();
 	 i2c_disable();
 	 BAR_POWER_DOWN();


 	  t = ((float) ret - 498.0F) / -5.35F +25.0F;           // C
 	  ret = (uint16_t)(t*100);
 	 return ret;
 }
Beispiel #27
0
/**********************************************************************************************************************
 * Routine:                 i2c_StartTransfer

 * Description:
 * Use this subroutine to launch the I2C communication. Please note that the buffer and all needed variables
 * must be set/defined before.   
 * 
 * Creator:                 A. Staub
 * Date of creation:        05.05.2015
 * Last modification on:    -
 * Modified by:             - 
 * 
 * Input:                   uin8_i2cx
 * Output:                  -
***********************************************************************************************************************/
void i2c_StartTransfer(unsigned char uint8_i2cx)
{
    if(uint8_i2cx == _i2c1)
    {
        g_i2c1.uint8_Busy = 1;          //set the busy variable already
        g_i2c1.uint8_BusColl = 0;       //reset flag bus collision
        g_i2c1.uint8_ErrACK = 0;        //reset ack error
        i2c_enable(_i2c1);              //enable interrupt
        g_i2c1.uint8_LastNACKsend = 0;  //reset variable
        g_i2c1.uint8_CurrDir = 0;       //current direction = write
        I2C1CONbits.RCEN = 0;           //receive sequence not in progress
        I2C1CONbits.ACKEN = 0;          //acknowledge sequence disable
        I2C1CONbits.SEN = 1;            //send start condition - launch interrupt routine
    }
    else if(uint8_i2cx == _i2c2)
    {
        //not programmed yet
    }
    else
    {
        //nothing is done
    }
}   //end of i2c_StartTransfer
Beispiel #28
0
/** Configure the I2C frequency
 *
 *  @param obj The I2C object
 *  @param hz  Frequency in Hz
 */
void i2c_frequency(i2c_t *obj, int hz)
{
    int timeout;
    struct i2c_s *obj_s = I2C_S(obj);

    /* wait until I2C_FLAG_I2CBSY flag is reset */
    timeout = BUSY_TIMEOUT;
    while ((i2c_flag_get(obj_s->i2c, I2C_FLAG_I2CBSY)) && (--timeout != 0));

    /* reset to clear pending flags */
    i2c_hw_reset(obj);

    /* disable I2C peripheral */
    i2c_disable(obj_s->i2c);

    /* configure I2C frequence */
    i2c_clock_config(obj_s->i2c, hz, I2C_DTCY_2);

    /* configure I2C address mode and slave address */
    i2c_mode_addr_config(obj_s->i2c, I2C_I2CMODE_ENABLE, I2C_ADDFORMAT_7BITS, 0);

    /* enable I2C peripheral */
    i2c_enable(obj_s->i2c);
}
int
i2c_getack(void)
{
	int ack = 1;
	/*
	 * enable output
	 */
	i2c_dir_out();
	/*
	 * Release data bus by setting
	 * data high
	 */
	i2c_data(I2C_DATA_HIGH);
	/*
	 * enable input
	 */
	i2c_dir_in();
	i2c_delay(CLOCK_HIGH_TIME/4);
	/*
	 * generate ACK clock pulse
	 */
	i2c_clk(I2C_CLOCK_HIGH);
	/*
	 * Use PORT PB instead of I2C
	 * for input. (I2C not working)
	 */
	i2c_clk(1);
	i2c_data(1);
	/*
	 * switch off I2C
	 */
	i2c_data(1);
	i2c_disable();
	i2c_dir_in();
	/*
	 * now wait for ack
	 */
	i2c_delay(CLOCK_HIGH_TIME/2);
	/*
	 * check for ack
	 */
	if(i2c_getbit())
		ack = 0;
	i2c_delay(CLOCK_HIGH_TIME/2);
	if(!ack){
		if(!i2c_getbit()) /* receiver pulld SDA low */
			ack = 1;
		i2c_delay(CLOCK_HIGH_TIME/2);
	}

	/*
	 * our clock is high now, make sure data is low
	 * before we enable our output. If we keep data high
	 * and enable output, we would generate a stop condition.
	 */
	i2c_data(I2C_DATA_LOW);

	/*
	 * end clock pulse
	 */
	i2c_enable();
	i2c_dir_out();
	i2c_clk(I2C_CLOCK_LOW);
	i2c_delay(CLOCK_HIGH_TIME/4);
	/*
	 * enable output
	 */
	i2c_dir_out();
	/*
	 * remove ACK clock pulse
	 */
	i2c_data(I2C_DATA_HIGH);
	i2c_delay(CLOCK_LOW_TIME/2);
	return ack;
}
Beispiel #30
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;
}