MEMS Accelerometer Con Quay Hồi Chuyển Từ Kế & Arduino

MEMS là các hệ thống hoặc thiết bị rất nhỏ, bao gồm các thành phần vi mô có kích thước từ 0,001 mm đến 0,1 mm. Những thành phần này được làm bằng silicon, polyme, kim loại và / hoặc gốm sứ, và chúng thường được kết hợp với một CPU (Vi điều khiển) để hoàn thành hệ thống. Bây giờ chúng tôi sẽ giải thích ngắn gọn về cách mà mỗi bộ cảm biến Micro-Electro-Mechanical-Systems (MEMS) hoạt động.

MEMS Accelerometer

---

Nó đo gia tốc bằng cách đo thay đổi về điện dung. Cấu trúc vi mô của nó trông giống như thế này. Nó có khối lượng gắn liền với một lò xo bị giới hạn để di chuyển theo một hướng và các tấm ngoài cố định. Vì vậy, khi một gia tốc theo hướng cụ thể sẽ được áp dụng khối lượng sẽ di chuyển và điện dung giữa các tấm và khối lượng sẽ thay đổi. Sự thay đổi về điện dung này sẽ được đo, xử lý và nó sẽ tương ứng với một giá trị gia tốc cụ thể.

MEMS Gyroscope

---

Con quay hồi chuyển đo tốc độ góc bằng cách sử dụng hiệu ứng Coriolis. Khi khối lượng di chuyển theo một hướng cụ thể với vận tốc cụ thể và khi tỷ lệ góc ngoài sẽ được áp dụng như hiển thị với mũi tên màu xanh, lực sẽ xuất hiện, như hiển thị với mũi tên màu xanh lam, sẽ làm chuyển vị vuông góc của khối lượng. Vì vậy, tương tự như gia tốc, chuyển dịch này sẽ gây ra thay đổi trong điện dung sẽ được đo, xử lý và nó sẽ tương ứng với một tỷ lệ góc cụ thể.

Cấu trúc vi mô của con quay hồi chuyển trông giống như thế này. Một khối lượng liên tục di chuyển, hoặc dao động, và khi tỷ lệ góc bên ngoài sẽ được áp dụng một phần linh hoạt của khối lượng sẽ di chuyển và làm cho chuyển vị vuông góc.

MEMS từ kế

---

Nó đo từ trường trái đất bằng cách sử dụng Hall Effect hoặc Magneto Resistive Effect. Trên thực tế gần 90% các cảm biến trên thị trường sử dụng hiệu ứng Hall và đây là cách nó hoạt động.

Nếu chúng ta có một tấm dẫn điện như được hiển thị trong ảnh và chúng ta đặt dòng điện chạy qua nó, các electron sẽ chảy thẳng từ một đến phía bên kia của tấm. Bây giờ nếu chúng ta mang một số từ trường gần tấm, chúng ta sẽ làm xáo trộn dòng chảy thẳng và các electron sẽ lệch sang một bên của tấm và các cực dương ở phía bên kia của tấm. Điều đó có nghĩa là nếu chúng ta đặt một đồng hồ giờ đây giữa hai bên, chúng ta sẽ nhận được một số điện áp phụ thuộc vào cường độ từ trường và hướng của nó.

10% cảm biến khác trên thị trường sử dụng hiệu ứng Magneto-resistive. Các cảm biến này sử dụng các vật liệu nhạy cảm với từ trường, thường bao gồm Sắt (Fe) và Nickel (Ne). Vì vậy, khi những vật liệu này được tiếp xúc với từ trường, chúng sẽ thay đổi sức đề kháng của chúng.

Arduino

---

Bây giờ chúng ta hãy kết nối các cảm biến này với Arduino Board và sử dụng chúng. Ví dụ, tôi sẽ sử dụng bảng đột phá GY-80 có các cảm biến sau: ADXL345 Máy gia tốc 3 trục, L3G4200D Con quay hồi chuyển 3 trục, MC5883L 3 Từ kế trục và đồng hồ áp kế và Nhiệt kế mà chúng tôi sẽ không sử dụng trong hướng dẫn này.

