아두 이노 자이로 센서 | 아두이노로 자이로 센서 신호 확인 하기…^^ 47 개의 베스트 답변

당신은 주제를 찾고 있습니까 “아두 이노 자이로 센서 – 아두이노로 자이로 센서 신호 확인 하기…^^“? 다음 카테고리의 웹사이트 sk.taphoamini.com 에서 귀하의 모든 질문에 답변해 드립니다: sk.taphoamini.com/wiki. 바로 아래에서 답을 찾을 수 있습니다. 작성자 설계하는 아부지 Innoker 이(가) 작성한 기사에는 조회수 4,182회 및 좋아요 31개 개의 좋아요가 있습니다.

아두 이노 자이로 센서 주제에 대한 동영상 보기

여기에서 이 주제에 대한 비디오를 시청하십시오. 주의 깊게 살펴보고 읽고 있는 내용에 대한 피드백을 제공하세요!

d여기에서 아두이노로 자이로 센서 신호 확인 하기…^^ – 아두 이노 자이로 센서 주제에 대한 세부정보를 참조하세요

게시일 : 2020/05/03
반갑습니다.
동수아부지 Innoker 입니다.
오늘은 아두이노로 자이로 센서 신호를 확인해 보고
Processing으로 3D 시뮬레이션을 해보겠습니다.
부담없는 영상으로 많은 시청 부탁드립니다.
메일 : [email protected]
블로그 : https://blog.naver.com/autofa
Processing : https://processing.org/download/?processing
MPU6050, I2C dev, toxi 라이브러리 다운로드 :
https://blog.naver.com/autofa/221943064034
License of Music
Intro Music
📢BGM
✔️Track – Anwar Amr – Epicness
✔️theartistunion – https://theartistunion.com/tracks/af8a3c
✔️나눔뮤직 – https://tv.naver.com/v/10425657
Main Music
Nostalgia – Tobu
Music by Tobu http://www.youtube.com/tobuofficial
Music Playlist by http://reurl.kr/1A02CADECG

아두 이노 자이로 센서 주제에 대한 자세한 내용은 여기를 참조하세요.

MPU-6050 가속도/자이로 센서 제어 (아두이노) – Steemit

MPU-6050 가속도/자이로 센서 제어 (아두이노) 온라인 가상시뮬레이터 : 참고 출처 : 오일러의 각 : 상보필터 : 필만필터 : MPU-6050 데이터시트 : 포스트… by …

+ 여기를 클릭

Source: steemit.com

Date Published: 3/6/2021

View: 5845

아두이노 자이로센서(MPU6050센서) 써보기

아두이노 가속도 / 자이로 센서 중에 가장 유명한 센서인 MPU6050을 가져와봤습니다. 동작전압: 2.375V~3.46V (수정) 통신방식: I²C(I2C,IIC) …

+ 자세한 내용은 여기를 클릭하십시오

Source: blog.tomclansys.com

Date Published: 11/26/2021

View: 1744

티스토리 – 라즈이노 iOT

【 아두이노모듈#30】 #1.기울기 센서(6축 가속도&자이로)에 대해 알아봅시다. 【 기울기 센서 개요 】. 자이로 센서(Gyro Sensor)의 원리는 자이로 …

+ 여기를 클릭

Source: rasino.tistory.com

Date Published: 1/1/2021

View: 7257

아두이노 MPU6050 자이로 가속도센서 실습 – 싸이피아SCIPIA

이 센서는 3축 자이로스코프와 3축 가속도계를 모두 포함하고 있으며 독립적으로 측정이 가능합니다. I2C 포트를 통해 아두이노 보드와 통신합니다.

+ 여기에 자세히 보기

Source: scipia.co.kr

Date Published: 4/2/2022

View: 7519

[아두이노] MPU-6050 자이로센서 TEST – 이번에는 뭐가 좋을까?

[아두이노] MPU-6050 자이로센서 TEST. Cocopop 2021. 9. 30. 00:30. 반응형. * 이 과정은 제가 공부 목적을 위해 작성한 글이므로 옳은 답은 없습니다.

+ 더 읽기

Source: cococulture.tistory.com

Date Published: 1/29/2022

View: 2915

아두이노 MPU6050 사용법 정리 by makeshare.org – N2 정보기술

안녕하세요 메카솔루션입니다. 이번에는 아두이노 가속도 / 자이로 센서 중에 가장 유명한 센서인 MPU6050의 사용법을 알아보고자 …

+ 여기에 보기

Source: n2infotech.co.kr

Date Published: 2/13/2021

View: 2286

자이로 센서 – 검색결과 – 쇼핑하우

[해외]Accelerometer MPU9250 앵글 자이로 센서 JY901 자석 필드 아두이노 dip 앵글 mpu6050 Ac … 아두이노 CA3 3축 가속도 자이로 센서 모듈 MPU-6050 아두이노.

+ 자세한 내용은 여기를 클릭하십시오

Source: m.shoppinghow.kakao.com

Date Published: 8/20/2021

View: 3752

주제와 관련된 이미지 아두 이노 자이로 센서

주제와 관련된 더 많은 사진을 참조하십시오 아두이노로 자이로 센서 신호 확인 하기…^^. 댓글에서 더 많은 관련 이미지를 보거나 필요한 경우 더 많은 관련 기사를 볼 수 있습니다.

---

주제에 대한 기사 평가 아두 이노 자이로 센서

• Author: 설계하는 아부지 Innoker
• Views: 조회수 4,182회
• Likes: 좋아요 31개
• Date Published: 2020. 5. 2.
• Video Url link: https://www.youtube.com/watch?v=qE4xyd8spcY

MPU-6050 가속도/자이로 센서 제어 (아두이노) — Steemit

MPU-6050 가속도/자이로 센서 제어 (아두이노)

오늘은 MPU-6050 가속도/자이로 센서를 이용하여 실험하는 시간을 갖도록 하겠습니다. 자이로 센서를 사용하려면 오일러의 공식을 알아야 하고 오일러의 공식 이해하셔야 하고 각속도와 오일러의 변화율 공식과 오일러의 각을 이해하기 위해서 피치, 롤, 요와 같은 용어적 의미와 공식을 알아야 합니다. 그리고 회전각을 구할 때 대표적인 2개의 필터가 있는데 상보필터와 칼만필터 중 하나 정도는 공식을 알아야 합니다. 이처럼 수학적인 공식을 알아야 제대로 사용할 수 있습니다. 나중에 깊게 공부할 때는 모두 알아야 할 내용인데 입문자에게는 버거운 내용입니다. 하지만 이 모든것을 몰라도 사용할 수 있습니다. MPU-6050라이브러리르 사용하면 쉽게 회전각을 구할 수 있습니다. 바로 라이브러리를 사용하는 것보다 먼저 간단히 어떤 값들이 MPU-6050 모듈을 통해 측정되는지 살펴봐야 겠지요. 우선, 간단히 MPU-6050에 대해서 살펴보고 실험해보도록 하죠.

1. MPU-6050 가속도/자이로 센서

MPU-6050 모듈은 가속도/자이로를 측정할 수 있는 센서입니다. 가속도는 지구 중력을 기준으로 x, y, z 축의 가속도 크기를 구할 수 있으면 자이로(각속도)는 시간당 x, y, z 축의 회전속도 속도를 구할 수 있습니다.

MPU-6050 모듈에서 측정된 값은 바로 회전각으로 이해하기 힘듭니다. 그래서 계산이 필요하는 데 오일러의 각 공식을 알아야 합니다. 아래 링크된 위키백과사전에서 한번 읽어주시기 바랍니다.

오일러의 각 : https://ko.wikipedia.org/wiki/%EC%98%A4%EC%9D%BC%EB%9F%AC_%EA%B0%81

3차원 회전 좌표계로 X축 회전을 롤, Y축 회전을 피치, Z축 회전을 요라고 합니다. 롤,피치,요에 대한 계산 공식이 따로 있습니다.

상보필터과 칼만필터는 회전각을 구할때 필요한 필터입니다.

아래는 상보필터의 공식입니다.

angle = 0.98*(angle+자이로값*dt)+0.02*(가속도값) [angle-출력각, dt-적분할 시간]

출처 : http://mechasolutionwiki.com/index.php?title=%EC%83%81%EB%B3%B4%ED%95%84%ED%84%B0

칼만필터은 아래 위키백과에 가셔서 공식을 살펴보시기 바랍니다.

https://ko.wikipedia.org/wiki/%EC%B9%BC%EB%A7%8C_%ED%95%84%ED%84%B0

대표적으로 이 두개의 필터로 회전각을 구하게 되는데 나중에 실험에서는 상보필터로 된 라이브러리를 이용할 예정입니다.

아래 MPU-6050 데이터 시트에 가셔서 MPU-6050에 대해서 알아두시기 바랍니다.

https://www.invensense.com/wp-content/uploads/2015/02/MPU-6000-Datasheet1.pdf

2. MPU-6050 가속도/자이로 센서 구조

MPU-6050 모듈은 가속도 (x,y,z)와 자이로(각속도) (x,y,z)의 값과 온도 값을 얻을 수 있습니다.

MPU-6050 모듈은 I2C 통신으로 14개의 레지지스터 값을 아두이노로 보내고 데이터는 16bit로 구성된 총 7개의 데이터를 얻게 됩니다.

MPU-6050 모듈의 핀에 대해서 위표를 잘 살펴보시고 인터럽트핀은 아두이노우노의 경우는 인터럽트 핀이 2번이기에 사용하실 경우 2번 핀에 연결하시면 되고 사용하는 아두이노보드에 따라 해당 I2C핀과 인터럽트 핀에 맞게 연결하시면 됩니다.

3. MPU-6050 가속도/자이로 회로도

준비물 : MPU-6050 모듈, 아두이노우노

내용 : I2C 통신을 위해 A4(SDA), A5(SCL)핀에 연결하시오

I2C핀만 주의해서 연결하시면 됩니다.

4. 코딩

참고 소스 출처 : https://playground.arduino.cc/Main/MPU-6050

우선 기본 라이브러리 없이 순수 MPU-6050 모듈에서 측정되는 값이 어떤 값들이 출력되는지 살펴보도록 하겟습니다.

위 링크된 MPU-6050소스에 대해 간단히 살펴보겠습니다.

[소스]

// By Arduino User JohnChi

#include const int MPU_addr=0x68; // I2C address of the MPU-6050 int16_t AcX,AcY,AcZ,Tmp,GyX,GyY,GyZ; void setup(){ Wire.begin(); Wire.beginTransmission(MPU_addr); Wire.write(0x6B); // PWR_MGMT_1 register Wire.write(0); // set to zero (wakes up the MPU-6050) Wire.endTransmission(true); Serial.begin(9600); } void loop(){ Wire.beginTransmission(MPU_addr); Wire.write(0x3B); // starting with register 0x3B (ACCEL_XOUT_H) Wire.endTransmission(false); Wire.requestFrom(MPU_addr,14,true); // request a total of 14 registers AcX=Wire.read()<<8|Wire.read(); // 0x3B (ACCEL_XOUT_H) & 0x3C (ACCEL_XOUT_L) AcY=Wire.read()<<8|Wire.read(); // 0x3D (ACCEL_YOUT_H) & 0x3E (ACCEL_YOUT_L) AcZ=Wire.read()<<8|Wire.read(); // 0x3F (ACCEL_ZOUT_H) & 0x40 (ACCEL_ZOUT_L) Tmp=Wire.read()<<8|Wire.read(); // 0x41 (TEMP_OUT_H) & 0x42 (TEMP_OUT_L) GyX=Wire.read()<<8|Wire.read(); // 0x43 (GYRO_XOUT_H) & 0x44 (GYRO_XOUT_L) GyY=Wire.read()<<8|Wire.read(); // 0x45 (GYRO_YOUT_H) & 0x46 (GYRO_YOUT_L) GyZ=Wire.read()<<8|Wire.read(); // 0x47 (GYRO_ZOUT_H) & 0x48 (GYRO_ZOUT_L) Serial.print("AcX = "); Serial.print(AcX); Serial.print(" | AcY = "); Serial.print(AcY); Serial.print(" | AcZ = "); Serial.print(AcZ); Serial.print(" | Tmp = "); Serial.print(Tmp/340.00+36.53); //equation for temperature in degrees C from datasheet Serial.print(" | GyX = "); Serial.print(GyX); Serial.print(" | GyY = "); Serial.print(GyY); Serial.print(" | GyZ = "); Serial.println(GyZ); delay(333); } MPU-6050의 I2C 주소는 '0x6B'입니다. int16_t AcX,AcY,AcZ,Tmp,GyX,GyY,GyZ; 16bit int형 자료형으로 가속도 3개, 온도 1개, 자이로 3개의 변수를 선언합니다. Wire.beginTransmission(MPU_addr); Wire.write(0x6B); // PWR_MGMT_1 register Wire.write(0); // set to zero (wakes up the MPU-6050) Wire.endTransmission(true); beginTransmission()함수로 '0x6B'주소로 I2C 슬레이브 디바이스로 전송을 시작합니다. 그리고 버스가 연결되면 '0x6B' 보내고 다시 '0'을 보내고 나서 endTransmission(true)함수로 버스를 해제하는 메세지를 보냅니다. 초기화 수행합니다. Wire.beginTransmission(MPU_addr); //MPU-6050 '0x6B'주소 시작 Wire.write(0x3B); // 0x3B 읽을 rigister주소 Wire.endTransmission(false) //버스를 연결 활성화 Wire.requestFrom(MPU_addr,14,true) //데이터 요청하는데 14 레지스터 값을 요청 이렇게 해서, Wire.read()함수를 이용해서 실제로 MPU-6050에서 값을 읽게 됩니다. 0x3B~0x48의 레지스터값을 읽어와서 가속도, 온도, 자이로 값을 만들어 내게 됩니다. Wire.read()<<8|Wire.read(); '0x3B' 레지스터 값을 왼쪽으로 8bit 이동시키고 '0x3C' 레지스터 값을 비트OR 연산을 수행합니다. 이 식을 통해서 2개의 레지스터 값을 합치게 됩니다. 예를 들어 임의의 값 A, B가 있을때 위 식으로 계산한다면 더 쉽게 살펴보면은, 비트OR 연산은 둘중 하나가 1이면 결과가 1이 나오는 연산입니다. 이렇게 14개의 레지스트값을 2개씩 이 수식을 통해서 가속도(x,y,z), 온도, 자이로(x,y,z)값을 순차적으로 Wire.read()함수를 14번 읽어서 연산을 수행하여 값을 얻게 됩니다. 그 값을 시리얼모니터로 출력하기 때문에 순수 MPU-6050 모듈에서 추출한 값입니다. [결과] 5. 결과 실제 영상으로 살펴보면 MPU-6050 가속도/자이로센서를 움직일 때마다 가속도 AcX, AcY, AcZ 값과 자이로 GyX, GyY, GyZ 값이 나옵니다. 추가로 Tmp(온도)값은 온도를 계산식이 간단해서 값으로 나오고 가속도와 자이로는 우리가 각도로 느끼기에는 다소 어려운 수치로 출력이 이뤄집니다. 이 값으로 나중에 계산해서 회전각을 구하게 되는데 우선 어떤 값들이 찍히는지는 알아야 계산을 할 수 있겠죠. 나중에 위 링크된 곳에 가셔서 한번 공식에 대해서 자세히 배워보시기 바랍니다.

