#include <stdarg.

h>
#include <stdbool.h>
#include <stdint.h>
#include <stdio.h>
#include <math.h>
#include <string.h>
#include "inc/hw_i2c.h"
#include "inc/hw_memmap.h"
#include "inc/hw_types.h"
#include "inc/hw_gpio.h"
#include "driverlib/i2c.h"
#include "driverlib/sysctl.h"
#include "driverlib/gpio.h"
#include "driverlib/uart.h"
#include "driverlib/pin_map.h"
#include "utils/uartstdio.h"
#include "inc/TM4C123GH6PM.h"

#define ADXL345_SLAVE_ADRESS 0x53

#define DATAX0 0x32
#define DATAX1 0x33
#define DATAY0 0x34
#define DATAY1 0x35
#define DATAZ0 0x36
#define DATAZ1 0x37

char Data_buffer[15]={0};
char Data_buffer1[15]={0};
char Data_buffer2[15]={0};
uint8_t Ax0, Ax1, Ay0 ,Ay1, Az0, Az1;
float X_out, Y_out, Z_out;
uint8_t buffer[8]={0};

// Function prototypes initialize, tranmit and rea functions

void I2C3_Init ( void );
char I2C3_read_Multiple(int slave_address, char slave_memory_address, int
bytes_count, uint8_t* data);
void InitUART0(void);
void InitConsole(void);

// reverses a string 'str' of length 'len'

void reverse(char *str, int len)
{
int i=0, j=len-1, temp;
while (i<j)
{
temp = str[i];
str[i] = str[j];
str[j] = temp;
i++; j--;
}
}

// Converts a given integer x to string str[]. d is the number

// of digits required in output. If d is more than the number
// of digits in x, then 0s are added at the beginning.
int intToStr(int x, char str[], int d)
{
 int i = 0;
while (x)
{
str[i++] = (x%10) + '0';
x = x/10;
}

// If number of digits required is more, then

// add 0s at the beginning
while (i < d)
str[i++] = '0';

reverse(str, i);
str[i] = ' ';
return i;
}

// Converts a floating point number to string.

void ftoa(float n, char *res, int afterpoint)
{
// Extract integer part
int ipart = (int)n;

// Extract floating part

float fpart = n - (float)ipart;

// convert integer part to string

int i = intToStr(ipart, res, 0);

// check for display option after point

if (afterpoint != 0)
{
res[i] = '.'; // add dot

// Get the value of fraction part upto given no.

// of points after dot. The third parameter is needed
// to handle cases like 233.007
fpart = fpart * pow(10, afterpoint);

intToStr((int)fpart, res + i + 1, afterpoint);

}
}

int main(void)
{
// Set the clocking to run directly from the external crystal/oscillator.
SysCtlClockSet(SYSCTL_SYSDIV_1 | SYSCTL_USE_PLL | SYSCTL_OSC_INT |
SYSCTL_XTAL_16MHZ);

//initialize UART module 0

// InitUART0();
InitConsole();

//initialize I2C module 3

I2C3_Init();
UARTprintf("ADXL345 SENSOR\n\r");

memset(Data_buffer,' ',sizeof(Data_buffer));
 memset(Data_buffer1,' ',sizeof(Data_buffer1));
memset(Data_buffer2,' ',sizeof(Data_buffer2));

while(1)
{
/* I2C3_read_Multiple(ADXL345_SLAVE_ADRESS,DATAX0,1,&Ax0);
UARTprintf("AX0:%x\n\r",Ax0);
I2C3_read_Multiple(ADXL345_SLAVE_ADRESS,DATAX1,1,&Ax1);
UARTprintf("AX1:%x\n\r",Ax1);
I2C3_read_Multiple(ADXL345_SLAVE_ADRESS,DATAY0,1,&Ay0);
UARTprintf("AY0:%x\n\r",Ay0);
I2C3_read_Multiple(ADXL345_SLAVE_ADRESS,DATAY1,1,&Ay1);
UARTprintf("AY1:%x\n\r",Ay1);
I2C3_read_Multiple(ADXL345_SLAVE_ADRESS,DATAZ0,1,&Az0);
UARTprintf("AZ0:%x\n\r",Az0);
I2C3_read_Multiple(ADXL345_SLAVE_ADRESS,DATAZ1,1,&Az1);
UARTprintf("AZ1:%x\n\r",Az1);

X_out = ( Ax0 | Ax1 << 8);

X_out = X_out/256;
Y_out = ( Ay0 | Ay1 << 8);
Y_out = Y_out/256;
Z_out = ( Az0 | Az1 << 8);
Z_out = Z_out/256; */

I2C3_read_Multiple(ADXL345_SLAVE_ADRESS,DATAX0,6,&buffer[0]);
UARTprintf("%x %x %x %x %x %x\n\
r",buffer[0],buffer[1],buffer[2],buffer[3],buffer[4],buffer[5]);

X_out = (((int)buffer[1]) << 8) | buffer[0];

X_out = X_out/256;
Y_out = (((int)buffer[3]) << 8) | buffer[2];
Y_out = Y_out/256;
Z_out = (((int)buffer[5]) << 8) | buffer[4];
Z_out = Z_out/256;

// UARTprintf("X-Axis : %f Y-Axis: %f Z-Axis: %f\n\r",X_out,Y_out,Z_out);

// sprintf(Data_buffer, "X-Axis : %f" ,X_out );
ftoa(X_out, Data_buffer, 2);
UARTprintf("X-AXIS:%s",Data_buffer);
ftoa(Y_out, Data_buffer1, 2);
UARTprintf("Y-AXIS:%s",Data_buffer1);
ftoa(Z_out, Data_buffer2, 2);
UARTprintf("Z-AXIS:%s\n\r",Data_buffer1);

SysCtlDelay(2000000);

memset(Data_buffer,0,sizeof(Data_buffer));
memset(Data_buffer1,0,sizeof(Data_buffer1));
memset(Data_buffer2,0,sizeof(Data_buffer2));

X_out = 0;
Y_out = 0;
Z_out = 0;

}
}