Bạn có thể lấy các thành phần này từ bất kỳ trang nào dưới đây:

• Máy gia tốc 3 trục ADXL345 ……………………………………………………… Amazon  / Banggood
• 2 trong 1: Con quay hồi chuyển 6 trục MPU6050 và gia tốc kế ………………… Amazon / Banggood
• 3 trong 1: Gy-80 Con quay hồi chuyển tốc độ từ trường 9 trục ……… Amazon 
• 3 trong 1: GY-86 10DOF MS5611 HMC5883L Mô-đun MPU6050 ……… Banggood

* Xin lưu ý: Đây là những liên kết liên kết. Tôi có thể thực hiện một khoản hoa hồng nếu bạn mua các thành phần thông qua các liên kết này. 
Tôi sẽ đánh giá cao sự hỗ trợ của bạn theo cách này!

Bảng này sử dụng giao thức truyền thông I2C có nghĩa là chúng ta có thể sử dụng tất cả các cảm biến chỉ với hai dây. Vì vậy, để thực hiện giao tiếp giữa Arduino và các cảm biến, chúng ta cần phải biết địa chỉ thiết bị duy nhất của chúng và địa chỉ đăng ký nội bộ của chúng để lấy dữ liệu ra khỏi chúng. Các địa chỉ này có thể được tìm thấy từ các biểu dữ liệu của các cảm biến:

• ADXL345 Datasheet Accelerometer        
• L3G4200D Con quay hồi chuyển               Datasheet
• MC5883L từ kế         Datasheet

Để biết thêm chi tiết về cách thức hoạt động của giao tiếp I2C, bạn có thể kiểm tra Hướng dẫn giao thức truyền thông I2C khác của tôi  .

Mã nguồn

---

Bây giờ chúng ta hãy xem các mã để lấy dữ liệu từ các cảm biến. Chúng tôi sẽ bắt đầu với gia tốc kế và sẽ có một số giải thích trước mỗi mã, cũng như một số mô tả bổ sung trong các ý kiến ​​của mã.

Mã gia tốc Arduino

Đầu tiên chúng ta cần phải bao gồm Thư viện dây Arduino và xác định địa chỉ đăng ký của cảm biến. Trong phần thiết lập, chúng ta cần khởi tạo Thư viện dây và bắt đầu truyền thông nối tiếp vì chúng ta sẽ sử dụng màn hình nối tiếp để hiển thị kết quả. Ngoài ra ở đây chúng ta cần phải kích hoạt cảm biến, hoặc kích hoạt phép đo bằng cách gửi byte thích hợp đến thanh ghi Power_CTL và đây là cách chúng ta làm điều đó. Sử dụng hàm Wire.beginTransmission (), chúng tôi chọn cảm biến mà chúng ta sẽ nói, Bộ gia tốc kế 3 trục trong trường hợp này. Sau đó, sử dụng hàm Wire.write (), chúng ta sẽ nói với thanh ghi bên trong nào chúng ta sẽ nói. Sau đó, chúng ta sẽ gửi byte thích hợp để kích hoạt phép đo. Sử dụng hàm Wire.endTransmission (), chúng ta sẽ kết thúc quá trình truyền và sẽ truyền dữ liệu đến thanh ghi.