아두이노 자이로센서(MPU6050센서) 써보기

아두이노 가속도 / 자이로 센서 중에 가장 유명한 센서인 MPU6050을 가져와봤습니다.

출처: https://www.amazon.com/SunFounder-MPU6050-Raspberry-Gyroscope-Accelerator/dp/B0151GI5VI

동작전압: 2.375V~3.46V (수정)

통신방식: I²C(I2C,IIC) , SPI

자이로 최대 측정값: ±(250/500/1000/2000)

자이로 센서 감도: (131/65.5/32.8/16.4)

데이터 시트

https://www.invensense.com/wp-content/uploads/2015/02/MPU-6500-Datasheet2.pdf

자이로/가속도 센서입니다.

원리는 이거 보고 이해하시길. https://mechaworld.tistory.com/11

주의사항!

납땜이 되어있는것도 있고 안되어 있는것도 있으니까 잘 보고 사시길.

안되어 있는건 본인이 인두기로 납땜해야 한다.

출처: https://blog.naver.com/roboholic84/220583168600

아두이노 보드의 i2c핀 위치

[출처] 아두이노 보드별 I²C 핀 알아보기! (i2c핀 아두이노 i2c)|작성자 오픈랩

연결법

출처: http://www.makeshare.org/bbs/board.php?bo_table=arduinosensor&wr_id=47

코딩하기..

코드는 요짝으로 코딩하자

// I2C device class (I2Cdev) demonstration Arduino sketch for MPU6050 class using DMP (MotionApps v2.0) // 6/21/2012 by Jeff Rowberg // Updates should (hopefully) always be available at https://github.com/jrowberg/i2cdevlib // // Changelog: // 2013-05-08 – added seamless Fastwire support // – added note about gyro calibration // 2012-06-21 – added note about Arduino 1.0.1 + Leonardo compatibility error // 2012-06-20 – improved FIFO overflow handling and simplified read process // 2012-06-19 – completely rearranged DMP initialization code and simplification // 2012-06-13 – pull gyro and accel data from FIFO packet instead of reading directly // 2012-06-09 – fix broken FIFO read sequence and change interrupt detection to RISING // 2012-06-05 – add gravity-compensated initial reference frame acceleration output // – add 3D math helper file to DMP6 example sketch // – add Euler output and Yaw/Pitch/Roll output formats // 2012-06-04 – remove accel offset clearing for better results (thanks Sungon Lee) // 2012-06-01 – fixed gyro sensitivity to be 2000 deg/sec instead of 250 // 2012-05-30 – basic DMP initialization working /* ============================================ I2Cdev device library code is placed under the MIT license Copyright (c) 2012 Jeff Rowberg Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the “Software”), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. =============================================== */ // I2Cdev and MPU6050 must be installed as libraries, or else the .cpp/.h files // for both classes must be in the include path of your project #include “I2Cdev.h” #include “MPU6050_6Axis_MotionApps20.h” //#include “MPU6050.h” // not necessary if using MotionApps include file // Arduino Wire library is required if I2Cdev I2CDEV_ARDUINO_WIRE implementation // is used in I2Cdev.h #if I2CDEV_IMPLEMENTATION == I2CDEV_ARDUINO_WIRE #include “Wire.h” #endif // class default I2C address is 0x68 // specific I2C addresses may be passed as a parameter here // AD0 low = 0x68 (default for SparkFun breakout and InvenSense evaluation board) // AD0 high = 0x69 MPU6050 mpu; //MPU6050 mpu(0x69); // <-- use for AD0 high /* ========================================================================= NOTE: In addition to connection 3.3v, GND, SDA, and SCL, this sketch depends on the MPU-6050's INT pin being connected to the Arduino's external interrupt #0 pin. On the Arduino Uno and Mega 2560, this is digital I/O pin 2. * ========================================================================= */ /* ========================================================================= NOTE: Arduino v1.0.1 with the Leonardo board generates a compile error when using Serial.write(buf, len). The Teapot output uses this method. The solution requires a modification to the Arduino USBAPI.h file, which is fortunately simple, but annoying. This will be fixed in the next IDE release. For more info, see these links: http://arduino.cc/forum/index.php/topic,109987.0.html http://code.google.com/p/arduino/issues/detail?id=958 * ========================================================================= */ // uncomment "OUTPUT_READABLE_QUATERNION" if you want to see the actual // quaternion components in a [w, x, y, z] format (not best for parsing // on a remote host such as Processing or something though) //#define OUTPUT_READABLE_QUATERNION // uncomment "OUTPUT_READABLE_EULER" if you want to see Euler angles // (in degrees) calculated from the quaternions coming from the FIFO. // Note that Euler angles suffer from gimbal lock (for more info, see // http://en.wikipedia.org/wiki/Gimbal_lock) //#define OUTPUT_READABLE_EULER // uncomment "OUTPUT_READABLE_YAWPITCHROLL" if you want to see the yaw/ // pitch/roll angles (in degrees) calculated from the quaternions coming // from the FIFO. Note this also requires gravity vector calculations. // Also note that yaw/pitch/roll angles suffer from gimbal lock (for // more info, see: http://en.wikipedia.org/wiki/Gimbal_lock) #define OUTPUT_READABLE_YAWPITCHROLL // uncomment "OUTPUT_READABLE_REALACCEL" if you want to see acceleration // components with gravity removed. This acceleration reference frame is // not compensated for orientation, so +X is always +X according to the // sensor, just without the effects of gravity. If you want acceleration // compensated for orientation, us OUTPUT_READABLE_WORLDACCEL instead. //#define OUTPUT_READABLE_REALACCEL // uncomment "OUTPUT_READABLE_WORLDACCEL" if you want to see acceleration // components with gravity removed and adjusted for the world frame of // reference (yaw is relative to initial orientation, since no magnetometer // is present in this case). Could be quite handy in some cases. //#define OUTPUT_READABLE_WORLDACCEL // uncomment "OUTPUT_TEAPOT" if you want output that matches the // format used for the InvenSense teapot demo //#define OUTPUT_TEAPOT #define INTERRUPT_PIN 2 // use pin 2 on Arduino Uno & most boards #define LED_PIN 13 // (Arduino is 13, Teensy is 11, Teensy++ is 6) bool blinkState = false; // MPU control/status vars bool dmpReady = false; // set true if DMP init was successful uint8_t mpuIntStatus; // holds actual interrupt status byte from MPU uint8_t devStatus; // return status after each device operation (0 = success, !0 = error) uint16_t packetSize; // expected DMP packet size (default is 42 bytes) uint16_t fifoCount; // count of all bytes currently in FIFO uint8_t fifoBuffer[64]; // FIFO storage buffer // orientation/motion vars Quaternion q; // [w, x, y, z] quaternion container VectorInt16 aa; // [x, y, z] accel sensor measurements VectorInt16 aaReal; // [x, y, z] gravity-free accel sensor measurements VectorInt16 aaWorld; // [x, y, z] world-frame accel sensor measurements VectorFloat gravity; // [x, y, z] gravity vector float euler[3]; // [psi, theta, phi] Euler angle container float ypr[3]; // [yaw, pitch, roll] yaw/pitch/roll container and gravity vector // packet structure for InvenSense teapot demo uint8_t teapotPacket[14] = { '$', 0x02, 0,0, 0,0, 0,0, 0,0, 0x00, 0x00, '\r', ' ' }; // ================================================================ // === INTERRUPT DETECTION ROUTINE === // ================================================================ volatile bool mpuInterrupt = false; // indicates whether MPU interrupt pin has gone high void dmpDataReady() { mpuInterrupt = true; } // ================================================================ // === INITIAL SETUP === // ================================================================ void setup() { // join I2C bus (I2Cdev library doesn't do this automatically) #if I2CDEV_IMPLEMENTATION == I2CDEV_ARDUINO_WIRE Wire.begin(); Wire.setClock(400000); // 400kHz I2C clock. Comment this line if having compilation difficulties #elif I2CDEV_IMPLEMENTATION == I2CDEV_BUILTIN_FASTWIRE Fastwire::setup(400, true); #endif // initialize serial communication // (115200 chosen because it is required for Teapot Demo output, but it's // really up to you depending on your project) Serial.begin(115200); while (!Serial); // wait for Leonardo enumeration, others continue immediately // NOTE: 8MHz or slower host processors, like the Teensy @ 3.3v or Ardunio // Pro Mini running at 3.3v, cannot handle this baud rate reliably due to // the baud timing being too misaligned with processor ticks. You must use // 38400 or slower in these cases, or use some kind of external separate // crystal solution for the UART timer. // initialize device Serial.println(F("Initializing I2C devices...")); mpu.initialize(); pinMode(INTERRUPT_PIN, INPUT); // verify connection Serial.println(F("Testing device connections...")); Serial.println(mpu.testConnection() ? F("MPU6050 connection successful") : F("MPU6050 connection failed")); // wait for ready Serial.println(F(" Send any character to begin DMP programming and demo: ")); while (Serial.available() && Serial.read()); // empty buffer while (!Serial.available()); // wait for data while (Serial.available() && Serial.read()); // empty buffer again // load and configure the DMP Serial.println(F("Initializing DMP...")); devStatus = mpu.dmpInitialize(); // supply your own gyro offsets here, scaled for min sensitivity mpu.setXGyroOffset(220); mpu.setYGyroOffset(76); mpu.setZGyroOffset(-85); mpu.setZAccelOffset(1788); // 1688 factory default for my test chip // make sure it worked (returns 0 if so) if (devStatus == 0) { // turn on the DMP, now that it's ready Serial.println(F("Enabling DMP...")); mpu.setDMPEnabled(true); // enable Arduino interrupt detection Serial.println(F("Enabling interrupt detection (Arduino external interrupt 0)...")); attachInterrupt(digitalPinToInterrupt(INTERRUPT_PIN), dmpDataReady, RISING); mpuIntStatus = mpu.getIntStatus(); // set our DMP Ready flag so the main loop() function knows it's okay to use it Serial.println(F("DMP ready! Waiting for first interrupt...")); dmpReady = true; // get expected DMP packet size for later comparison packetSize = mpu.dmpGetFIFOPacketSize(); } else { // ERROR! // 1 = initial memory load failed // 2 = DMP configuration updates failed // (if it's going to break, usually the code will be 1) Serial.print(F("DMP Initialization failed (code ")); Serial.print(devStatus); Serial.println(F(")")); } // configure LED for output pinMode(LED_PIN, OUTPUT); } // ================================================================ // === MAIN PROGRAM LOOP === // ================================================================ void loop() { // if programming failed, don't try to do anything if (!dmpReady) return; // wait for MPU interrupt or extra packet(s) available while (!mpuInterrupt && fifoCount < packetSize) { // other program behavior stuff here // . // . // . // if you are really paranoid you can frequently test in between other // stuff to see if mpuInterrupt is true, and if so, "break;" from the // while() loop to immediately process the MPU data // . // . // . } // reset interrupt flag and get INT_STATUS byte mpuInterrupt = false; mpuIntStatus = mpu.getIntStatus(); // get current FIFO count fifoCount = mpu.getFIFOCount(); // check for overflow (this should never happen unless our code is too inefficient) if ((mpuIntStatus & 0x10) || fifoCount == 1024) { // reset so we can continue cleanly mpu.resetFIFO(); Serial.println(F("FIFO overflow!")); // otherwise, check for DMP data ready interrupt (this should happen frequently) } else if (mpuIntStatus & 0x02) { // wait for correct available data length, should be a VERY short wait while (fifoCount < packetSize) fifoCount = mpu.getFIFOCount(); // read a packet from FIFO mpu.getFIFOBytes(fifoBuffer, packetSize); // track FIFO count here in case there is > 1 packet available // (this lets us immediately read more without waiting for an interrupt) fifoCount -= packetSize; #ifdef OUTPUT_READABLE_QUATERNION // display quaternion values in easy matrix form: w x y z mpu.dmpGetQuaternion(&q, fifoBuffer); Serial.print(“quat\t”); Serial.print(q.w); Serial.print(“\t”); Serial.print(q.x); Serial.print(“\t”); Serial.print(q.y); Serial.print(“\t”); Serial.println(q.z); #endif #ifdef OUTPUT_READABLE_EULER // display Euler angles in degrees mpu.dmpGetQuaternion(&q, fifoBuffer); mpu.dmpGetEuler(euler, &q); Serial.print(“euler\t”); Serial.print(euler[0] * 180/M_PI); Serial.print(“\t”); Serial.print(euler[1] * 180/M_PI); Serial.print(“\t”); Serial.println(euler[2] * 180/M_PI); #endif #ifdef OUTPUT_READABLE_YAWPITCHROLL // display Euler angles in degrees mpu.dmpGetQuaternion(&q, fifoBuffer); mpu.dmpGetGravity(&gravity, &q); mpu.dmpGetYawPitchRoll(ypr, &q, &gravity); Serial.print(“ypr\t”); Serial.print(ypr[0] * 180/M_PI); Serial.print(“\t”); Serial.print(ypr[1] * 180/M_PI); Serial.print(“\t”); Serial.println(ypr[2] * 180/M_PI); #endif #ifdef OUTPUT_READABLE_REALACCEL // display real acceleration, adjusted to remove gravity mpu.dmpGetQuaternion(&q, fifoBuffer); mpu.dmpGetAccel(&aa, fifoBuffer); mpu.dmpGetGravity(&gravity, &q); mpu.dmpGetLinearAccel(&aaReal, &aa, &gravity); Serial.print(“areal\t”); Serial.print(aaReal.x); Serial.print(“\t”); Serial.print(aaReal.y); Serial.print(“\t”); Serial.println(aaReal.z); #endif #ifdef OUTPUT_READABLE_WORLDACCEL // display initial world-frame acceleration, adjusted to remove gravity // and rotated based on known orientation from quaternion mpu.dmpGetQuaternion(&q, fifoBuffer); mpu.dmpGetAccel(&aa, fifoBuffer); mpu.dmpGetGravity(&gravity, &q); mpu.dmpGetLinearAccel(&aaReal, &aa, &gravity); mpu.dmpGetLinearAccelInWorld(&aaWorld, &aaReal, &q); Serial.print(“aworld\t”); Serial.print(aaWorld.x); Serial.print(“\t”); Serial.print(aaWorld.y); Serial.print(“\t”); Serial.println(aaWorld.z); #endif #ifdef OUTPUT_TEAPOT // display quaternion values in InvenSense Teapot demo format: teapotPacket[2] = fifoBuffer[0]; teapotPacket[3] = fifoBuffer[1]; teapotPacket[4] = fifoBuffer[4]; teapotPacket[5] = fifoBuffer[5]; teapotPacket[6] = fifoBuffer[8]; teapotPacket[7] = fifoBuffer[9]; teapotPacket[8] = fifoBuffer[12]; teapotPacket[9] = fifoBuffer[13]; Serial.write(teapotPacket, 14); teapotPacket[11]++; // packetCount, loops at 0xFF on purpose #endif // blink LED to indicate activity blinkState = !blinkState; digitalWrite(LED_PIN, blinkState); } }

