Hazırlık Yapalım. MPU-6050

[muhittin_kaplan]

MPU-6050 siparişi yaptım. Gelmesi Sürer biraz
Bu sensörle çalışmış olan varmı ?

[Mr.Java]

Buradan

http://www.leopoldina.cefetmg.br/~gamboa/viewer.php?/projetos/accelerometer.html

fikir edinebilirsiniz.Teferruatlı anlatmış..

[iyildirim]

Geçen bahar SPI olan 6000 ile çalışmıştım. O zamanlar chip olarak bulabildiğim için pcb uğraştırmıştı.
Raw veri okumak vs. de hiç sorun yaşamadım. Kitabında yazdığı gibi çalışıyor. Ama üzerindeki işlemciyi kullanmak isterseniz hiç kaynak yok desem yeridir. O dönemde okumuştum. Bir rivayete göre sony ve nindento 6000 serilerini kapatmışmış. Bu yüzden detaylı datasheetler ortada yokmuş.
Yine de I2C için nette paylaşılmış bazı örnek kodlar var. Kod dediğimde hex kod gibi, sensöre yükleniyor. 3-5 örnekten kesip biçip quaternion elde edecek kadar birşeyler yapabilmiştim.

Bende 1-2 hafta önce 6050 li 10DOF bir modül aldım. 32f4 ile birşeyler yapmak niyetim var.
Sizin aldığınız ne tür. Sade 6050 mi, manyetik pusulalı vs. xDOF modül şeklinde mi?

[muhittin_kaplan]

Sadece 6050 modül. ve üzerindeki acc. ve gyro yu raw olarak okuyacağım.
http://www.ebay.com/itm/261080395340?ssPageName=STRK:MEWNX:IT&_trksid=p3984.m1439.l2649
mesaj birleştirme:: 15 Haziran 2013, 12:50:05
alsında tam olarak gyrosununa ihtiyacım var. Okuduğum bilgiyi PC ye aktaracağım, Geri kalan işlemler pc de hallolacak ve açı vs hesaplanacak.

[muhittin_kaplan]

https://github.com/jrowberg/i2cdevlib/tree/master/Arduino/MPU6050

buradan birşeyler çıkartırız zannımca
mesaj birleştirme:: 15 Haziran 2013, 15:12:49
https://github.com/Harinadha/STM32_MPU6050lib/blob/master/MPU6050.c

[muhittin_kaplan]

/*******************************************************************************
// GY-52 MPU3050 IIC²âÊÔ³ÌĞò
// ʹÓõ¥Æ¬»úSTM32F103C8T6
// ¾§Õñ£º8.00M
// ±àÒë»·¾³ Keil uVision4
// ʱ¼ä£º2011Äê9ÔÂ1ÈÕ
// ÓëÄ£¿éÁ¬½Ó GPIOB6->SCL GPIOB7->SDA      
// ʹÓãºSTM32F103C8T6´®¿Ú1Á¬½ÓµçÄÔ
// µçÄÔ´®¿ÚÖúÊÖÏÔʾ£¬²¨ÌØÂÊ£º115200
// QQ£º531389319
*******************************************************************************/

#include "stm32f10x_lib.h"
#include  <math.h>    //Keil library  

GPIO_InitTypeDef GPIO_InitStructure;
ErrorStatus HSEStartUpStatus;

#define   uchar unsigned char
#define   uint unsigned int	

//¶¨ÒåMPU3050ÄÚ²¿µØÖ·********************
#define WHO	    0x00
#define	SMPL	0x15
#define DLPF	0x16
#define INT_C	0x17
#define INT_S	0x1A
#define	TMP_H	0x1B
#define	TMP_L	0x1C
#define	GX_H	0x1D
#define	GX_L	0x1E
#define	GY_H	0x1F
#define	GY_L	0x20
#define GZ_H	0x21
#define GZ_L	0x22
#define PWR_M	0x3E
//****************************

#define	MPU3050_Addr   0xD0	  //¶¨ÒåÆ÷¼şÔÚIIC×ÜÏßÖеĴӵØÖ·,¸ù¾İALT  ADDRESSµØÖ·Òı½Å²»Í¬Ğ޸Ä

unsigned char TX_DATA[4];  	 //ÏÔʾ¾İ»º´æÇø
unsigned char BUF[10];       //½ÓÊÕÊı¾İ»º´æÇø
char  test=0; 				 //IICÓõ½
short T_X,T_Y,T_Z,T_T;		 //X,Y,ZÖᣬζÈ

