ATNEL tech-forum 2016-04-19T21:42:49+01:00 https://forum.atnel.pl/feed.php?f=4&t=15154&mode 2016-04-19T21:42:49+01:00 2016-04-19T21:42:49+01:00 https://forum.atnel.pl/viewtopic.php?t=15154&p=158929#p158929 <![CDATA[Re: MPU6050 problem z i2c z bluebooka]]> W takim razie dla potomnych kroczacych sciezka odnajdywania orientacji w przestrzeni 3d :
adres MPU6050 ma 7 bitow, wiec aby podczas odczytu z tego urzadzenia mozna bylo dodac 1 do ostatniego bitu to trzeba zrobic tak:
AdresMPU6050<<1 |1

czyli przesunac o 1 w lewo.

i wszystko działa :)

dodatkowo, przypominam ze pomiar jest bardzo zaszumiony, i o tym aby poprawnie rzutowac zmienne przy natloku funkcji odczytujacych!

Statystyki: Napisane przez klimek476 — 19 kwi 2016, o 21:42

]]> 2016-04-18T08:51:22+01:00 2016-04-18T08:51:22+01:00 https://forum.atnel.pl/viewtopic.php?t=15154&p=158827#p158827 <![CDATA[Re: MPU6050 problem z i2c z bluebooka]]>

co do tych funkcji write_byte(); i read_str(); to poza nazwa i nazwami zmiennych nie dostrzegam istotnej roznicy (poza tym +1 dla bitu r/w) chyba czegos nie widze :p

Niestety - nic sie nie zmienilo (jedynie transmisja dziala nieco szybciej), bajty sie zapisuja do pamieci urzadzenia ale caly czas jest problem z odczytem, cokolwiek proboje odczytac dostaje wartosc 104, jezeli proboje odczytac rejestry zyroskopu otrzymuje 0, jesli akcelerometru(16 bit) otrzymuje 26758

Ktos wie co jest nie tak z tymi funkcjami?
i dlaczego jak dodaje ten bit stopu(adres+1) to przestaje dzialac?

Statystyki: Napisane przez klimek476 — 18 kwi 2016, o 08:51

]]> 2016-04-18T08:34:58+01:00 2016-04-18T08:34:58+01:00 https://forum.atnel.pl/viewtopic.php?t=15154&p=158826#p158826 <![CDATA[Re: MPU6050 problem z i2c z bluebooka]]> [syntax=c]bitrate_div=((F_CPU/10001)/bitrate);[/syntax]
powinno być:
[syntax=c]bitrate_div=((F_CPU/1000l)/bitrate);[/syntax]

------------------------ [ Dodano po: 10 minutach ]

Zobacz jak wyglądają te dwie funkcje i2c_write_byte oraz i2c_read_str w BB. ;)

Statystyki: Napisane przez anshar — 18 kwi 2016, o 08:34

]]> 2016-04-18T07:41:02+01:00 2016-04-18T07:41:02+01:00 https://forum.atnel.pl/viewtopic.php?t=15154&p=158815#p158815 <![CDATA[Re: MPU6050 problem z i2c z bluebooka]]> Statystyki: Napisane przez klimek476 — 18 kwi 2016, o 07:41

]]> 2016-04-18T07:25:22+01:00 2016-04-18T07:25:22+01:00 https://forum.atnel.pl/viewtopic.php?t=15154&p=158811#p158811 <![CDATA[Re: MPU6050 problem z i2c z bluebooka]]> [syntax=c]void i2c_read_str(uint8_t device, uint8_t Address, uint8_t *buffer, uint8_t length)
{
twi_start();
twi_write(device);
twi_write(Address);
twi_stop();

twi_start();
twi_write(device + 1); //tu nie wiedziec czemu po wstawieniu +1 nic nie dziala
while (length--) *buffer = twi_read( length ? ACK : NACK );
twi_stop();
}[/syntax]
Masz jakiś analizator stanów logicznych? Oscyloskop?