예제를 참고해서 적느라 코드가 좀 길다.(복붙 매우 권장)

센서 동작 사진

실행시키려면 아무 문자나 입력 후 엔터하자

코드를 동작시키고 아무 문자나 (ex, A) 입력하면 센서가 동작한다.

구부렸을때

구부렸을때 값이 달라지는것을 확인할 수 있다.

또 다른쪽으로 휘게 했을때

다른쪽으로 휘게 해도 아까와는 값이 또 달라지는것을 확인할 수 있다.

TMI 정보

MPU6050 모듈은 드론에도 적용되는 자이로/가속도 센서이다.

이 모듈이 있어야 드론이 회전, 기울기 등을 측정할 수 있다고 한다. 모터 정밀 조정을 위해.

MPU6050 모듈은 가속도 자이로 센서를 이용하여 드론의 기울어진 정도와 회전한 정도를 알아낼 수있다.

회전정도와 기울기정도를 가지고 모터의 속도를 조절하여 드론을 올바르게 균형을 잡는데 도와주기도 한다.

간단한 자이로/가속도 센서 활용(?)법을 올렸다.

저번 색상센서와 마찬가지로 난이도는 쉬운편이다.

부품만 있으면 누구나 시도해볼만 하다.

라즈이노 iOT :: 【 아두이노모듈#30】 #1.기울기 센서(6축 가속도&자이로)에 대해 알아봅시다.(GY-521/MPU6050 센서 실습 #1)

반응형

【 아두이노 모듈 #30 】 #1. 기울기 센서 ( 6축 가속도 & 자이로 ) 에 대해 알아봅시다.

【 기울기 센서 개요 】

자이로 센서(Gyro Sensor)의 원리는 자이로스코프가 내장된 물체가 회전 운동을 하면 생기는 회전 반발력을 측정하여 전기신호로 바꾸어 출력하고 이를 수치화하여 활용하게 됩니다. 그래서 기울기 센서는 가속도 센서와 자이로 센서의 기능을 통합하여 자세나 위치를 추정할 수 있는 장치를 말하며, 이를 활용한 항공기 및 배(Ship) 등에 사용되는 관성항법장치(INS)는 이동거리와 방향까지 추정할 수 있도록 되어 있습니다.

▶ 주요 활용분야 :

센서 주요활용분야: 드론/AR스마트안경/VR고글/나인봇/핏빗, 미밴드/스마트워치/전자수평계 등

– 드론 : 비행 중인 드론은 현재의 기울기나 위치 파악은 물론이며, 특정 위치에서의 고정 비행을 할 경우 바람 등으로 인하여 원래의 위치와 자세를 유지하는 기능이 필요한데, 가속도 센서와 자이로 센서가 각각 중력가속도와 각속도를 측정하여 얼마나 기울어졌는지를 파악하여 보정할 수 있도록 해줍니다.

– VR/AR : 대표적 VR제품인 오큘러스 고글이나 구글 스마트 안경과 같은 AR 제품의 경우 사용자의 머리(얼굴 방향) 움직임이 있을 경우 자이로 센서를 이용하여 회전을 인식하거나 물체와의 위치를 파악하게 해주는 등의 중요한 역할을 합니다.

– 세그웨이나 나인봇 : 사람의 몸이 기울이는 정도와 방향에 따라 세그웨이/나인봇을 제어할 수 있도록 하는 곳에 자이로(가속도) 센서가 사용됩니다.

– 운동 관련 웨어러블 기기인 핏빗이나 샤오미 밴드 , 스마트 워치 등에서 사람의 움직임 등을 파악하기 위해 사용됩니다.

이처럼, 기울기 센서(가속도/자이로 센서)는 다양한 곳에 활용되는데요, 대표적으로 많이 사용되는 GY-521(MPU6050) 모듈을 아두이노를 통하여 학습해 본다면, 이후 아두이노와 함께 다양한 응용 작품을 만드는데 좋은 기회가 될 것으로 생각됩니다 ^^.

라즈이노 IoT에서는 앞으로 몇 회차에 걸쳐 기울기 센서 모듈을 이용해서 흥미로운 학습과제를 진행할 예정입니다.

본 페이지에서는 GY-521 모듈의 스펙과 기본 사용법에 관련된 학습이 진행됩니다.

《 GY-521 모듈(MPU-6050 6축-자이로 가속도 센서) 》

GY-521 기울기 센서 앞·뒷면 모습

IMU-6040 기울기 센서 모듈의 동작원리에 대한, 간략한 설명을 드리면,

센서 이름에 있는 IMU의 뜻은 Inertial Measurement Unit의 약어로, 관성 측정 장치라는 뜻이 있으며,

IMU-6040 모듈에는 X, Y, Z의 3축 가속도 센서와, 3축 자이로 센서, 온도 센서로 구성되어 있습니다. 온도 센서는 가속도 자이로 값이 급격한 온도 변화에 영향을 받을 경우 적용하기 위해 있는 센서로 일반적인 환경하에서는 적용하지 않고 사용하게 됩니다.

기울기는, 자이로 스코프(Gyroscope)로 측정이 가능하며, 가속도 센서로도 측정 가능합니다. 두 가지가 함께 있는 이유는 서로의 단점이 존재하는데, 이를 보완하기 위함이라고 보시면 됩니다. “자이로 스코프”에는 MEMS Gyroscope 라는 칩, 시스템 혹은 센서라고 하는 것이 들어 있습니다.

MEMS 뜻은 “Micro Electro Mechanical System”의 약어로, MEMS 센서는 칩이 회전 또는 기울어질 때 전압을 출력 시킵니다. 기울어지는 정도에 따라 비례해서 전압값이 다르게 출력됩니다.

이 전압은 칩 내부에서 16bit ADC 컨버터(아날로그 전압을 디지털 숫자 값으로 변환하는)에 의해 16비트(0 ~ 2의 16승 값 범위)값으로 변환 되고, 이 값을 가지고 아두이노 라이브러리와 프로그래밍 코드에서 처리하여 각도 값으로 변환해서 보여주게 됩니다.

그리고 MPU-6050에는 Accelerometer(가속도 계)라는 측정 센서가 있습니다. 역시, X, Y, Z 3개의 축으로 구성 되어 있으며, 조금 설명하기 쉽게, 어떤 박스 안에 무게가 있는 둥근 공이 있을 때, -X ↔ 공 ↔ +X 예를 들어, X축을 기준으로 -X축 방향으로 박스를 빠르게 밀었을 때, 공은 제자리에 머물러 있게 되는데, 이는 관성에 의해 +X축 방향으로 이동한 것으로 볼 수 있습니다. 센서에서는 이런 움직임에 대해 각 축 별로 전압으로 측정해 내게 되고, 자이로 센서의 경우처럼, 이를 수치 값으로 변환하여 코드에서 기울기 값 등으로 처리 할 수 있게 됩니다.

MPU-6050은 위 이미지에서 가운데 정사각형의 IC칩 명칭이며, 이 칩을 이용해서 만든 모듈 이름이 GY-521입니다. 따라서 같은 MPU-6050 칩을 사용한 다른 모델 제품도 있을 수 있으며, 경우에 따라 핀 배열이 다를 수 있습니다.

하지만 GY-521 모듈이 대표적으로 많이 사용되고 있습니다.

MPU-6050은 6축의 자유도(DOF : Degree of Freedom)를 가지며, 3축(x, y, z) 가속도계와 3축(x,y,z) 자이로를 합하여 6 축이라고 하며, 또는 3축 가속도+자이로 2축+온도 1축을 합하여 6축이라고도 합니다. (온도 센서가 포함된 이유는 가속도와 자이로 값이 온도에도 영향을 받기 때문에 온도센서를 활용하면 온도 변화에도 대응하는 값을 얻을 수 있기 때문입니다) 여기에, 지자기(지구자기) 센서의 3축을 추가한 모델이 MPU-9060 , 9축 센서입니다. 9축 센서를 이용하면 3차원의 위치(지구 상 공간)와 3차원의 방향을 모두 파악할 수 있게 됩니다.

– 가속도 센서 는 시간에 대한 속도 변화의 비율을 말하는 데요, 중력가속도를 이용하여 가속도를 측정하게 됩니다.

중력 가속도가 3개의 축 각각에 얼마만큼의 영향을 주었는지를 측정하여 센서의 기울어진 정도를 파악할 수 있게 됩니다. 다만, 가속도 센서의 경우 움직이는 동적인 물체에서는 가속도와 중력이 섞여서 검출되기 때문에 정확한 데이터를 얻기가 힘듭니다, 따라서 정적인 상태에서만 정확한 기울기를 측정할 수 있는 한계가 있습니다.

– 자이로 센서 는 물체의 회전 속도인 ‘각속도’를 이용하는 센서이기 때문에 각속도 센서라고도 합니다. 역시 3축의 물리량을 측정하여 센서의 움직임을 감지하고 기울기를 측정할 수 있는데요, 동적인 상황에서 가속도 센서에 비해 비교적 안정적인 값이 출력되지만 각도를 계산하는 과정에서 적분 방식을 사용하기 때문에 시간이 지날수록 누적되는 오차가 발생합니다.

※ 따라서, 가속도 센서와 자이로 센서의 장점을 적절하게 적용하여 코드를 구성한다면 보다 정밀한 결과를 얻을 수 있습니다. 그러므로 센서를 적용하려는 형태와 방법에 따라 코드가 심플해지기도 하며, 외부 라이브러리 사용과 함께 아주 복잡해지기도 합니다.

바로 위 ‘6050칩 이미지’를 보면, 직선방향의 화살표가 향하는 방향이 x, y, z 축의 가속도 센서가 적용되는 방향입니다.

( 센서를 통해 얻을 수 있는 RAW 데이터 파일 값 중에서 화살표 방향이 +값으로 표시된다면, 화살표 반대방향으로 움직일 시, -(마이너스) 값으로 표시됩니다. 좀 더 정확히 얘기하자면, 중력의 방향을 기준으로 잡고, 중력의 방향은 – , 중력의 반대 방향이 +입니다. )

그리고 회전하는 모양의 화살표가 x, y, z 축의 자이로 센서가 적용되는 방향입니다.

(마찬가지로, 화살표 방향으로의 회전 일 때 +값이 얻어진다면, 반대 방향으로의 회전 시, -(마이너스) 값이 얻어집니다. 회전 방향에 대한 + 방향은 위 이미지를 참고하세요)

그리고, 이 회전 방향은 특히 드론과 같은 비행체나 배와 같은 곳에 필수적으로 적용이 되는데요, 이 센서가 있어야, 기울기/자세를 유지하거나 보정할 수 있기 때문입니다.

X축 회전 각도를 Roll (롤) , Y축 회전 각도를 Pitch(피치) , Z 축 회전 각도는 Yaw(야우)라고 불립니다.

★ 기억하기 쉽도록 : 사람 머리를 기준으로

– Roll 은 → 고개를 좌우로 갸우뚱갸우뚱

– Pitch는 → 고개를 앞뒤로 끄덕끄덕

– Yaw는 → 고개를 도리 도리

그럼, MPU6050 칩의 상세 스펙과 MPU6050을 내장한 GY-521 모듈에 대해 본격적으로 살펴볼게요.

【 기울기 센서 MPU6050 스팩 】

전원 사용은 일반적으로 5V를 입력하지만, 3V~5V 사이의 전원은 모두 동작하므로, 3.3V 전원을 사용하는 다른 모듈들과 함께 3.3V 전원 연결도 자주 이용됩니다.

보시는 바와 같이 MPU6050은 I2C 인터페이스를 이용한 통신으로 측정값을 얻어낼 수 있습니다. 일반적으로 모듈로부터 데이터를 얻기 위해 SCL과 SDA 핀을 이용(모듈이 슬레이브로 동작) 합니다. 좀더 구체적으로 설명하자면, I2C는 필립스에서 개발한 직렬 컴퓨터 버스이며, 임베디드시스템 혹은 저속의 주변기기와의 통신을 위해 사용된 직렬 통신 방식입니다. 기본적으로 하나의 마스터와 하나 혹은 여러 대의 슬레이브 연결 구조이며 SDA핀으로 데이터를 주고받고,핀의 클럭신호(동기화)에 맞추어 통신하게 됩니다. 아두이노에서는 라이브러리를 활용하면 손쉽게 I2C 통신을 할 수 있습니다.