//************************************
/*Ä£ÄâIIC¶Ë¿ÚÊä³öÊäÈ붨Òå*/
#define SCL_H         GPIOB->BSRR = GPIO_Pin_6
#define SCL_L         GPIOB->BRR  = GPIO_Pin_6 
   
#define SDA_H         GPIOB->BSRR = GPIO_Pin_7
#define SDA_L         GPIOB->BRR  = GPIO_Pin_7

#define SCL_read      GPIOB->IDR  & GPIO_Pin_6
#define SDA_read      GPIOB->IDR  & GPIO_Pin_7

/* º¯ÊıÉêÃ÷ -----------------------------------------------*/
void RCC_Configuration(void);
void GPIO_Configuration(void);
void NVIC_Configuration(void);
void USART1_Configuration(void);
void WWDG_Configuration(void);
void Delay(u32 nTime);
void Delayms(vu32 m);  
/* ±äÁ¿¶¨Òå ----------------------------------------------*/

  /*******************************/
void DATA_printf(uchar *s,short temp_data)
{
	if(temp_data<0){
	temp_data=-temp_data;
    *s='-';
	}
	else *s=' ';
    *++s =temp_data/100+0x30;
    temp_data=temp_data%100;     //È¡ÓàÔËËã
    *++s =temp_data/10+0x30;
    temp_data=temp_data%10;      //È¡ÓàÔËËã
    *++s =temp_data+0x30; 	
}

/*******************************************************************************
* Function Name  : I2C_GPIO_Config
* Description    : Configration Simulation IIC GPIO
* Input          : None 
* Output         : None
* Return         : None
****************************************************************************** */
void I2C_GPIO_Config(void)
{
  GPIO_InitTypeDef  GPIO_InitStructure; 
 
  GPIO_InitStructure.GPIO_Pin =  GPIO_Pin_6;
  GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
  GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_OD;  
  GPIO_Init(GPIOB, &GPIO_InitStructure);

  GPIO_InitStructure.GPIO_Pin =  GPIO_Pin_7;
  GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
  GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_OD;
  GPIO_Init(GPIOB, &GPIO_InitStructure);
}

/*******************************************************************************
* Function Name  : I2C_delay
* Description    : Simulation IIC Timing series delay
* Input          : None
* Output         : None
* Return         : None
****************************************************************************** */
void I2C_delay(void)
{
		
   u8 i=30; //ÕâÀï¿ÉÒÔÓÅ»¯ËÙ¶È	£¬¾­²âÊÔ×îµÍµ½5»¹ÄÜĞ´Èë
   while(i) 
   { 
     i--; 
   }  
}

