ADXL345 三軸重力加速感測器

ID:399412 · 發表于 2018-9-18 11:12

這是我在網上找的最詳細的資料了, 針對 ADXL345 三軸G重力加速 sensor 最新的原理圖, 單芯片說明書, ST源成碼, Arduino 代碼. 希望對你有幫助. 如果覺得好用, 別忘了打賞 !

Arduino .h 代碼:

/**************************************************************************/
/*!
@file Adafruit_ADS1015.h
@author K. Townsend (Adafruit Industries)
@license BSD (see license.txt)
This is a library for the Adafruit ADS1015 breakout board
----> https://www.adafruit.com/products/???
Adafruit invests time and resources providing this open source code,
please support Adafruit and open-source hardware by purchasing
products from Adafruit!
@section HISTORY
v1.0 - First release
*/
/**************************************************************************/
#if ARDUINO >= 100
#include "Arduino.h"
#else
#include "WProgram.h"
#endif
#include <Adafruit_Sensor.h>
#include <Wire.h>
/*=========================================================================
I2C ADDRESS/BITS
-----------------------------------------------------------------------*/
#define ADXL345_ADDRESS (0x53) // Assumes ALT address pin low
/*=========================================================================*/
/*=========================================================================
REGISTERS
-----------------------------------------------------------------------*/
#define ADXL345_REG_DEVID (0x00) // Device ID
#define ADXL345_REG_THRESH_TAP (0x1D) // Tap threshold
#define ADXL345_REG_OFSX (0x1E) // X-axis offset
#define ADXL345_REG_OFSY (0x1F) // Y-axis offset
#define ADXL345_REG_OFSZ (0x20) // Z-axis offset
#define ADXL345_REG_DUR (0x21) // Tap duration
#define ADXL345_REG_LATENT (0x22) // Tap latency
#define ADXL345_REG_WINDOW (0x23) // Tap window
#define ADXL345_REG_THRESH_ACT (0x24) // Activity threshold
#define ADXL345_REG_THRESH_INACT (0x25) // Inactivity threshold
#define ADXL345_REG_TIME_INACT (0x26) // Inactivity time
#define ADXL345_REG_ACT_INACT_CTL (0x27) // Axis enable control for activity and inactivity detection
#define ADXL345_REG_THRESH_FF (0x28) // Free-fall threshold
#define ADXL345_REG_TIME_FF (0x29) // Free-fall time
#define ADXL345_REG_TAP_AXES (0x2A) // Axis control for single/double tap
#define ADXL345_REG_ACT_TAP_STATUS (0x2B) // Source for single/double tap
#define ADXL345_REG_BW_RATE (0x2C) // Data rate and power mode control
#define ADXL345_REG_POWER_CTL (0x2D) // Power-saving features control
#define ADXL345_REG_INT_ENABLE (0x2E) // Interrupt enable control
#define ADXL345_REG_INT_MAP (0x2F) // Interrupt mapping control
#define ADXL345_REG_INT_SOURCE (0x30) // Source of interrupts
#define ADXL345_REG_DATA_FORMAT (0x31) // Data format control
#define ADXL345_REG_DATAX0 (0x32) // X-axis data 0
#define ADXL345_REG_DATAX1 (0x33) // X-axis data 1
#define ADXL345_REG_DATAY0 (0x34) // Y-axis data 0
#define ADXL345_REG_DATAY1 (0x35) // Y-axis data 1
#define ADXL345_REG_DATAZ0 (0x36) // Z-axis data 0
#define ADXL345_REG_DATAZ1 (0x37) // Z-axis data 1
#define ADXL345_REG_FIFO_CTL (0x38) // FIFO control
#define ADXL345_REG_FIFO_STATUS (0x39) // FIFO status
/*=========================================================================*/
/*=========================================================================
REGISTERS
-----------------------------------------------------------------------*/
#define ADXL345_MG2G_MULTIPLIER (0.004) // 4mg per lsb
/*=========================================================================*/
/* Used with register 0x2C (ADXL345_REG_BW_RATE) to set bandwidth */
typedef enum
{
ADXL345_DATARATE_3200_HZ = 0b1111, // 1600Hz Bandwidth 140渙 IDD
ADXL345_DATARATE_1600_HZ = 0b1110, // 800Hz Bandwidth 90渙 IDD
ADXL345_DATARATE_800_HZ = 0b1101, // 400Hz Bandwidth 140渙 IDD
ADXL345_DATARATE_400_HZ = 0b1100, // 200Hz Bandwidth 140渙 IDD
ADXL345_DATARATE_200_HZ = 0b1011, // 100Hz Bandwidth 140渙 IDD
ADXL345_DATARATE_100_HZ = 0b1010, // 50Hz Bandwidth 140渙 IDD
ADXL345_DATARATE_50_HZ = 0b1001, // 25Hz Bandwidth 90渙 IDD
ADXL345_DATARATE_25_HZ = 0b1000, // 12.5Hz Bandwidth 60渙 IDD
ADXL345_DATARATE_12_5_HZ = 0b0111, // 6.25Hz Bandwidth 50渙 IDD
ADXL345_DATARATE_6_25HZ = 0b0110, // 3.13Hz Bandwidth 45渙 IDD
ADXL345_DATARATE_3_13_HZ = 0b0101, // 1.56Hz Bandwidth 40渙 IDD
ADXL345_DATARATE_1_56_HZ = 0b0100, // 0.78Hz Bandwidth 34渙 IDD
ADXL345_DATARATE_0_78_HZ = 0b0011, // 0.39Hz Bandwidth 23渙 IDD
ADXL345_DATARATE_0_39_HZ = 0b0010, // 0.20Hz Bandwidth 23渙 IDD
ADXL345_DATARATE_0_20_HZ = 0b0001, // 0.10Hz Bandwidth 23渙 IDD
ADXL345_DATARATE_0_10_HZ = 0b0000 // 0.05Hz Bandwidth 23渙 IDD (default value)
} dataRate_t;
/* Used with register 0x31 (ADXL345_REG_DATA_FORMAT) to set g range */
typedef enum
{
ADXL345_RANGE_16_G = 0b11, // +/- 16g
ADXL345_RANGE_8_G = 0b10, // +/- 8g
ADXL345_RANGE_4_G = 0b01, // +/- 4g
ADXL345_RANGE_2_G = 0b00 // +/- 2g (default value)
} range_t;
class Adafruit_ADXL345_Unified : public Adafruit_Sensor {
public:
Adafruit_ADXL345_Unified(int32_t sensorID = -1);
Adafruit_ADXL345_Unified(uint8_t clock, uint8_t miso, uint8_t mosi, uint8_t cs, int32_t sensorID = -1);
bool begin(void);
void setRange(range_t range);
range_t getRange(void);
void setDataRate(dataRate_t dataRate);
dataRate_t getDataRate(void);
bool getEvent(sensors_event_t*);
void getSensor(sensor_t*);
uint8_t getDeviceID(void);
void writeRegister(uint8_t reg, uint8_t value);
uint8_t readRegister(uint8_t reg);
int16_t read16(uint8_t reg);
int16_t getX(void), getY(void), getZ(void);
private:
inline uint8_t i2cread(void);
inline void i2cwrite(uint8_t x);
int32_t _sensorID;
range_t _range;
uint8_t _clk, _do, _di, _cs;
bool _i2c;
};