Statystyki: Napisane przez Sparrow-hawk — 18 kwi 2016, o 07:25

]]> 2016-04-18T00:07:39+01:00 2016-04-18T00:07:39+01:00 https://forum.atnel.pl/viewtopic.php?t=15154&p=158798#p158798 <![CDATA[MPU6050 problem z i2c z bluebooka]]> Funkcje kalibrujace i odczytujace mam z internetu i generalnie nawet dzialaja... problemem jest to ze po calej konfiguracji kiedy chce dokonac jakiegokolwiek odczytu to od zyroskopu dostaje 0 a od accelerometru 26728 i nic ani drgnie (bez wzgledu na wybor osi)

podejrzewam ze cos nie tak jest z funkcja i2c_read_str() czyli odczyt bajtu, ale mi sie juz pomysly skonczyly, W bluebooku jest to wyjasnione dobrze ale chyba trzeba nieco zaadoptowac uzyta tam implementacje i2c do projektu tutaj... ma ktos jakis pomysl co w tej funkcji jest nie tak?

Chyba najwieksza zagadka jest tutaj to ze w tej funkcji gdy chce ustawic bit zapis/odczyt na 1 to wszystko sie sypie i nic nie dziala :/ (83 linijka)

funkcja obslugi TWI jest wzieta z bluebooka jednak moze w niej byc troche herezji bo edytowalem juz co popadnie ale caly czas bez zmian :/

[syntax=c]#include <avr/io.h>
#include <util/twi.h>
#include <util/delay.h>
#include <stdlib.h>
#include "MPU6050.h"

#include "i2c.h"


#define ACK 1
#define NACK 0

//bitrate w KHz


void i2c_init(void)
{
TWCR = (1<<TWEA)|(1<<TWEN);
twi_ustaw_bitrate(100);
}


void twi_ustaw_bitrate(uint16_t bitrate)
{
uint8_t bitrate_div;
bitrate_div=((F_CPU/10001)/bitrate);
if(bitrate_div>=16)
bitrate_div=(bitrate_div-16)/2;

TWBR=bitrate_div;
}

void twi_start(void)
{
TWCR =(1<<TWINT)|(1<<TWEN)|(1<<TWSTA);
while(!(TWCR&(1<<TWINT)));
}

void twi_stop(void)
{
TWCR =(1<<TWINT)|(1<<TWEN)|(1<<TWSTO);
while(TWCR&(1<<TWSTO));
}

void twi_write(uint8_t data)
{
TWDR=data;
TWCR =(1<<TWINT)|(1<<TWEN);
while(!(TWCR&(1<<TWINT)));
}

uint8_t twi_read(uint8_t ack)
{
TWCR =(1<<TWINT)|(ack<<TWEA)|(1<<TWEN);
while(!(TWCR&(1<<TWINT)));
return TWDR;
}


void i2c_write_byte(uint8_t device, uint8_t Address, unsigned char *buffer)
{

twi_start(); //Generate Start COndition

twi_write(device); //Write Control byte

twi_write(Address); //Write Low Address


twi_write(*buffer); //Write Data


twi_stop(); //Initiate Stop Condition
}

void i2c_read_str(uint8_t device, uint8_t Address, uint8_t *buffer, uint8_t length)
{

twi_start();
twi_write(device);
twi_write(Address);
twi_start();
twi_write(device );//tu nie wiedziec czemu po wstawieniu +1 nic nie dziala
while (length--) *buffer = twi_read( length ? ACK : NACK );
twi_stop();


}[/syntax]


Tutaj obsluga MPU6050

[syntax=c]#include <avr/io.h>
#include "mpu6050.h" //biblioteka adresow MPU6050
#include <util/delay.h>
#include "i2c.h"
#include "HD44780.h"
#include <stdlib.h>

#define gyro_sensitivity 65.5 // dla skali 500 degrees/s - z dokumentacji
volatile signed int GYRO_XOUT, GYRO_YOUT, GYRO_ZOUT, ACCEL_XOUT, ACCEL_YOUT, ACCEL_ZOUT,
GYRO_XOUT_OFFSET, GYRO_YOUT_OFFSET, GYRO_ZOUT_OFFSET;
volatile double ACCEL_XANGLE, ACCEL_YANGLE,
GYRO_XRATE, GYRO_YRATE, GYRO_ZRATE;
char wynik[10];


void usart_str(char *tekst)
{
LCD_GoTo(0, 0);
LCD_WriteText(" ");
LCD_GoTo(0,0);
LCD_WriteText(tekst);
_delay_ms(200);
}




