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;
}
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);
}
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);
}
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();
}
}
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();
}
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]
}
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");
}
/*
* 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;
}
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;
}
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;
}
/*
* 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;
}
/*---------------------------------------------------------------------------*/
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;
}
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
}
/** 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);
}
//------------------------------------------------------------------------------
// 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
}
/*!
\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);
}
}
/** 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;
}
//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");
}
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);
}
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;
}
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;
}
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();
}
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;
}
/**********************************************************************************************************************
* 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
/** 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;
}
/**
* 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;
}