Trong phần vòng lặp, chúng ta cần đọc dữ liệu cho mỗi trục. Chúng ta sẽ bắt đầu với X-Axis. Đầu tiên, chúng ta sẽ chọn các sổ đăng ký mà chúng ta sẽ nói, hai thanh ghi bên trong X-Axis trong trường hợp này. Sau đó, sử dụng hàm Wire.requestFrom (), chúng tôi sẽ yêu cầu dữ liệu được truyền hoặc hai byte từ hai thanh ghi. Hàm Wire.available ()  sẽ trả về số byte có sẵn để truy xuất và nếu số đó khớp với byte yêu cầu của chúng tôi, trong trường hợp của chúng tôi là 2 byte, sử dụng hàm  Wire.read (), chúng ta sẽ đọc các byte từ hai thanh ghi trục X.

Dữ liệu đầu ra từ thanh ghi là bổ sung của hai, với X0 là byte quan trọng nhất và X1 là byte quan trọng nhất, do đó chúng ta cần chuyển đổi các byte này thành các giá trị float từ -1 đến +1 phụ thuộc vào hướng của trục tương đối X để tăng tốc Trái đất hoặc lực hấp dẫn. Chúng ta sẽ lặp lại quy trình này cho hai trục kia và cuối cùng chúng ta sẽ in các giá trị này trên màn hình nối tiếp.

1. #include <Wire.h>
3. //--- Accelerometer Register Addresses
4. #define Power_Register 0x2D
5. #define X_Axis_Register_DATAX0 0x32 // Hexadecima address for the DATAX0 internal register.
6. #define X_Axis_Register_DATAX1 0x33 // Hexadecima address for the DATAX1 internal register.
7. #define Y_Axis_Register_DATAY0 0x34
8. #define Y_Axis_Register_DATAY1 0x35
9. #define Z_Axis_Register_DATAZ0 0x36
10. #define Z_Axis_Register_DATAZ1 0x37
12. int ADXAddress = 0x53; //Device address in which is also included the 8th bit for selecting the mode, read in this case.
14. int X0,X1,X_out;
15. int Y0,Y1,Y_out;
16. int Z1,Z0,Z_out;
17. float Xa,Ya,Za;
19. void setup() {
20. Wire.begin(); // Initiate the Wire library
21. Serial.begin(9600);
22. delay(100);
24. Wire.beginTransmission(ADXAddress);
25. Wire.write(Power_Register); // Power_CTL Register
26. // Enable measurement
27. Wire.write(8); // Bit D3 High for measuring enable (0000 1000)
28. Wire.endTransmission();
29. }
31. void loop() {
32. // X-axis
33. Wire.beginTransmission(ADXAddress); // Begin transmission to the Sensor
34. //Ask the particular registers for data
35. Wire.write(X_Axis_Register_DATAX0);
36. Wire.write(X_Axis_Register_DATAX1);
37. Wire.endTransmission(); // Ends the transmission and transmits the data from the two registers
38. Wire.requestFrom(ADXAddress,2); // Request the transmitted two bytes from the two registers
39. if(Wire.available()<=2) { //
40. X0 = Wire.read(); // Reads the data from the register
41. X1 = Wire.read();
42. /* Converting the raw data of the X-Axis into X-Axis Acceleration
43. - The output data is Two's complement
44. - X0 as the least significant byte
45. - X1 as the most significant byte */
46. X1=X1<<8;
47. X_out =X0+X1;
48. Xa=X_out/256.0; // Xa = output value from -1 to +1, Gravity acceleration acting on the X-Axis
49. }
50. // Y-Axis
51. Wire.beginTransmission(ADXAddress);
52. Wire.write(Y_Axis_Register_DATAY0);
53. Wire.write(Y_Axis_Register_DATAY1);
54. Wire.endTransmission();
55. Wire.requestFrom(ADXAddress,2);
56. if(Wire.available()<=2) {
57. Y0 = Wire.read();
58. Y1 = Wire.read();
59. Y1=Y1<<8;
60. Y_out =Y0+Y1;
61. Ya=Y_out/256.0;
62. }
63. // Z-Axis
64. Wire.beginTransmission(ADXAddress);
65. Wire.write(Z_Axis_Register_DATAZ0);
66. Wire.write(Z_Axis_Register_DATAZ1);
67. Wire.endTransmission();
68. Wire.requestFrom(ADXAddress,2);
69. if(Wire.available()<=2) {
70. Z0 = Wire.read();
71. Z1 = Wire.read();
72. Z1=Z1<<8;
73. Z_out =Z0+Z1;
74. Za=Z_out/256.0;
75. }
76. // Prints the data on the Serial Monitor
77. Serial.print("Xa= ");
78. Serial.print(Xa);
79. Serial.print(" Ya= ");
80. Serial.print(Ya);
81. Serial.print(" Za= ");
82. Serial.println(Za);
83. }