void delay5ms(void)
{
		
   int i=5000;  
   while(i) 
   { 
     i--; 
   }  
}
/*******************************************************************************
* Function Name  : I2C_Start
* Description    : Master Start Simulation IIC Communication
* Input          : None
* Output         : None
* Return         : Wheather	 Start
****************************************************************************** */
bool I2C_Start(void)
{
	SDA_H;
	SCL_H;
	I2C_delay();
	if(!SDA_read)return FALSE;	//SDAÏßΪµÍµçƽÔò×ÜÏßæ,Í˳ö
	SDA_L;
	I2C_delay();
	if(SDA_read) return FALSE;	//SDAÏßΪ¸ßµçƽÔò×ÜÏß³ö´í,Í˳ö
	SDA_L;
	I2C_delay();
	return TRUE;
}
/*******************************************************************************
* Function Name  : I2C_Stop
* Description    : Master Stop Simulation IIC Communication
* Input          : None
* Output         : None
* Return         : None
****************************************************************************** */
void I2C_Stop(void)
{
	SCL_L;
	I2C_delay();
	SDA_L;
	I2C_delay();
	SCL_H;
	I2C_delay();
	SDA_H;
	I2C_delay();
} 
/*******************************************************************************
* Function Name  : I2C_Ack
* Description    : Master Send Acknowledge Single
* Input          : None
* Output         : None
* Return         : None
****************************************************************************** */
void I2C_Ack(void)
{	
	SCL_L;
	I2C_delay();
	SDA_L;
	I2C_delay();
	SCL_H;
	I2C_delay();
	SCL_L;
	I2C_delay();
}   
/*******************************************************************************
* Function Name  : I2C_NoAck
* Description    : Master Send No Acknowledge Single
* Input          : None
* Output         : None
* Return         : None
****************************************************************************** */
void I2C_NoAck(void)
{	
	SCL_L;
	I2C_delay();
	SDA_H;
	I2C_delay();
	SCL_H;
	I2C_delay();
	SCL_L;
	I2C_delay();
} 
/*******************************************************************************
* Function Name  : I2C_WaitAck
* Description    : Master Reserive Slave Acknowledge Single
* Input          : None
* Output         : None
* Return         : Wheather	 Reserive Slave Acknowledge Single
****************************************************************************** */
bool I2C_WaitAck(void) 	 //·µ»ØΪ:=1ÓĞACK,=0ÎŞACK
{
	SCL_L;
	I2C_delay();
	SDA_H;			
	I2C_delay();
	SCL_H;
	I2C_delay();
	if(SDA_read)
	{
      SCL_L;
	  I2C_delay();
      return FALSE;
	}
	SCL_L;
	I2C_delay();
	return TRUE;
}
/*******************************************************************************
* Function Name  : I2C_SendByte
* Description    : Master Send a Byte to Slave
* Input          : Will Send Date
* Output         : None
* Return         : None
****************************************************************************** */
void I2C_SendByte(u8 SendByte) //Êı¾İ´Ó¸ßλµ½µÍλ//
{
    u8 i=8;
    while(i--)
    {
        SCL_L;
        I2C_delay();
      if(SendByte&0x80)
        SDA_H;  
      else 
        SDA_L;   
        SendByte<<=1;
        I2C_delay();
		SCL_H;
        I2C_delay();
    }
    SCL_L;
}  
/*******************************************************************************
* Function Name  : I2C_RadeByte
* Description    : Master Reserive a Byte From Slave
* Input          : None
* Output         : None
* Return         : Date From Slave 
****************************************************************************** */
unsigned char I2C_RadeByte(void)  //Êı¾İ´Ó¸ßλµ½µÍλ//
{ 
    u8 i=8;
    u8 ReceiveByte=0;

    SDA_H;				
    while(i--)
    {
      ReceiveByte<<=1;      
      SCL_L;
      I2C_delay();
	  SCL_H;
      I2C_delay();	
      if(SDA_read)
      {
        ReceiveByte|=0x01;
      }
    }
    SCL_L;
    return ReceiveByte;
} 
//ZRX          
//µ¥×Ö½ÚĞ´Èë*******************************************

bool Single_Write(unsigned char SlaveAddress,unsigned char REG_Address,unsigned char REG_data)		     //void
{
  	if(!I2C_Start())return FALSE;
    I2C_SendByte(SlaveAddress);   //·¢ËÍÉ豸µØÖ·+Ğ´ĞźÅ//I2C_SendByte(((REG_Address & 0x0700) >>7) | SlaveAddress & 0xFFFE);//ÉèÖøßÆğʼµØÖ·+Æ÷¼şµØÖ· 
    if(!I2C_WaitAck()){I2C_Stop(); return FALSE;}
    I2C_SendByte(REG_Address );   //ÉèÖõÍÆğʼµØÖ·      
    I2C_WaitAck();	
    I2C_SendByte(REG_data);
    I2C_WaitAck();   
    I2C_Stop(); 
    delay5ms();
    return TRUE;
}

//µ¥×Ö½Ú¶ÁÈ¡*****************************************
unsigned char Single_Read(unsigned char SlaveAddress,unsigned char REG_Address)
{   unsigned char REG_data;     	
	if(!I2C_Start())return FALSE;
    I2C_SendByte(SlaveAddress); //I2C_SendByte(((REG_Address & 0x0700) >>7) | REG_Address & 0xFFFE);//ÉèÖøßÆğʼµØÖ·+Æ÷¼şµØÖ· 
    if(!I2C_WaitAck()){I2C_Stop();test=1; return FALSE;}
    I2C_SendByte((u8) REG_Address);   //ÉèÖõÍÆğʼµØÖ·      
    I2C_WaitAck();
    I2C_Start();
    I2C_SendByte(SlaveAddress+1);
    I2C_WaitAck();

	REG_data= I2C_RadeByte();
    I2C_NoAck();
    I2C_Stop();
    //return TRUE;
	return REG_data;

}						      

