int active_g(int g)
{
if ( g != 2 && g != 4 && g != 8 )
{
printf("Value of passed argument must be 2, 4 or 8\n");
return -1;
}
//try to put the device into standby mode
if (!standby())
return -1;
//chooses the g mode
char addr = 0x0E;
char n = 0b11111100;
write_acc(addr, read_acc(addr) & n);
if ( g == 4 )
{
n = 0b00000001;
write_acc(addr, read_acc(addr) | n);
}
else if ( g == 8 )
{
n = 0b00000010;
write_acc(addr, read_acc(addr) | n);
}
//try to put the device into active mode
if (!active())
return -1;
return g;
}
A2dpAudioInterface::A2dpAudioStreamOut::~A2dpAudioStreamOut()
{
LOGV("A2dpAudioStreamOut destructor");
standby();
close();
LOGV("A2dpAudioStreamOut destructor returning from close()");
}
void FXAS21002C::init()
{
standby(); // Must be in standby to change registers
// Set up the full scale range to 250, 500, 1000, or 2000 deg/s.
writeReg(FXAS21002C_H_CTRL_REG0, gyroFSR);
// Setup the 3 data rate bits, 4:2
if (gyroODR < 8)
writeReg(FXAS21002C_H_CTRL_REG1, gyroODR << 2);
// Disable FIFO, route FIFO and rate threshold interrupts to INT2, enable data ready interrupt, route to INT1
// Active HIGH, push-pull output driver on interrupts
writeReg(FXAS21002C_H_CTRL_REG2, 0x0E);
// Set up rate threshold detection; at max rate threshold = FSR; rate threshold = THS*FSR/128
writeReg(FXAS21002C_H_RT_CFG, 0x07); // enable rate threshold detection on all axes
writeReg(FXAS21002C_H_RT_THS, 0x00 | 0x0D); // unsigned 7-bit THS, set to one-tenth FSR; set clearing debounce counter
writeReg(FXAS21002C_H_RT_COUNT, 0x04); // set to 4 (can set up to 255)
// Configure interrupts 1 and 2
//writeReg(CTRL_REG3, readReg(CTRL_REG3) & ~(0x02)); // clear bits 0, 1
//writeReg(CTRL_REG3, readReg(CTRL_REG3) | (0x02)); // select ACTIVE HIGH, push-pull interrupts
//writeReg(CTRL_REG4, readReg(CTRL_REG4) & ~(0x1D)); // clear bits 0, 3, and 4
//writeReg(CTRL_REG4, readReg(CTRL_REG4) | (0x1D)); // DRDY, Freefall/Motion, P/L and tap ints enabled
//writeReg(CTRL_REG5, 0x01); // DRDY on INT1, P/L and taps on INT2
active(); // Set to active to start reading
}
/**
* writeTo - Write a word to specified address
* @addr: address to write to
* @value: value to store
*
* Returns false if write did not complete.
*
* Note: Make sure EEPROM is selected and writable before attempting
* to write. Use getReady() and stop() to select/deselect
* EEPROM.
**/
bool EEPROMTest::writeTo(uint16_t addr, uint16_t value)
{
writeOpAddr(WRITE_OPCODE, WRITE_OPCODE_BITS, addr, WRITE_ADDR_BITS);
writeData(value);
standby();
return waitForCompletion();
}
// INITIALIZATION
// This function initializes the MMA8452Q. It sets up the scale (either 2, 4,
// or 8g), output data rate, portrait/landscape detection and tap detection.
// It also checks the WHO_AM_I register to make sure we can communicate with
// the sensor. Returns a 0 if communication failed, 1 if successful.
byte MMA8452Q::init(MMA8452Q_Scale fsr, MMA8452Q_ODR odr)
{
scale = fsr; // Haul fsr into our class variable, scale
Wire.setModule(1);
Wire.begin(); // Initialize I2C
byte c = readRegister(WHO_AM_I); // Read WHO_AM_I register
if (c != 0x2A) // WHO_AM_I should always be 0x2A
{
return 0;
}
standby(); // Must be in standby to change registers
setScale(scale); // Set up accelerometer scale
setODR(odr); // Set up output data rate
setupPL(); // Set up portrait/landscape detection
// Multiply parameter by 0.0625g to calculate threshold.
setupTap(0x80, 0x80, 0x08); // Disable x, y, set z to 0.5g
active(); // Set to active to start reading
return 1;
}
status_t A2dpAudioInterface::A2dpAudioStreamOut::setSuspended(bool onOff)
{
LOGV("setSuspended %d", onOff);
mSuspended = onOff;
standby();
return NO_ERROR;
}
void r8712_eeprom_write16(struct _adapter *padapter, u16 reg, u16 data)
{
u8 x;
u8 tmp8_ori, tmp8_new, tmp8_clk_ori, tmp8_clk_new;
tmp8_ori = r8712_read8(padapter, 0x102502f1);
tmp8_new = tmp8_ori & 0xf7;
if (tmp8_ori != tmp8_new)
r8712_write8(padapter, 0x102502f1, tmp8_new);
tmp8_clk_ori = r8712_read8(padapter, 0x10250003);
tmp8_clk_new = tmp8_clk_ori | 0x20;
if (tmp8_clk_new != tmp8_clk_ori)
r8712_write8(padapter, 0x10250003, tmp8_clk_new);
x = r8712_read8(padapter, EE_9346CR);
x &= ~(_EEDI | _EEDO | _EESK | _EEM0);
x |= _EEM1 | _EECS;
r8712_write8(padapter, EE_9346CR, x);
shift_out_bits(padapter, EEPROM_EWEN_OPCODE, 5);
if (padapter->EepromAddressSize == 8) /*CF+ and SDIO*/
shift_out_bits(padapter, 0, 6);
else /* USB */
shift_out_bits(padapter, 0, 4);
standby(padapter);
/* Erase this particular word. Write the erase opcode and register
* number in that order. The opcode is 3bits in length; reg is 6
* bits long.
*/
standby(padapter);
/* write the new word to the EEPROM
* send the write opcode the EEPORM
*/
shift_out_bits(padapter, EEPROM_WRITE_OPCODE, 3);
/* select which word in the EEPROM that we are writing to. */
shift_out_bits(padapter, reg, padapter->EepromAddressSize);
/* write the data to the selected EEPROM word. */
shift_out_bits(padapter, data, 16);
if (wait_eeprom_cmd_done(padapter)) {
standby(padapter);
shift_out_bits(padapter, EEPROM_EWDS_OPCODE, 5);
shift_out_bits(padapter, reg, 4);
eeprom_clean(padapter);
}
if (tmp8_clk_new != tmp8_clk_ori)
r8712_write8(padapter, 0x10250003, tmp8_clk_ori);
if (tmp8_new != tmp8_ori)
r8712_write8(padapter, 0x102502f1, tmp8_ori);
}
void testEraseAll()
{
//unused: int i;
uint16_t addr = 0x1F;
getReady();
// Enable write
writeOpAddr(EWEN_OPCODE, EWEN_OPCODE_BITS, 0, EWEN_ADDR_BITS);
standby();
// Fill all memory
writeOpAddr(WRITE_OPCODE, WRITE_OPCODE_BITS, addr, WRITE_ADDR_BITS);
writeData(0);
standby();
if (waitForCompletion()) {
stop();
getReady();
// Write successful -- verify random location
CPPUNIT_ASSERT_EQUAL((uint16_t)0, readAt(addr));
stop();
getReady();
writeOpAddr(ERAL_OPCODE, ERAL_OPCODE_BITS, addr, ERAL_ADDR_BITS);
standby();
if (!waitForCompletion()) {
CPPUNIT_FAIL("EEPROM erase was not completed");
stop();
return;
}
standby();
writeOpAddr(EWDS_OPCODE, EWDS_OPCODE_BITS, 0, EWDS_ADDR_BITS);
stop();
getReady();
for ( addr=0; addr < EEPROM93C46::SIZE; addr++ ) {
CPPUNIT_ASSERT_EQUAL((uint16_t)0xFFFF, readAt(addr));
}
}
else {
CPPUNIT_FAIL("EEPROM write was not completed");
}
stop();
}
void tick_handler(struct tm *tick_time, TimeUnits units_changed){
//check if should be in standby
standby();
//update the time
if (standbyFlag==false){
updateTime();
}
}
int main() { // line 25
setup();
timerSetup();
while(1) {
standby();
}
return 0;
}
/**
* waitForCompletion - Wait until EEPROM clears the busy bit
*
* Returns false if the EEPROM is still busy.
*/
bool EEPROMTest::waitForCompletion() {
for (int i = 0; i < 200; i++) {
if (eeprom->read() & DO) {
standby();
return true;
}
// Wait 50 usec;
}
return false;
}
void testRead()
{
getReady();
for ( uint32_t wordAddr=0; wordAddr < EEPROM93C46::SIZE; wordAddr++ ) {
shiftOutBits(READ_OPCODE, READ_OPCODE_BITS);
shiftOutBits(wordAddr, READ_ADDR_BITS);
CPPUNIT_ASSERT_EQUAL( initialContent[wordAddr], (uint16_t)wordAddr );
CPPUNIT_ASSERT_EQUAL( initialContent[wordAddr], shiftInBits(DATA_BITS) );
standby();
}
stop();
}
void really(int i)
{
if (i < 3)
{
puts("Try again...");
}
else
{
puts("Come back after learning to read.");
standby();
exit(0);
}
}
static u16 wait_eeprom_cmd_done(struct _adapter *padapter)
{
u8 x;
u16 i;
standby(padapter);
for (i = 0; i < 200; i++) {
x = r8712_read8(padapter, EE_9346CR);
if (x & _EEDO)
return true;
udelay(CLOCK_RATE);
}
return false;
}
void suspend_power_down(void)
{
#ifdef NO_SUSPEND_POWER_DOWN
;
#elif defined(SUSPEND_MODE_NOPOWERSAVE)
;
#elif defined(SUSPEND_MODE_STANDBY)
standby();
#elif defined(SUSPEND_MODE_IDLE)
idle();
#else
power_down(WDTO_15MS);
#endif
}
void error(char *msg)
{
unsigned char i;
standby();
battery_state = STATE_ERROR;
for(i=0; i<8 ;i++)
{
error_msg[i] = msg[i];
}
RESET_LEDS();
SET_LED(LED_R);
}
void testWrite()
{
//unused: int i;
uint16_t wordAddr;
getReady();
// Enable write
writeOpAddr(EWEN_OPCODE, EWEN_OPCODE_BITS, 0, EWEN_ADDR_BITS);
standby();
for ( wordAddr=0; wordAddr < EEPROM93C46::SIZE; wordAddr++ ) {
//writeOpAddr(WRITE_OPCODE, WRITE_OPCODE_BITS, (uint16_t)wordAddr, WRITE_ADDR_BITS);
writeTo(wordAddr, 0x3F00 - (wordAddr<<8));
standby();
if (!waitForCompletion()) {
CPPUNIT_FAIL("EEPROM write was not completed");
stop();
return;
}
standby();
}
// Disable write
writeOpAddr(EWDS_OPCODE, EWDS_OPCODE_BITS, 0, EWDS_ADDR_BITS);
stop();
// Now check the result
getReady();
writeOpAddr(READ_OPCODE, READ_OPCODE_BITS, 0, READ_ADDR_BITS);
for ( wordAddr=0; wordAddr < EEPROM93C46::SIZE; wordAddr++ ) {
CPPUNIT_ASSERT_EQUAL((uint16_t)(0x3F00 - (wordAddr<<8)), shiftInBits(DATA_BITS) );
}
stop();
}
// Run the function of the next state
void state() {
switch (NEXT_STATE) {
case STATE_NO_SD:
STATE = STATE_NO_SD;
noSD();
break;
case STATE_SD_SETUP:
STATE = STATE_SD_SETUP;
sdSetup();
break;
case STATE_STANDBY:
STATE = STATE_STANDBY;
standby();
break;
case STATE_DATA_SETUP:
STATE = STATE_DATA_SETUP;
dataSetup();
break;
case STATE_DATA_COLLECT:
STATE = STATE_DATA_COLLECT;
dataCollect_fixed();
break;
case STATE_DATA_CONCLUDE:
STATE = STATE_DATA_CONCLUDE;
dataConclude();
break;
case STATE_WARNING:
STATE = STATE_WARNING;
warning();
break;
case STATE_ERROR:
STATE = STATE_ERROR;
error();
break;
} // End of switch
} // End of state
void main(void)
{
P2SEL=0;
P2SELH=0;
P2DIR=0xFF;
i2c_init();
i2c_WriteOneByte(0x00,0x0E);
standby();
for (;;)
{
active();
Read_X_Value();
Read_Y_Value();
Read_Z_Value();
_delay_cycles(500000);
}
}
void FXOS8700CQ::init()
{
reset();
delayMicroseconds(1);
standby(); // Must be in standby to change registers
writeReg(FXOS8700CQ_XYZ_DATA_CFG, 0x00); // Choose the full scale range to 2, 4, or 8 g.
// write 0001 1111 = 0x1F to magnetometer control register 1
// [7]: m_acal=1: auto calibration enabled
// [6]: m_rst=0: no one-shot magnetic reset
// [5]: m_ost=0: no one-shot magnetic measurement
// [4-2]: m_os=111=7: 8x oversampling (for 200Hz) to reduce magnetometer noise
// [1-0]: m_hms=11=3: select hybrid mode with accel and magnetometer active
writeReg(FXOS8700CQ_M_CTRL_REG1, 0x1F);
// write 0010 0000 = 0x20 to magnetometer control register 2
// [7]: reserved
// [6]: reserved
// [5]: hyb_autoinc_mode=1 to map the magnetometer registers to follow the
// accelerometer registers
// [4]: m_maxmin_dis=0 to retain default min/max latching even though not used
// [3]: m_maxmin_dis_ths=0
// [2]: m_maxmin_rst=0
// [1-0]: m_rst_cnt=00 to enable magnetic reset each cycle
//writeReg(FXOS8700CQ_M_CTRL_REG2, 0x20);
//writeReg(FXOS8700CQ_CTRL_REG2, 0x02); // High Resolution mode
//writeReg(FXOS8700CQ_CTRL_REG3, 0x01); // Open-drain, active low interrupt
// write 0000 1100 = 0x0C to accelerometer control register 1
// [7-6]: aslp_rate=00
// [5-3]: dr=001 for 200Hz data rate (when in hybrid mode)
// [2]: lnoise=1 for low noise mode
// [1]: f_read=0 for normal 16 bit reads
// [0]: active=0
writeReg(FXOS8700CQ_CTRL_REG1, 0x0C);
//writeReg(FXOS8700CQ_CTRL_REG1, 0x34);
active(); // Set to active to start reading
}
void FXAS21002C::calibrate(float * gBias)
{
int32_t gyro_bias[3] = {0, 0, 0};
uint16_t ii, fcount;
int16_t temp[3];
// Clear all interrupts by reading the data output and STATUS registers
//readGyroData(temp);
readReg(FXAS21002C_H_STATUS);
standby(); // Must be in standby to change registers
writeReg(FXAS21002C_H_CTRL_REG1, 0x08); // select 50 Hz ODR
fcount = 50; // sample for 1 second
writeReg(FXAS21002C_H_CTRL_REG0, 0x03); // select 200 deg/s full scale
uint16_t gyrosensitivity = 41; // 40.96 LSB/deg/s
active(); // Set to active to start collecting data
uint8_t rawData[6]; // x/y/z FIFO accel data stored here
for(ii = 0; ii < fcount; ii++) // construct count sums for each axis
{
readRegs(FXAS21002C_H_OUT_X_MSB, 6, &rawData[0]); // Read the FIFO data registers into data array
temp[0] = ((int16_t)( rawData[0] << 8 | rawData[1])) >> 2;
temp[1] = ((int16_t)( rawData[2] << 8 | rawData[3])) >> 2;
temp[2] = ((int16_t)( rawData[4] << 8 | rawData[5])) >> 2;
gyro_bias[0] += (int32_t) temp[0];
gyro_bias[1] += (int32_t) temp[1];
gyro_bias[2] += (int32_t) temp[2];
delay(25); // wait for next data sample at 50 Hz rate
}
gyro_bias[0] /= (int32_t) fcount; // get average values
gyro_bias[1] /= (int32_t) fcount;
gyro_bias[2] /= (int32_t) fcount;
gBias[0] = (float)gyro_bias[0]/(float) gyrosensitivity; // get average values
gBias[1] = (float)gyro_bias[1]/(float) gyrosensitivity; // get average values
gBias[2] = (float)gyro_bias[2]/(float) gyrosensitivity; // get average values
ready(); // Set to ready
}
void I2C_EE_Upload(void)
{
int percentage;
uint8_t byte;
unsigned int LEDbackup;
int i;
LEDbackup=LEDbyte;
clear();
write('S');
write('e');
write('n');
write('d');
write('i');
write('n');
write('g');
for (i=CONFIGLENGTH;i<EEPROM_BYTES;i++)
{
if((i%100)==0){
setCursor(0,1);
percentage = (100*i)/(EEPROM_BYTES-CONFIGLENGTH);
writenumber(percentage);
// write('0'+(i/(EEPROM_BYTES-CONFIGLENGTH)*100)/100);
// write('0'+((i/(EEPROM_BYTES-CONFIGLENGTH)*100)/10)%10);
// write('0'+(i/(EEPROM_BYTES-CONFIGLENGTH)*100)%10);
write('%');
write(' ');
write(' ');}
LEDbyte = LEDGripple[(i/80)%10];
setLEDS();
I2C_EE_BufferRead(&byte, i, 1);
UART_send_byte(byte);
}
clear();
delay_ms(2000);
clear();
standby();
LEDbyte=LEDbackup;
setLEDS();
}
/**
* \brief begin function - must be called before using other functions
*
* This function enables the magnetometer.
* The magnetometer is an I2C device so we initialise the I2C communications,
* make contact with the magnetometer, and check that it's what we think it is.
*
* We set the sampling rate to 10Hz, but where the values are from a heavily
* oversampled set of values
*/
void EngduinoMagnetometerClass::begin()
{ uint8_t reg;
// Join I2C bus as master
//
Wire.begin();
// Check to see that the device is there
//
Wire.beginTransmission(FXMS3110_IIC_ADDRESS);
int error = Wire.endTransmission();
if (error != 0) {
Serial.println("Error: I2C device not found");
return;
}
// Check that it's the device we think it is
//
readReg(FXMS3110_WHO_AM_I, ®);
if (reg != FXMS3110) {
Serial.println("Error: Not an FXMS3110");
return;
}
// Set this to raw mode - no user correction
// and automatically enable reset to deal with big magnetic
// fields
readReg(FXMS3110_CTRL_REG2, ®);
reg |= AUTO_MRST_EN_MASK | RAW_MASK;
writeReg(FXMS3110_CTRL_REG2, ®);
standby(); // Stop the magnetometer
// Set 10Hz data rate = 1280 Hz ADC with 128 times oversampling
readReg(FXMS3110_CTRL_REG1, ®);
reg &= ~(DR_MASK | OS_MASK);
reg |= DATA_RATE_1280_128;
writeReg(FXMS3110_CTRL_REG1, ®);
activate(); // And start it again
}
int main()
{
// 1. Initiera (Görs ovan med definitionerna?)
unsigned int door = DOOR_CLOSED;
init_irq();
while(1)
{
// Sätt IRQ typ till 0 eftersom vi inte har avbrott
interrupt_type = NO_IRQ_TYPE;
// Vänta på avbrott, WAI i assembler modulen
standby();
// Nu har vi avbrott, switcha på interrupt_type som sätts
// i assemblermodulen för att avgöra vilken typ av avbrott
switch(interrupt_type)
{
// Sensor har gett utslag, öppna dörren
case SENSOR:
if(door == DOOR_CLOSED)
setControl(OPEN_DOOR);
break;
// Dörren har stängts
case DOOR_CLOSED:
door = DOOR_CLOSED;
break;
// Dörren har öppnats, börja räkna ner innan den ska stängas igen
case DOOR_OPENED:
door = DOOR_OPENED;
set_timeout(30);
break;
// Timeouten är klar, stäng nu dörren
case TIME_OUT:
if(door == DOOR_OPENED)
setControl(CLOSE_DOOR);
break;
}
}
return 0;
}
void I2C_EE_Erase(void)
{
int percentage;
unsigned int LEDbackup;
int i;
clear();
write('E');
write('R');
write('A');
write('S');
write('I');
write('N');
write('G');
for (i=CONFIGLENGTH;i<EEPROM_BYTES;i++)
{
I2C_EE_BufferWrite(blank, i, 1);
// I2C_EE_ByteWrite(blank, i);
if((i%100)==0){
setCursor(0,1);
percentage = (100*i)/(EEPROM_BYTES-CONFIGLENGTH);
writenumber(percentage);
write('%');
write(' ');
write(' ');}
LEDbyte = LEDRripple[(i/80)%10];
setLEDS();
}
clear();
complete();
delay_ms(2000);
clear();
standby();
LEDbyte=LEDbackup;
setLEDS();
}
void item_press(GtkWidget *widget, GdkEventButton *event, gpointer data)
{
ITEM_IMG *item_img = (ITEM_IMG *)data;
gint index = item_img->index;
switch(index)
{
case REBOOT:
do_reboot();
break;
case STANDBY:
standby();
break;
case SHUTDOWN:
do_shutdown();
break;
case CANCEL:
cancel();
break;
}
}
ssize_t AudioHardware::AudioStreamInMSM72xx::read( void* buffer, ssize_t bytes)
{
LOGV("AudioStreamInMSM72xx::read(%p, %ld)", buffer, bytes);
if (!mHardware) return -1;
size_t count = bytes;
uint8_t* p = static_cast<uint8_t*>(buffer);
if (mState < AUDIO_INPUT_OPENED) {
Mutex::Autolock lock(mHardware->mLock);
if (set(mHardware, mDevices, &mFormat, &mChannels, &mSampleRate) != NO_ERROR) {
return -1;
}
}
if (mState < AUDIO_INPUT_STARTED) {
mState = AUDIO_INPUT_STARTED;
// force routing to input device
mHardware->clearCurDevice();
mHardware->doRouting();
if (ioctl(mFd, AUDIO_START, 0)) {
LOGE("Error starting record");
standby();
return -1;
}
}
while (count) {
ssize_t bytesRead = ::read(mFd, buffer, count);
if (bytesRead >= 0) {
count -= bytesRead;
p += bytesRead;
} else {
if (errno != EAGAIN) return bytesRead;
mRetryCount++;
LOGW("EAGAIN - retrying");
}
}
return bytes;
}
void I2C_EE_FinishLog(void)
{
// int loglength = ((int)Config[0])<<8 + Config[1];
int loglength;
loglength = (currentByte-CONFIGLENGTH)/ENTRYBYTES;
Config[0] = loglength>>8;
Config[1] = loglength % 0x100;
I2C_EE_WriteConfig();
clear();
write('S');
write('t');
write('o');
write('p');
write('p');
write('i');
write('n');
write('g');
delay_ms(2000);
clear();
standby();
}
void main() {
puts("Started...");
initIRQ();
while(1) {
interruptType = NO_IRQ_TYPE;
standby();
switch(interruptType) {
case SENSOR :
*base_address = 0x01;
break;
case OPENED_DOOR :
setTimeout(1);
break;
case TIME_OUT :
*base_address = 0x02;
break;
default :
break;
}
}
}
void FXOS8700CQ::init()
{
standby(); // Must be in standby to change registers
// Configure the accelerometer
writeReg(FXOS8700CQ_XYZ_DATA_CFG, accelFSR); // Choose the full scale range to 2, 4, or 8 g.
//writeReg(FXOS8700CQ_CTRL_REG1, readReg(FXOS8700CQ_CTRL_REG1) & ~(0x38)); // Clear the 3 data rate bits 5:3
if (accelODR <= 7)
writeReg(FXOS8700CQ_CTRL_REG1, readReg(FXOS8700CQ_CTRL_REG1) | (accelODR << 3));
//writeReg(FXOS8700CQ_CTRL_REG2, readReg(FXOS8700CQ_CTRL_REG2) & ~(0x03)); // clear bits 0 and 1
//writeReg(FXOS8700CQ_CTRL_REG2, readReg(FXOS8700CQ_CTRL_REG2) | (0x02)); // select normal(00) or high resolution (10) mode
// Configure the magnetometer
writeReg(FXOS8700CQ_M_CTRL_REG1, 0x80 | magOSR << 2 | 0x03); // Set auto-calibration, set oversampling, enable hybrid mode
// Configure interrupts 1 and 2
//writeReg(CTRL_REG3, readReg(CTRL_REG3) & ~(0x02)); // clear bits 0, 1
//writeReg(CTRL_REG3, readReg(CTRL_REG3) | (0x02)); // select ACTIVE HIGH, push-pull interrupts
//writeReg(CTRL_REG4, readReg(CTRL_REG4) & ~(0x1D)); // clear bits 0, 3, and 4
//writeReg(CTRL_REG4, readReg(CTRL_REG4) | (0x1D)); // DRDY, Freefall/Motion, P/L and tap ints enabled
//writeReg(CTRL_REG5, 0x01); // DRDY on INT1, P/L and taps on INT2
active(); // Set to active to start reading
}