XDA와 XCL은 추가적인 외부의 지자기 센서나 또 다른 센서 연결을 확장하는 시리얼 통신 단자입니다. External , XDA, XCL 연결 단자 입니다.

그리고, 하나의 회로에서 만약 동일한 GY521 모듈을 두 개 구성하여 사용할 경우, I2C 통신 주소를 다르게 하기 위해 AD0 핀에 풀업 저항을 달면 주소를 달리 할 수 있습니다. 모듈의 기본 Slave address 주소는 1101000 이며(0x68), +Vcc쪽으로 풀업 저항(1㏀~10㏀) 연결 시 1101001로(0x69) 변경됩니다.

【 기울기 센서 실습 #1 】

: 기울기 센서 기본 실습으로 센서로부터 기본적인 RAW 데이터 값을 얻어내 보도록 하겠습니다.

활용도와 정확도를 높이기 위해서는 라이브러리를 사용해야 하지만, 복잡하고 코드 내용 파악이 어려울 수 있기 때문에, 기초 실습 #1에서는 라이브러리 없이 진행됩니다.

– MPU6050센서는 16bit ADC가 내장되어 있습니다. 센서의 각축으로부터 가속도와 자이로에 대한 아날로그 데이터를 16bit 분해능을 가진 ADC(Analog Digital Converter)를 거치면서 디지털 수치값으로 얻을 수 있다는 말인데요, 16bit는 2^16 이니 65536의 값인데, -(마이너스)부분까지 반으로 나누어 표시하면 기본적으로는 ” -32768 ~ +32767 ” 사이값의 출력 범위를 가진다는 말이 됩니다.

실습 #1에서는 우선 원시 RAW 데이터를 각센서 축별로 출력해보고,

실습 #2는 가속도 센서를 통해 얻은 RAW 데이터로부터 X축과 Y축의 각도를 계산해 내는 실습으로 진행하고,

실습 #3에서는 자이로 센서를 통해 얻은 RAW 데이터로부터 X축과 Y축의 각도를 얻는 과정으로 진행합니다.

실습 #4 상보필터 적용 실습

각 실습별 방법에 대한 장단점 및 기본적인 설명이 안내해 드리며, 상호 보완필터(상보필터)를 적용한 실습 #4로 이어지니 차근차근 하나씩 실습해 보시기 바랍니다. 가급적 실습 #4까지는 외부라이브러리를 배제한 코드를 사용하여 코드 단순화를 통해 동작원리를 이해하는데 도움이 되도록 하였습니다.

아래 회로 연결도를 구성해 주고 PC와 연결합니다.

▶ 회로 연결도 (아두이노 나노와 GY521(MPU6050) 연결도)

아두이노 나노와 GY521(MPU6050) 연결도

▶ 아두이노 코드

(가속도 x, y, z 축 값과 자이로 x, y, z 축 값의 raw data를 시리얼 모니터로 출력해 보기)

/* 기울기 센서 GY-521(MPU6050) 기초 실습 #1 (RAW 데이터 얻기) */ /* 아래 코드관련 실습에 대한 설명과 회로도 및 자료는 https://rasino.tistory.com/ 에 있습니다 */ #include const int MPU_ADDR = 0x68; // I2C통신을 위한 MPU6050의 주소 int16_t AcX, AcY, AcZ, Tmp, GyX, GyY, GyZ; // 가속도(Acceleration) 와 void getRawData(); // 센서값 얻는 서브함수의 프로토타입 선언 void setup() { initSensor(); Serial.begin(9600); delay(200); } void loop() { getRawData(); // 센서값 얻어오는 함수 호출 Serial.print(“AcX:”); Serial.print(AcX); Serial.print(” AcY:”); Serial.print(AcY); Serial.print(” AcZ:”); Serial.print(AcZ); Serial.print(” GyX:”); Serial.print(GyX); Serial.print(” GyY:”); Serial.print(GyY); Serial.print(” GyZ:”); Serial.print(GyZ); Serial.println(); delay(300); } void initSensor() { Wire.begin(); Wire.beginTransmission(MPU_ADDR); // I2C 통신용 어드레스(주소) Wire.write(0x6B); // MPU6050과 통신을 시작하기 위해서는 0x6B번지에 Wire.write(0); // MPU6050을 동작 대기 모드로 변경 Wire.endTransmission(true); } void getRawData() { Wire.beginTransmission(MPU_ADDR); Wire.write(0x3B); // AcX 레지스터 위치(주소)를 지칭합니다 Wire.endTransmission(false); Wire.requestFrom(MPU_ADDR, 14, true); // AcX 주소 이후의 14byte의 데이터를 요청 AcX = Wire.read() << 8 | Wire.read(); //두 개의 나뉘어진 바이트를 하나로 이어 붙여서 각 변수에 저장 AcY = Wire.read() << 8 | Wire.read(); AcZ = Wire.read() << 8 | Wire.read(); Tmp = Wire.read() << 8 | Wire.read(); GyX = Wire.read() << 8 | Wire.read(); GyY = Wire.read() << 8 | Wire.read(); GyZ = Wire.read() << 8 | Wire.read(); } 《 위 코드 다운로드 》 Angle_RawData.zip 0.00MB ▶ 실행 결과 : 코드를 실행해 보면, 가속도 값 3개와 자이로 값3개 총 6개의 값이 일렬로 나타납니다. 센서를 움직여보면 데이터 값이 변하는 것을 볼 수 있습니다. 방향에 따라 + , - 값으로 나타나는데요, 현재 보이는 값은 어떤 각도 값이나 보정된 값이 아닌 말 그대로 순수한 Raw data이기 때문에 방향과 위치에 따른 데이터 변화를 유추하기는 어렵습니다. 때문에, 기본적인 Raw 데이터를 추출하는 원리 정도만 파악하시면 되고, 다음 실험에서 삼각함수를 이용한 각도 값을 계산해 보거나 , 특정 라이브러리를 이용해서 고정시킨 위치 데이터를 확인해 볼 수 있게 됩니다. 또는 프로세싱(Processing)과 같은 그래픽 구현 툴을 이용해서 3D 이미지로 센서의 움직임을 그래픽 화면으로 볼 수 있는 실험도 진행할 예정입니다. 기울기센서(MPU6050)로부터 Raw 데이터 얻기 ▶ 동작 영상 (본 글 제일 아래 전체 동영상을 참고해보세요 : 설명 음성 추가) 【 기울기 센서 실습 #2 】 : 실습 #1에서 Raw 데이터를 얻었다면, 이번엔 이 데이터를 가지고 우리가 흔히 알아보기 쉬운 각도(라디안: radian) 값으로 바꾸어 출력해 보는 실습입니다. 먼저 각도를 얻을 수 있는 방법은, 앞서 설명한 것처럼 크게 세 가지입니다. 1. 가속도 센서를 이용한 방법 2. 자이로 센서를 이용한 방법 3. 이 둘을 합쳐놓은 '상호보완 필터' 코드를 통해 구하는 방법 이번 실습은 움직임이 없는 상태에서 보다 정확한 값을 구할 수 있는 1번 가속도 센서를 이용한 간단한 방법으로 진행합니다. 때문에 라이브러리 설치 없이 간단히 진행할 수 있고 코드도 비교적 단순하여 파악과 응용이 쉽습니다. 각도(라디안)를 라이브러리 설치 없이 진행되어 구하기 위해서는 중력과 X축, Y축, Z 축과의 기울기를 이용한 삼각함수를 적용해야 하는데요, 해당 수식은 아래와 같습니다. Roll/Pitch/Yaw 각도를 구하기 위한 삼각함수 수식 물론 코드에서는 이 수식이 적용되어 있습니다. 회로 연결은 실습 1과 같고 아래에 있는 아두이노 코드를 업로드해 주세요. ▶ 아두이노 코드 ( 코드에서는 가속도 AcX에 대한 'Roll 각도'와 가속도 AcY에 대한 'Pitch 각도'만 구합니다. 앞서 설명드린 것처럼 가속도 센서만 가지고는 Yaw에 해당하는 정확한 AcZ 각도가 구할 수 없습니다. Z축 Yaw가 중력 방향과 평행한 회전을 하기 때문에 삼각함수를 적용해도 올바른 데이터가 출력되지 않습니다.) // Roll과 Pitch 각도 구하기 실습 》 // 가속도 센서만 가지고 롤(Roll)과 피치(Pitch)를 구하는 예제입니다. // 본 코드는 드론과 같은 움직임이 심한 경우가 아닌 비교적 정적인 상태에서 안정된 값을 얻을 수 있으며, // 복잡한 외부라이브러리를 사용하지 않아 코드가 심플해서 파악후 적용하기가 쉽습니다. // 아래 코드관련 실습에 대한 설명과 회로도 및 자료는 https://rasino.tistory.com/ 에 있습니다 #include const int MPU_ADDR = 0x68; // I2C통신을 위한 MPU6050의 주소 int16_t AcX, AcY, AcZ, Tmp, GyX, GyY, GyZ; // 가속도(Acceleration)와 자이로(Gyro) double angleAcX; double angleAcY; // double angleAcZ; const double RADIAN_TO_DEGREE = 180 / 3.14159; void setup() { initSensor(); Serial.begin(9600); delay(200); } void loop() { getAngleXY(); Serial.print(“Angle x : “); Serial.print(angleAcX); Serial.print(“\t\t Angle y : “); Serial.println(angleAcY); delay(20); } double getAngleXY() { getData(); // 삼각함수를 이용한 롤(Roll)의 각도 구하기 angleAcX = atan(AcY / sqrt(pow(AcX, 2) + pow(AcZ, 2))); angleAcX *= RADIAN_TO_DEGREE; // 삼각함수를 이용한 피치(Pitch)의 각도 구하기 angleAcY = atan(-AcX / sqrt(pow(AcY, 2) + pow(AcZ, 2))); angleAcY *= RADIAN_TO_DEGREE; // angleAcZ값(Yaw)은 아래의 삼각함수 공식은 있으나, 가속도 센서만 이용해서는 원하는 데이터를 얻을 수 없어 생략 // angleAcZ = atan(sqrt(pow(AcX, 2) + pow(AcY, 2)) / AcZ ); // angleAcZ *= RADIAN_TO_DEGREE; } void initSensor() { Wire.begin(); Wire.beginTransmission(MPU_ADDR); // I2C 통신용 어드레스(주소) Wire.write(0x6B); // MPU6050과 통신을 시작하기 위해서는 0x6B번지에 Wire.write(0); Wire.endTransmission(true); } void getData() { Wire.beginTransmission(MPU_ADDR); Wire.write(0x3B); // AcX 레지스터 위치(주소)를 지칭합니다 Wire.endTransmission(false); Wire.requestFrom(MPU_ADDR, 14, true); // AcX 주소 이후의 14byte의 데이터를 요청 AcX = Wire.read() << 8 | Wire.read(); //두 개의 나뉘어진 바이트를 하나로 이어 붙여서 각 변수에 저장 AcY = Wire.read() << 8 | Wire.read(); AcZ = Wire.read() << 8 | Wire.read(); Tmp = Wire.read() << 8 | Wire.read(); GyX = Wire.read() << 8 | Wire.read(); GyY = Wire.read() << 8 | Wire.read(); GyZ = Wire.read() << 8 | Wire.read(); } 《 위 코드 다운로드 》 Angle_Roll_Pitch.zip 0.00MB ▶ 실행 결과 : main loop( )에 있는 delay(20)을 느리게 혹은 빠르게 조절하여 확인해 볼 수 있습니다. 센서 보드를 중력의 방향과 수직으로 놓으면 X와 Y는 0도를 가리킵니다. 그 상태에서 Roll(X)을 앞 뒤로 돌려보고, Pitch(Y)를 앞뒤로 돌려 보세요. - Roll은 센서 보드 위 화살표 표시를 참고 기준으로 하여, 중력과 반대로 머리를 들면 +각도로 나오며, 중력의 방향으로 머리를 숙이면 -각도를 표시합니다. - Pitch 또한 피치 화살표를 기준으로, 화살표 방향으로 숙이면 +각도로 표시되며, 반대방향으로 회전시키면 -각도로 표시됩니다. - 아래 이미지는 시리얼 플로터를 실행시킨 화면인데요, 각도 값을 그래프 형태로 보면 좀 더 직관적으로 파악하기 좋습니다. ( 시리얼 플로터 창 열기 : 아두이노 IDE 툴 메뉴 클릭 》 시리얼 플로터 클릭! ) 파란선이 Roll (AcX)에 대한 각도 그래프이며, 빨간선이 Pitch(AcY)에 대한 각도 그래프입니다. 기울기 센서 모듈은 접촉이 불안정할 경우, 데이터가 원하는 대로 나오지 않거나, 오작동 할 수 있습니다. 접촉이 헐렁한 브레드보드를 바꾸어 보거나 연결선을 확인해 보세요. 필요한 경우 납땜으로 연결해 주면 더욱 안정된 접촉이 이루어집니다. 그 외에 동작은 정상 동작하나, 데이터 값이 튀는 노이즈가 심할 경우에는, 추출 값을 3~10회 정도의 평균값 처리하는 루틴을 넣어 주면 어느 정도 해결할 수 있습니다. ▶ 동작 영상 【 기울기 센서 실습 #3 】 : 실습 #2에서 MPU6050에 있는 가속도 센서를 이용해서 각도(라디안: radian) 값으로 바꾸어 출력해 보는 실습을 했다면, 이번엔 MPU6050에 있는 자이로 센서를 이용해서 각도를 계산해 출력해 보겠습니다. 1. 가속도 센서를 이용한 방법 2. 자이로 센서를 이용한 방법 3. 이 둘을 합쳐놓은 '상호보완 필터' 코드를 통해 구하는 방법 이번 실습은 2. 자이로 센서를 이용한 방법 입니다. 먼저 자이로 센서는 진자의 움직임과 같은 축을 중심으로 회전하는 각속도를 측정합니다. 각속도는 시간당 회전하는 각도를 의미하는데요, 예를 들면, 1. 수평한 자세를 유지하고 있는 상태이라면, 각속도는 0도/sec를 나타낼 텐데요, 2. 이 물체가 10초 동안 50도만큼 기울어졌을 경우 , 이 10초동안은 0이 아닌 각속도 값을 가지게 됩니다. 10초 동안의 평균 각속도는 5도/sec 가 되는데요, 즉, 초당 5도를 움직이는 속력이라 말할 수 있습니다. 3. 기울어지는 동작을 한 후 다시 멈춰서 50도를 유지한다고 할 때, 이때는 다시 각속도가 0도/sec 가 됩니다. 1번 2번 3번 과정을 거치면서 각속도는 0 -> 5 -> 0으로 바뀌었는데요, 그런데 각도는 0도에서 점차 증가해서 50도가 된 상태입니다. 그래서 각속도가 움직인 각도에 비례해서 증가하는 것이 아니기 때문에, 각도를 구하려면 전체 시간에 해당하는 만큼의 각속도를 모두 합(적분을) 해야합니다. 자이로 센서는 이와 같이 각속도를 데이터로 출력하기 때문에 이 각속도 데이터를 모두 합(적분)하면 기울어진 각도를 계산해 낼 수 있는 원리입니다. 그런데 자이로 센서의 경우 문제는 이러한 적분 때문에 발생하게 됩니다. 센서에서 측정되는 각속도는 노이즈나 미세한 기본 오차 값들이 적분으로 인해, 시간이 지날 수록 쌓여 결국 측정값(각도 오차)의 오차가 커지게 되는 문제가 있습니다. Drift 현상이 발생합니다.