/*
********************************************************************************
** º¯ÊıÃû³Æ £º RCC_Configuration(void)
** º¯Êı¹¦ÄÜ £º ʱÖÓ³õʼ»¯
** Êä    Èë	£º ÎŞ
** Êä    ³ö	£º ÎŞ
** ·µ    »Ø	£º ÎŞ
********************************************************************************
*/
void RCC_Configuration(void)
{   
  /* RCC system reset(for debug purpose) */
  RCC_DeInit();

  /* Enable HSE */
  RCC_HSEConfig(RCC_HSE_ON);

  /* Wait till HSE is ready */
  HSEStartUpStatus = RCC_WaitForHSEStartUp();

  if(HSEStartUpStatus == SUCCESS)
  {
    /* HCLK = SYSCLK */
    RCC_HCLKConfig(RCC_SYSCLK_Div1); 
  
    /* PCLK2 = HCLK */
    RCC_PCLK2Config(RCC_HCLK_Div1); 

    /* PCLK1 = HCLK/2 */
    RCC_PCLK1Config(RCC_HCLK_Div2);

    /* Flash 2 wait state */
    FLASH_SetLatency(FLASH_Latency_2);
    /* Enable Prefetch Buffer */
    FLASH_PrefetchBufferCmd(FLASH_PrefetchBuffer_Enable);

    /* PLLCLK = 8MHz * 9 = 72 MHz */
    RCC_PLLConfig(RCC_PLLSource_HSE_Div1, RCC_PLLMul_9);

    /* Enable PLL */ 
    RCC_PLLCmd(ENABLE);

    /* Wait till PLL is ready */
    while(RCC_GetFlagStatus(RCC_FLAG_PLLRDY) == RESET)
    {
    }

    /* Select PLL as system clock source */
    RCC_SYSCLKConfig(RCC_SYSCLKSource_PLLCLK);

    /* Wait till PLL is used as system clock source */
    while(RCC_GetSYSCLKSource() != 0x08)
    {
    }
  } 
   /* Enable GPIOA, GPIOB, GPIOC, GPIOD, GPIOE, GPIOF, GPIOG and AFIO clocks */
    RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA | RCC_APB2Periph_GPIOB , ENABLE);
	RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOC | RCC_APB2Periph_GPIOD , ENABLE);
	RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOE | RCC_APB2Periph_GPIOF , ENABLE);
	RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOG | RCC_APB2Periph_AFIO  , ENABLE);  
}

/*
********************************************************************************
** º¯ÊıÃû³Æ £º GPIO_Configuration(void)
** º¯Êı¹¦ÄÜ £º ¶Ë¿Ú³õʼ»¯
** Êä    Èë	£º ÎŞ
** Êä    ³ö	£º ÎŞ
** ·µ    »Ø	£º ÎŞ
********************************************************************************
*/
void GPIO_Configuration(void)
{
  GPIO_InitTypeDef GPIO_InitStructure;
  RCC_APB2PeriphClockCmd( RCC_APB2Periph_GPIOA | RCC_APB2Periph_GPIOB | RCC_APB2Periph_GPIOC | RCC_APB2Periph_GPIOD, ENABLE  );
   /* Configure USART1 Tx (PA.09) as alternate function push-pull */
  GPIO_InitStructure.GPIO_Pin = GPIO_Pin_9;				 //	Ñ¡ÖйܽÅ9
  GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;		 // ¸´ÓÃÍÆÍìÊä³ö
  GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;		 // ×î¸ßÊä³öËÙÂÊ50MHz
  GPIO_Init(GPIOA, &GPIO_InitStructure);				 // Ñ¡ÔñA¶Ë¿Ú
    
  /* Configure USART1 Rx (PA.10) as input floating */
  GPIO_InitStructure.GPIO_Pin = GPIO_Pin_10;			  //Ñ¡ÖйܽÅ10
  GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;	  //¸¡¿ÕÊäÈë
  GPIO_Init(GPIOA, &GPIO_InitStructure);				  //Ñ¡ÔñA¶Ë¿Ú

}