復制代碼

Arduino .cpp代碼:

/**************************************************************************/
/*!
@file Adafruit_ADXL345.cpp
@author K.Townsend (Adafruit Industries)
@license BSD (see license.txt)
The ADXL345 is a digital accelerometer with 13-bit resolution, capable
of measuring up to +/-16g. This driver communicate using I2C.
This is a library for the Adafruit ADXL345 breakout
----> https://www.adafruit.com/products/1231
Adafruit invests time and resources providing this open source code,
please support Adafruit and open-source hardware by purchasing
products from Adafruit!
@section HISTORY
v1.1 - Added Adafruit_Sensor library support
v1.0 - First release
*/
/**************************************************************************/
#if ARDUINO >= 100
#include "Arduino.h"
#else
#include "WProgram.h"
#endif
#include <Wire.h>
#include <limits.h>
#include "Adafruit_ADXL345_U.h"
/**************************************************************************/
/*!
@brief Abstract away platform differences in Arduino wire library
*/
/**************************************************************************/
inline uint8_t Adafruit_ADXL345_Unified::i2cread(void) {
#if ARDUINO >= 100
return Wire.read();
#else
return Wire.receive();
#endif
}
/**************************************************************************/
/*!
@brief Abstract away platform differences in Arduino wire library
*/
/**************************************************************************/
inline void Adafruit_ADXL345_Unified::i2cwrite(uint8_t x) {
#if ARDUINO >= 100
Wire.write((uint8_t)x);
#else
Wire.send(x);
#endif
}
/**************************************************************************/
/*!
@brief Abstract away SPI receiver & transmitter
*/
/**************************************************************************/
static uint8_t spixfer(uint8_t clock, uint8_t miso, uint8_t mosi, uint8_t data) {
uint8_t reply = 0;
for (int i=7; i>=0; i--) {
reply <<= 1;
digitalWrite(clock, LOW);
digitalWrite(mosi, data & (1<<i));
digitalWrite(clock, HIGH);
if (digitalRead(miso))
reply |= 1;
}
return reply;
}
/**************************************************************************/
/*!
@brief Writes 8-bits to the specified destination register
*/
/**************************************************************************/
void Adafruit_ADXL345_Unified::writeRegister(uint8_t reg, uint8_t value) {
if (_i2c) {
Wire.beginTransmission(ADXL345_ADDRESS);
i2cwrite((uint8_t)reg);
i2cwrite((uint8_t)(value));
Wire.endTransmission();
} else {
digitalWrite(_cs, LOW);
spixfer(_clk, _di, _do, reg);
spixfer(_clk, _di, _do, value);
digitalWrite(_cs, HIGH);
}
}
/**************************************************************************/
/*!
@brief Reads 8-bits from the specified register
*/
/**************************************************************************/
uint8_t Adafruit_ADXL345_Unified::readRegister(uint8_t reg) {
if (_i2c) {
Wire.beginTransmission(ADXL345_ADDRESS);
i2cwrite(reg);
Wire.endTransmission();
Wire.requestFrom(ADXL345_ADDRESS, 1);
return (i2cread());
} else {
reg |= 0x80; // read byte
digitalWrite(_cs, LOW);
spixfer(_clk, _di, _do, reg);
uint8_t reply = spixfer(_clk, _di, _do, 0xFF);
digitalWrite(_cs, HIGH);
return reply;
}
}
/**************************************************************************/
/*!
@brief Reads 16-bits from the specified register
*/
/**************************************************************************/
int16_t Adafruit_ADXL345_Unified::read16(uint8_t reg) {
if (_i2c) {
Wire.beginTransmission(ADXL345_ADDRESS);
i2cwrite(reg);
Wire.endTransmission();
Wire.requestFrom(ADXL345_ADDRESS, 2);
return (uint16_t)(i2cread() | (i2cread() << 8));
} else {
reg |= 0x80 | 0x40; // read byte | multibyte
digitalWrite(_cs, LOW);
spixfer(_clk, _di, _do, reg);
uint16_t reply = spixfer(_clk, _di, _do, 0xFF) | (spixfer(_clk, _di, _do, 0xFF) << 8);
digitalWrite(_cs, HIGH);
return reply;
}
}
/**************************************************************************/
/*!
@brief Read the device ID (can be used to check connection)
*/
/**************************************************************************/
uint8_t Adafruit_ADXL345_Unified::getDeviceID(void) {
// Check device ID register
return readRegister(ADXL345_REG_DEVID);
}
/**************************************************************************/
/*!
@brief Gets the most recent X axis value
*/
/**************************************************************************/
int16_t Adafruit_ADXL345_Unified::getX(void) {
return read16(ADXL345_REG_DATAX0);
}
/**************************************************************************/
/*!
@brief Gets the most recent Y axis value
*/
/**************************************************************************/
int16_t Adafruit_ADXL345_Unified::getY(void) {
return read16(ADXL345_REG_DATAY0);
}
/**************************************************************************/
/*!
@brief Gets the most recent Z axis value
*/
/**************************************************************************/
int16_t Adafruit_ADXL345_Unified::getZ(void) {
return read16(ADXL345_REG_DATAZ0);
}
/**************************************************************************/
/*!
@brief Instantiates a new ADXL345 class
*/
/**************************************************************************/
Adafruit_ADXL345_Unified::Adafruit_ADXL345_Unified(int32_t sensorID) {
_sensorID = sensorID;
_range = ADXL345_RANGE_2_G;
_i2c = true;
}
/**************************************************************************/
/*!
@brief Instantiates a new ADXL345 class in SPI mode
*/
/**************************************************************************/
Adafruit_ADXL345_Unified::Adafruit_ADXL345_Unified(uint8_t clock, uint8_t miso, uint8_t mosi, uint8_t cs, int32_t sensorID) {
_sensorID = sensorID;
_range = ADXL345_RANGE_2_G;
_cs = cs;
_clk = clock;
_do = mosi;
_di = miso;
_i2c = false;
}
/**************************************************************************/
/*!
@brief Setups the HW (reads coefficients values, etc.)
*/
/**************************************************************************/
bool Adafruit_ADXL345_Unified::begin() {
if (_i2c)
Wire.begin();
else {
pinMode(_cs, OUTPUT);
pinMode(_clk, OUTPUT);
digitalWrite(_clk, HIGH);
pinMode(_do, OUTPUT);
pinMode(_di, INPUT);
}
/* Check connection */
uint8_t deviceid = getDeviceID();
if (deviceid != 0xE5)
{
/* No ADXL345 detected ... return false */
Serial.println(deviceid, HEX);
return false;
}
// Enable measurements
writeRegister(ADXL345_REG_POWER_CTL, 0x08);
return true;
}
/**************************************************************************/
/*!
@brief Sets the g range for the accelerometer
*/
/**************************************************************************/
void Adafruit_ADXL345_Unified::setRange(range_t range)
{
/* Red the data format register to preserve bits */
uint8_t format = readRegister(ADXL345_REG_DATA_FORMAT);
/* Update the data rate */
format &= ~0x0F;
format |= range;
/* Make sure that the FULL-RES bit is enabled for range scaling */
format |= 0x08;
/* Write the register back to the IC */
writeRegister(ADXL345_REG_DATA_FORMAT, format);
/* Keep track of the current range (to avoid readbacks) */
_range = range;
}
/**************************************************************************/
/*!
@brief Sets the g range for the accelerometer
*/
/**************************************************************************/
range_t Adafruit_ADXL345_Unified::getRange(void)
{
/* Red the data format register to preserve bits */
return (range_t)(readRegister(ADXL345_REG_DATA_FORMAT) & 0x03);
}
/**************************************************************************/
/*!
@brief Sets the data rate for the ADXL345 (controls power consumption)
*/
/**************************************************************************/
void Adafruit_ADXL345_Unified::setDataRate(dataRate_t dataRate)
{
/* Note: The LOW_POWER bits are currently ignored and we always keep
the device in 'normal' mode */
writeRegister(ADXL345_REG_BW_RATE, dataRate);
}
/**************************************************************************/
/*!
@brief Sets the data rate for the ADXL345 (controls power consumption)
*/
/**************************************************************************/
dataRate_t Adafruit_ADXL345_Unified::getDataRate(void)
{
return (dataRate_t)(readRegister(ADXL345_REG_BW_RATE) & 0x0F);
}
/**************************************************************************/
/*!
@brief Gets the most recent sensor event
*/
/**************************************************************************/
bool Adafruit_ADXL345_Unified::getEvent(sensors_event_t *event) {
/* Clear the event */
memset(event, 0, sizeof(sensors_event_t));
event->version = sizeof(sensors_event_t);
event->sensor_id = _sensorID;
event->type = SENSOR_TYPE_ACCELEROMETER;
event->timestamp = 0;
event->acceleration.x = getX() * ADXL345_MG2G_MULTIPLIER * SENSORS_GRAVITY_STANDARD;
event->acceleration.y = getY() * ADXL345_MG2G_MULTIPLIER * SENSORS_GRAVITY_STANDARD;
event->acceleration.z = getZ() * ADXL345_MG2G_MULTIPLIER * SENSORS_GRAVITY_STANDARD;
return true;
}
/**************************************************************************/
/*!
@brief Gets the sensor_t data
*/
/**************************************************************************/
void Adafruit_ADXL345_Unified::getSensor(sensor_t *sensor) {
/* Clear the sensor_t object */
memset(sensor, 0, sizeof(sensor_t));
/* Insert the sensor name in the fixed length char array */
strncpy (sensor->name, "ADXL345", sizeof(sensor->name) - 1);
sensor->name[sizeof(sensor->name)- 1] = 0;
sensor->version = 1;
sensor->sensor_id = _sensorID;
sensor->type = SENSOR_TYPE_PRESSURE;
sensor->min_delay = 0;
sensor->max_value = -156.9064F; /* -16g = 156.9064 m/s^2 */
sensor->min_value = 156.9064F; /* 16g = 156.9064 m/s^2 */
sensor->resolution = 0.03923F; /* 4mg = 0.0392266 m/s^2 */
}