void MPU6050_i2c_test( void )
{
usart_str("MPU6050 I2C Read");
unsigned char Data = 0x00;

i2c_read_str(MPU6050_ADDRESS, MPU6050_RA_WHO_AM_I, &Data, 1);

if(Data == 0x68) // = 104 w dziesietnym
{
usart_str("Passed, MPU6050 Address: ");
itoa(Data,wynik,16);
usart_str(wynik);

}
else
{
usart_str("Failed, Stopping. Address: ");
itoa(Data,wynik,16);
usart_str(wynik);
while(1);
}
}

void MPU6050_setup( void )
{
usart_str("MPU6050 Setup... ");

//Sets sample rate to 8000/1+7 = 1000Hz

i2c_write_byte(MPU6050_ADDRESS, MPU6050_RA_SMPLRT_DIV, 0x07);
//Disable FSync, 256Hz DLPF

i2c_write_byte(MPU6050_ADDRESS, MPU6050_RA_CONFIG, 0x00);
//Disable gyro self tests, scale of 500 degrees/s

i2c_write_byte(MPU6050_ADDRESS, MPU6050_RA_GYRO_CONFIG, 0b00001000);
//Disable accel self tests, scale of +-2g, no DHPF

i2c_write_byte(MPU6050_ADDRESS, MPU6050_RA_ACCEL_CONFIG, 0x00);
//Freefall threshold of |0mg|
i2c_write_byte(MPU6050_ADDRESS, MPU6050_RA_FF_THR, 0x00);
//Freefall duration limit of 0

i2c_write_byte(MPU6050_ADDRESS, MPU6050_RA_FF_DUR, 0x00);
//Motion threshold of 0mg
i2c_write_byte(MPU6050_ADDRESS, MPU6050_RA_MOT_THR, 0x00);
//Motion duration of 0s
i2c_write_byte(MPU6050_ADDRESS, MPU6050_RA_MOT_DUR, 0x00);
//Zero motion threshold
i2c_write_byte(MPU6050_ADDRESS, MPU6050_RA_ZRMOT_THR, 0x00);
//Zero motion duration threshold
i2c_write_byte(MPU6050_ADDRESS, MPU6050_RA_ZRMOT_DUR, 0x00);
//Disable sensor output to FIFO buffer
i2c_write_byte(MPU6050_ADDRESS, MPU6050_RA_FIFO_EN, 0x00);

//AUX I2C setup
//Sets AUX I2C to single master control, plus other config
i2c_write_byte(MPU6050_ADDRESS, MPU6050_RA_I2C_MST_CTRL, 0x00);
//Setup AUX I2C slaves
i2c_write_byte(MPU6050_ADDRESS, MPU6050_RA_I2C_SLV0_ADDR, 0x00);
i2c_write_byte(MPU6050_ADDRESS, MPU6050_RA_I2C_SLV0_REG, 0x00);
i2c_write_byte(MPU6050_ADDRESS, MPU6050_RA_I2C_SLV0_CTRL, 0x00);
i2c_write_byte(MPU6050_ADDRESS, MPU6050_RA_I2C_SLV1_ADDR, 0x00);
i2c_write_byte(MPU6050_ADDRESS, MPU6050_RA_I2C_SLV1_REG, 0x00);
i2c_write_byte(MPU6050_ADDRESS, MPU6050_RA_I2C_SLV1_CTRL, 0x00);
i2c_write_byte(MPU6050_ADDRESS, MPU6050_RA_I2C_SLV2_ADDR, 0x00);
i2c_write_byte(MPU6050_ADDRESS, MPU6050_RA_I2C_SLV2_REG, 0x00);
i2c_write_byte(MPU6050_ADDRESS, MPU6050_RA_I2C_SLV2_CTRL, 0x00);
i2c_write_byte(MPU6050_ADDRESS, MPU6050_RA_I2C_SLV3_ADDR, 0x00);
i2c_write_byte(MPU6050_ADDRESS, MPU6050_RA_I2C_SLV3_REG, 0x00);
i2c_write_byte(MPU6050_ADDRESS, MPU6050_RA_I2C_SLV3_CTRL, 0x00);
i2c_write_byte(MPU6050_ADDRESS, MPU6050_RA_I2C_SLV4_ADDR, 0x00);
i2c_write_byte(MPU6050_ADDRESS, MPU6050_RA_I2C_SLV4_REG, 0x00);
i2c_write_byte(MPU6050_ADDRESS, MPU6050_RA_I2C_SLV4_DO, 0x00);
i2c_write_byte(MPU6050_ADDRESS, MPU6050_RA_I2C_SLV4_CTRL, 0x00);
i2c_write_byte(MPU6050_ADDRESS, MPU6050_RA_I2C_SLV4_DI, 0x00);

//MPU6050_RA_I2C_MST_STATUS //Read-only
//Setup INT pin and AUX I2C pass through
i2c_write_byte(MPU6050_ADDRESS, MPU6050_RA_INT_PIN_CFG, 0x00);
//Enable data ready interrupt
i2c_write_byte(MPU6050_ADDRESS, MPU6050_RA_INT_ENABLE, 0x00);

//MPU6050_RA_DMP_INT_STATUS //Read-only
//MPU6050_RA_INT_STATUS 3A //Read-only
//MPU6050_RA_ACCEL_XOUT_H //Read-only
//MPU6050_RA_ACCEL_XOUT_L //Read-only
//MPU6050_RA_ACCEL_YOUT_H //Read-only
//MPU6050_RA_ACCEL_YOUT_L //Read-only
//MPU6050_RA_ACCEL_ZOUT_H //Read-only
//MPU6050_RA_ACCEL_ZOUT_L //Read-only
//MPU6050_RA_TEMP_OUT_H //Read-only
//MPU6050_RA_TEMP_OUT_L //Read-only
//MPU6050_RA_GYRO_XOUT_H //Read-only
//MPU6050_RA_GYRO_XOUT_L //Read-only
//MPU6050_RA_GYRO_YOUT_H //Read-only
//MPU6050_RA_GYRO_YOUT_L //Read-only
//MPU6050_RA_GYRO_ZOUT_H //Read-only
//MPU6050_RA_GYRO_ZOUT_L //Read-only
//MPU6050_RA_EXT_SENS_DATA_00 //Read-only
//MPU6050_RA_EXT_SENS_DATA_01 //Read-only
//MPU6050_RA_EXT_SENS_DATA_02 //Read-only
//MPU6050_RA_EXT_SENS_DATA_03 //Read-only
//MPU6050_RA_EXT_SENS_DATA_04 //Read-only
//MPU6050_RA_EXT_SENS_DATA_05 //Read-only
//MPU6050_RA_EXT_SENS_DATA_06 //Read-only
//MPU6050_RA_EXT_SENS_DATA_07 //Read-only
//MPU6050_RA_EXT_SENS_DATA_08 //Read-only
//MPU6050_RA_EXT_SENS_DATA_09 //Read-only
//MPU6050_RA_EXT_SENS_DATA_10 //Read-only
//MPU6050_RA_EXT_SENS_DATA_11 //Read-only
//MPU6050_RA_EXT_SENS_DATA_12 //Read-only
//MPU6050_RA_EXT_SENS_DATA_13 //Read-only
//MPU6050_RA_EXT_SENS_DATA_14 //Read-only
//MPU6050_RA_EXT_SENS_DATA_15 //Read-only
//MPU6050_RA_EXT_SENS_DATA_16 //Read-only
//MPU6050_RA_EXT_SENS_DATA_17 //Read-only
//MPU6050_RA_EXT_SENS_DATA_18 //Read-only
//MPU6050_RA_EXT_SENS_DATA_19 //Read-only
//MPU6050_RA_EXT_SENS_DATA_20 //Read-only
//MPU6050_RA_EXT_SENS_DATA_21 //Read-only
//MPU6050_RA_EXT_SENS_DATA_22 //Read-only
//MPU6050_RA_EXT_SENS_DATA_23 //Read-only
//MPU6050_RA_MOT_DETECT_STATUS //Read-only

//Slave out, dont care
i2c_write_byte(MPU6050_ADDRESS, MPU6050_RA_I2C_SLV0_DO, 0x00);
i2c_write_byte(MPU6050_ADDRESS, MPU6050_RA_I2C_SLV1_DO, 0x00);
i2c_write_byte(MPU6050_ADDRESS, MPU6050_RA_I2C_SLV2_DO, 0x00);
i2c_write_byte(MPU6050_ADDRESS, MPU6050_RA_I2C_SLV3_DO, 0x00);
//More slave config
i2c_write_byte(MPU6050_ADDRESS, MPU6050_RA_I2C_MST_DELAY_CTRL, 0x00);
//Reset sensor signal paths
i2c_write_byte(MPU6050_ADDRESS, MPU6050_RA_SIGNAL_PATH_RESET, 0x00);
//Motion detection control
i2c_write_byte(MPU6050_ADDRESS, MPU6050_RA_MOT_DETECT_CTRL, 0x00);
//Disables FIFO, AUX I2C, FIFO and I2C reset bits to 0
i2c_write_byte(MPU6050_ADDRESS, MPU6050_RA_USER_CTRL, 0x00);
//Sets clock source to gyro reference w/ PLL
i2c_write_byte(MPU6050_ADDRESS, MPU6050_RA_PWR_MGMT_1, 0b00000010);
//Controls frequency of wakeups in accel low power mode plus the sensor standby modes
i2c_write_byte(MPU6050_ADDRESS, MPU6050_RA_PWR_MGMT_2, 0x00);
//MPU6050_RA_BANK_SEL //Not in datasheet
//MPU6050_RA_MEM_START_ADDR //Not in datasheet
//MPU6050_RA_MEM_R_W //Not in datasheet
//MPU6050_RA_DMP_CFG_1 //Not in datasheet
//MPU6050_RA_DMP_CFG_2 //Not in datasheet
//MPU6050_RA_FIFO_COUNTH //Read-only
//MPU6050_RA_FIFO_COUNTL //Read-only
//Data transfer to and from the FIFO buffer
i2c_write_byte(MPU6050_ADDRESS, MPU6050_RA_FIFO_R_W, 0x00);
//MPU6050_RA_WHO_AM_I //Read-only, I2C address

usart_str("Complete!");
}

