//*****************************************************************************
// Initializes both the A and B ports of the IO expander to be outputs.
// The IODIRA and IODIRB registers need to be set to 0x00.
//
// Paramters
// i2c_base: a valid base address of an I2C peripheral
//*****************************************************************************
void ioExpanderInit(uint32_t i2cBase)
{
//==============================================================
// Set Slave Address of the MCP23017
//==============================================================
i2cSetSlaveAddr(i2cBase, MCP23017_DEV_ID, I2C_WRITE);
//==============================================================
// Set the Direction of IODIRA to be outputs
// Write 0x00 to IODIRA
//==============================================================
// Send the IODIRA Address
i2cSendByte( i2cBase, IODIRA, I2C_MCS_START | I2C_MCS_RUN );
// Set PortA to be outputs
i2cSendByte( i2cBase, IODIRA, I2C_MCS_RUN | I2C_MCS_STOP );
//==============================================================
// Set the Direction of IODIRB to be outputs
// Write 0x00 to IODIRB
//==============================================================
// Send the IODIRB Address
i2cSendByte( i2cBase, IODIRB, I2C_MCS_START | I2C_MCS_RUN );
// Set PortB to be outputs
i2cSendByte( i2cBase, IODIRB, I2C_MCS_RUN | I2C_MCS_STOP );
}
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
// Maps the selected page to the device & address, and writes the device and address
// bytes to the device, leaving it in a state to accept more data.
EE_STATUS __writeActiveAddress(uint16_t page)
{
// map device and address to selected page
ee_mapdevice(page);
// send start condition
i2cSendStart();
i2cWaitForComplete();
// send device address with write
i2cSendByte(_device & I2C_WRITE);
i2cWaitForComplete();
// check if device is present and live
// device did not ACK it's address,
// data will not be transferred
// return error
if (i2cGetStatus() != TW_MT_SLA_ACK)
{
i2cSendStop();
return I2C_ERROR_NODEV;
}
// address MSB
i2cSendByte(_address >> 8);
i2cWaitForComplete();
// address LSB
i2cSendByte(_address & 0xFF);
i2cWaitForComplete();
return I2C_OK;
}
byte DetectTouch::mpr121Read(uint8_t address)
{
byte data;
i2cSendStart();
i2cWaitForComplete();
i2cSendByte(i2c_address); // write 0xB4
i2cWaitForComplete();
i2cSendByte(address); // write register address
i2cWaitForComplete();
i2cSendStart();
i2cSendByte(i2c_address+1); // write 0xB5
i2cWaitForComplete();
i2cReceiveByte(TRUE);
i2cWaitForComplete();
data = i2cGetReceivedByte(); // Get MSB result
i2cWaitForComplete();
i2cSendStop();
cbi(TWCR, TWEN); // Disable TWI
sbi(TWCR, TWEN); // Enable TWI
return data;
}
char ITG3200Read(unsigned char address)
{
char data;
cbi(TWCR, TWEN); // Disable TWI
sbi(TWCR, TWEN); // Enable TWI
i2cSendStart();
i2cWaitForComplete();
i2cSendByte(ITG3200_W); // write 0xD2
i2cWaitForComplete();
i2cSendByte(address); // write register address
i2cWaitForComplete();
i2cSendStart();
i2cSendByte(ITG3200_R); // write 0xD3
i2cWaitForComplete();
i2cReceiveByte(FALSE);
i2cWaitForComplete();
data = i2cGetReceivedByte(); // Get MSB result
i2cWaitForComplete();
i2cSendStop();
cbi(TWCR, TWEN); // Disable TWI
sbi(TWCR, TWEN); // Enable TWI
return data;
}
uint8_t Daisy23::mpr_read(uint8_t address)
{
byte data;
i2cSendStart();
i2cWaitForComplete();
i2cSendByte(0xB4); // write 0xB4
i2cWaitForComplete();
i2cSendByte(address); // write register address
i2cWaitForComplete();
i2cSendStart();
i2cSendByte(0xB5); // write 0xB5
i2cWaitForComplete();
i2cReceiveByte(TRUE);
i2cWaitForComplete();
data = i2cGetReceivedByte(); // Get MSB result
i2cWaitForComplete();
i2cSendStop();
cbi(TWCR, TWEN); // Disable TWI
sbi(TWCR, TWEN); // Enable TWI
return data;
}
// USED TO GET VALUES FROM I2C
void i2cMasterTransferNI(u08 deviceAddr, u08 sendlength, u08* senddata, u08 receivelength, u08* receivedata)
{
// disable TWI interrupt
cbi(TWCR, TWIE);
// send start condition
i2cSendStart();
i2cWaitForComplete();
// if there's data to be sent, do it
if(sendlength)
{
// send device address with write
i2cSendByte( deviceAddr & 0xFE );
i2cWaitForComplete();
// send data
while(sendlength)
{
i2cSendByte( *senddata++ );
i2cWaitForComplete();
sendlength--;
}
}
// if there's data to be received, do it
if(receivelength)
{
// send repeated start condition
i2cSendStart();
i2cWaitForComplete();
// send device address with read
i2cSendByte( deviceAddr | 0x01 );
i2cWaitForComplete();
// accept receive data and ack it
while(receivelength > 1)
{
i2cReceiveByte(TRUE);
i2cWaitForComplete();
*receivedata++ = i2cGetReceivedByte();
// decrement length
receivelength--;
}
// accept receive data and nack it (last-byte signal)
i2cReceiveByte(FALSE);
i2cWaitForComplete();
*receivedata++ = i2cGetReceivedByte();
}
// transmit stop condition
// leave with TWEA on for slave receiving
i2cSendStop();
while( !(inb(TWCR) & BV(TWSTO)) );
// enable TWI interrupt
sbi(TWCR, TWIE);
}
int16_t read_adxl345(char reg_adr)
{
char lsb, msb;
i2cSendStart();
i2cWaitForComplete();
i2cSendByte(ADXL345_W); // write to this I2C address, R/*W cleared
i2cWaitForComplete();
i2cSendByte(reg_adr); //Read from a given address
i2cWaitForComplete();
i2cSendStart();
i2cSendByte(ADXL345_R); // read from this I2C address, R/*W Set
i2cWaitForComplete();
i2cReceiveByte(TRUE);
i2cWaitForComplete();
lsb = i2cGetReceivedByte(); //Read the LSB data
i2cWaitForComplete();
i2cReceiveByte(FALSE);
i2cWaitForComplete();
msb = i2cGetReceivedByte(); //Read the MSB data
i2cWaitForComplete();
i2cSendStop();
return( (msb<<8) | lsb);
}
//write a byte to eeprom
void writeEEPROM(short address, BYTE data){
i2cStart(I2C2);
i2cSendByte(I2C2, 0x50 << 1);
i2cSendByte(I2C2, (address & 0xFF00)>> 8);
i2cSendByte(I2C2, address & 0xFF);
i2cSendByte(I2C2, data);
i2cStop(I2C2);
}
void magnetometer(void)
{
/*
The magnetometer values must be read consecutively
in order to move the magnetometer pointer. Therefore the x, y, and z
outputs need to be kept in this function. To read the magnetometer
values, call the function magnetometer(), then global vars
x_mag, y_mag, z_mag.
*/
magnetometer_init();
uint8_t xh, xl, yh, yl, zh, zl;
//must read all six registers plus one to move the pointer back to 0x03
i2cSendStart();
i2cWaitForComplete();
i2cSendByte(0x3D); //write to HMC
i2cWaitForComplete();
i2cReceiveByte(TRUE);
i2cWaitForComplete();
xh = i2cGetReceivedByte(); //x high byte
i2cWaitForComplete();
i2cReceiveByte(TRUE);
i2cWaitForComplete();
xl = i2cGetReceivedByte(); //x low byte
i2cWaitForComplete();
x_mag = xl|(xh << 8);
i2cReceiveByte(TRUE);
i2cWaitForComplete();
zh = i2cGetReceivedByte();
i2cWaitForComplete(); //z high byte
i2cReceiveByte(TRUE);
i2cWaitForComplete();
zl = i2cGetReceivedByte(); //z low byte
i2cWaitForComplete();
z_mag = zl|(zh << 8);
i2cReceiveByte(TRUE);
i2cWaitForComplete();
yh = i2cGetReceivedByte(); //y high byte
i2cWaitForComplete();
i2cReceiveByte(TRUE);
i2cWaitForComplete();
yl = i2cGetReceivedByte(); //y low byte
i2cWaitForComplete();
y_mag = yl|(yh << 8);
i2cSendByte(0x3D); //must reach 0x09 to go back to 0x03
i2cWaitForComplete();
i2cSendStop();
}
void magnetometer_init(void)
{
i2cSendStart();
i2cWaitForComplete();
i2cSendByte(0x3C); //write to HMC
i2cWaitForComplete();
i2cSendByte(0x00); //mode register
i2cWaitForComplete();
i2cSendByte(0x70); //8 average, 15Hz, normal measurement
i2cWaitForComplete();
i2cSendStop();
i2cSendStart();
i2cWaitForComplete();
i2cSendByte(0x3C); //write to HMC
i2cWaitForComplete();
i2cSendByte(0x01); //mode register
i2cWaitForComplete();
i2cSendByte(0xA0); //gain = 5
i2cWaitForComplete();
i2cSendStop();
i2cSendStart();
i2cWaitForComplete();
i2cSendByte(0x3C); //write to HMC
i2cWaitForComplete();
i2cSendByte(0x02); //mode register
i2cWaitForComplete();
i2cSendByte(0x00); //continuous measurement mode
i2cWaitForComplete();
i2cSendStop();
}
//read a byte from the eeprom
BYTE readEEPROM(BYTE address){
i2cStart(I2C2);
i2cSendByte(I2C2, 0x50 << 1);
i2cSendByte(I2C2, (address & 0xFF00)>> 8);
i2cSendByte(I2C2, address & 0xFF);
i2cRepeatedStart(I2C2);
i2cSendByte(I2C2, 0x50 << 1 | 0x01);
BYTE temp = i2cRecieveByte(I2C2, FALSE);
i2cStop(I2C2);
return temp;
}
//write several bytes to the eeprom
void writeMultiEEPROM(short address, BYTE *data, int length){
i2cStart(I2C2);
i2cSendByte(I2C2, 0x50 << 1);
BYTE high = (address & 0xFF00) >> 8;
BYTE low = address & 0xFF;
i2cSendByte(I2C2, high);
i2cSendByte(I2C2, low);
int i;
for(i = 0; i < length; i++){
i2cSendByte(I2C2, data[i]);
}
i2cStop(I2C2);
}
void Daisy23::mpr_send(unsigned char address, unsigned char data)
{
i2cSendStart();
i2cWaitForComplete();
i2cSendByte(ADDR);// write 0xB4
i2cWaitForComplete();
i2cSendByte(address); // write register address
i2cWaitForComplete();
i2cSendByte(data);
i2cWaitForComplete();
i2cSendStop();
}
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
void ee_poll(void)
{
/*
ACKNOWLEDGE POLLING: Once the internally timed write cycle has started and the
EEPROM inputs are disabled, acknowledge polling can be initiated. This involves sending a
start condition followed by the device address word. The read/write bit is representative of the
operation desired. Only if the internal write cycle has completed will the EEPROM respond with
a zero, allowing the read or write sequence to continue.
*/
while(1)
{
i2cSendStart();
i2cWaitForComplete();
i2cSendByte(_device & I2C_WRITE);
i2cWaitForComplete();
if (i2cGetStatus() == TW_MT_SLA_ACK)
{
i2cSendStop();
//i2cWaitForComplete();
break;
}
}
}
void DetectTouch::mpr121Write(unsigned char address, unsigned char data)
{
i2cSendStart();
i2cWaitForComplete();
i2cSendByte(i2c_address);// write 0xB4
i2cWaitForComplete();
i2cSendByte(address); // write register address
i2cWaitForComplete();
i2cSendByte(data);
i2cWaitForComplete();
i2cSendStop();
}
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
// Reads a single byte of data from the EEPROM chip
uint8_t ee_read(void)
{
// sequential read is:
// Master EEPROM
// Start->
// <-Ack
// Device->
// <-Ack
// <-Send Byte
// (N)Ack->
// Stop->
// The TWI control module knows to ack/nack the response to the slave
// when in master-receive mode
// send start condition
i2cSendStart();
i2cWaitForComplete();
// send SLA+R
i2cSendByte(_device | I2C_READ);
i2cWaitForComplete();
// nack the last byte sent
i2cNack();
i2cWaitForComplete();
uint8_t data = i2cGetReceivedByte();
// increment the address pointer
//incrementAddress();
return data;
}
void ITG3200Write(unsigned char address, unsigned char data)
{
i2cSendStart();
i2cWaitForComplete();
i2cSendByte(ITG3200_W); // write 0xB4
i2cWaitForComplete();
i2cSendByte(address); // write register address
i2cWaitForComplete();
i2cSendByte(data);
i2cWaitForComplete();
i2cSendStop();
}
//Setup ADXL345 for constant measurement mode
void init_adxl345(void)
{
i2cSendStart();
i2cWaitForComplete();
i2cSendByte(ADXL345_W); //write to ADXL345
i2cWaitForComplete();
i2cSendByte(0x2D); //Write to Power CTL register
i2cWaitForComplete();
i2cSendByte( (1<<3) ); //Set the measure bit on D3
i2cWaitForComplete();
i2cSendStop();
}
//Read a tmp102 sensor on a given temp_number or channel
int16_t tmp102Read(void)
{
uint8_t msb, lsb;
int16_t temp;
i2cSendStart(); // send start condition
i2cWaitForComplete();
i2cSendByte(TMP102_WRITE); // send WRITE address of TMP102
i2cWaitForComplete();
i2cSendByte(0x00); // set TMP102 pointer register to 0 (read temperature)
i2cWaitForComplete();
i2cSendStart(); // send repeated start condition
i2cWaitForComplete();
i2cSendByte(TMP102_READ); // send READ address of TMP102
i2cWaitForComplete();
i2cReceiveByte(true); // receives one byte from the bus and ACKs it
i2cWaitForComplete();
msb = i2cGetReceivedByte(); // reads the MSB (it is a 12 bit value!)
i2cWaitForComplete();
i2cReceiveByte(false); // receives one byte from the bus and NAKs it (last one)
i2cWaitForComplete();
lsb = i2cGetReceivedByte(); // reads the LSB
i2cWaitForComplete();
i2cSendStop(); // send stop condition
TWCR = 0; // stop everything
// Convert the number to an 8-bit degree Celsius value
temp = (msb<<8) | lsb; // combine those two values into one 16 bit value
temp >>= 4; // the values are left justified; fix that by shifting 4 right
// negative numbers are represented in two's complement, but we just shifted the value and thereby potentially messed it up
if(temp & (1<<11)) // Hence: if it is a negative number
temp |= 0xF800; // restore the uppermost bits
// The 12 bit value has 0.0625°C precision, which is too much for what we want (and the sensor is anyways only about 0.5°C precise)
// 0.0625 is 1/16 -> Dividing by 16 leaves 1°C precision for the output. Note that shifting >> 4 might go wrong here for negative numbers.
temp /= 16;
return(temp);
}
uint8_t i2cMasterSendNI(uint8_t deviceAddr, uint8_t length, uint8_t const *data)
{
uint8_t retval = I2C_OK;
// disable TWI interrupt
cbi(TWCR, TWIE);
// send start condition
i2cSendStart();
i2cWaitForComplete();
// send device address with write
i2cSendByte(deviceAddr & 0xFE);
i2cWaitForComplete();
// check if device is present and live
if (inb(TWSR) == TW_MT_SLA_ACK)
{
// send data
while (length)
{
i2cSendByte(*data++);
i2cWaitForComplete();
length--;
}
}
else
{
// device did not ACK it's address,
// data will not be transferred
// return error
retval = I2C_ERROR_NODEV;
}
// transmit stop condition
// leave with TWEA on for slave receiving
i2cSendStop();
while (!(inb(TWCR) & BV(TWSTO)))
;
// enable TWI interrupt
sbi(TWCR, TWIE);
return retval;
}
// Blocking encoder read. This will fail if the encoders are in a weird state
void amsEncoderBlockingRead(unsigned char num) {
unsigned char enc_data[2];
CRITICAL_SECTION_START
i2cStartTx(ENC_I2C_CHAN); //Setup to burst read both registers, 0xFE and 0xFF
i2cSendByte(ENC_I2C_CHAN, encAddr[2*num+1]); //Write address
i2cSendByte(ENC_I2C_CHAN, AMS_ENC_ANGLE_REG);
i2cEndTx(ENC_I2C_CHAN);
i2cStartTx(ENC_I2C_CHAN);
i2cSendByte(ENC_I2C_CHAN, encAddr[2*num]); //Read address
i2cReadString(1,2,enc_data,10000);
i2cEndTx(ENC_I2C_CHAN);
IdleI2C1();
_MI2C1IF = 0;
CRITICAL_SECTION_END
amsEncoderUpdatePos(num,((enc_data[1] << 6)+(enc_data[0] & 0x3F)));
}
int8_t i2cSingleWrite(uint8_t addr,uint8_t data) {
if(device_addr > 0xFf)return I2C_ERR_ADDRESS_LONG;
i2cSendStop();
i2cSendStart();
switch(i2cSendByte(device_addr | I2C_WRITE)) {
case TW_MT_SLA_ACK:
break;
case TW_MT_SLA_NACK:
printf("Recieve Nack\n");
return I2C_ERR_NACK;
default:
return I2C_ERR_UNKNOWN;
}
switch(i2cSendByte(addr)) {
case TW_MT_DATA_ACK:
break;
case TW_MT_DATA_NACK:
printf("Recieve Nack\n");
return I2C_ERR_NACK;
default:
return I2C_ERR_UNKNOWN;
}
switch(i2cSendByte(data)) {
case TW_MT_DATA_ACK:
break;
case TW_MT_DATA_NACK:
printf("Recieve Nack\n");
return I2C_ERR_NACK;
default:
return I2C_ERR_UNKNOWN;
}
i2cSendStop();
return 1;
}
//Need to implement a check here so that it doesn't get stuck if the PSOC isn't attached
void PSOC_Read(){
//First 12 bytes are current sensor data, next 8 bytes are shock pots
BYTE PSOC_Data[24];
int i;
i2cStart(I2C1);
i2cSendByte(I2C1, (0x08 << 1) + 0) ;//send addresss and write
i2cSendByte(I2C1, 0x00);//send data pointer
i2cRepeatedStart(I2C1); //Repeat start to change data direction
// i2cStart(I2C1);
i2cSendByte(I2C1, (0x08 << 1) + 1) ;//send addresss and read
for(i = 0 ; i < 23; i++){
PSOC_Data[i] = i2cRecieveByte(I2C1, TRUE);
}
PSOC_Data[23] = i2cRecieveByte(I2C1, FALSE);
i2cStop(I2C1);//Stop the bus
//Combine the bytes
for(i = 0; i<12; i++){
PSOC_volts[i] = (PSOC_Data[2*i+1] <<8 | PSOC_Data[2*i]);
}
}
void i2cInit(void)
{
// set i2c bit rate to 40KHz
i2cSetBitrate(100);
// enable TWI (two-wire interface)
sbi(TWCR, TWEN);
//initialize
i2cSendStart();
i2cWaitForComplete();
i2cSendByte(0xA6); //write to ADXL
i2cWaitForComplete();
i2cSendByte(0x2D); //power register
i2cWaitForComplete();
i2cSendByte(0x08); //measurement mode
i2cWaitForComplete();
i2cSendStop();
i2cSendStart();
i2cWaitForComplete();
i2cSendByte(0xA6); //write to ADXL
i2cWaitForComplete();
i2cSendByte(0x31); //data format
i2cWaitForComplete();
i2cSendByte(0x08); //full resolution
i2cWaitForComplete();
i2cSendStop();
}
void accelerometer_init(void)
{
//initialize
i2cSendStart();
i2cWaitForComplete();
i2cSendByte(0xA6); //write to ADXL
i2cWaitForComplete();
i2cSendByte(0x2D); //power register
i2cWaitForComplete();
i2cSendByte(0x08); //measurement mode
i2cWaitForComplete();
i2cSendStop();
i2cSendStart();
i2cWaitForComplete();
i2cSendByte(0xA6); //write to ADXL
i2cWaitForComplete();
i2cSendByte(0x31); //data format
i2cWaitForComplete();
i2cSendByte(0x08); //full resolution
i2cWaitForComplete();
i2cSendStop();
}
//read multiple bytes from the eeprom
BOOL readMultiEEPROM(BYTE address, BYTE *data, int length){
BOOL keepReading = TRUE;
i2cStart(I2C2);
i2cSendByte(I2C2, 0x50 << 1);
i2cSendByte(I2C2, (address & 0xFF00)>> 8);
i2cSendByte(I2C2, address & 0xFF);
i2cRepeatedStart(I2C2);
i2cSendByte(I2C2, 0x50 << 1 | 0x01);
int i;
for(i = 0; i < length-1; i++){
*(data + i) = i2cRecieveByte(I2C2, TRUE);
if(*(data+i) == 0xFF){
keepReading = FALSE;
}
if(keepReading == FALSE){
*(data +i) = 0xFF;
}
}
*(data + length - 1) = i2cRecieveByte(I2C2, FALSE);
i2cStop(I2C2);
return keepReading;
}
uint8_t i2cMasterReceiveNI(uint8_t deviceAddr, uint8_t length, uint8_t *data)
{
uint8_t retval = I2C_OK;
// disable TWI interrupt
cbi(TWCR, TWIE);
// send start condition
i2cSendStart();
i2cWaitForComplete();
// send device address with read
i2cSendByte(deviceAddr | 0x01);
i2cWaitForComplete();
//rprintf("receive TWSR = 0x%x\n", TWSR);
// check if device is present and live
if (inb(TWSR) == TW_MR_SLA_ACK)
{
// accept receive data and ack it
while(length > 1)
{
i2cReceiveByte(TRUE);
i2cWaitForComplete();
*data++ = i2cGetReceivedByte();
// decrement length
length--;
}
// accept receive data and nack it (last-byte signal)
i2cReceiveByte(FALSE);
i2cWaitForComplete();
*data++ = i2cGetReceivedByte();
}
else
{
// device did not ACK it's address,
// data will not be transferred
// return error
retval = I2C_ERROR_NODEV;
}
// transmit stop condition
// leave with TWEA on for slave receiving
i2cSendStop();
// enable TWI interrupt
sbi(TWCR, TWIE);
return retval;
}
uint16_t z_accel(void)
{
//0xA6 for a write
//0xA7 for a read
uint8_t dummy, zh, zl;
uint16_t zo;
//0x36 data registers
i2cSendStart();
i2cWaitForComplete();
i2cSendByte(0xA6); //write to ADXL
i2cWaitForComplete();
i2cSendByte(0x36); //Z0 data register
i2cWaitForComplete();
i2cSendStop(); //repeat start
i2cSendStart();
i2cWaitForComplete();
i2cSendByte(0xA7); //read from ADXL
i2cWaitForComplete();
i2cReceiveByte(TRUE);
i2cWaitForComplete();
zl = i2cGetReceivedByte(); //z low byte
i2cWaitForComplete();
i2cReceiveByte(FALSE);
i2cWaitForComplete();
dummy = i2cGetReceivedByte(); //must do a multiple byte read?
i2cWaitForComplete();
i2cSendStop();
//0x37 data registers
i2cSendStart();
i2cWaitForComplete();
i2cSendByte(0xA6); //write to ADXL
i2cWaitForComplete();
i2cSendByte(0x37); //Z1 data register
i2cWaitForComplete();
i2cSendStop(); //repeat start
i2cSendStart();
i2cWaitForComplete();
i2cSendByte(0xA7); //read from ADXL
i2cWaitForComplete();
i2cReceiveByte(TRUE);
i2cWaitForComplete();
zh = i2cGetReceivedByte(); //z high byte
i2cWaitForComplete();
i2cReceiveByte(FALSE);
i2cWaitForComplete();
dummy = i2cGetReceivedByte(); //must do a multiple byte read?
i2cWaitForComplete();
i2cSendStop();
zo = zl|(zh << 8);
return zo;
}
uint16_t y_accel(void)
{
//0xA6 for a write
//0xA7 for a read
uint8_t dummy, yh, yl;
uint16_t yo;
//0x34 data registers
i2cSendStart();
i2cWaitForComplete();
i2cSendByte(0xA6); //write to ADXL
i2cWaitForComplete();
i2cSendByte(0x34); //Y0 data register
i2cWaitForComplete();
i2cSendStop(); //repeat start
i2cSendStart();
i2cWaitForComplete();
i2cSendByte(0xA7); //read from ADXL
i2cWaitForComplete();
i2cReceiveByte(TRUE);
i2cWaitForComplete();
yl = i2cGetReceivedByte(); //x low byte
i2cWaitForComplete();
i2cReceiveByte(FALSE);
i2cWaitForComplete();
dummy = i2cGetReceivedByte(); //must do a multiple byte read?
i2cWaitForComplete();
i2cSendStop();
//0x35 data registers
i2cSendStart();
i2cWaitForComplete();
i2cSendByte(0xA6); //write to ADXL
i2cWaitForComplete();
i2cSendByte(0x35); //Y1 data register
i2cWaitForComplete();
i2cSendStop(); //repeat start
i2cSendStart();
i2cWaitForComplete();
i2cSendByte(0xA7); //read from ADXL
i2cWaitForComplete();
i2cReceiveByte(TRUE);
i2cWaitForComplete();
yh = i2cGetReceivedByte(); //y high byte
i2cWaitForComplete();
i2cReceiveByte(FALSE);
i2cWaitForComplete();
dummy = i2cGetReceivedByte(); //must do a multiple byte read?
i2cWaitForComplete();
i2cSendStop();
yo = yl|(yh << 8);
return yo;
}
uint16_t x_accel(void)
{
//0xA6 for a write
//0xA7 for a read
uint8_t dummy, xh, xl;
uint16_t xo;
//0x32 data registers
i2cSendStart();
i2cWaitForComplete();
i2cSendByte(0xA6); //write to ADXL
i2cWaitForComplete();
i2cSendByte(0x32); //X0 data register
i2cWaitForComplete();
i2cSendStop(); //repeat start
i2cSendStart();
i2cWaitForComplete();
i2cSendByte(0xA7); //read from ADXL
i2cWaitForComplete();
i2cReceiveByte(TRUE);
i2cWaitForComplete();
xl = i2cGetReceivedByte(); //x low byte
i2cWaitForComplete();
i2cReceiveByte(FALSE);
i2cWaitForComplete();
dummy = i2cGetReceivedByte(); //must do a multiple byte read?
i2cWaitForComplete();
i2cSendStop();
//0x33 data registers
i2cSendStart();
i2cWaitForComplete();
i2cSendByte(0xA6); //write to ADXL
i2cWaitForComplete();
i2cSendByte(0x33); //X1 data register
i2cWaitForComplete();
i2cSendStop(); //repeat start
i2cSendStart();
i2cWaitForComplete();
i2cSendByte(0xA7); //read from ADXL
i2cWaitForComplete();
i2cReceiveByte(TRUE);
i2cWaitForComplete();
xh = i2cGetReceivedByte(); //x high byte
i2cWaitForComplete();
i2cReceiveByte(FALSE);
i2cWaitForComplete();
dummy = i2cGetReceivedByte(); //must do a multiple byte read?
i2cWaitForComplete();
i2cSendStop();
xo = xl|(xh << 8);
return xo;
}