復制代碼

Arduino 測試程序:

#include <Wire.h>
#include <Adafruit_Sensor.h>
#include <Adafruit_ADXL345_U.h>
/* Assign a unique ID to this sensor at the same time */
Adafruit_ADXL345_Unified accel = Adafruit_ADXL345_Unified(12345);
void displaySensorDetails(void)
{
sensor_t sensor;
accel.getSensor(&sensor);
Serial.println("------------------------------------");
Serial.print ("Sensor: "); Serial.println(sensor.name);
Serial.print ("Driver Ver: "); Serial.println(sensor.version);
Serial.print ("Unique ID: "); Serial.println(sensor.sensor_id);
Serial.print ("Max Value: "); Serial.print(sensor.max_value); Serial.println(" m/s^2");
Serial.print ("Min Value: "); Serial.print(sensor.min_value); Serial.println(" m/s^2");
Serial.print ("Resolution: "); Serial.print(sensor.resolution); Serial.println(" m/s^2");
Serial.println("------------------------------------");
Serial.println("");
delay(500);
}
void displayDataRate(void)
{
Serial.print ("Data Rate: ");
switch(accel.getDataRate())
{
case ADXL345_DATARATE_3200_HZ:
Serial.print ("3200 ");
break;
case ADXL345_DATARATE_1600_HZ:
Serial.print ("1600 ");
break;
case ADXL345_DATARATE_800_HZ:
Serial.print ("800 ");
break;
case ADXL345_DATARATE_400_HZ:
Serial.print ("400 ");
break;
case ADXL345_DATARATE_200_HZ:
Serial.print ("200 ");
break;
case ADXL345_DATARATE_100_HZ:
Serial.print ("100 ");
break;
case ADXL345_DATARATE_50_HZ:
Serial.print ("50 ");
break;
case ADXL345_DATARATE_25_HZ:
Serial.print ("25 ");
break;
case ADXL345_DATARATE_12_5_HZ:
Serial.print ("12.5 ");
break;
case ADXL345_DATARATE_6_25HZ:
Serial.print ("6.25 ");
break;
case ADXL345_DATARATE_3_13_HZ:
Serial.print ("3.13 ");
break;
case ADXL345_DATARATE_1_56_HZ:
Serial.print ("1.56 ");
break;
case ADXL345_DATARATE_0_78_HZ:
Serial.print ("0.78 ");
break;
case ADXL345_DATARATE_0_39_HZ:
Serial.print ("0.39 ");
break;
case ADXL345_DATARATE_0_20_HZ:
Serial.print ("0.20 ");
break;
case ADXL345_DATARATE_0_10_HZ:
Serial.print ("0.10 ");
break;
default:
Serial.print ("???? ");
break;
}
Serial.println(" Hz");
}
void displayRange(void)
{
Serial.print ("Range: +/- ");
switch(accel.getRange())
{
case ADXL345_RANGE_16_G:
Serial.print ("16 ");
break;
case ADXL345_RANGE_8_G:
Serial.print ("8 ");
break;
case ADXL345_RANGE_4_G:
Serial.print ("4 ");
break;
case ADXL345_RANGE_2_G:
Serial.print ("2 ");
break;
default:
Serial.print ("?? ");
break;
}
Serial.println(" g");
}
void setup(void)
{
#ifndef ESP8266
while (!Serial); // for Leonardo/Micro/Zero
#endif
Serial.begin(9600);
Serial.println("Accelerometer Test"); Serial.println("");
/* Initialise the sensor */
if(!accel.begin())
{
/* There was a problem detecting the ADXL345 ... check your connections */
Serial.println("Ooops, no ADXL345 detected ... Check your wiring!");
while(1);
}
/* Set the range to whatever is appropriate for your project */
accel.setRange(ADXL345_RANGE_16_G);
// displaySetRange(ADXL345_RANGE_8_G);
// displaySetRange(ADXL345_RANGE_4_G);
// displaySetRange(ADXL345_RANGE_2_G);
/* Display some basic information on this sensor */
displaySensorDetails();
/* Display additional settings (outside the scope of sensor_t) */
displayDataRate();
displayRange();
Serial.println("");
}
void loop(void)
{
/* Get a new sensor event */
sensors_event_t event;
accel.getEvent(&event);
/* Display the results (acceleration is measured in m/s^2) */
Serial.print("X: "); Serial.print(event.acceleration.x); Serial.print(" ");
Serial.print("Y: "); Serial.print(event.acceleration.y); Serial.print(" ");
Serial.print("Z: "); Serial.print(event.acceleration.z); Serial.print(" ");Serial.println("m/s^2 ");
delay(500);
}