Mã con quay hồi chuyển Arduino

Để lấy dữ liệu từ con quay hồi chuyển, chúng ta sẽ có một mã tương tự như mã trước đó. Vì vậy, trước tiên chúng ta phải xác định địa chỉ đăng ký và một số biến cho dữ liệu. Trong phần thiết lập, chúng ta phải thức dậy và đặt cảm biến ở chế độ bình thường bằng cách sử dụng CTRL_REG1 và cũng chọn độ nhạy của cảm biến. Trong ví dụ này, tôi sẽ chọn chế độ độ nhạy 2000dps.

Trong phần vòng lặp tương tự như gia tốc kế, chúng ta sẽ đọc dữ liệu cho trục X, Y và Z. Sau đó, dữ liệu thô phải được chuyển đổi thành các giá trị góc. Từ biểu dữ liệu của cảm biến, chúng ta có thể thấy rằng đối với chế độ độ nhạy 2000dps tương ứng với đơn vị 70 mdps / chữ số. Điều này có nghĩa rằng chúng ta phải nhân dữ liệu đầu ra thô với 0,07 để có được tốc độ góc theo độ / giây. Sau đó, nếu nhân tỷ lệ góc theo thời gian, nó sẽ cho chúng ta giá trị góc. Vì vậy, chúng ta cần tính toán khoảng thời gian của mỗi phần vòng lặp và chúng ta có thể làm điều đó bằng cách sử dụng hàm millis () ở trên cùng và dưới cùng của phần vòng lặp, và chúng ta sẽ lưu giá trị của nó vào biến "dt" này. Vì vậy, đối với mỗi vòng lặp thực hiện, chúng tôi sẽ tính toán góc và thêm nó vào giá trị góc cuối cùng.