/*
********************************************************************************
** º¯ÊıÃû³Æ £º USART1_Configuration(void)
** º¯Êı¹¦ÄÜ £º ´®¿Ú1³õʼ»¯
** Êä    Èë	£º ÎŞ
** Êä    ³ö	£º ÎŞ
** ·µ    »Ø	£º ÎŞ
********************************************************************************
*/
void USART1_Configuration(void)
{

USART_InitTypeDef USART_InitStructure;
USART_ClockInitTypeDef  USART_ClockInitStructure;

RCC_APB2PeriphClockCmd(RCC_APB2Periph_TIM1 |RCC_APB2Periph_USART1, ENABLE  );

USART_ClockInitStructure.USART_Clock = USART_Clock_Disable;			// ʱÖӵ͵çƽ»î¶¯
USART_ClockInitStructure.USART_CPOL = USART_CPOL_Low;				// ʱÖӵ͵çƽ
USART_ClockInitStructure.USART_CPHA = USART_CPHA_2Edge;				// ʱÖÓµÚ¶ş¸ö±ßÑؽøĞĞÊı¾İ²¶»ñ
USART_ClockInitStructure.USART_LastBit = USART_LastBit_Disable;		// ×îºóһλÊı¾İµÄʱÖÓÂö³å²»´ÓSCLKÊä³ö
/* Configure the USART1 synchronous paramters */
USART_ClockInit(USART1, &USART_ClockInitStructure);					// ʱÖÓ²ÎÊı³õʼ»¯ÉèÖÃ
																	 
USART_InitStructure.USART_BaudRate = 115200;						  // ²¨ÌØÂÊΪ£º115200
USART_InitStructure.USART_WordLength = USART_WordLength_8b;			  // 8λÊı¾İ
USART_InitStructure.USART_StopBits = USART_StopBits_1;				  // ÔÚÖ¡½áβ´«Êä1¸öֹͣλ
USART_InitStructure.USART_Parity = USART_Parity_No ;				  // ÆæżʧÄÜ
USART_InitStructure.USART_HardwareFlowControl = USART_HardwareFlowControl_None;	// Ó²¼şÁ÷¿ØÖÆʧÄÜ

USART_InitStructure.USART_Mode = USART_Mode_Rx | USART_Mode_Tx;		  // ·¢ËÍʹÄÜ+½ÓÊÕʹÄÜ
/* Configure USART1 basic and asynchronous paramters */
USART_Init(USART1, &USART_InitStructure);
    
  /* Enable USART1 */
USART_ClearFlag(USART1, USART_IT_RXNE); 			//ÇåÖжϣ¬ÒÔÃâÒ»ÆôÓÃÖжϺóÁ¢¼´²úÉúÖжÏ
USART_ITConfig(USART1,USART_IT_RXNE, ENABLE);		//ʹÄÜUSART1ÖжÏÔ´
USART_Cmd(USART1, ENABLE);							//USART1×Ü¿ª¹Ø£º¿ªÆô 
}


/*
********************************************************************************
** º¯ÊıÃû³Æ £º NVIC_Configuration(void)
** º¯Êı¹¦ÄÜ £º Öжϳõʼ»¯
** Êä    Èë	£º ÎŞ
** Êä    ³ö	£º ÎŞ
** ·µ    »Ø	£º ÎŞ
********************************************************************************
*/
void NVIC_Configuration(void)
{ 
  NVIC_InitTypeDef NVIC_InitStructure;  
  NVIC_PriorityGroupConfig(NVIC_PriorityGroup_0); 
 
  NVIC_InitStructure.NVIC_IRQChannel = WWDG_IRQChannel;
  NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0;
  NVIC_Init(&NVIC_InitStructure);

}

 /*
********************************************************************************
** º¯ÊıÃû³Æ £º WWDG_Configuration(void)
** º¯Êı¹¦ÄÜ £º ¿´ÃŹ·³õʼ»¯
** Êä    Èë	£º ÎŞ
** Êä    ³ö	£º ÎŞ
** ·µ    »Ø	£º ÎŞ
********************************************************************************
*/
void WWDG_Configuration(void)
{
  RCC_APB1PeriphClockCmd(RCC_APB1Periph_WWDG, ENABLE);	
  WWDG_SetPrescaler(WWDG_Prescaler_8);	              //  WWDG clock counter = (PCLK1/4096)/8 = 244 Hz (~4 ms)  
  WWDG_SetWindowValue(0x41);		                 // Set Window value to 0x41
  WWDG_Enable(0x50);		       // Enable WWDG and set counter value to 0x7F, WWDG timeout = ~4 ms * 64 = 262 ms 
  WWDG_ClearFlag();			       // Clear EWI flag
  WWDG_EnableIT();			       // Enable EW interrupt
}

/*
********************************************************************************
** º¯ÊıÃû³Æ £º Delay(vu32 nCount)
** º¯Êı¹¦ÄÜ £º ÑÓʱº¯Êı
** Êä    Èë	£º ÎŞ
** Êä    ³ö	£º ÎŞ
** ·µ    »Ø	£º ÎŞ
********************************************************************************
*/
 void Delay(vu32 nCount)
{
  for(; nCount != 0; nCount--);
}

/*
********************************************************************************
** º¯ÊıÃû³Æ £º void Delayms(vu32 m)
** º¯Êı¹¦ÄÜ £º ³¤ÑÓʱº¯Êı	 m=1,ÑÓʱ1ms
** Êä    Èë	£º ÎŞ
** Êä    ³ö	£º ÎŞ
** ·µ    »Ø	£º ÎŞ
********************************************************************************
*/
 void Delayms(vu32 m)
{
  u32 i;
  
  for(; m != 0; m--)	
       for (i=0; i<50000; i++);
}