復制代碼

STMicro 測試代碼:

//***************************************
// GY-29 ADXL345 IIC
//****************************************
#include <REG51.H>
#include <math.h> //Keil library
#include <stdio.h> //Keil library
#include <INTRINS.H>
#define uchar unsigned char
#define uint unsigned int
#define DataPort P0 //LCD1602杅擂傷諳
sbit SCL=P1^0; //IIC奀笘竘褐隅砱
sbit SDA=P1^1; //IIC杅擂竘褐隅砱
sbit LCM_RS=P2^0; //LCD1602韜鍔傷諳
sbit LCM_RW=P2^1; //LCD1602韜鍔傷諳
sbit LCM_EN=P2^2; //LCD1602韜鍔傷諳
#define SlaveAddress 0xA6 //隅砱璃婓IIC軞盄笢腔植華硊,跦擂ALT ADDRESS華硊竘褐祥骯黨蜊
//ALT ADDRESS竘褐諉華奀華硊峈0xA6ㄛ諉萇埭奀華硊峈0x3A
typedef unsigned char BYTE;
typedef unsigned short WORD;
BYTE BUF[8]; //諉彶杅擂遣湔
uchar ge,shi,bai,qian,wan; //珆尨曹講
int dis_data; //曹講
void delay(unsigned int k);
void InitLcd(); //場宎趙lcd1602
void Init_ADXL345(void); //場宎趙ADXL345
void WriteDataLCM(uchar dataW);
void WriteCommandLCM(uchar CMD,uchar Attribc);
void DisplayOneChar(uchar X,uchar Y,uchar DData);
void conversion(uint temp_data);
void Single_Write_ADXL345(uchar REG_Address,uchar REG_data); //等跺迡杅擂
uchar Single_Read_ADXL345(uchar REG_Address); //等跺黍囀窒敵湔杅擂
void Multiple_Read_ADXL345(); //蟀哿腔黍囀窒敵湔杅擂
//------------------------------------
void Delay5us();
void Delay5ms();
void ADXL345_Start();
void ADXL345_Stop();
void ADXL345_SendACK(bit ack);
bit ADXL345_RecvACK();
void ADXL345_SendByte(BYTE dat);
BYTE ADXL345_RecvByte();
void ADXL345_ReadPage();
void ADXL345_WritePage();
//-----------------------------------
//*********************************************************
void conversion(uint temp_data)
{
wan=temp_data/10000+0x30 ;
temp_data=temp_data%10000; //豻堍呾
qian=temp_data/1000+0x30 ;
temp_data=temp_data%1000; //豻堍呾
bai=temp_data/100+0x30 ;
temp_data=temp_data%100; //豻堍呾
shi=temp_data/10+0x30 ;
temp_data=temp_data%10; //豻堍呾
ge=temp_data+0x30;
}
/*******************************/
void delay(unsigned int k)
{
unsigned int i,j;
for(i=0;i<k;i++)
{
for(j=0;j<121;j++)
{;}}
}
/*******************************/
void WaitForEnable(void)
{
DataPort=0xff;
LCM_RS=0;LCM_RW=1;_nop_();
LCM_EN=1;_nop_();_nop_();
while(DataPort&0x80);
LCM_EN=0;
}
/*******************************/
void WriteCommandLCM(uchar CMD,uchar Attribc)
{
if(Attribc)WaitForEnable();
LCM_RS=0;LCM_RW=0;_nop_();
DataPort=CMD;_nop_();
LCM_EN=1;_nop_();_nop_();LCM_EN=0;
}
/*******************************/
void WriteDataLCM(uchar dataW)
{
WaitForEnable();
LCM_RS=1;LCM_RW=0;_nop_();
DataPort=dataW;_nop_();
LCM_EN=1;_nop_();_nop_();LCM_EN=0;
}
/***********************************/
void InitLcd()
{
WriteCommandLCM(0x38,1);
WriteCommandLCM(0x08,1);
WriteCommandLCM(0x01,1);
WriteCommandLCM(0x06,1);
WriteCommandLCM(0x0c,1);
}
/***********************************/
void DisplayOneChar(uchar X,uchar Y,uchar DData)
{
Y&=1;
X&=15;
if(Y)X|=0x40;
X|=0x80;
WriteCommandLCM(X,0);
WriteDataLCM(DData);
}
/**************************************
晊奀5峚鏃(STC90C52RC@12M)
祥骯腔馱釬遠噫,剒猁覃淕森滲杅ㄛ蛁砩奀笘徹辦奀剒猁黨蜊
絞蜊蚚1T腔MCU奀,覃淕森晊奀滲杅
**************************************/
void Delay5us()
{
_nop_();_nop_();_nop_();_nop_();
_nop_();_nop_();_nop_();_nop_();
_nop_();_nop_();_nop_();_nop_();
}
/**************************************
晊奀5瑭鏃(STC90C52RC@12M)
祥骯腔馱釬遠噫,剒猁覃淕森滲杅
絞蜊蚚1T腔MCU奀,覃淕森晊奀滲杅
**************************************/
void Delay5ms()
{
WORD n = 560;
while (n--);
}
/**************************************
宎陓瘍
**************************************/
void ADXL345_Start()
{
SDA = 1; //嶺詢杅擂盄
SCL = 1; //嶺詢奀笘盄
Delay5us(); //晊奀
SDA = 0; //莉汜狟蔥朓
Delay5us(); //晊奀
SCL = 0; //嶺腴奀笘盄
}
/**************************************
礿砦陓瘍
**************************************/
void ADXL345_Stop()
{
SDA = 0; //嶺腴杅擂盄
SCL = 1; //嶺詢奀笘盄
Delay5us(); //晊奀
SDA = 1; //莉汜奻汔朓
Delay5us(); //晊奀
}
/**************************************
楷冞茼湘陓瘍
諳統杅:ack (0:ACK 1:NAK)
**************************************/
void ADXL345_SendACK(bit ack)
{
SDA = ack; //迡茼湘陓瘍
SCL = 1; //嶺詢奀笘盄
Delay5us(); //晊奀
SCL = 0; //嶺腴奀笘盄
Delay5us(); //晊奀
}
/**************************************
諉彶茼湘陓瘍
**************************************/
bit ADXL345_RecvACK()
{
SCL = 1; //嶺詢奀笘盄
Delay5us(); //晊奀
CY = SDA; //黍茼湘陓瘍
SCL = 0; //嶺腴奀笘盄
Delay5us(); //晊奀
return CY;
}
/**************************************
砃IIC軞盄楷冞珨跺趼誹杅擂
**************************************/
void ADXL345_SendByte(BYTE dat)
{
BYTE i;
for (i=0; i<8; i++) //8弇數杅
{
dat <<= 1; //痄堤杅擂腔郔詢弇
SDA = CY; //冞杅擂諳
SCL = 1; //嶺詢奀笘盄
Delay5us(); //晊奀
SCL = 0; //嶺腴奀笘盄
Delay5us(); //晊奀
}
ADXL345_RecvACK();
}
/**************************************
植IIC軞盄諉彶珨跺趼誹杅擂
**************************************/
BYTE ADXL345_RecvByte()
{
BYTE i;
BYTE dat = 0;
SDA = 1; //妏夔囀窒奻嶺,袧掘黍杅擂,
for (i=0; i<8; i++) //8弇數杅
{
dat <<= 1;
SCL = 1; //嶺詢奀笘盄
Delay5us(); //晊奀
dat |= SDA; //黍杅擂
SCL = 0; //嶺腴奀笘盄
Delay5us(); //晊奀
}
return dat;
}
//******等趼誹迡*******************************************
void Single_Write_ADXL345(uchar REG_Address,uchar REG_data)
{
ADXL345_Start(); //宎陓瘍
ADXL345_SendByte(SlaveAddress); //楷冞扢掘華硊+迡陓瘍
ADXL345_SendByte(REG_Address); //囀窒敵湔華硊ㄛ統蕉笢恅pdf22珜
ADXL345_SendByte(REG_data); //囀窒敵湔杅擂ㄛ統蕉笢恅pdf22珜
ADXL345_Stop(); //楷冞礿砦陓瘍
}
//********等趼誹黍*****************************************
uchar Single_Read_ADXL345(uchar REG_Address)
{ uchar REG_data;
ADXL345_Start(); //宎陓瘍
ADXL345_SendByte(SlaveAddress); //楷冞扢掘華硊+迡陓瘍
ADXL345_SendByte(REG_Address); //楷冞湔揣等啋華硊ㄛ植0羲宎
ADXL345_Start(); //宎陓瘍
ADXL345_SendByte(SlaveAddress+1); //楷冞扢掘華硊+黍陓瘍
REG_data=ADXL345_RecvByte(); //黍堤敵湔杅擂
ADXL345_SendACK(1);
ADXL345_Stop(); //礿砦陓瘍
return REG_data;
}
//*********************************************************
//
//蟀哿黍堤ADXL345囀窒樓厒僅杅擂ㄛ華硊毓峓0x32~0x37
//
//*********************************************************
void Multiple_read_ADXL345(void)
{ uchar i;
ADXL345_Start(); //宎陓瘍
ADXL345_SendByte(SlaveAddress); //楷冞扢掘華硊+迡陓瘍
ADXL345_SendByte(0x32); //楷冞湔揣等啋華硊ㄛ植0x32羲宎
ADXL345_Start(); //宎陓瘍
ADXL345_SendByte(SlaveAddress+1); //楷冞扢掘華硊+黍陓瘍
for (i=0; i<6; i++) //蟀哿黍6跺華硊杅擂ㄛ湔揣笢BUF
{
BUF[i] = ADXL345_RecvByte(); //BUF[0]湔揣0x32華硊笢腔杅擂
if (i == 5)
{
ADXL345_SendACK(1); //郔綴珨跺杅擂剒猁隙NOACK
}
else
{
ADXL345_SendACK(0); //隙茼ACK
}
}
ADXL345_Stop(); //礿砦陓瘍
Delay5ms();
}
//*****************************************************************
//場宎趙ADXL345ㄛ跦擂剒猁統蕉pdf輛俴黨蜊************************
void Init_ADXL345()
{
Single_Write_ADXL345(0x31,0x0B); //聆講毓峓,淏蛹16gㄛ13弇耀宒
Single_Write_ADXL345(0x2C,0x08); //厒薹扢隅峈12.5 統蕉pdf13珜
Single_Write_ADXL345(0x2D,0x08); //恁寁萇埭耀宒統蕉pdf24珜
Single_Write_ADXL345(0x2E,0x80); //妏夔 DATA_READY 笢剿
Single_Write_ADXL345(0x1E,0x00); //X 痄講跦擂聆彸換覜腔袨怓迡pdf29珜
Single_Write_ADXL345(0x1F,0x00); //Y 痄講跦擂聆彸換覜腔袨怓迡pdf29珜
Single_Write_ADXL345(0x20,0x05); //Z 痄講跦擂聆彸換覜腔袨怓迡pdf29珜
}
//***********************************************************************
//珆尨x粣
void display_x()
{ float temp;
dis_data=(BUF[1]<<8)+BUF[0]; //磁傖杅擂
if(dis_data<0){
dis_data=-dis_data;
DisplayOneChar(2,0,'-'); //珆尨淏蛹睫瘍弇
}
else DisplayOneChar(2,0,' '); //珆尨諾跡
temp=(float)dis_data*3.9; //數呾杅擂睿珆尨,脤蕉ADXL345辦厒藷菴4珜
conversion(temp); //蛌遙堤珆尨剒猁腔杅擂
DisplayOneChar(0,0,'X'); //菴0俴ㄛ菴0蹈珆尨X
DisplayOneChar(1,0,':');
DisplayOneChar(3,0,qian);
DisplayOneChar(4,0,'.');
DisplayOneChar(5,0,bai);
DisplayOneChar(6,0,shi);
DisplayOneChar(7,0,'g');
}
//***********************************************************************
//珆尨y粣
void display_y()
{ float temp;
dis_data=(BUF[3]<<8)+BUF[2]; //磁傖杅擂
if(dis_data<0){
dis_data=-dis_data;
DisplayOneChar(2,1,'-'); //珆尨淏蛹睫瘍弇
}
else DisplayOneChar(2,1,' '); //珆尨諾跡
temp=(float)dis_data*3.9; //數呾杅擂睿珆尨,脤蕉ADXL345辦厒藷菴4珜
conversion(temp); //蛌遙堤珆尨剒猁腔杅擂
DisplayOneChar(0,1,'Y'); //菴1俴ㄛ菴0蹈珆尨y
DisplayOneChar(1,1,':');
DisplayOneChar(3,1,qian);
DisplayOneChar(4,1,'.');
DisplayOneChar(5,1,bai);
DisplayOneChar(6,1,shi);
DisplayOneChar(7,1,'g');
}
//***********************************************************************
//珆尨z粣
void display_z()
{ float temp;
dis_data=(BUF[5]<<8)+BUF[4]; //磁傖杅擂
if(dis_data<0){
dis_data=-dis_data;
DisplayOneChar(10,1,'-'); //珆尨蛹睫瘍弇
}
else DisplayOneChar(10,1,' '); //珆尨諾跡
temp=(float)dis_data*3.9; //數呾杅擂睿珆尨,脤蕉ADXL345辦厒藷菴4珜
conversion(temp); //蛌遙堤珆尨剒猁腔杅擂
DisplayOneChar(10,0,'Z'); //菴0俴ㄛ菴10蹈珆尨Z
DisplayOneChar(11,0,':');
DisplayOneChar(11,1,qian);
DisplayOneChar(12,1,'.');
DisplayOneChar(13,1,bai);
DisplayOneChar(14,1,shi);
DisplayOneChar(15,1,'g');
}
//*********************************************************
//******翋最唗********
//*********************************************************
void main()
{
uchar devid;
delay(500); //奻萇晊奀
InitLcd(); //珘儒場宎趙ADXL345
Init_ADXL345(); //場宎趙ADXL345
devid=Single_Read_ADXL345(0X00);//黍堤腔杅擂峈0XE5,桶尨淏
while(1) //悜遠
{
Multiple_Read_ADXL345(); //蟀哿黍堤杅擂ㄛ湔揣婓BUF笢
display_x(); //---------珆尨X粣
display_y(); //---------珆尨Y粣
display_z(); //---------珆尨Z粣
delay(200); //晊奀
}
}

復制代碼

ID:398299 · 發表于 2018-9-29 15:17

怎么很多的亂碼

帳號		自動登錄	找回密碼
密碼			立即注冊

久久久久久久999_99精品久久精品一区二区爱城_成人欧美一区二区三区在线播放_国产精品日本一区二区不卡视频_国产午夜视频_欧美精品在线观看免费

ADXL345 三軸重力加速感測器

評分

相關帖子