1. #include <Wire.h>
3. //--- Gyro Register Addresses
4. #define Gyro_gX0 0x28
5. #define Gyro_gX1 0x29
6. #define Gyro_gY0 0x2A
7. #define Gyro_gY1 0x2B
8. #define Gyro_gZ0 0x2C
9. #define Gyro_gZ1 0x2D
11. int Gyro = 0x69; //Device address in which is also included the 8th bit for selecting the mode, read in this case.
13. int gX0, gX1, gX_out;
14. int gY0, gY1, gY_out;
15. int gZ0, gZ1, gZ_out;
16. float Xg,Yg,Zg;
17. float angleX,angleY,angleZ,angleXc,angleYc,angleZc;
20. unsigned long start, finished, elapsed;
21. float dt=0.015;
23. void setup()
24. {
25. Wire.begin();
26. Serial.begin(9600);
27. delay(100);
29. Wire.beginTransmission(Gyro);
30. Wire.write(0x20); // CTRL_REG1 - Power Mode
31. Wire.write(15); // Normal mode: 15d - 00001111b
32. Wire.endTransmission();
34. Wire.beginTransmission(Gyro);
35. Wire.write(0x23); // CTRL_REG4 - Sensitivity, Scale Selection
36. Wire.write(48); // 2000dps: 48d - 00110000b
37. Wire.endTransmission();
38. }
40. void loop()
41. {
42. start=millis();
43. //---- X-Axis
44. Wire.beginTransmission(Gyro); // transmit to device
45. Wire.write(Gyro_gX0);
46. Wire.endTransmission();
47. Wire.requestFrom(Gyro,1);
48. if(Wire.available()<=1)
49. {
50. gX0 = Wire.read();
51. }
52. Wire.beginTransmission(Gyro); // transmit to device
53. Wire.write(Gyro_gX1);
54. Wire.endTransmission();
55. Wire.requestFrom(Gyro,1);
56. if(Wire.available()<=1)
57. {
58. gX1 = Wire.read();
59. }
61. //---- Y-Axis
62. Wire.beginTransmission(Gyro); // transmit to device
63. Wire.write(Gyro_gY0);
64. Wire.endTransmission();
65. Wire.requestFrom(Gyro,1);
66. if(Wire.available()<=1)
67. {
68. gY0 = Wire.read();
69. }
70. Wire.beginTransmission(Gyro); // transmit to device
71. Wire.write(Gyro_gY1);
72. Wire.endTransmission();
73. Wire.requestFrom(Gyro,1);
74. if(Wire.available()<=1)
75. {
76. gY1 = Wire.read();
77. }
79. //---- Z-Axis
80. Wire.beginTransmission(Gyro); // transmit to device
81. Wire.write(Gyro_gZ0);
82. Wire.endTransmission();
83. Wire.requestFrom(Gyro,1);
84. if(Wire.available()<=1)
85. {
86. gZ0 = Wire.read();
87. }
88. Wire.beginTransmission(Gyro); // transmit to device
89. Wire.write(Gyro_gZ1);
90. Wire.endTransmission();
91. Wire.requestFrom(Gyro,1);
92. if(Wire.available()<=1)
93. {
94. gZ1 = Wire.read();
95. }
97. //---------- X - Axis
99. // Raw Data
100. gX1=gX1<<8;
101. gX_out =gX0+gX1;
103. // From the datasheet: 70 mdps/digit
104. Xg=gX_out*0.07; // Angular rate
105. // Angular_rate * dt = angle
106. angleXc = Xg*dt;
107. angleX = angleX + angleXc;
109. //---------- Y - Axis
110. gY1=gY1<<8;
111. gY_out =gY0+gY1;
112. Yg=gY_out*0.07;
113. angleYc = Yg*dt;
114. angleY = angleY + angleYc;
116. //---------- Z - Axis
117. gZ1=gZ1<<8;
118. gZ_out =gZ0+gZ1;
119. Zg=gZ_out*0.07;
120. angleZc = Zg*dt;
121. angleZ = angleZ + angleZc;
124. // Prints the data on the Serial Monitor
125. Serial.print("angleX= ");
126. Serial.print(angleX);
127. Serial.print(" angleY= ");
128. Serial.print(angleY);
129. Serial.print(" angleZ= ");
130. Serial.println(angleZ);
132. delay(10);
133. // Calculating dt
134. finished=millis();
135. elapsed=finished-start;
136. dt=elapsed/1000.0;
137. start = elapsed = 0;
139. }

Arduino từ kế mã

Một lần nữa chúng ta sẽ sử dụng một kỹ thuật tương tự với kỹ thuật trước đó. Đầu tiên chúng ta cần phải xác định địa chỉ đăng ký và phần thiết lập thiết lập cảm biến ở chế độ đo liên tục. Trong phần vòng lặp, chúng tôi sẽ lấy dữ liệu thô cho mỗi trục với cùng phương pháp như đối với các cảm biến trước đó.

Sau đó chúng ta cần chuyển đổi dữ liệu thô thành giá trị từ trường hoặc đơn vị Gauss. Từ biểu dữ liệu của cảm biến, chúng ta có thể thấy rằng chế độ nhạy mặc định là 0,92mG / chữ số. Điều đó có nghĩa là chúng ta cần phải nhân dữ liệu thô với 0,00092 để có được từ trường trái đất trong các đơn vị Gauss. Cuối cùng, chúng ta sẽ in các giá trị trên màn hình nối tiếp.