/*
********************************************************************************
** º¯ÊıÃû³Æ £º WWDG_IRQHandler(void)
** º¯Êı¹¦ÄÜ £º ´°¿ÚÌáÇ°»½ĞÑÖжÏ
** Êä    Èë	£º ÎŞ
** Êä    ³ö	£º ÎŞ
** ·µ    »Ø	£º ÎŞ
********************************************************************************
*/ 

void WWDG_IRQHandler(void)
{
  /* Update WWDG counter */
  WWDG_SetCounter(0x50);
	
  /* Clear EWI flag */
  WWDG_ClearFlag(); 
}
 //************************************************
void  USART1_SendData(uchar SendData)
{
USART_SendData(USART1, SendData);
Delayms(1);
}
//³õʼ»¯MPU3050£¬¸ù¾İĞèÒªÇë²Î¿¼pdf½øĞĞĞŞ¸Ä************************
void Init_MPU3050(void)
{
   Single_Write(MPU3050_Addr,PWR_M, 0x80);   //
   Single_Write(MPU3050_Addr,SMPL, 0x07);    //
   Single_Write(MPU3050_Addr,DLPF, 0x1E);    //¡À2000¡ã
   Single_Write(MPU3050_Addr,INT_C, 0x00 );  //
   Single_Write(MPU3050_Addr,PWR_M, 0x00);   //
}
	
//******¶ÁÈ¡MPU3050Êı¾İ****************************************
void READ_MPU3050(void)
{
   BUF[0]=Single_Read(MPU3050_Addr,GX_L); 
   BUF[1]=Single_Read(MPU3050_Addr,GX_H);
   T_X=	(BUF[1]<<8)|BUF[0];
   T_X/=16.4; 						   //¶ÁÈ¡¼ÆËãXÖáÊı¾İ

   BUF[2]=Single_Read(MPU3050_Addr,GY_L);
   BUF[3]=Single_Read(MPU3050_Addr,GY_H);
   T_Y=	(BUF[3]<<8)|BUF[2];
   T_Y/=16.4; 						   //¶ÁÈ¡¼ÆËãYÖáÊı¾İ
   BUF[4]=Single_Read(MPU3050_Addr,GZ_L);
   BUF[5]=Single_Read(MPU3050_Addr,GZ_H);
   T_Z=	(BUF[5]<<8)|BUF[4];
   T_Z/=16.4; 					       //¶ÁÈ¡¼ÆËãZÖáÊı¾İ

   BUF[6]=Single_Read(MPU3050_Addr,TMP_L); 
   BUF[7]=Single_Read(MPU3050_Addr,TMP_H); 
   T_T=(BUF[7]<<8)|BUF[6];
   T_T = 35+ ((double) (T_T + 13200)) / 280;// ¶ÁÈ¡¼ÆËã³öζÈ
}
 //********´®¿Ú·¢ËÍÊı¾İ***************************************
 void Send_data(uchar axis)
 {uchar i;
  USART1_SendData(axis);
  USART1_SendData(':');
  for(i=0;i<4;i++)USART1_SendData(TX_DATA[i]);
  USART1_SendData(' ');
  USART1_SendData(' ');
 }

  /*
********************************************************************************
** º¯ÊıÃû³Æ £º main(void)
** º¯Êı¹¦ÄÜ £º Ö÷º¯Êı
** Êä    Èë	£º ÎŞ
** Êä    ³ö	£º ÎŞ
** ·µ    »Ø	£º ÎŞ
********************************************************************************
*/
int main(void)
{ 
  RCC_Configuration();		 //ÅäÖÃRCC
  GPIO_Configuration();		 //ÅäÖÃGPIO
  USART1_Configuration();	 //ÅäÖô®¿Ú1
  I2C_GPIO_Config();		 //ÅäÖÃIICʹÓö˿Ú
  Delayms(10);				 //ÑÓʱ
  Init_MPU3050();		     //³õʼ»¯MPU3050
  while(1)
 {
	READ_MPU3050();	         //¶ÁÈ¡MPU3050Êı¾İ
    DATA_printf(TX_DATA,T_X);//ת»»XÖáÊı¾İµ½Êı×é
	Send_data('X');			 //·¢ËÍXÖáÊı
	DATA_printf(TX_DATA,T_Y);//ת»»YÖáÊı¾İµ½Êı×é
	Send_data('Y');			 //·¢ËÍYÖáÊı
	DATA_printf(TX_DATA,T_Z);//ת»»ZÖáÊı¾İµ½Êı×é
	Send_data('Z');			 //·¢ËÍZÖáÊı
	DATA_printf(TX_DATA,T_T);//ת»»Î¶ÈÊı¾İµ½Êı×é
	Send_data('T');			 //·¢ËÍζÈÊı¾İ
	USART1_SendData(0X0D);	 //»»ĞĞ
	USART1_SendData(0X0A);	 //»Ø³µ
	Delayms(5);				 //ÑÓʱ
  }
}