void MPU6050_accel_values( void )
{
unsigned char ACCEL_XOUT_H, ACCEL_XOUT_L, ACCEL_YOUT_H, ACCEL_YOUT_L, ACCEL_ZOUT_H, ACCEL_ZOUT_L;
// odczyt danych akcelerometru
i2c_read_str(MPU6050_ADDRESS, MPU6050_RA_ACCEL_XOUT_H, &ACCEL_XOUT_H, 1);
i2c_read_str(MPU6050_ADDRESS, MPU6050_RA_ACCEL_XOUT_H, &ACCEL_XOUT_L, 1);
i2c_read_str(MPU6050_ADDRESS, MPU6050_RA_ACCEL_YOUT_H, &ACCEL_YOUT_H, 1);
i2c_read_str(MPU6050_ADDRESS, MPU6050_RA_ACCEL_YOUT_L, &ACCEL_YOUT_L, 1);
i2c_read_str(MPU6050_ADDRESS, MPU6050_RA_ACCEL_ZOUT_H, &ACCEL_ZOUT_H, 1);
i2c_read_str(MPU6050_ADDRESS, MPU6050_RA_ACCEL_ZOUT_L, &ACCEL_ZOUT_L, 1);

// konwersja odebranych danych
ACCEL_XOUT = ( ACCEL_XOUT_H<<8 | ACCEL_XOUT_L );
ACCEL_YOUT = ( ACCEL_YOUT_H<<8 | ACCEL_YOUT_L );
ACCEL_ZOUT = ( ACCEL_ZOUT_H<<8 | ACCEL_ZOUT_L );

}
void MPU6050_accel_angles( void )
{
if( ACCEL_ZOUT >= 0 )
ACCEL_YANGLE = 57.295 * atan2((float) -ACCEL_XOUT , sqrt(pow((float) ACCEL_ZOUT, 2) + pow((float) ACCEL_YOUT, 2)));
else
ACCEL_YANGLE = 57.295 * atan2((float) -ACCEL_XOUT , -sqrt(pow((float) ACCEL_ZOUT, 2) + pow((float) ACCEL_YOUT, 2)));
}