1. #include <Wire.h> //I2C Arduino Library
3. #define Magnetometer_mX0 0x03
4. #define Magnetometer_mX1 0x04
5. #define Magnetometer_mZ0 0x05
6. #define Magnetometer_mZ1 0x06
7. #define Magnetometer_mY0 0x07
8. #define Magnetometer_mY1 0x08
11. int mX0, mX1, mX_out;
12. int mY0, mY1, mY_out;
13. int mZ0, mZ1, mZ_out;
15. float Xm,Ym,Zm;
18. #define Magnetometer 0x1E //I2C 7bit address of HMC5883
20. void setup(){
21. //Initialize Serial and I2C communications
22. Serial.begin(9600);
23. Wire.begin();
24. delay(100);
26. Wire.beginTransmission(Magnetometer);
27. Wire.write(0x02); // Select mode register
28. Wire.write(0x00); // Continuous measurement mode
29. Wire.endTransmission();
30. }
32. void loop(){
34. //---- X-Axis
35. Wire.beginTransmission(Magnetometer); // transmit to device
36. Wire.write(Magnetometer_mX1);
37. Wire.endTransmission();
38. Wire.requestFrom(Magnetometer,1);
39. if(Wire.available()<=1)
40. {
41. mX0 = Wire.read();
42. }
43. Wire.beginTransmission(Magnetometer); // transmit to device
44. Wire.write(Magnetometer_mX0);
45. Wire.endTransmission();
46. Wire.requestFrom(Magnetometer,1);
47. if(Wire.available()<=1)
48. {
49. mX1 = Wire.read();
50. }
52. //---- Y-Axis
53. Wire.beginTransmission(Magnetometer); // transmit to device
54. Wire.write(Magnetometer_mY1);
55. Wire.endTransmission();
56. Wire.requestFrom(Magnetometer,1);
57. if(Wire.available()<=1)
58. {
59. mY0 = Wire.read();
60. }
61. Wire.beginTransmission(Magnetometer); // transmit to device
62. Wire.write(Magnetometer_mY0);
63. Wire.endTransmission();
64. Wire.requestFrom(Magnetometer,1);
65. if(Wire.available()<=1)
66. {
67. mY1 = Wire.read();
68. }
70. //---- Z-Axis
71. Wire.beginTransmission(Magnetometer); // transmit to device
72. Wire.write(Magnetometer_mZ1);
73. Wire.endTransmission();
74. Wire.requestFrom(Magnetometer,1);
75. if(Wire.available()<=1)
76. {
77. mZ0 = Wire.read();
78. }
79. Wire.beginTransmission(Magnetometer); // transmit to device
80. Wire.write(Magnetometer_mZ0);
81. Wire.endTransmission();
82. Wire.requestFrom(Magnetometer,1);
83. if(Wire.available()<=1)
84. {
85. mZ1 = Wire.read();
86. }
88. //---- X-Axis
89. mX1=mX1<<8;
90. mX_out =mX0+mX1; // Raw data
91. // From the datasheet: 0.92 mG/digit
92. Xm = mX_out*0.00092; // Gauss unit
93. //* Earth magnetic field ranges from 0.25 to 0.65 Gauss, so these are the values that we need to get approximately.
95. //---- Y-Axis
96. mY1=mY1<<8;
97. mY_out =mY0+mY1;
98. Ym = mY_out*0.00092;
100. //---- Z-Axis
101. mZ1=mZ1<<8;
102. mZ_out =mZ0+mZ1;
103. Zm = mZ_out*0.00092;
105. //Print out values of each axis
106. Serial.print("x: ");
107. Serial.print(Xm);
108. Serial.print(" y: ");
109. Serial.print(Ym);
110. Serial.print(" z: ");
111. Serial.println(Zm);
113. delay(50);
114. }