/*void InitUART0(void)
{
SysCtlPeripheralEnable(SYSCTL_PERIPH_UART0);

SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOA);

GPIOPinConfigure(GPIO_PA0_U0RX);
GPIOPinConfigure(GPIO_PA1_U0TX);

GPIOPinTypeUART(GPIO_PORTA_BASE, GPIO_PIN_0 | GPIO_PIN_1);

UARTConfigSetExpClk(UART0_BASE, SysCtlClockGet(), 115200,

(UART_CONFIG_WLEN_8 | UART_CONFIG_STOP_ONE | UART_CONFIG_PAR_NONE));

}*/

void InitConsole(void)
{
SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOA);

GPIOPinConfigure(GPIO_PA0_U0RX);
GPIOPinConfigure(GPIO_PA1_U0TX);

SysCtlPeripheralEnable(SYSCTL_PERIPH_UART0);

UARTClockSourceSet(UART0_BASE, UART_CLOCK_PIOSC);

GPIOPinTypeUART(GPIO_PORTA_BASE, GPIO_PIN_0 | GPIO_PIN_1);

UARTStdioConfig(0, 115200, 16000000);

}

// I2C intialization and GPIO alternate function configuration

void I2C3_Init ( void )
{
SYSCTL_RCGCGPIO_R = (1<<3); // Enable the clock for port D
SYSCTL_RCGCI2C_R = (1<<3); // Enable the clock for I2C 3
GPIO_PORTD_DEN_R = (1<<0)|(1<<1); // Assert DEN for port D
// Configure Port D pins 0 and 1 as I2C 3
GPIO_PORTD_AFSEL_R = (1<<0)|(1<<1);
GPIO_PORTD_PCTL_R = 0x00000033 ;
GPIO_PORTD_ODR_R = (1<<1) ; // SDA (PD1 ) pin as open darin
I2C3_MCR_R = (1<<4) ; // Enable I2C 3 master function
/* Configure I2C 3 clock frequency
(1 + TIME_PERIOD ) = SYS_CLK /(2*
( SCL_LP + SCL_HP ) * I2C_CLK_Freq )
TIME_PERIOD = 16 ,000 ,000/(2(6+4) *100000) - 1 = 7 */
I2C3_MTPR_R = 0X07 ;

HWREG(I2C3_BASE + I2C_O_FIFOCTL) = 80008000;

}
/* wait untill I2C Master module is busy */
/* and if not busy and no error return 0 */
static int I2C_wait_till_done(void)
{
while(I2C3_MCS_R & 1); /* wait until I2C master is not busy */
 return I2C3_MCS_R & 0xE; /* return I2C error code, 0 if no error*/
}

char I2C3_read_Multiple(int slave_address, char slave_memory_address, int

bytes_count, uint8_t* data)
{
char error;

if (bytes_count <= 0)
return 1; /* no read was performed */

/* send slave address and starting address */

I2C3_MSA_R = slave_address << 1;
I2C3_MDR_R = slave_memory_address;
I2C3_MCS_R = 3;
error = I2C_wait_till_done();
if (error)
return error;

I2C3_MSA_R = (slave_address << 1) + 1; /* restart: -R-(saddr+r)-ACK */

if (bytes_count == 1) /* if last byte, don't ack */

I2C3_MCS_R = 7; /* -data-NACK-P */
else /* else ack */
I2C3_MCS_R = 0xB; /* -data-ACK- */
error = I2C_wait_till_done();
if (error) return error;

*data++ = I2C3_MDR_R; /* store the data received */

if (--bytes_count == 0)
{
while(I2C3_MCS_R & 0x40);
return 0;
}

while (bytes_count > 1)

{
I2C3_MCS_R = 9;
error = I2C_wait_till_done();
if (error) return error;
bytes_count--;
*data++ = I2C3_MDR_R;
}

I2C3_MCS_R = 5;
error = I2C_wait_till_done();
*data = I2C3_MDR_R;
while(I2C3_MCS_R & 0x40);

return 0; /* no error */
}