Buscando un programa para usar el microcontrolador 51 para controlar ADXL345 para medir el ángulo. A través del sensor ADXL345, use el microcontrolador 51 para controlar el programa para medir el ángulo de inclinación.

/******************************************

Señal de parada

************ ********************** ******/

void ADXL345_Stop()

{

SDA = 0; // Baja la línea de datos

SCL = 1; // Lleva la línea del reloj hacia arriba

Delay5us(); //Retraso

SDA = 1 //Genera flanco ascendente

Delay5us; (); //Retraso

}

/******** ******************** **********

Enviar señal de respuesta

Parámetros de entrada: ack (0: ACK 1: NAK)

********************************* *** *******/

void ADXL345_SendACK(bit ack)

{

SDA = ack //Escribe señal de respuesta

SCL = 1; // Baja la línea del reloj

Delay5us(); //Delay

SCL = 0 // Baja la línea del reloj

Retraso5us(); //Retraso

}

/********************** ******** *************

Recibir señal de respuesta

************ ************ *******************/

bit ADXL345_RecvACK()

{

SCL = 1; // Levanta la línea del reloj

Delay5us(); //Retraso

CY = SDA //Leer señal de respuesta

p>

SCL = 0; //Tirar de la línea de reloj baja

Delay5us(); //Retraso

return CY;

}

/****** *************************************

Enviar un byte de datos al bus IIC

****************************** ***********/

void ADXL345_SendByte(BYTE dat)

{

BYTE i; > for (i=0; ilt; 8; i) // Contador de 8 bits

{

dat lt; = 1; data

SDA = CY; // Puerto de envío de datos

SCL = 1; // Tira de la línea del reloj hacia arriba

Delay5us() // Retraso

SCL = 0; // Baja la línea del reloj

Delay5us(); //Retraso

}

ADXL345_RecvACK();

}

/******* **************************** **

Recibir un byte de datos del bus IIC

*************************** *****

************/

BYTE ADXL345_RecvByte()

{

BYTE i;

BYTE dat = 0;

SDA = 1; //Habilitar pull-up interno, listo para leer datos,

for (i=0; ilt; 8; i) //8 Contador de bits

{

dat lt; = 1;

SCL = 1; //tirar la línea del reloj hacia arriba

Delay5us (); //Retraso

dat |= SDA; //Leer datos

SCL = 0; //Bajar la línea del reloj

Delay5us() ; //Retraso

}

return dat;

}

//******Escritura de un solo byte Enter* *****************************************

void Single_Write_ADXL345 (uchar REG_Address, uchar REG_data)

{

ADXL345_Start(); //Señal de inicio

ADXL345_SendByte(SlaveAddress); //Enviando señal de escritura de dirección del dispositivo

ADXL345_SendByte(REG_Address); //Dirección de registro interno, consulte la página 22 del pdf en chino

ADXL345_SendByte(REG_data); //Datos del registro interno, consulte la página 22 del pdf en chino

ADXL345_Stop(); //Enviar señal de parada

}

//*********Lectura de un solo byte***** ** ********************************

uchar Single_Read_ADXL345(uchar REG_Address)

{ uchar REG_data;

ADXL345_Start(); //Iniciar señal

ADXL345_SendByte(SlaveAddress); //Enviar señal de escritura de dirección del dispositivo

ADXL345_SendByte (REG_Address); //Envía la dirección de la unidad de memoria, comenzando desde 0

ADXL345_Start(); //Señal de inicio

ADXL345_SendByte(SlaveAddress 1);

//Enviar señal de lectura de dirección del dispositivo

REG_data=ADXL345_RecvByte(); //Leer datos de registro

ADXL345_SendACK(1);

ADXL345_Stop(); Señal de parada

return REG_data

}

//********************* * ************************************

//

//Lea continuamente los datos de aceleración interna de ADXL345, rango de direcciones 0x32~0x37

//

//************** *****************************************

void Multiple_read_ADXL345(void)

{ uchar i;

ADXL345_Start(); //Señal de inicio

ADXL345_SendByte(SlaveAddress); Signal

ADXL345_SendByte(0x32); //Enviar dirección de unidad de almacenamiento, comenzando desde 0x32

ADXL345_Start(); //Iniciar señal

ADXL345_SendByte(SlaveAddress 1 ) ; //Enviar señal de lectura de dirección del dispositivo

for (i=0; ilt; 6; i) //Leer continuamente 6 datos de dirección, almacenados en BUF

{

BUF[i] = ADXL345_RecvByte(); //BUF[0] almacena los datos en la dirección 0x32

if (i == 5)

{

ADXL345_SendACK(1); //Los últimos datos deben devolver NOACK

}

else

{

ADXL345_SendACK( 0); //Respuesta a ACK

}

}

ADXL345_Stop(); //Señal de parada

Delay5ms() ;

}

//********************************* * ********************************

//Inicialice ADXL345, consulte el pdf según sea necesario Realizar cambios************************

p>void Init_ADXL345()