/*************½áÊø***************/

[CoşkuN]

Sadece 6050 modül. ve üzerindeki acc. ve gyro yu raw olarak okuyacağım.
http://www.ebay.com/itm/261080395340?ssPageName=STRK:MEWNX:IT&_trksid=p3984.m1439.l2649
mesaj birleştirme:: 15 Haziran 2013, 12:50:05
alsında tam olarak gyrosununa ihtiyacım var. Okuduğum bilgiyi PC ye aktaracağım, Geri kalan işlemler pc de hallolacak ve açı vs hesaplanacak.

Bu çipin fiyatı Farnell gibi satıcılarda çok yüksek iken bu ebay'deki modüller nasıl böyle ucuz olabiliyor acaba?
http://tr.farnell.com/invensense/mpu-6050/gyro-accel-9-axis-fusion-i2c-24qfn/dp/1864742

[muhittin_kaplan]

Ne zamandır GYRO arıyordum. Ama Nedense Ya Yoktu Yada Acayip Pahalıydı. Görünce Atladım.
Bu adamdan Daha Öncede Alışverişim Oldu. Bakalım Bindik Bir alamate
mesaj birleştirme:: 15 Haziran 2013, 20:55:51
Farnel de Dürtüyor resmen

https://www.sparkfun.com/products/10937

https://www.sparkfun.com/products/11028

[berat23]

şu çin işi sensör kartlarından biriyle uğraşmışlığım var. aslınd kendin yapman en iyisi,hazır kartta herşey istediğin gibi olmuyor. mesela manyetometreyi mpu6050 nin aux I2c hattına bağlamışlar. sizin aldığınız daha iyi,en azından kart üzerinde sadece regülatör var. ben doğrusu istediğim gibi çalıştıramadım,doğrusu çalışmıyor. genelde iyi fakat keyfi olmazsa düzgün çalışmıyor. sadece raw verileri almak için kullandım,kuarterniyon falan denemedim bile ki zaten kaynak yok. o işleri işlemcide yapmıştım. işlemci olarak stelaris launchpad kullandım,ti ürünlerine karşı ayrı bir sempatim var. stm32f4 ile birşeyler yapmaya çalışmıştım,sevmedim.

aslında şu dmp kullanmayı öğrensek fena olmaz ,bu açıları doğrudan almak işlemsel olarak kolaylık getirir. önümüzdeki hafta boş zaman bulursam tekrardan bakmayı planlıyorum.

kullandığım modül;
http://www.ebay.com/itm/10DOF-IMU-MS5611-HMC5883L-MPU6050-Sensor-module-/140889804122?pt=LH_DefaultDomain_0&hash=item20cdafcd5a

[muhittin_kaplan]

Peki Gyro yu Açısal Değere Çevirmek İçin Nasıl bir yöntem izlediniz ?

örneğin (gerçi bu aletin çalışmasını bilmiyorum ama)
Belli bir ofset değerinde mi çıkış veriyor durağan halde ?
değişimi algılayıp timer çalıştırılıp ofset degerine gelene kadar süremi ölçüyorsunuz?
algoritma nasıl oluşturursam verimli olur
(stm serisi işlemci kullanacağım muhtemelen 103 yada 407)

[muhittin_kaplan]

Merhaba 6050

Bu zamazing ile iletişime geçmiş bulunmatayım. GyroY bilgisini alıp Bluetooth üzerinden bilgiyi PC ye yolladım.
Stabil haldeyken 142 ile 50 arasında değişen değerler alıyorum.

Çok Hızlı Şekilde Hareketimde 32768 ile -32768 arasında değerler görüyorum.

Biliyorum ki Gyro ile Açı ölçek istediğimde sadece bu değer değil Zaman yani bu değeri ne kadar süre ile verdiğide önemli.