void MPU6050_gyro_calibrate( void )
{
unsigned char GYRO_XOUT_H, GYRO_XOUT_L, GYRO_YOUT_H, GYRO_YOUT_L, GYRO_ZOUT_H ,GYRO_ZOUT_L;
long long int GYRO_XOUT_OFFSET_1000SUM=0, GYRO_YOUT_OFFSET_1000SUM=0, GYRO_ZOUT_OFFSET_1000SUM=0;
int x = 0;

usart_str("Gyro calib... ");

for (x = 0; x < 2500; x++)
{
i2c_read_str(MPU6050_ADDRESS, MPU6050_RA_GYRO_XOUT_H, &GYRO_XOUT_H, 1);
i2c_read_str(MPU6050_ADDRESS, MPU6050_RA_GYRO_XOUT_L, &GYRO_XOUT_L, 1);
i2c_read_str(MPU6050_ADDRESS, MPU6050_RA_GYRO_YOUT_H, &GYRO_YOUT_H, 1);
i2c_read_str(MPU6050_ADDRESS, MPU6050_RA_GYRO_YOUT_L, &GYRO_YOUT_L, 1);
i2c_read_str(MPU6050_ADDRESS, MPU6050_RA_GYRO_ZOUT_H, &GYRO_ZOUT_H, 1);
i2c_read_str(MPU6050_ADDRESS, MPU6050_RA_GYRO_ZOUT_L, &GYRO_ZOUT_L, 1);

GYRO_XOUT_OFFSET_1000SUM += ((GYRO_XOUT_H << 8) | GYRO_XOUT_L);
GYRO_YOUT_OFFSET_1000SUM += ((GYRO_YOUT_H << 8) | GYRO_YOUT_L);
GYRO_ZOUT_OFFSET_1000SUM += ((GYRO_ZOUT_H << 8) | GYRO_ZOUT_L);

_delay_ms(1);
}

GYRO_XOUT_OFFSET = GYRO_XOUT_OFFSET_1000SUM / 2500;
GYRO_YOUT_OFFSET = GYRO_YOUT_OFFSET_1000SUM / 2500;
GYRO_ZOUT_OFFSET = GYRO_ZOUT_OFFSET_1000SUM / 2500;

usart_str("Complete!");
}