(즉, 이 방법만으로는 시간이 지날 수록 각도 혹은 기울기의 오차가 커지게 되는 단점이 있죠. 하지만, 가속도 센서처럼 진동에 영향이 크게 없으며 중력과 일치하는 Z축의 Yaw 각도도 구할 수 있는 장점이 있습니다.

[ 용어 정리 ]

– Drift 현상 : 조건이 일정함에도 시간이 경과함에 따라서 값이 이탈 또는 흘러가는 현상.

– 각속도란 : 각속도 오메가(ω)는 원운동에서 단위 시간 동안에 회전한 각도를 말하며, 즉, 회전하는 물체에 대한 회전의 빠르기를 의미합니다.

– 각도 : 각속도에 시간을 곱한 것이 각도 이며, 이것들을 모두 합치면 움직인 전체 각도가 됩니다

속력/속도/가속도 와의 관계식

회로 연결은 실습 1과 같고 아래에 있는 아두이노 코드를 업로드해 주세요.

▶ 아두이노 코드

( 코드에서는 시리얼 모니터 통신속도를 115200bps 으로 바꾸었으니, 실행시 시리얼 모니터 창의 보드레이트를 115200 bps로 맞추어 주세요)

// 《 자이로 Gyro 센서로 Roll과 Pitch, Yaw의 각도 구하기 실습 》 // 자이로 센서만 가지고 롤(Roll)과 피치(Pitch), 야우(Yaw)를 구하는 예제입니다. /* 아래 코드관련 실습에 대한 설명과 회로도 및 자료는 https://rasino.tistory.com/ 에 있습니다 */ #include const int MPU_ADDR = 0x68; // I2C통신을 위한 MPU6050의 주소 int16_t AcX, AcY, AcZ, Tmp, GyX, GyY, GyZ; // 가속도(Acceleration)와 자이로(Gyro) double angleAcX, angleAcY, angleAcZ; double angleGyX, angleGyY, angleGyZ; const double RADIAN_TO_DEGREE = 180 / 3.14159; const double DEG_PER_SEC = 32767 / 250; // 1초에 회전하는 각도 // GyX, GyY, GyZ 값의 범위 : -32768 ~ +32767 (16비트 정수범위) unsigned long now = 0; // 현재 시간 저장용 변수 unsigned long past = 0; // 이전 시간 저장용 변수 double dt = 0; // 한 사이클 동안 걸린 시간 변수 double averAcX, averAcY, averAcZ; double averGyX, averGyY, averGyZ; void setup() { initSensor(); Serial.begin(115200); caliSensor(); // 초기 센서 캘리브레이션 함수 호출 past = millis(); // past에 현재 시간 저장 } void loop() { getData(); getDT(); angleGyX += ((GyX – averGyX) / DEG_PER_SEC) * dt; angleGyY += ((GyY – averGyY) / DEG_PER_SEC) * dt; angleGyZ += ((GyZ – averGyZ) / DEG_PER_SEC) * dt; Serial.print(“Angle Gyro X:”); Serial.print(angleGyX); Serial.print(“\t\t Angle Gyro y:”); Serial.print(angleGyY); Serial.print(“\t\t Angle Gyro Z:”); Serial.println(angleGyZ); delay(20); } void initSensor() { Wire.begin(); Wire.beginTransmission(MPU_ADDR); // I2C 통신용 어드레스(주소) Wire.write(0x6B); // MPU6050과 통신을 시작하기 위해서는 0x6B번지에 Wire.write(0); Wire.endTransmission(true); } void getData() { Wire.beginTransmission(MPU_ADDR); Wire.write(0x3B); // AcX 레지스터 위치(주소)를 지칭합니다 Wire.endTransmission(false); Wire.requestFrom(MPU_ADDR, 14, true); // AcX 주소 이후의 14byte의 데이터를 요청 AcX = Wire.read() << 8 | Wire.read(); //두 개의 나뉘어진 바이트를 하나로 이어 붙여서 각 변수에 저장 AcY = Wire.read() << 8 | Wire.read(); AcZ = Wire.read() << 8 | Wire.read(); Tmp = Wire.read() << 8 | Wire.read(); GyX = Wire.read() << 8 | Wire.read(); GyY = Wire.read() << 8 | Wire.read(); GyZ = Wire.read() << 8 | Wire.read(); } // loop 한 사이클동안 걸리는 시간을 알기위한 함수 void getDT() { now = millis(); dt = (now - past) / 1000.0; past = now; } // 센서의 초기값을 10회 정도 평균값으로 구하여 저장하는 함수 void caliSensor() { double sumAcX = 0 , sumAcY = 0, sumAcZ = 0; double sumGyX = 0 , sumGyY = 0, sumGyZ = 0; getData(); for (int i=0;i<10;i++) { getData(); sumAcX+=AcX; sumAcY+=AcY; sumAcZ+=AcZ; sumGyX+=GyX; sumGyY+=GyY; sumGyZ+=GyZ; delay(50); } averAcX=sumAcX/10; averAcY=sumAcY/10; averAcZ=sumAcY/10; averGyX=sumGyX/10; averGyY=sumGyY/10; averGyZ=sumGyZ/10; } 《 위 코드 다운로드 》 Angle_Gyro.zip 0.00MB ▶ 실행 결과 : 센서 보드를 X축 Y축 Z축 각각 움직여 보세요. ▶ 실행 영상 (제일 아래 전체 설명 동영상 참고) 【 기울기 센서 실습 #4 】 : 실습 #2와 실습#3에서는 각각 가속도 센서와 자이로 센서를 이용한 각도를 구했는데요, 가속도센서는 진동에 약하기 때문에(튀는 데이터값의 영향이 큼) 짧은 시간의 변화에는 약하지만, 긴 시간에 대해서는 정확한 각도를 산출해 낼 수 있고, 자이로센서는 진동에 강하기 때문에 짧은 시간에 대해서는 정확한 각도를 얻을 수 있지만 시간이 지나면서 오차가 누적되어 긴 시간에서는 취약합니다. 그래서 각각의 장점도 있지만, 단점이 명확하여 어느 하나의 센서 만으로는 드론과 같은 자세제어나 보정은 어렵습니다. 따라서 센서 둘을 모두 이용하고, 이 둘의 장점을 이용하여 서로의 단점을 보완한 상호보완 필터 코드를 적용하여 사용한다면, 비교적 오류가 없는 각도를 구할 수 있어서 드론 등의 자세제어 코드에 사용할 수 있습니다. 1. 가속도 센서를 이용한 방법 2. 자이로 센서를 이용한 방법 3. 이 둘을 합쳐놓은 '상호보완 필터' 코드를 통해 구하는 방법 이번 실습은 3. 상호보완 필터를 이용한 방법 입니다. 아래 이미지는 상호보완 필터의 개념도 입니다. 상보필터(상호보완) 개념도 [ 상보필터의 원리 - Complementary Filter ] - 가속도 센서(Accelerometer)는 센서 특성상 고주파 영역에서 노이즈가 많이 발생하게 되어 정확한 값을 얻기 어려운데요, 그래서 노이즈 영역을 제거하고자 고역은 감쇠시키고, 낮은 주파수 영역을 통과시키는 저역필터(Low Pass Filter)를 적용해주면 정확도가 올라갑니다. - 자이로 센서(Gyroscope)는 센서 특성상 저주파 영역에서 값이 변하는 Drift현상이 발생하여 정확한 값을 기대하기가 어렵습니다. 그래서 저역을 감쇠시키고 노이즈가 적은 고역을 통과시키기 위한 고역필터(High Pass Filter)를 적용해주면 역시 정확도가 올라갑니다. ※ 이렇게 각각의 필터를 통과해서 노이즈가 걸러진 값들을 합하여 보다더 정확한 각도값을 얻게 됩니다. 이외에 칼만필터(Kalman Filter), Quanternion 라는 것도 있습니다. 상보필터에서는 가속도 센서의 저주파 영역에서의 장점과 , 자이로센서의 고주파 영역에서의 장점만을 융합한 필터로서 , 방법과 코드가 간단하여 적용하기 쉬운 장점이 있습니다. 상보필터에서는 ALPHA라는 가중치 값을 통해 자이로센서와 가속도센서 각각으로부터 얻은 각도를 어떤 비중으로 적용시킬지 정하여 계산하게 되는데요. 아래가 바로 보정값(가중치) ALPHA를 적용한 보정된 각도 값의 식(angleFiX) 입니다. angleFiX = ALPHA * angleTmpX + (1.0 - ALPHA) * angleAcX; 여기서 angleTmp 는 자이로센서 값을 기준으로 만든 상보필터 처리를 위한 임시각도이며 X축에 대해 정리하면 angleTmpX = angleFiX + angleGyX * dt 가 됩니다. 가중치 ALPHA 값은 α = T/(T+Δt) 식으로 구하는데요, α (ALPHA) = 1 / (1+0.04) 가되어, α 값은 0.96 이 됩니다. 즉, 1(T) 사이클 도는 동안의 loop Time(Δt=0.04) 을 적용한 식입니다. 그런데 이 값은 고정값은 아니며, loop Time이 길어지거나 등의 이유로 알파값을 시스템에 맞게 변경할 수 있습니다. 즉, angleFiX 식을 보면 아시겠지만, 자이로 값에 * 0.96 가중치를 곱하고(주고), 가속도 값에 * 0.04의 가중치를 줘서 합한 값이어서 자이로센서(자이로스코프)에 더 의존하는 형태라고 말 할 수 있습니다. 그런데, 이런 형태가 비교적 정밀한(안정적인) 출력값을 내는 이유는, 식을 다시 살펴보면 angleFiX = ALPHA * angleTmpX + (1.0 - ALPHA) * angleAcX; 각도 변화가 상당히 느린 구간(저주파 영역)에서는 자이로센서의 데이터 값이 작아지기 때문에(angleGyX * dt의 누적값 감소), (1.0-ALPHA) = 0.04 가중치 적용으로 작았던 가속도 데이터 값이 상대적으로 커지게 되어 , 자이로스코프의 저주파 영역에서 발생하는 Drift(드리프트)에 대한 단점을 보완 할 수 있게 됩니다. ▶ 아두이노 코드 ( 위에서 설명한 식을 코드에 적용한 아두이노 코드입니다. 실습 #1과 실습#2에 소개한 코드를 합쳐서, 상보필터 식을 적용한 코드입니다. 축 3가지를 동시에 시리얼모니터로 확인하기 불편하기 때문에, 일부 축에 주석처리 되어 있으니, 필요한 경우 주석을 해제하여 사용하세요. ) - 시리얼모티너(플로터) 출력은 아래처럼 각 축별로 비교하기 쉽도록 배치하였습니다. 《가속도센서 X축》 출력과 《필터링된 X축》 출력 《가속도센서 Y축》 출력과 《필터링된 Y축》 출력 《자이로센서 Z축》 출력과 《필터링된 Z축》 출력 // 《 상보필터를 적용한 Roll과 Pitch, Yaw의 각도 구하기 실습 》 /* 아래 코드관련 실습에 대한 설명과 회로도 및 자료는 https://rasino.tistory.com/ 에 있습니다 */ #include const int MPU_ADDR = 0x68; // I2C통신을 위한 MPU6050의 주소 int16_t AcX, AcY, AcZ, Tmp, GyX, GyY, GyZ; // 가속도(Acceleration)와 자이로(Gyro) double angleAcX, angleAcY, angleAcZ; double angleGyX, angleGyY, angleGyZ; double angleFiX, angleFiY, angleFiZ; const double RADIAN_TO_DEGREE = 180 / 3.14159; const double DEG_PER_SEC = 32767 / 250; // 1초에 회전하는 각도 const double ALPHA = 1 / (1 + 0.04); // GyX, GyY, GyZ 값의 범위 : -32768 ~ +32767 (16비트 정수범위) unsigned long now = 0; // 현재 시간 저장용 변수 unsigned long past = 0; // 이전 시간 저장용 변수 double dt = 0; // 한 사이클 동안 걸린 시간 변수 double averAcX, averAcY, averAcZ; double averGyX, averGyY, averGyZ; void setup() { initSensor(); Serial.begin(115200); caliSensor(); // 초기 센서 캘리브레이션 함수 호출 past = millis(); // past에 현재 시간 저장 } void loop() { getData(); getDT(); angleAcX = atan(AcY / sqrt(pow(AcX, 2) + pow(AcZ, 2))); angleAcX *= RADIAN_TO_DEGREE; angleAcY = atan(-AcX / sqrt(pow(AcY, 2) + pow(AcZ, 2))); angleAcY *= RADIAN_TO_DEGREE; // 가속도 센서로는 Z축 회전각 계산 불가함. // 가속도 현재 값에서 초기평균값을 빼서 센서값에 대한 보정 angleGyX += ((GyX – averGyX) / DEG_PER_SEC) * dt; //각속도로 변환 angleGyY += ((GyY – averGyY) / DEG_PER_SEC) * dt; angleGyZ += ((GyZ – averGyZ) / DEG_PER_SEC) * dt; // 상보필터 처리를 위한 임시각도 저장 double angleTmpX = angleFiX + angleGyX * dt; double angleTmpY = angleFiY + angleGyY * dt; double angleTmpZ = angleFiZ + angleGyZ * dt; // (상보필터 값 처리) 임시 각도에 0.96가속도 센서로 얻어진 각도 0.04의 비중을 두어 현재 각도를 구함. angleFiX = ALPHA * angleTmpX + (1.0 – ALPHA) * angleAcX; angleFiY = ALPHA * angleTmpY + (1.0 – ALPHA) * angleAcY; angleFiZ = angleGyZ; // Z축은 자이로 센서만을 이용하열 구함. Serial.print(“AngleAcX:”); Serial.print(angleAcX); Serial.print(“\t FilteredX:”); Serial.print(angleFiX); Serial.print(“\t AngleAcY:”); Serial.print(angleAcY); Serial.print(“\t FilteredY:”); Serial.println(angleFiY); Serial.print(“\t AngleAcZ:”); Serial.print(angleGyZ); Serial.print(“\t FilteredZ:”); Serial.println(angleFiZ); // Serial.print(“Angle Gyro X:”); // Serial.print(angleGyX); // Serial.print(“\t\t Angle Gyro y:”); // Serial.print(angleGyY); // Serial.print(“\t\t Angle Gyro Z:”); // Serial.println(angleGyZ); // delay(20); } void initSensor() { Wire.begin(); Wire.beginTransmission(MPU_ADDR); // I2C 통신용 어드레스(주소) Wire.write(0x6B); // MPU6050과 통신을 시작하기 위해서는 0x6B번지에 Wire.write(0); Wire.endTransmission(true); } void getData() { Wire.beginTransmission(MPU_ADDR); Wire.write(0x3B); // AcX 레지스터 위치(주소)를 지칭합니다 Wire.endTransmission(false); Wire.requestFrom(MPU_ADDR, 14, true); // AcX 주소 이후의 14byte의 데이터를 요청 AcX = Wire.read() << 8 | Wire.read(); //두 개의 나뉘어진 바이트를 하나로 이어 붙여서 각 변수에 저장 AcY = Wire.read() << 8 | Wire.read(); AcZ = Wire.read() << 8 | Wire.read(); Tmp = Wire.read() << 8 | Wire.read(); GyX = Wire.read() << 8 | Wire.read(); GyY = Wire.read() << 8 | Wire.read(); GyZ = Wire.read() << 8 | Wire.read(); } // loop 한 사이클동안 걸리는 시간을 알기위한 함수 void getDT() { now = millis(); dt = (now - past) / 1000.0; past = now; } // 센서의 초기값을 10회 정도 평균값으로 구하여 저장하는 함수 void caliSensor() { double sumAcX = 0 , sumAcY = 0, sumAcZ = 0; double sumGyX = 0 , sumGyY = 0, sumGyZ = 0; getData(); for (int i=0;i<10;i++) { getData(); sumAcX+=AcX; sumAcY+=AcY; sumAcZ+=AcZ; sumGyX+=GyX; sumGyY+=GyY; sumGyZ+=GyZ; delay(50); } averAcX=sumAcX/10; averAcY=sumAcY/10; averAcZ=sumAcY/10; averGyX=sumGyX/10; averGyY=sumGyY/10; averGyZ=sumGyZ/10; } 《 위 코드 다운로드 》 Angle_Acc_Gyro_CompFilter.zip 0.00MB ※ 아래 실행결과 화면을 보시면 알겠지만, 상보필터를 적용 후의 그래프는 노이즈나 한 번씩 크게 튀는 값 들이 상당히 제거되어 나타나는 것을 알 수 있습니다. 단, 노이즈 향상을 위해 ALPHA값 등, 보정값을 과도하게 조정하게 되면, 보정된 데이터의 출력 딜레이(시간차)가 발생하게 됩니다. 이는 드론(Drone)과 같은 제어에 있어서는 적시에 올바른 제어를 할 수 없게 만들 수도 있습니다. ▶ 실행 결과 1. 《가속도센서 X축》 출력과《필터링된 X축》 출력 비교 화면 먼저, 시리얼모니터 화면을 살펴 보세요.(아래 이미지) , 보드를 77도 정도에서 고정한 상태에서 가속도센서에서 얻은 데이터는 각도 값이 68~70도 사이를 짧은 순간에 제법 심하게 요동치고 있는 반면에, 필터링한 각도 값은, 77도에서 소수점 단위 정도만 변동이 있을 뿐 매우 안정된 출력을 보여주고 있는 것을 알 수 있습니다. 그럼, 이제 시리얼 모니터만으로는 잘 체감이 안 되실텐데요, 같은 출력을 아두이노 IDE 메뉴에 있는 '시리얼 플로터'를 통해 그래프로 보면 좀더 확연히 그 차이를 구분하실 수 있게 됩니다. (아래) 파란색 그래프가 가속도센서로 부터 얻은 X축 회전(각도)상태의 데이터인데요, 떨림과 같은 병동이 심한 반면에, 필터링 코드를 거친 빨간색 X축의 데이터는 이런 노이즈들이 깔끔하게 제거 된 것을 알 수 있습니다. 2. 《가속도센서 Y축》 출력과《필터링된 Y축》 출력 비교 화면 그럼, Y축 그래프도 살펴 볼게요. 역시 마찬가지로, 필터링 되지 않은 Y축 출력과 필터링된 Y축 출력에 차이가 있음을 볼수 있습니다. 3. 《자이로센서 Z축》 출력과《필터링된 Z축》 출력 비교 화면 그리고, Z축 같은 경우는 앞서 설명드린대로, 가속도 센서로부터는 데이터를 얻을 수 없는 상태이고, 따라서 자이로 센서로 부터 얻은 Z축 데이터와, 자이로센서 데이터 가중치가 높은 필터링된 Z축 데이터를 출력해 본 것이어서 두 그래프간의 차이가 거의 없는 그래프 모습을 보여주고 있습니다. 3. 끝으로 전체 축을 동시에 비교해봤습니다. 《자이로센서 X-Y-Z-축》 출력과

아두이노 MPU6050 자이로 가속도센서 실습

MPU6050 자이로 가속도센서는 단일 칩에 MEMS(마이크로 전자 기계 시스템) 가속계와 MEMS 자이로를 포함하고 있습니다. 이 센서는 3축 자이로스코프와 3축 가속도계를 모두 포함하고 있으며 독립적으로 측정이 가능합니다. I2C 포트를 통해 아두이노 보드와 통신합니다.

MPU6050 센서는 드론, RC비행기, 짐벌 등과 같이 주로 3차원 위치제어를 통해 균형을 잡을 필요가 있는 곳에 사용됩니다. 이를 제어하기 위한 3가지 요소가 요(Yaw), 롤(Roll), 피치(Pitch)입니다.

아래 그림은 비행기의 무게중심에서 직각으로 교차하는 세 개의 선을 그리고 여기에 요(Yaw), 롤(Roll), 피치(Pitch)의 개념을 표시하였습니다.

– 롤(Roll)은 앞뒤 축을 중심으로 회전하는 것을 말합니다.

– 피치(Pitch)는 측면 축 주변으로 회전하는 것을 말합니다. 주로 고도 변경을 위해 사용됩니다.

– 요(Yaw)는 수직축을 중심으로 회전하는 것을 말합니다.

아래는 아두이노 보드와 MPU6050을 사용하여 LCD에 요(Yaw), 롤(Roll), 피치(Pitch) 값을 표시하는 회로입니다.

라이브러리는 아래 링크에서 다운로드하고 아두이노 프로그램 메뉴에서 스케치->라이브러리 포함하기->.ZIP 라이브러리 추가를 누르고, 파일선택창이 나오면 다운받은 라이브러리 파일을 선택하시면 됩니다.

라이브러리

소스코드

아래는 소스코드입니다. 아두이노 IDE에 붙여넣기 하여 컴파일하고 업로드합니다.

#include #include “I2Cdev.h” #include “MPU6050_6Axis_MotionApps20.h” #if I2CDEV_IMPLEMENTATION == I2CDEV_ARDUINO_WIRE #include “Wire.h” #endif LiquidCrystal lcd(7,8,9,10,11,12);//RS,E,DB4,DB5,DB6,DB7 MPU6050 mpu; #define INTERRUPT_PIN 2 // 인터럽트 핀 #define LED_PIN 13 // 아두이노 내장 LED bool blinkState = false; // MPU6050 제어 및 상태표시 변수 bool dmpReady = false; // set true if DMP init was successful uint8_t mpuIntStatus; // holds actual interrupt status byte from MPU uint8_t devStatus; // return status after each device operation (0 = success, !0 = error) uint16_t packetSize; // expected DMP packet size (default is 42 bytes) uint16_t fifoCount; // count of all bytes currently in FIFO uint8_t fifoBuffer[64]; // FIFO storage buffer // 요롤피치 계산용 Quaternion q; // [w, x, y, z] 4원법 변수 VectorFloat gravity; // [x, y, z] 중력 벡터 float ypr[3]; // [yaw, pitch, roll] 요롤피치 변수 int intCount; volatile bool mpuInterrupt = false; // MPU6050 인터럽트 발생유무 확인용 // 인터럽트 루틴 void dmpDataReady() { mpuInterrupt = true; } void setup() { #if I2CDEV_IMPLEMENTATION == I2CDEV_ARDUINO_WIRE Wire.begin(); Wire.setClock(400000); // 400kHz I2C clock. Comment this line if having compilation difficulties #elif I2CDEV_IMPLEMENTATION == I2CDEV_BUILTIN_FASTWIRE Fastwire::setup(400, true); #endif lcd.begin(16,2); intCount = 0; Serial.begin(9600); while (!Serial); //초기화 Serial.println(F(“Initializing I2C devices…”)); mpu.initialize(); pinMode(INTERRUPT_PIN, INPUT); //MPU6050과 연결상태 확인 Serial.println(F(“Testing device connections…”)); Serial.println(mpu.testConnection() ? F(“MPU6050 connection successful”) : F(“MPU6050 connection failed”)); //요롤피치 산출을 위한 DMP(Digital Motion Processor) 초기화 Serial.println(F(“Initializing DMP…”)); devStatus = mpu.dmpInitialize(); //옵셋 설정 mpu.setXGyroOffset(220); mpu.setYGyroOffset(76); mpu.setZGyroOffset(-85); mpu.setZAccelOffset(1688); //정상동작여부 확인 0이면 정상 if (devStatus == 0) { //DMP 활성화 Serial.println(F(“Enabling DMP…”)); mpu.setDMPEnabled(true); //아두이노 인터럽트 활성화 Serial.print(F(“Enabling interrupt detection (Arduino external interrupt “)); Serial.print(digitalPinToInterrupt(INTERRUPT_PIN)); Serial.println(F(“)…”)); attachInterrupt(digitalPinToInterrupt(INTERRUPT_PIN), dmpDataReady, RISING); mpuIntStatus = mpu.getIntStatus(); //DMP 대기상태 Serial.println(F(“DMP ready! Waiting for first interrupt…”)); dmpReady = true; // DMP패킷 크기 비교 packetSize = mpu.dmpGetFIFOPacketSize(); } else { // ERROR! // 1 = initial memory load failed // 2 = DMP configuration updates failed // (if it’s going to break, usually the code will be 1) Serial.print(F(“DMP Initialization failed (code “)); Serial.print(devStatus); Serial.println(F(“)”)); } //LED 포트 출력으로 설정 pinMode(LED_PIN, OUTPUT); } void loop() { // 오류시 종료 if (!dmpReady) return; //MPU6050 데이터 대기 while (!mpuInterrupt && fifoCount < packetSize) { if (mpuInterrupt && fifoCount < packetSize) { // try to get out of the infinite loop fifoCount = mpu.getFIFOCount(); } // 사용자 프로그램은 여기에 작성 // . } // 인터럽트 플래그를 리셋 mpuInterrupt = false; mpuIntStatus = mpu.getIntStatus(); // get current FIFO count fifoCount = mpu.getFIFOCount(); // check for overflow (this should never happen unless our code is too inefficient) if ((mpuIntStatus & _BV(MPU6050_INTERRUPT_FIFO_OFLOW_BIT)) || fifoCount >= 1024) { // reset so we can continue cleanly mpu.resetFIFO(); fifoCount = mpu.getFIFOCount(); Serial.println(F(“FIFO overflow!”)); // otherwise, check for DMP data ready interrupt (this should happen frequently) } else if (mpuIntStatus & _BV(MPU6050_INTERRUPT_DMP_INT_BIT)) { // wait for correct available data length, should be a VERY short wait while (fifoCount < packetSize) fifoCount = mpu.getFIFOCount(); // read a packet from FIFO mpu.getFIFOBytes(fifoBuffer, packetSize); // track FIFO count here in case there is > 1 packet available // (this lets us immediately read more without waiting for an interrupt) fifoCount -= packetSize; if(intCount++ > 20) //LCD표시 주기 조절용 { intCount = 0; showYPR(); } } } void showYPR() { mpu.dmpGetQuaternion(&q, fifoBuffer); mpu.dmpGetGravity(&gravity, &q); mpu.dmpGetYawPitchRoll(ypr, &q, &gravity); lcd.clear(); lcd.print(” Y P R”); lcd.setCursor(0,1); lcd.print(ypr[0] * 180/M_PI,0); lcd.setCursor(6,1); lcd.print(ypr[1] * 180/M_PI,0); lcd.setCursor(12,1); lcd.print(ypr[2] * 180/M_PI,0); Serial.print(“ypr\t”); Serial.print(ypr[0] * 180/M_PI); Serial.print(“\t”); Serial.print(ypr[1] * 180/M_PI); Serial.print(“\t”); Serial.println(ypr[2] * 180/M_PI); // 데이터 1번 표시할 때마다 LED 상태를 바꿈 blinkState = !blinkState; digitalWrite(LED_PIN, blinkState); }

[아두이노] MPU-6050 자이로센서 TEST

반응형

* 이 과정은 제가 공부 목적을 위해 작성한 글이므로 옳은 답은 없습니다.

(설명들이 제가 찾아보고 생각한 부분에서만 작성한거기 때문에 틀린 부분일 수도 있어요 ㅎㅎ)

이번에 테스트 해볼 부품은 바로 “MPU-6050” 제품으로 자이로 센서 입니다.

자이로 센서가 어디에 쓰는 부품일까요?

먼저 자이로 센서 테스트를 하기 앞서 자이로스코프의 대해

이해를 하고 넘어가도록 할게요.

(저도 디테일한 내용은 잘 모르지만.. 최대한 이해할 수 있게 설명해보겠습니다.)

첫번째로 이해해야 할 부분은

자이로스코프! 입니다.

Gyro(회전하다), Scope(관찰하다)

위키백과

자이로스코프(Gyroscope)는 위아래가 완전히 대칭인 팽이(Rotor)를 고리를

이용하여 팽이의 축에 직각인 방향(Spin axis)으로 만들고 다시 그것을

제 2의 고리(Gimbal)를 써서 앞의 것과 직각 방향으로 만든 후

다시 제 3의 고리(Gyroscope frame)를 만들어 앞의 둘의 직각 되는 방향으로 지탱하여

팽이의 회전이 어떤 방향으로도 일어날 수 있도록(회전할 수 있도록) 한 장치를 말합니다.

(밑에 유튜브 영상으로 자이로스코프가 진짜 안떨어지더라구요 ㅋㅋ)

이는 각운동량 보존법칙에 의해 일어나는데요.(위키백과)

회전하고 있는 물체는 외부로부터 회전력(힘)이 작용하지 않는 한 물체의 각운동량이 항상 일정하게

보존된다고 합니다. 회전하는 각운동량은 물체의 회전 반경과 운동량의 곱으로 외부로부터 회전력이 작용하지 않을 경우 각운동량은 항상 보존되어 회전 반경의 축소화되고 그 방향은 거의 고정하게 되는것이지요.

즉, 외부에서 받은 힘에 따라 운동 속도가 달라지는 기구입니다.

하지만 이 각운동량은 외부에서 힘이 작용하지 않는다면 일정하게 보존됩니다.

이런 기능으로 현대에서 주로 사용하고 있는 기기는 스마트폰, 드론, 비행기, 게임기 등 엄청 많이 사용되고 있습니다.

자! 이제 자이로스코프의 대해 간단한 이해가 끝났는데요.

그럼 자이로 센서는 또 무엇일까요?

자이로 센서 : 자이로스코프가 내재된 물체가 회전운동을 하면 생기는 회전 반발력을 측정하고 전기신호로 바꾸는 장치.

즉, 자이로스코프의 각운동량의 값을 전기신호로 잡아 데이터를 뿌려주는 센서 입니다.

이 센서 종류는 세가지 정도 있는걸로 알고 있는데요.

1. 광학식 자이로

2. Inertial 자이로

3. MEMS 자이로

그 중에서 제가 테스트할 MPU-6050은 MEMS 자이로 센서입니다.

MEMS 자이로 센서 : 코리올리의 힘을 이용한 튜닝포크(Tuning Fork)방식의 MESE 센서로

코리올리 힘을 측정하여 전기신호로 변환하고 힘에 대한 각속도를 계산하는 센서입니다.

여기서 또 코리올리의 힘이라는게 나오는데요…. 이건 또 무엇일까요?

======

======

위키백과

코리올리의 힘 : 회전하는 좌표계 내에서 물체가 운동을 하는 경우 힘을 주면 좌표계에 의해

위에 사진으로 보면 수직으로 직선운동을 하는것 처럼 보이지만, 실제로는 회전을 하면서

운동을 합니다. 이런 효과를 코리올리 효과라고 하는데요.

이 물체의 코리올리 효과를 유발하는 힘을 코리올리 힘이라고 합니다.

직선운동의 방향을 바꿔버리기 때문에 저향력이라고도 부르네요.

공식 : F(coriolis) = 2m(v x Ω)

위키백과

위에 설명으로 코리올리 힘의 예를 들자면,

적도에서 북풍이 부는 경우에도 바람은 코리올리 힘을 받게 됩니다.

지구는 자전을 하기 때문에 회전좌표계이며, 북풍이 부는 바람은 경우 시계/반시계 회전이 모두 코리올리 힘을

받아 회전하는 것이라고 합니다.

자이로 센서 테스트를 하기 전에 이것저것 알아야 할것들이 정말

많네요.. 진짜 발명품들은 물리와 수학으로 이루어졌다는게 맞는것 같습니다.

(어려워요 ㅜㅜ)

=====

=====

그래서 결론은 저희가 쓰는 MPU-6050은 MEMS 기반의 자이로 센서이고,

코리올리의 법칙으로 계산을 해서 받은 값을 전기신호로 전해집니다.

이제 자이로센서 구조를 봐볼까요?

MPU-6050의 통신은 I2C 방식으로 사용됩니다.

그래서 기본적으로 GND, VCC, SDA, SCL 단자만으로 사용해서

테스트를 해볼 수 있습니다.

센서 사양은 위에 표처럼 나와 있는데요.

초기값을 설정할때 사용됩니다.

<< MPU - 6050 TEST >>

제가 사용할 칩은 STM32 계열 칩으로

테스트를 할건데요.

(Atmega, 8051계열도 상관없습니다)

<초기화>

자이로센서를 실행하기 앞서 초기화 설정부터 시작해줘야 합니다.

<< 초기 설정별 설명>>

1. 첫번째로 저는 WHO_AM_I로 장치의 ID를 체크합니다.

AD0 Pin으로 인해 기본값이 달라 질 수 있는데요.

AD0 Pin : LOW = 기본값은 0x68(104) 입니다.

AD0 Pin : High(Vcc 3.3v 연결) = 기본값은 0x60(96) 입니다.

연결을 안하면 기기는 기본적으로 AD0 Pin이 Low로 되어

있어서 연결 안할 때는 0x68로 ID체크 하시면 됩니다.

2. ID 체크가 끝나고 나서 첫번째 초기화 시켜준 레지스터는

PWR_MGMT_1입니다.

이 레지스터는 전원 모드와 클럭 소스를 구성할 수 있습니다.

또한 전체장치를 재설정하기 위한 비트 및 온도 센서를 비활성화하기 위한 비트도 제공됩니다.

DEVICE_RESET : 재설정모드

SLEEP : 1=저전력 절전모드, 0=절전모드 아님.

CYCLE : 1=SLEEP가 0인 상태에서 CYCLE_MODE로 전환.

(CYCLE_MODE : 절전 모드와 웨이크업 사이를 순환하여 LP_WAKE_CTRL(레지스터 108)에 의해 결정된 가속도계 속도에서 단일 샘플의 데이터를 취합니다.)

* Wake주파수를 구성하려면 전원 관리 2 레지스터(레지스터 108)를 사용하여 LP_WAKE_CTRL을 설정합니다.

TEMP_DIS : 온도 센서 활성 비활성.

CLKSEL : 내부 8MHz 오실레이터, 자이로스코프 기반 클럭 또는 외부 소스를 선택가능.

* 내부 8MHz 오실레이터 또는 외부 소스를 클럭 소스로 선택 = 자이로스코프가 비활성화된 저전력 모드에서 작동할 수 있습니다.

(but, 안정성이 향상되려면 장치가 자이로스코프 중 하나를 표보고 참고하고 사용하도록 구성하는게 좋다고 합니다.)

저는 0으로 설정해서 내부 클럭 8MHz를 사용하도록 합니다.

=====

=====

3. SMPLRT_DIV 레지스터 입니다. 이 레지스터는 샘플 속도를 생성하는데 사용되는 자이로 스코프 출력 속도의 구분선을 지정합니다.

센서 레지스터 출력, FIFO 출력 및 DMP 샘플링은 모두 이 샘플링 속도를 토대로 사용됩니다.

샘플 속도는 자이로스코프 출력 속도를

SMPLRT_DIV(샘플 속도) = 자이로스코프 출력 속도 / (1+ SMPLRT_DIV)

공식으로 나누어 생성됩니다.

만약, DLPF가 비활성화 된 경우는 자이로스코프 출력 속도는 8KHz로 정해집니다.

(DLPF_CFG = 0 or 7) = 이부분은 0x1A 레지스터와 연관되어 있어요.

그렇게 되면 가속계 출력 속도는 1KHz 입니다.

(즉, 1KHz보다 큰 샘플 속도의 경우 동일한 가속도계 샘플이 FIFO, DMP 및 센서 레지스터로 두 번 이상 출력될 수 있습니다.)

저는 0x07로 설정했으니, 8/(1+7) = 1KHz 샘플 속도가 나올 것 같습니다.(맞나요? 저도 솔직히..잘은 모르겠습니다)

4. 이 부분은 제가 주석처리를 하고 넘어갔는데요.

그래도 사용할 사람들은 사용하는 부분이라 넣었습니다.

이 레지스터는 자이로스코프 및 가속도계 모두에 대한 외부 프레임 동기화(FSYNC) 핀 샘플링 및 디지털 로우패스 필터(DLPF)설정을 구성하는 레지스터입니다.

DLPF – 자이로스코프 출력속도 영향이 있습니다.

EXT_SYNC_SET : FSYNC 핀에 연결된 외부 신호를 샘플링 할 수 있습니다.

위에 표를 보면서 원하는 신호를 설정합니다.

래치된 FSYNC 신호는 레지스터 25에 정의된 대로 샘플링 속도로 샘플링 합니다.

DLPF_CFG : 가속도계와 자이로스코프 필터링 값을 설정하는 곳.

위에서 말했듯이 DLPF가 비활성화 되면 자이로스코프 출력 속도는 8KHz가 된다고

말했는데, 표를 보시면 0일때 자이로스코프 출력 속도가 8KHz로 설정되어 있습니다.

이부분은 처음에 설정하다가 주석으로 빼버렸습니다.

5. 이 레지스터는 가속도계 설정 레지스터 입니다.

디지털 출력 3축 가속도계 풀 스케일 범위 를 구성하는데 사용합니다.

(단위는 중력가속도)

이 레지스터는 DHPF(Digital High Pass Filter)도 구성합니다.

각 가속도계 축에 대한 자가 테스트는 XA_ST, YA_ST, ZA_ST를 제어하여 활성화 할 수 있습니다.

(자체 테스트가 활성화 되면 온보드 전자 장치가 해당 센서를 작동시킵니다.)

– 이 작동은 외부 힘을 시뮬레이션 합니다.

– 작동된 센서가 해당 출력 신호를 생성합니다. 출력 신호는 자가 테스트 반응을 관찰하는 데 사용합니다.

자가 테스트 반응은 다음과 같이 정의 됩니다.

자체 테스트 응답 = 자체 테스트가 활성화된 센서 출력 – 자체 테스트가 활성화되지 않은 센서 출력

이 부분은 각 가속도 센서들을 테스트함을 위한 설정인것 같습니다.

제가 사용하는 부분은 AFS_SEL 에서 0으로 설정해서 최소 스케일 범위를 선택했습니다.

6. 이 레지스터는 자이로 설정부분인데요.

가속도와 같습니다.

각 XG_ST, YG_ST, ZG_ST를 제어해서 활성화하고 자가 테스트를 진행 할 수 있습니다.

그리고 FS_SEL를 설정해서 자이로스코프 출력의 전체 스케일 범위를 선택합니다.

(사용자가 프로그래밍할 수 있는 최대 범위(Full Scale Range) 초의 디지털 출력)

(1초에 몇 도를 회전하는가)

저는 여기서도 0으로 설정해서 최소 범위를 택했습니다.

이렇게 초기값을 정했는데요.

제가 정한 수치를 본다면

온도센서 비활성화, 절전모드 비활성화, 내부클럭 8MHz

샘플 속도 1KHz, 가속도 스케일 범위 2g, 자이로 스케일 범위 250/s

설정 했습니다.

=====

=====

이제 가속도와 자이로 각속도를 받아볼까요?

첫 번째 함수는 가속도 함수이며,

위에 표와 같이 0x3B부터 시작해서 0x40까지 가속도 레지스터 주소가 있습니다.

이 값들은 16bit 값을 가지고 있어서 상위 하위로 나눠 불러와 16bit 변수에 넣습니다.

그래서 함수를 보시면 시작 값은 0x3B로 설정하고 총 6개 레지스터 주소에서 데이터를 받고

각각 해당하는 Ax, Ay, Az 변수에 데이터 값을 넣습니다.

Ax 변수에 데이터를 넣을 때! DataStruct->Ax = DataStruct->Accel_X_RAW / 16384.0;

중에 16384라는 숫자가 있잖아요?

그게 무엇이냐면

MPU-6050 datasheet를 보면 가속도계 측정에 풀 스케일 부분에 맞게

LSBin ACEL_xOUTIS 당 가속도계의 감도 수치가 있습니다.

그거에 맞게 설정해서 나눠줍니다.

제가 위에서 0으로 설정해서 2g을 설정했잖아요?

그래서 16384가 나온거에요.

두번째 함수는 자이로 센서값을 얻는 함수입니다.

자이로 센서도 가속도 센서와 마찬가지고 16bit 데이터를 가지고 있으며, 0x43으로 시작해서

0x48로 끝납니다. 위와 같이 데이터를 불러와 16bit 변수에 집어 넣습니다.

이 부분에서도 Gx = DataStruct->Gyro_X_RAW / 131.0;

중 131이 있는데요.

이것도 가속도와 같습니다.

표에 맞게 설정한 FS_SEL에 맞게 LSB Sensitivity 값(자이로스코프의 감도)을 넣어줍니다.

가속도와 각속도를 모두 불러왔으니 이제 일단 데이터를 먼저 확인을 해야죠?

아직 상보필터와 다른 필터들을 사용하지 않아서 불안정할 수도 있습니다.

저는 시리얼을 printf로 설정해서 사용했어요.

시리얼로 데이터를 받아보면 제가 움직일때, 가속도와 각속도가 데이터가 바뀝니다.

(아 저 수치는 제가 소수점 첫번째자리를 받게해서 저렇게 나온거에요)

300×250

아두이노 MPU6050 사용법 정리 by makeshare.org

이번에는 아두이노 가속도 / 자이로 센서 중에 가장 유명한 센서인 MPU6050의 사용법을 알아보고자 합니다. 가장 저렴한 MPU6050와 기술 문의 바로가기 어째선지 가장 유명하면서도 관련 콘텐츠나 정리되어있는 자료도 많지 않아 제가 접해보면서 알게 된 내용을 조금이나마 정리해보고자 합니다. MPU6050이란? MP6050은 인벤센스(invensense) 사에서 개발한 자이로, 가속도 센서 중의 하나입니다. 쓰기도 간편하고 가격도 저렴한 편이어서 인기가 정말 많은데 다음과 같은 특징을 가지고 있습니다. 특징 내용 단위 부가 설명 동작전압 5V ~ 3.3V ic 자체는 1.7~ 3.3V이지만 센서 모듈에 레귤레이터가 있습니다. 통신 방식 I²C(I2C,IIC) , SPI 기본 I2C입니다. 자이로 최대 측정값 ±(250/500/1000/2000) (*/sec) 자이로는 각속도입니다.(1초에 몇 도를 회전하는가) 자이로 센서 감도 (131/65.5/32.8/16.4) (LSB/*/sec) 얼마나 미세하게 측정하느냐입니다. 값이 클수록 감도가 높습니다. 자이로 잡음(오차) 0.01 (dps/√Hz) 자이로 센서에서 발생할 수 있는 오차입니다. 가속도 센서 최대값 ±(2/4/8/16) (g) 가속도 센서 값입니다. 단위는 중력가속도 기준입니다. 자이로 센서 감도 (16384/8192/4096/2048) (LSB/g) 얼마나 미세하게 측정하느냐입니다. 값이 클수록 감도가 높습니다. 데이터 시트 바로 가기 -> 다운로드 특징으로 정리되어있는 표를 보면 약간의 의문점이 있을 것입니다. 왜 가속도 센서나 자이로 센서의 최댓값 최솟값이 있는 것일까요? 그 이유는 레지스터를 통해 저희가 설정한 대로 자유롭게 최대 측정값들을 변경할 수 있습니다. 그리고 감도들은 최대 측정값들이 변경되면 이에 따라 자동으로 감도가 변경되게 됩니다. 미세한 움직임을 정확히 측정하고 싶다면 최대 측정값을 가장 낮게 설정하고, 크고 빠른 움직임을 측정한다면 최대 측정값을 크게 설정하면 되는 것입니다. 기본적인 회로도 알아보기 우선 아두이노의 회로도를 알아보도록 하겠습니다. 아두이노 보드마다 다른 경우가 있는데 이런 경우에는 다음 블로그의 예제를 참고할 수 있습니다. http://blog.naver.com/roboholic84/220583168600

아두이노의 A4, A5(SDA, SCL) 핀은 I2C 통진 핀으로 아두이노와 MPU6050이 통신하기 위해 연결할 수 있습니다. 레오나르도나 메가 보드와 같이 I2C통신핀이 다른 보드들은 위 링크에서 맞게 연결하는 법을 찾을 수 있습니다. 번외! MPU6050보드를 2개 연결 하고 싶다면?? MPU6050센서를 두 개를 사용하고자 하면 어디에 연결을 해야 하나 당황할 수도 있겠지만 다행히도 방법이 있습니다. MPU6050 의 AD0 핀에 5v를 연결해주면 MPU6050의 I2C 통신 주소를 변경할 수 있습니다.(0x68 -> 0x69) 번외! MPU6050을 납땜을 하지 않고 사용해도 될까? 꼭! 납땜을 하고 사용하는 것을 추천합니다. 납땜을 하지 않아 접촉이 불안정해지면 아두이노 보드와 MPU6050간의 통신에 불량이 생겨 정상적으로 동작하지 않을 수 있습니다. 소스 코드와 라이브러리 알아보기

MPU6050은 라이브러리 없이 간단한 데이터 통신을 통해 원시 값(RAW)을 받아보아서 테스트를 해볼 수도 있고, 라이브러리를 통해 실제 값을 측정해 볼 수도 있습니다.

라이브러리 없이 RAW 값 읽어보기

#include const int MPU=0x68;//MPU6050 I2C주소 int AcX,AcY,AcZ,Tmp,GyX,GyY,GyZ; void get6050(); void setup() { Wire.begin(); Wire.beginTransmission(MPU); Wire.write(0x6B); Wire.write(0);//MPU6050 을 동작 대기 모드로 변경 Wire.endTransmission(true); Serial.begin(9600); } void loop() { get6050();//센서값 갱신 //받아온 센서값을 출력합니다. Serial.print(AcX); Serial.print(“”); Serial.print(AcY); Serial.print(“”); Serial.print(AcZ); Serial.println(); delay(15); } void get6050(){ Wire.beginTransmission(MPU);//MPU6050 호출 Wire.write(0x3B);//AcX 레지스터 위치 요청 Wire.endTransmission(false); Wire.requestFrom(MPU,14,true);//14byte의 데이터를 요청 AcX=Wire.read()<<8|Wire.read();//두개의 나뉘어진 바이트를 하나로 이어붙입니다. AcY=Wire.read()<<8|Wire.read(); AcZ=Wire.read()<<8|Wire.read(); Tmp=Wire.read()<<8|Wire.read(); GyX=Wire.read()<<8|Wire.read(); GyY=Wire.read()<<8|Wire.read(); GyZ=Wire.read()<<8|Wire.read(); 소스 코드에 대한 설명은 주석을 참고하면 더 좋습니다. 간단히 요약을 하자면 I2C 통신으로 MPU6050의 모드를 설정하고 MPU6050의 레지스터에 저장된 센서 값을 가져옵니다. MPU6050의 데이터시트를 읽고 레지스터 맵을 읽는다 한들 저 레지스터를 어떻게 설정을 해주어야 할지 직접 감이 잡히지 않습니다. 그렇기 때문에 더더욱 라이브러리를 사용해보고 이해를 해보아야 합니다. 라이브러리 설치하기 우선 라이브러리의 설치가 필요하지요 MPU6050의 라이브러리는 제가 아는 것 중에서는 i2c 통신을 사용하는 센서의 라이브러리 등을 정리하는 개발자 그룹인 i2cDev 의 MPU6050 라이브러리가 가장 완성도가 높습니다.(더 좋은 것이 있다면 덧글에서 추천해주세요~) 우선 라이브러리를 먼저 다운로드하도록 하겠습 니다 위 링크에 찾아가면 초록색 버튼으로 Clone or Download 라 적혀있는 것을 클릭하여 다운로드해줍니다. i2cdevlib-master.zip 이라는 파일을 찾아 볼 수 있는데, 압축을 풀어주면 [Arduino, EFM32 ....]으로 여러 가지 폴더들을 볼 수 있습니다. 이 중에서 우리가 사용하는 개발 보드는 아두이노이기 때문에 바로 아두이노 폴더에 들어가 줍니다. 일단 들어가고 보면 라이브러리가 아주 많은데 다양한 센서들의 라이브러리가 있기 때문에 전부 가져오는 것도 좋지만 중요한 파일들만 챙겨가도록 합시다. 두개의 폴더를 가져와야 하는데 [MPU6050] 과 [I2Cdev] 폴더를 \문서\아두이노\libraries 폴더에 넣어주어야 합니다. 그러면 라이브러리 설치는 완료 됩니다. 라이브러리 예제 실행하기 & 약간의 함수 설명 라이브러리의 설치가 완료되었다면 라이브러리 예제를 실행합니다. MPU6050의 MPU6050_RAW 예제를 실행해 보도록 합니다. 라이브러리의 예제가 조금 길기 때문에 본문에 함께 적지는 못하지만 소스 코드에 들어있는 함수나 변수들에 대해 간단하게 설명하도록 하겠습니다. MPU6050 accelgyro; 예제 49번 줄에서 확인이 가능합니다. MPU6050을 제어하기 위해 MPU6050의 객체를 accelgyro 라고 이름을 붙여서 사용하기 시작합니다. 회로도에서 설명한 내용과 같이 I2C 주소를 변경하여 사용한다면 MPU6050 accelgyro(0x69); 를 대신 입력해서 사용이 가능합니다. accelgyro.initialize(); 예제 87번 줄에서 확인이 가능합니다. MPU6050을 사용하기 위해 모드를 설정하는등의 동작을 합니다. 라이브러리 없이 값을 읽어보았을 때 0x6B 를 보내는 등의 동작을 하였는데 이러한 내용이 해당 함수에서 실행됩니다. accelgyro.testConnection(); 예제 91번 줄에서 확인이 가능합니다. MPU6050와 아두이노 보드가 정상적으로 연결이 되었는지 확인을 하기 위해 사용됩니다. 회로도에서 설명한 내용과 같이 납땜을 하지 않고 사용할 경우 이곳에서 동작에 문제가 생길 수 있습니다. accelgyro.getMotion6(&ax, &ay, &az, &gx, &gy, &gz); 예제 122번 줄에서 확인이 가능합니다. MPU6050에서 가속도 센서 값과 자이로 센서 값의 정보를 받아와서 소스 코드 윗부분에 정의된 ax.... 변수들에 저장을 합니다. 여기서 다른 변수를 넣고자 할 때 앞에 &을 적지 않으면 변수값이 변경되지 않습니다.(이유가 궁금하다면 포인터에 대해 찾아봅시다.) 여기까지가 예제에 사용되었던 중요한 부분들을 정리하였는데 이것저것 아쉬운 감이 있습니다. 초반에 설명해드렸던 최대 측정값에 대한 설정들이 있는데 이에 대한 설명이 없어 아쉬웠을 거라 생각합니다. 그래서 그 부분에 대한 함수와 알면 유용한 함수들을 정리해서 소개해 드리도록 하겠습니다. accelgyro.setFullScaleGyroRange(MPU6050_GYRO_FS_250); 자이로 센서의 풀스케일 (최대 측정값) 을 설정하는 함수입니다. accelgyro.initialize(); 함수에서 초기화되기 때문에 그다음에 실행되어야 합니다. MPU6050_GYRO_FS_250 MPU6050_GYRO_FS_500 MPU6050_GYRO_FS_1000 MPU6050_GYRO_FS_2000 의 값을 넣어 변경할 수 있습니다. accelgyro.setFullScaleAccelRange(MPU6050_ACCEL_FS_2); 가속도 센서의 풀스케일 (최대 측정값) 을 설정하는 함수입니다. accelgyro.initialize(); 함수에서 초기화되기 때문에 그다음에 실행되어야 합니다. MPU6050_ACCEL_FS_2 MPU6050_ACCEL_FS_4 MPU6050_ACCEL_FS_8 MPU6050_ACCEL_FS_16 의 값을 넣어 변경할 수 있습니다. accelgyro.setDLPFMode(MPU6050_DLPF_BW_256); MPU6050의 센서 값의 잡음을 줄이는 방법 중 LOW PASS FILTER 을 적용할 수 있습니다. MPU6050_DLPF_BW_256 MPU6050_DLPF_BW_188 MPU6050_DLPF_BW_98 MPU6050_DLPF_BW_42 MPU6050_DLPF_BW_20 MPU6050_DLPF_BW_10 MPU6050_DLPF_BW_5 의 값을 넣어 변경할 수 있습니다. 라이브러리를 읽다가 발견했는데 이런 게 있은 줄은 처음 알았네요! DMP 사용해 보기 다음은 DMP 예제를 실행해 보도록 하겠습니다. DMP는 Digital Motion Processor 의 약자로 MPU6050에서 자체적으로 제공하는 자이로 가속도 연산 프로그램입니다. 이를 통해 pitch roll yaw 값을 얻어내거나 쿼터니안, 오일러값을 계산해 낼 수 있습니다. 예제코드는 MPU6050_DMP6 를 실행해 줍니다. DMP기능을 위해 인터럽트 핀을 사용합니다. MPU6050의 INT 핀을 아두이노 디지털 2번핀에 연결해주세요 실행한 다음, 시리얼 모니터에서 아무 키나 눌러 데이터를 보내주면 동작합니다. 여기서도 간단한 함수만 정리해 보도록 하겠습니다. mpu.setDMPEnabled(true); 212 번줄 , DMP기능을 활성화합니다. attachInterrupt(digitalPinToInterrupt(INTERRUPT_PIN), dmpDataReady, RISING); 인터럽트가 발생할때마다 실행할 함수를 정해줍니다. mpu.getFIFOBytes(fifoBuffer, packetSize); fifoBuffer에 DMP 패킷을 저장합니다. 받아온 패킷의 길이가 부족하거나 넘치게 되어 손실이 생길 경우 정상적인 값을 못 받습니다. mpu.dmpGetQuaternion(&q, fifoBuffer); DMP 패킷을 쿼터니언으로 변환합니다. mpu.dmpGetEuler(euler, &q);

키워드에 대한 정보 아두 이노 자이로 센서

다음은 Bing에서 아두 이노 자이로 센서 주제에 대한 검색 결과입니다. 필요한 경우 더 읽을 수 있습니다.

이 기사는 인터넷의 다양한 출처에서 편집되었습니다. 이 기사가 유용했기를 바랍니다. 이 기사가 유용하다고 생각되면 공유하십시오. 매우 감사합니다!

사람들이 주제에 대해 자주 검색하는 키워드 아두이노로 자이로 센서 신호 확인 하기…^^

• 아두이노
• 우노
• arduino
• UNO
• 자이로
• 센서
• gyro
• sensor
• MPU6050

아두이노로 #자이로 #센서 #신호 #확인 #하기…^^

---

YouTube에서 아두 이노 자이로 센서 주제의 다른 동영상 보기

주제에 대한 기사를 시청해 주셔서 감사합니다 아두이노로 자이로 센서 신호 확인 하기…^^ | 아두 이노 자이로 센서, 이 기사가 유용하다고 생각되면 공유하십시오, 매우 감사합니다.