ADXL345.c

#include <fcntl.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <errno.h>
#include <stdio.h>
#include <linux/i2c-dev.h>

#include "ADXL345.h"

//Write only an address
int write_address(const unsigned char reg){
    if (write(i2c_bus, &reg, 1) != 1) {
        //printf("Failed to write to the i2c bus.\n");
        //printf("%s\n\n",strerror(errno));
        return 0;
    }
    return 1;
}

//Write a byte to an address
int write_byte(unsigned char reg, unsigned char data){
    buf[0] = reg;
    buf[1] = data;

    if (write(i2c_bus, buf, 2) != 2) {
        //printf("Failed to write to the i2c bus.\n");
        //printf("%s\n\n",strerror(errno));
        return 0;
    }

    return 1;
}

//Read the current register at an address, then change only the masked bytes based on data
int write_masked_byte(unsigned char reg, unsigned char data, char mask){
    unsigned char current_data;

    //Write desired register
    if(write_address(reg) == 0)
        return 1;

    //Read current value of register
    if(read_current_byte(&current_data) == 0)
        return 1;

    //Write masked data
    data = (current_data & ~mask) | (data & mask);

    return write_byte(reg, data);
}

//Read a byte from the current address
int read_current_byte(unsigned char * data){
    if (read(i2c_bus,buf,1) != 1) {
        //printf("Failed to read from the i2c bus.\n");
        //printf("%s\n\n",strerror(errno));
        return 0;
    }

    *data = buf[0];
    return 1;
}

//Read a byte from the passed register
int read_byte(unsigned char reg, unsigned char * data){
    //Write the register's address
    if(write_address(reg) == 0)
        return 0;

    //Read from that address
    return read_current_byte(data);
}

//Go from standby to measurement mode
int measure_mode(){
    //printf("Go to measure mode... ");
    if(write_masked_byte(REG_POWER_CTL,0x08,0x08) == 0)
        return 0;
    //printf("Set to measure mode okay.\n");
    return 1;
}

//Go to standby mode
int standby_mode(){
    //printf("Go to standby mode... ");
        if(write_masked_byte(REG_POWER_CTL,0x00,0x08) == 0)
                return 0;
        //printf("Set to standby mode okay.\n");
        return 1;
}

//Pass 1 to set power mode, 0 to turn off
//0 by default
int set_low_power(unsigned char power){
    return write_masked_byte(REG_BW_RATE, power<<3,0x10);
}

//Pass a value to set sensed range
//Potential values are 2,4,8,16g
int set_range(char range_set){
    unsigned char rate = 0xF;
    switch(range_set){
        case 2: rate = 0x0; break;
        case 4: rate = 0x1; break;
        case 8: rate = 0x2; break;
        case 16: rate = 0x3; break;
        default: printf("Not a valid range.\n"); return 0;
    }
    if(write_masked_byte(REG_DATA_FORMAT,rate,0x3) == 0)
        return 0;

    range = range_set;

    return 1;
}

int get_range(){
    unsigned char data;
    if(read_byte(REG_DATA_FORMAT,&data) == 0)
        return 0;
    //Mask off non-range bits
    data = data & 0x3;
        switch(data){
                case 0x0: range = 2; break;
                case 0x1: range = 4; break;
                case 0x2: range = 8; break;
                case 0x3: range = 16; break;
                default: printf("Not a valid range.\n"); return 0;
        }
    return 1;
}

//Read a multiple bytes starting with register reg and proceeding for length len
//Data should be at least len long, otherwise an overflow will occur
int read_multibyte(unsigned char reg, unsigned char * data, unsigned char len){
    unsigned char ret = 0;

    ret = write(i2c_bus, &reg, 1);
    ret = read(i2c_bus, data, len);

    if (ret != len) {
        printf("MultiByte read error\n");
    }

    return ret;
}

float convert_to_g(unsigned short raw){
    char negative = 0;
    float result;
    //Convert from twos complement
    if((raw >> 15) == 1){
                raw = ~raw + 1;
                negative = 1;
        }
        result = (float)raw;
        if(negative)
                result *= -1;

    //1FF is the maximum value of a 10-bit signed register
    result = (float)4 * (result/(0x1FF));
}

vec get_orientation() {
    char xyz[6];
    vec orientation;

    read_multibyte(REG_DATAX0, xyz, 6);
    orientation.x = convert_to_g(xyz[1] << 8 | xyz[0]);
    orientation.y = convert_to_g(xyz[3] << 8 | xyz[2]);
    orientation.z = convert_to_g(xyz[5] << 8 | xyz[4]);

    return orientation;
}