void MPU6050_gyro_rate( void )
{
unsigned char GYRO_XOUT_H, GYRO_XOUT_L, GYRO_YOUT_H, GYRO_YOUT_L, GYRO_ZOUT_H ,GYRO_ZOUT_L;

// odcyt danych z zyroskopu
i2c_read_str(MPU6050_ADDRESS, MPU6050_RA_GYRO_XOUT_H, &GYRO_XOUT_H, 1);
i2c_read_str(MPU6050_ADDRESS, MPU6050_RA_GYRO_XOUT_L, &GYRO_XOUT_L, 1);
i2c_read_str(MPU6050_ADDRESS, MPU6050_RA_GYRO_YOUT_H, &GYRO_YOUT_H, 1);
i2c_read_str(MPU6050_ADDRESS, MPU6050_RA_GYRO_YOUT_L, &GYRO_YOUT_L, 1);
i2c_read_str(MPU6050_ADDRESS, MPU6050_RA_GYRO_ZOUT_H, &GYRO_ZOUT_H, 1);
i2c_read_str(MPU6050_ADDRESS, MPU6050_RA_GYRO_ZOUT_L, &GYRO_ZOUT_L, 1);

// konwersja odebranych danych
GYRO_XOUT = ( GYRO_XOUT_H << 8 | GYRO_XOUT_L ) - GYRO_XOUT_OFFSET;
GYRO_YOUT = ( GYRO_YOUT_H << 8 | GYRO_YOUT_L ) - GYRO_YOUT_OFFSET;
GYRO_ZOUT = ( GYRO_ZOUT_H << 8 | GYRO_ZOUT_L ) - GYRO_ZOUT_OFFSET;

// konwersja na degrees/s
GYRO_XRATE = (float)GYRO_XOUT/gyro_sensitivity;
GYRO_YRATE = (float)GYRO_YOUT/gyro_sensitivity;
GYRO_ZRATE = (float)GYRO_ZOUT/gyro_sensitivity;
}