Nasıl Yaparımda Açsını Ölçerim ? Zaman İşi İçine girince "Anlayamamıyorum" gibi geliyor. (Lütfen link vermeyin BarışSamancının bloguna, Anlatın Bana Bir Kalın Kafalıya Anlatıyor Gibi)

[pea]

Gyro, anlık açısal hız bilgisini veriyor. Açısal hızın integrali de açısal konum olduğu için kısaca; (okunan değer*geçen süre) sürekli toplanırsa modülün açısal konumu elde edilir. Ama, gyrolarda zamanla kayma(drift) hatası oluşuyor. 3 derece zamanla oluyor 13 derece.
İvmeölçerde de yerçekimi etkisinden direkt açı hesaplanabiliyor. (atan2 fonksiyonu) Ama ivmeölçerde de hassasiyet yüksek, en ufak etkide okuma coşuyor.

Bu ikisinin artıları birleştirilip, eksileri yok ediliyor çeşitli filtreler ile. Pek etkilenmediği için gyro, kaymadığı için ivmeölçer verilerine yüksek geçiren/alçak geçiren filtre mantığı ile manipülasyon yapılıyor.
En popüler 2 filtre tipi var. Biri Kalman; çok detaylı ve hassas, akademik uygulamalarda tercih ediliyor. Diğeri ise "Complementary/Tümleyici Filter", filtre işlemlerini katsayılar ile hallediyor, çok kullanılan pratik bir formülü var.
Burada formül, grafik, detaylı bilgi vs var: http://www.pieter-jan.com/node/11

[muhittin_kaplan]

Gyroda Kayma nın olmadığını düşünerek yola çıkarsak,
Programsal yada donanımsal Neler yapmalıyım ki açı hesaplayayım.
Örneğin Timer Kurabilirim vs vs  gibi.

[iyildirim]

Gyroda Kayma nın olmadığını düşünerek yola çıkarsak,
Programsal yada donanımsal Neler yapmalıyım ki açı hesaplayayım.
Örneğin Timer Kurabilirim vs vs  gibi.

Timer vs. kurmaya pek gerek yok.
Sensörü kullanabilmek için zaten konfigüre etmek gerekiyor. Bu işlem sırasında kaç hertz lik çıkış istediğimizi sensöre söyleyebiliyoruz. Sensör yeni değerler oluştuğunda kesme üretiyor. Kesme anında okuma yapılarak kullanılıyor.
Donanımsal olarak int pini bağlantısını kesme üretecek bir pine bağlamak yeterli.

Konfigürasyonda hatırladığım kadarı ile reset self-test işlemleri, acc. ve gyro nun ölçüm aralığı, sample rate, FIFO kullanımı, osilatör seçimi, kesme sinyalinin polaritesi gibi şeyler vardı.
6050 nin bir de gyro ve acc. nin offset kalibrasyonu için registerleri var. Startup anında hareketsiz durumda bir kaç on adet ölçüm yapıp buna göre offset registerleri güncellenebiliyor. Buraya kadar olan kısmı için datasheette yeterli veri var.
DMP yi kullanacaksanız bir de bunun konfigürasyonu işlemleri var. Ve bununla ilgili açık bir kaynak, datasheet vs. yok. Olan da bir invensense in çıkardığı bir kitin hacklenmesinden elde edilmiş hex kodlar. 
Ayrıca external bir manyetik pusula bağlanırsa  6050 nin bunu okuyabilmesi de sağlanabiliyor. Ama ben beceremedim. Daha doğrusu dmp yi bu şekilde kullanım için konfigüre edemedim.

Daha önce dediğim gibi bende de 10DOF bir modül var ve 32f4 ile birşeyler  yapmak niyetindeyim ama henüz başlayamadım.

İşime yarar derseniz SPI iletişim yapan 6000 le çalışan  dsPIC için C30 ile yazılmış örnek bir proje verebilirim. DMP kullanılıp quaternion sonuçlar okunuyor. Deneme yanılmalar yüzünden kod oldukça karışık ama olabildiğince düzenlemeye çalışırım.  En azından setup kısmı ve raw veri okumak için örnek olabilir.
Gerçi nette de raw veri hatta stm32 için bir sürü örnek var. 

[muhittin_kaplan]

Hocam bilgileri aliyorum. Yukarda verdigim bir linkteki kutupbaneyi kullandim. Ve bilgisayara seri uzerinden aktariyorum. Belli araliklarla geliyor zaten bilgiler. Ben  bu  bilgileri kullanarak pc de aci hesabi yapmak iztiyorum. Mumkun oldugunca register felan ugrasmak istemiyorum