{

Single_Write_ADXL345(0x31, 0x0B); //Rango de medición, más o menos 16 g, modo de 13 bits

Single_Write_ADXL345 (0x2C, 0x08); //Establezca la velocidad en 12,5, consulte la página 13 del pdf

Single_Write_ADXL345(0x2D, ​​​​0x08); //Seleccione el modo de energía, consulte la página 24 del pdf

Single_Write_ADXL345(0x2E, 0x80); //Habilitar interrupción DATA_READY

Single_Write_ADXL345(0x1E, 0x00); //El desplazamiento X se escribe en la página pdf29 según el estado del sensor de prueba

Single_Write_ADXL345(0x1F, 0x00); / /El desplazamiento Y se escribe en la página 29 del pdf según el estado del sensor de prueba

Single_Write_ADXL345(0x20, 0x05); pdf página 29 según el estado del sensor de prueba

}

//************************ ******************* *******************************

//Mostrar eje x

void display_x()

{ float temp;

dis_data=(BUF[1]lt; lt;8) BUF[0]; //Datos sintéticos

if(dis_datalt; 0){

dis_data=-dis_data;

DisplayOneChar(2, 0, '-'); //Mostrar los bits de signo positivo y negativo

}

else DisplayOneChar(2, 0, ' ');

temp=(float)dis_data*3.9; //Calcule los datos y visualícelos, consulte la página de inicio rápido 4 de ADXL345

conversion(temp); p> DisplayOneChar(0, 0, 'X'); // Línea 0, no. La columna 0 muestra ,'.

DisplayOneChar(5, 0, bai); p> DisplayOneChar(6, 0, shi);

DisplayOneChar(7, 0 ,'g');

}

//**** ************************** ************************* *********************

>Mostrar eje y

void display_y()

{ temperatura flotante;

dis_data=(BUF[3]

lt;lt;8) BUF[2]; //Datos sintéticos

if(dis_datalt;0){

dis_data=-dis_data;

DisplayOneChar( 2, 1, '-'); //Mostrar bits de signo positivos y negativos

}

else DisplayOneChar(2, 1, ' '); >

temp=(float)dis_data*3.9; //Calcule los datos y visualícelos, consulte la página 4 del inicio rápido de ADXL345

conversion(temp); //Convierta los datos necesarios para la visualización

DisplayOneChar(0, 1, 'Y'); // Fila 1, columna 0 muestra y

DisplayOneChar(1, 1, ':'); (3, 1, qian);

DisplayOneChar(4, 1, '.');

DisplayOneChar(5, 1, bai

DisplayOneChar); (6, 1, shi);

DisplayOneChar(7, 1, 'g'

}

//****** *); ************************************************** ***************

//Mostrar eje z

void display_z()

{ float temp;

dis_data=(BUF[5]lt;lt;8) BUF[4]; //Datos sintéticos

if(dis_datalt;0){

dis_data =-dis_data;

DisplayOneChar(10, 1, '-'); //Mostrar bit de signo negativo

}

else DisplayOneChar(10, 1 , ' '); //Mostrar espacios

temp=(float)dis_data*3.9; //Calcular datos y mostrar, consulte la página 4 del inicio rápido de ADXL345

conversion(temp) ; //Convierte los datos necesarios para la visualización

/*

DisplayOneChar(10, 0, 'Z'); //Fila 0, columna 10 muestra Z

DisplayOneChar(11, 0, ':');

DisplayOneChar(11, 1, qian

DisplayOneChar(12, 1, '.'); > p>

DisplayOneChar(13, 1, bai);

DisplayOneChar(14, 1, shi

DisplayOneChar(15, 1, 'g'); /p>

p>

*/

}

//********************* ****** *******************************

p>//******Programa principal************

//******************* *** *************************************

void main()

{

uchar devid;

float Roll, Pitch, Q, T, K

retardo(500); Retraso de encendido

InitLcd(); //Inicialización de LCD ADXL345

Init_ADXL345(); //Inicialización de ADXL345

devid=Single_Read_ADXL345(0X00); /Leer Los datos son 0XE5, lo que significa correcto

while(1) //Bucle

{

Init_ADXL345() //Inicializar ADXL345

Multiple_Read_ADXL345(); //Leer datos continuamente y almacenarlos en BUF

data_xyz[0]=(BUF[1]lt;lt;8) BUF[0];

data_xyz[1]=(BUF[3]lt;lt;8) BUF[2] //Datos sintéticos

data_xyz[2]=(BUF[5 ]lt;lt ;8) BUF[4]; //Datos sintéticos

//Los datos originales de aceleración X, Y, Z respectivamente, 10 bits

Q=(float )data_xyz[ 0]*3.9;

T=(float)data_xyz[1]*3.9;

K=(float)data_xyz[2]*3.9;

Q=-Q;

Roll=(float)(((atan2(K, Q)*180)/3.14159265) 180); //Valor del ángulo del eje X

Pitch= (float)(((atan2(K, T)*180)/3.14159265) 180); //Valor del ángulo del eje Y

conversión(Roll); datos del eje necesarios para la visualización, o eje Y

DisplayOneChar(9, 1, 'A'

DisplayOneChar(10, 1, ':'); p> DisplayOneChar(11, 1, bai);

DisplayOneChar(12, 1, shi

DisplayOneChar(13, 1, ge); retraso(200); / /Retraso

}

}