void MPU6050_single_axis_gyro_calibrate( unsigned char AXIS )
{
unsigned char GYRO_H, GYRO_L;
long long int GYRO_OFFSET_SUM=0;
int x;

usart_str("Gyroscope Calibrate... ");

switch( AXIS )
{
case 'X':
for (x = 0; x < 1000; x++)
{
i2c_read_str(MPU6050_ADDRESS, MPU6050_RA_GYRO_XOUT_H, &GYRO_H, 1);
i2c_read_str(MPU6050_ADDRESS, MPU6050_RA_GYRO_XOUT_L, &GYRO_L, 1);
GYRO_OFFSET_SUM += ((GYRO_H << 8) | GYRO_L);
_delay_ms(3);
}
GYRO_XOUT_OFFSET = (signed int)GYRO_OFFSET_SUM / 1000;
break;
case 'Y':
for (x = 0; x < 1000; x++)
{
i2c_read_str(MPU6050_ADDRESS, MPU6050_RA_GYRO_YOUT_H, &GYRO_H, 1);
i2c_read_str(MPU6050_ADDRESS, MPU6050_RA_GYRO_YOUT_L, &GYRO_L, 1);
GYRO_OFFSET_SUM += ((GYRO_H << 8) | GYRO_L);
_delay_ms(3);
}
GYRO_YOUT_OFFSET = (signed int)GYRO_OFFSET_SUM / 1000;
break;
case 'Z':
for (x = 0; x < 1000; x++)
{
i2c_read_str(MPU6050_ADDRESS, MPU6050_RA_GYRO_ZOUT_H, &GYRO_H, 1);
i2c_read_str(MPU6050_ADDRESS, MPU6050_RA_GYRO_ZOUT_L, &GYRO_L, 1);
GYRO_OFFSET_SUM += ((GYRO_H << 8) | GYRO_L);
_delay_ms(3);
}
GYRO_ZOUT_OFFSET = (signed int)GYRO_OFFSET_SUM / 1000;
break;
}

usart_str("Complete!");
}

signed int MPU6050ReadSingleAxisAccel( unsigned char AXIS )
{
unsigned char ACCEL_H, ACCEL_L;

switch( AXIS )
{
case 'X':
i2c_read_str(MPU6050_ADDRESS, MPU6050_RA_ACCEL_XOUT_H, &ACCEL_H, 1);
i2c_read_str(MPU6050_ADDRESS, MPU6050_RA_ACCEL_XOUT_L, &ACCEL_L, 1);
break;
case 'Y':
i2c_read_str(MPU6050_ADDRESS, MPU6050_RA_ACCEL_YOUT_H, &ACCEL_H, 1);
i2c_read_str(MPU6050_ADDRESS, MPU6050_RA_ACCEL_YOUT_L, &ACCEL_L, 1);
break;
case 'Z':
i2c_read_str(MPU6050_ADDRESS, MPU6050_RA_ACCEL_ZOUT_H, &ACCEL_H, 1);
i2c_read_str(MPU6050_ADDRESS, MPU6050_RA_ACCEL_ZOUT_L, &ACCEL_L, 1);
break;
}

return ((signed int)( ACCEL_H<<8 | ACCEL_L ));
}

signed int MPU6050ReadSingleAxisGyro( unsigned char AXIS )
{
unsigned char GYRO_H, GYRO_L;

switch( AXIS )
{
case 'X':
i2c_read_str(MPU6050_ADDRESS, MPU6050_RA_GYRO_XOUT_H, &GYRO_H, 1);
i2c_read_str(MPU6050_ADDRESS, MPU6050_RA_GYRO_XOUT_L, &GYRO_L, 1);
break;
case 'Y':
i2c_read_str(MPU6050_ADDRESS, MPU6050_RA_GYRO_YOUT_H, &GYRO_H, 1);
i2c_read_str(MPU6050_ADDRESS, MPU6050_RA_GYRO_YOUT_L, &GYRO_L, 1);
break;
case 'Z':
i2c_read_str(MPU6050_ADDRESS, MPU6050_RA_GYRO_ZOUT_H, &GYRO_H, 1);
i2c_read_str(MPU6050_ADDRESS, MPU6050_RA_GYRO_ZOUT_L, &GYRO_L, 1);
break;
}

return (signed int)( GYRO_H<<8 | GYRO_L ) - GYRO_YOUT_OFFSET;
}[/syntax]

Statystyki: Napisane przez klimek476 — 18 kwi 2016, o 00:07

]]>